This section includes the Riemann zeta functions and associated functions pertaining to analytic number theory.
zeta(s) computes the Riemann zeta function, .
The Riemann zeta function is defined for
by
and for by analytic continuation. It has a pole
at
.
Examples
Some exact values of the zeta function are:
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> zeta(2)
1.64493406684823
>>> pi**2 / 6
1.64493406684823
>>> zeta(0)
-0.5
>>> zeta(-1)
-0.0833333333333333
>>> zeta(-2)
0.0
zeta() supports arbitrary precision evaluation and complex arguments:
>>> mp.dps = 50
>>> zeta(pi)
1.1762417383825827588721504519380520911697389900217
>>> zeta(1+2j) # doctest: +NORMALIZE_WHITESPACE
(0.5981655697623817367034568491742186771747764868876 -
0.35185474521784529049653859679690026505229177886045j)
The Riemann zeta function has so-called nontrivial zeros on
the critical line :
>>> mp.dps = 15
>>> findroot(zeta, 0.5+14j)
(0.5 + 14.1347251417347j)
>>> findroot(zeta, 0.5+21j)
(0.5 + 21.0220396387716j)
>>> findroot(zeta, 0.5+25j)
(0.5 + 25.0108575801457j)
For investigation of the zeta function zeros, the Riemann-Siegel Z-function is often more convenient than working with the Riemann zeta function directly (see siegelz()).
For large positive ,
rapidly approaches 1:
>>> zeta(30)
1.00000000093133
>>> zeta(100)
1.0
>>> zeta(inf)
1.0
The following series converges and in fact has a simple closed form value:
>>> nsum(lambda k: zeta(k)-1, [2, inf])
1.0
Algorithm
The primary algorithm is Borwein’s algorithm for the Dirichlet eta function. Three separate implementations are used: for general real arguments, general complex arguments, and for integers. The reflection formula is applied to arguments in the negative half-plane. For very large real arguments, either direct summation or the Euler prime product is used.
It should be noted that computation of gets very slow
when
is far away from the real axis.
References
Computes the Hurwitz zeta function
With , this reduces to the ordinary Riemann zeta function.
Optionally, hurwitz(s, a, n) computes
the
-th derivative with respect to
,
Although these series only converge for , the Hurwitz
zeta function is defined through analytic continuation for arbitrary
complex
(
is a pole). The implementation uses Euler-Maclaurin
summation along with reflection formulas in some cases when
.
The parameter is usually a rational number
, and may be specified
as such by passing an integer tuple
. Evaluation is supported for
arbitrary complex
, but may be slow and/or inaccurate when
for
nonrational
or when computing derivatives.
Examples
Some basic evaluations:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> hurwitz(2, 3); -5./4 + pi**2/6
0.3949340668482264364724152
0.3949340668482264364724152
>>> hurwitz(2, (3,4)); pi**2 - 8*catalan
2.541879647671606498397663
2.541879647671606498397663
For positive integer values of , the Hurwitz zeta function can be evaluated
using polygamma functions:
>>> hurwitz(4, (1,5)); psi(3, '1/5')/6
625.5408324774542966919938
625.5408324774542966919938
Some Riemann zeta function values:
>>> hurwitz(2)
1.644934066848226436472415
>>> 1-sum((hurwitz(k)-1)/k for k in range(2,85))
0.5772156649015328606065121
>>> +euler
0.5772156649015328606065121
>>> hurwitz(inf)
1.0
Evaluation on the critical line:
>>> findroot(hurwitz, 0.5+14j)
(0.5 + 14.13472514173469379045725j)
A derivative identity; evaluation for :
>>> hurwitz(0, 3+4j, 1)
(-2.675565317808456852310934 + 4.742664438034657928194889j)
>>> loggamma(3+4j) - ln(2*pi)/2
(-2.675565317808456852310934 + 4.742664438034657928194889j)
A high order derivative:
>>> hurwitz(2, 1, 20)
2432902008176640000.000242
A fourth derivative at a complex value:
>>> hurwitz(3+4j, 5.5+2j, 4)
(-0.140075548947797130681075 - 0.3109263360275413251313634j)
Generating a Taylor series at using derivatives:
>>> for k in range(11): print hurwitz(2,1,k)/fac(k), "*", "(s-2)^%i" % k
...
1.644934066848226436472415 * (s-2)^0
-0.9375482543158437537025741 * (s-2)^1
0.9946401171494505117104293 * (s-2)^2
-1.000024300473840810940657 * (s-2)^3
1.000061933072352565457512 * (s-2)^4
-1.000006869443931806408941 * (s-2)^5
1.000000173233769531820592 * (s-2)^6
-0.9999999569989868493432399 * (s-2)^7
0.9999999937218844508684206 * (s-2)^8
-0.9999999996355013916608284 * (s-2)^9
1.000000000004610645020747 * (s-2)^10
Evaluation at zero and for negative integer :
>>> hurwitz(0); zeta(0)
-0.5
-0.5
>>> hurwitz(0, 10)
-9.5
>>> hurwitz(-1); zeta(-1)
-0.08333333333333333333333333
-0.08333333333333333333333333
>>> hurwitz(-2); zeta(-2)
0.0
0.0
>>> hurwitz(-2, (2,3)); mpf(1)/81
0.01234567901234567901234568
0.01234567901234567901234568
Evaluation for negative , with rational and nonrational
:
>>> hurwitz(-3+4j, (5,4))
(0.2899236037682695182085988 + 0.06561206166091757973112783j)
>>> hurwitz(-3.25, 1/pi)
-0.0005117269627574430494396877
>>> hurwitz(-3.5, pi(dps=30), 1)
11.15636039044000329471003
>>> hurwitz(-100.5, (8,3))
-4.68162300487989766727122e+77
>>> hurwitz(-10.5, (-8,3))
(-0.01521913704446246609237979 + 29907.72510874248161608216j)
>>> hurwitz(-1000.5, (-8,3))
(1.031911949062334538202567e+1770 + 1.519555750556794218804724e+426j)
>>> hurwitz(-1+j, 3+4j)
(-16.32988355630802510888631 - 22.17706465801374033261383j)
>>> hurwitz(-1+j, 3+4j, 2)
(32.48985276392056641594055 - 51.11604466157397267043655j)
>>> diff(lambda s: hurwitz(s, 3+4j), -1+j, 2)
(32.48985276392056641594055 - 51.11604466157397267043655j)
Gives the Dirichlet eta function, , also known as the
alternating zeta function. This function is defined in analogy
with the Riemann zeta function as providing the sum of the
alternating series
The eta function, unlike the Riemann zeta function, is an entire
function, having a finite value for all complex . The special case
gives the value of the alternating harmonic series.
The alternating zeta function may expressed using the Riemann zeta function
as . It can also be expressed
in terms of the Hurwitz zeta function (hurwitz()), for example using
dirichlet() (see documentation for that function).
Examples
Some special values are:
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> altzeta(1)
0.693147180559945
>>> altzeta(0)
0.5
>>> altzeta(-1)
0.25
>>> altzeta(-2)
0.0
An example of a sum that can be computed more accurately and efficiently via altzeta() than via numerical summation:
>>> sum(-(-1)**n / n**2.5 for n in range(1, 100))
0.86720495150398402
>>> altzeta(2.5)
0.867199889012184
At positive even integers, the Dirichlet eta function
evaluates to a rational multiple of a power of :
>>> altzeta(2)
0.822467033424113
>>> pi**2/12
0.822467033424113
Like the Riemann zeta function, , approaches 1
as
approaches positive infinity, although it does
so from below rather than from above:
>>> altzeta(30)
0.999999999068682
>>> altzeta(inf)
1.0
>>> mp.pretty = False
>>> altzeta(1000, rounding='d')
mpf('0.99999999999999989')
>>> altzeta(1000, rounding='u')
mpf('1.0')
References
Evaluates the Dirichlet L-function
where is a periodic sequence of length
which should be supplied
in the form of a list
.
Strictly,
should be a Dirichlet character, but any periodic
sequence will work.
For example, dirichlet(s, [1]) gives the ordinary Riemann zeta function and dirichlet(s, [-1,1]) gives the alternating zeta function (Dirichlet eta function).
Also the derivative with respect to (currently only a first
derivative) can be evaluated.
Examples
The ordinary Riemann zeta function:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> dirichlet(3, [1]); zeta(3)
1.202056903159594285399738
1.202056903159594285399738
>>> dirichlet(1, [1])
+inf
The alternating zeta function:
>>> dirichlet(1, [-1,1]); ln(2)
0.6931471805599453094172321
0.6931471805599453094172321
The following defines the Dirichlet beta function
and verifies
several values of this function:
>>> B = lambda s, d=0: dirichlet(s, [0, 1, 0, -1], d)
>>> B(0); 1./2
0.5
0.5
>>> B(1); pi/4
0.7853981633974483096156609
0.7853981633974483096156609
>>> B(2); +catalan
0.9159655941772190150546035
0.9159655941772190150546035
>>> B(2,1); diff(B, 2)
0.08158073611659279510291217
0.08158073611659279510291217
>>> B(-1,1); 2*catalan/pi
0.5831218080616375602767689
0.5831218080616375602767689
>>> B(0,1); log(gamma(0.25)**2/(2*pi*sqrt(2)))
0.3915943927068367764719453
0.3915943927068367764719454
>>> B(1,1); 0.25*pi*(euler+2*ln2+3*ln(pi)-4*ln(gamma(0.25)))
0.1929013167969124293631898
0.1929013167969124293631898
A custom L-series of period 3:
>>> dirichlet(2, [2,0,1])
0.7059715047839078092146831
>>> 2*nsum(lambda k: (3*k)**-2, [1,inf]) + \
... nsum(lambda k: (3*k+2)**-2, [0,inf])
0.7059715047839078092146831
Computes the prime zeta function, which is defined in analogy with the Riemann zeta function (zeta()) as
where the sum is taken over all prime numbers . Although
this sum only converges for
, the
function is defined by analytic continuation in the
half-plane
.
Examples
Arbitrary-precision evaluation for real and complex arguments is supported:
>>> from mpmath import *
>>> mp.dps = 30; mp.pretty = True
>>> primezeta(2)
0.452247420041065498506543364832
>>> primezeta(pi)
0.15483752698840284272036497397
>>> mp.dps = 50
>>> primezeta(3)
0.17476263929944353642311331466570670097541212192615
>>> mp.dps = 20
>>> primezeta(3+4j)
(-0.12085382601645763295 - 0.013370403397787023602j)
The prime zeta function has a logarithmic pole at ,
with residue equal to the difference of the Mertens and
Euler constants:
>>> primezeta(1)
+inf
>>> extradps(25)(lambda x: primezeta(1+x)+log(x))(+eps)
-0.31571845205389007685
>>> mertens-euler
-0.31571845205389007685
The analytic continuation to
is implemented. In this strip the function exhibits
very complex behavior; on the unit interval, it has poles at
for every squarefree integer
:
>>> primezeta(0.5) # Pole at s = 1/2
(-inf + 3.1415926535897932385j)
>>> primezeta(0.25)
(-1.0416106801757269036 + 0.52359877559829887308j)
>>> primezeta(0.5+10j)
(0.54892423556409790529 + 0.45626803423487934264j)
Although evaluation works in principle for any ,
it should be noted that the evaluation time increases exponentially
as
approaches the imaginary axis.
For large ,
is asymptotic to
:
>>> primezeta(inf)
0.0
>>> primezeta(10), mpf(2)**-10
(0.00099360357443698021786, 0.0009765625)
>>> primezeta(1000)
9.3326361850321887899e-302
>>> primezeta(1000+1000j)
(-3.8565440833654995949e-302 - 8.4985390447553234305e-302j)
References
Carl-Erik Froberg, “On the prime zeta function”, BIT 8 (1968), pp. 187-202.
Returns the -th nontrivial zero of the Riemann zeta function.
The zero is computed using findroot(), using a table lookup
for the initial point.
The zeros are located on the critical line with real part 1/2:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> zetazero(1)
(0.5 + 14.13472514173469379045725j)
>>> zetazero(2)
(0.5 + 21.02203963877155499262848j)
>>> zetazero(20)
(0.5 + 77.14484006887480537268266j)
Negative indices give the conjugate zeros ( is undefined):
>>> zetazero(-1)
(0.5 - 14.13472514173469379045725j)
The default table only provides up to 100. For larger
up to
100,000, zetazero() will automatically download a table
(1.8 MB) from the website of Andrew Odlyzko [1]. This requires a
fast connection to the internet. Alternatively, you can supply the
url to a custom table. The table should be a file listing the
imaginary parts as float literals, separated by line breaks.
These functions are used for the study of the Riemann zeta function in the critical strip.
Computes the Z-function, also known as the Riemann-Siegel Z function,
where is the Riemann zeta function (zeta())
and where
denotes the Riemann-Siegel theta function
(see siegeltheta()).
Evaluation is supported for real and complex arguments:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> siegelz(1)
-0.7363054628673177346778998
>>> siegelz(3+4j)
(-0.1852895764366314976003936 - 0.2773099198055652246992479j)
The Z-function has a Maclaurin expansion:
>>> nprint(chop(taylor(siegelz, 0, 4)))
[-1.46035, 0.0, 2.73588, 0.0, -8.39357]
The Z-function is equal to
on the
critical line
(i.e. for real arguments
to
). Its zeros coincide with those of the Riemann zeta
function:
>>> findroot(siegelz, 14)
14.13472514173469379045725
>>> findroot(siegelz, 20)
21.02203963877155499262848
>>> findroot(zeta, 0.5+14j)
(0.5 + 14.13472514173469379045725j)
>>> findroot(zeta, 0.5+20j)
(0.5 + 21.02203963877155499262848j)
Since the Z-function is real-valued on the critical line
(and unlike analytic), it is useful for
investigating the zeros of the Riemann zeta function.
For example, one can use a root-finding algorithm based
on sign changes:
>>> findroot(siegelz, [100, 200], solver='bisect')
176.4414342977104188888926
To locate roots, Gram points which can be computed
by grampoint() are useful. If
is
positive for two consecutive
, then
must have
a zero between those points:
>>> g10 = grampoint(10)
>>> g11 = grampoint(11)
>>> (-1)**10 * siegelz(g10) > 0
True
>>> (-1)**11 * siegelz(g11) > 0
True
>>> findroot(siegelz, [g10, g11], solver='bisect')
56.44624769706339480436776
>>> g10, g11
(54.67523744685325626632663, 57.54516517954725443703014)
Computes the Riemann-Siegel theta function,
The Riemann-Siegel theta function is important in providing the phase factor for the Z-function (see siegelz()). Evaluation is supported for real and complex arguments:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> siegeltheta(0)
0.0
>>> siegeltheta(inf)
+inf
>>> siegeltheta(-inf)
-inf
>>> siegeltheta(1)
-1.767547952812290388302216
>>> siegeltheta(10+0.25j)
(-3.068638039426838572528867 + 0.05804937947429712998395177j)
The Riemann-Siegel theta function has odd symmetry around ,
two local extreme points and three real roots including 0 (located
symmetrically):
>>> nprint(chop(taylor(siegeltheta, 0, 5)))
[0.0, -2.68609, 0.0, 2.69433, 0.0, -6.40218]
>>> findroot(diffun(siegeltheta), 7)
6.28983598883690277966509
>>> findroot(siegeltheta, 20)
17.84559954041086081682634
For large , there is a famous asymptotic formula
for
, to first order given by:
>>> t = mpf(10**6)
>>> siegeltheta(t)
5488816.353078403444882823
>>> -t*log(2*pi/t)/2-t/2
5488816.745777464310273645
Gives the -th Gram point
, defined as the solution
to the equation
where
is the Riemann-Siegel theta function (siegeltheta()).
The first few Gram points are:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> grampoint(0)
17.84559954041086081682634
>>> grampoint(1)
23.17028270124630927899664
>>> grampoint(2)
27.67018221781633796093849
>>> grampoint(3)
31.71797995476405317955149
Checking the definition:
>>> siegeltheta(grampoint(3))
9.42477796076937971538793
>>> 3*pi
9.42477796076937971538793
A large Gram point:
>>> grampoint(10**10)
3293531632.728335454561153
Gram points are useful when studying the Z-function (siegelz()). See the documentation of that function for additional examples.
grampoint() can solve the defining equation for
nonintegral . There is a fixed point where
:
>>> findroot(lambda x: grampoint(x) - x, 10000)
9146.698193171459265866198
References
For a nonnegative integer , stieltjes(n) computes the
-th Stieltjes constant
, defined as the
-th coefficient in the Laurent series expansion of the
Riemann zeta function around the pole at
. That is,
we have:
More generally, stieltjes(n, a) gives the corresponding
coefficient for the Hurwitz zeta function
(with
).
Examples
The zeroth Stieltjes constant is just Euler’s constant :
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> stieltjes(0)
0.577215664901533
Some more values are:
>>> stieltjes(1)
-0.0728158454836767
>>> stieltjes(10)
0.000205332814909065
>>> stieltjes(30)
0.00355772885557316
>>> stieltjes(1000)
-1.57095384420474e+486
>>> stieltjes(2000)
2.680424678918e+1109
>>> stieltjes(1, 2.5)
-0.23747539175716
An alternative way to compute :
>>> diff(extradps(25)(lambda x: 1/(x-1) - zeta(x)), 1)
-0.0728158454836767
stieltjes() supports arbitrary precision evaluation:
>>> mp.dps = 50
>>> stieltjes(2)
-0.0096903631928723184845303860352125293590658061013408
Algorithm
stieltjes() numerically evaluates the integral in the following representation due to Ainsworth, Howell and Coffey [1], [2]:
For some reference values with , see e.g. [4].
References
Computes the polylogarithm, defined by the sum
This series is convergent only for , so elsewhere
the analytic continuation is implied.
The polylogarithm should not be confused with the logarithmic integral (also denoted by Li or li), which is implemented as li().
Examples
The polylogarithm satisfies a huge number of functional identities. A sample of polylogarithm evaluations is shown below:
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> polylog(1,0.5), log(2)
(0.693147180559945, 0.693147180559945)
>>> polylog(2,0.5), (pi**2-6*log(2)**2)/12
(0.582240526465012, 0.582240526465012)
>>> polylog(2,-phi), -log(phi)**2-pi**2/10
(-1.21852526068613, -1.21852526068613)
>>> polylog(3,0.5), 7*zeta(3)/8-pi**2*log(2)/12+log(2)**3/6
(0.53721319360804, 0.53721319360804)
polylog() can evaluate the analytic continuation of the
polylogarithm when is an integer:
>>> polylog(2, 10)
(0.536301287357863 - 7.23378441241546j)
>>> polylog(2, -10)
-4.1982778868581
>>> polylog(2, 10j)
(-3.05968879432873 + 3.71678149306807j)
>>> polylog(-2, 10)
-0.150891632373114
>>> polylog(-2, -10)
0.067618332081142
>>> polylog(-2, 10j)
(0.0384353698579347 + 0.0912451798066779j)
Some more examples, with arguments on the unit circle (note that the series definition cannot be used for computation here):
>>> polylog(2,j)
(-0.205616758356028 + 0.915965594177219j)
>>> j*catalan-pi**2/48
(-0.205616758356028 + 0.915965594177219j)
>>> polylog(3,exp(2*pi*j/3))
(-0.534247512515375 + 0.765587078525922j)
>>> -4*zeta(3)/9 + 2*j*pi**3/81
(-0.534247512515375 + 0.765587078525921j)
Polylogarithms of different order are related by integration and differentiation:
>>> s, z = 3, 0.5
>>> polylog(s+1, z)
0.517479061673899
>>> quad(lambda t: polylog(s,t)/t, [0, z])
0.517479061673899
>>> z*diff(lambda t: polylog(s+2,t), z)
0.517479061673899
Taylor series expansions around are:
>>> for n in range(-3, 4):
... nprint(taylor(lambda x: polylog(n,x), 0, 5))
...
[0.0, 1.0, 8.0, 27.0, 64.0, 125.0]
[0.0, 1.0, 4.0, 9.0, 16.0, 25.0]
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
[0.0, 1.0, 1.0, 1.0, 1.0, 1.0]
[0.0, 1.0, 0.5, 0.333333, 0.25, 0.2]
[0.0, 1.0, 0.25, 0.111111, 6.25e-2, 4.0e-2]
[0.0, 1.0, 0.125, 3.7037e-2, 1.5625e-2, 8.0e-3]
The series defining the polylogarithm is simultaneously
a Taylor series and an L-series. For certain values of , the
polylogarithm reduces to a pure zeta function:
>>> polylog(pi, 1), zeta(pi)
(1.17624173838258, 1.17624173838258)
>>> polylog(pi, -1), -altzeta(pi)
(-0.909670702980385, -0.909670702980385)
Evaluation for arbitrary, nonintegral is supported
for
within the unit circle:
>>> polylog(3+4j, 0.25)
(0.24258605789446 - 0.00222938275488344j)
>>> nsum(lambda k: 0.25**k / k**(3+4j), [1,inf])
(0.24258605789446 - 0.00222938275488344j)
It is also currently supported outside of the unit circle for
not too large in magnitude:
>>> polylog(1+j, 20+40j)
(-7.1421172179728 - 3.92726697721369j)
>>> polylog(1+j, 200+400j)
Traceback (most recent call last):
...
NotImplementedError: polylog for arbitrary s and z
References
Computes the Clausen sine function, defined formally by the series
The special case (i.e. clsin(2,z)) is the classical
“Clausen function”. More generally, the Clausen function is defined for
complex
and
, even when the series does not converge. The
Clausen function is related to the polylogarithm (polylog()) as
and this representation can be taken to provide the analytic continuation of the series. The complementary function clcos() gives the corresponding cosine sum.
Examples
Evaluation for arbitrarily chosen and
:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> s, z = 3, 4
>>> clsin(s, z); nsum(lambda k: sin(z*k)/k**s, [1,inf])
-0.6533010136329338746275795
-0.6533010136329338746275795
Using instead of
gives an alternating series:
>>> clsin(s, z+pi)
0.8860032351260589402871624
>>> nsum(lambda k: (-1)**k*sin(z*k)/k**s, [1,inf])
0.8860032351260589402871624
With , the sum can be expressed in closed form
using elementary functions:
>>> z = 1 + sqrt(3)
>>> clsin(1, z)
0.2047709230104579724675985
>>> chop((log(1-exp(-j*z)) - log(1-exp(j*z)))/(2*j))
0.2047709230104579724675985
>>> nsum(lambda k: sin(k*z)/k, [1,inf])
0.2047709230104579724675985
The classical Clausen function gives the
value of the integral
for
:
>>> cl2 = lambda t: clsin(2, t)
>>> cl2(3.5)
-0.2465045302347694216534255
>>> -quad(lambda x: ln(2*sin(0.5*x)), [0, 3.5])
-0.2465045302347694216534255
This function is symmetric about with zeros and extreme
points:
>>> cl2(0); cl2(pi/3); chop(cl2(pi)); cl2(5*pi/3); chop(cl2(2*pi))
0.0
1.014941606409653625021203
0.0
-1.014941606409653625021203
0.0
Catalan’s constant is a special value:
>>> cl2(pi/2)
0.9159655941772190150546035
>>> +catalan
0.9159655941772190150546035
The Clausen sine function can be expressed in closed form when
is an odd integer (becoming zero when
< 0):
>>> z = 1 + sqrt(2)
>>> clsin(1, z); (pi-z)/2
0.3636895456083490948304773
0.3636895456083490948304773
>>> clsin(3, z); pi**2/6*z - pi*z**2/4 + z**3/12
0.5661751584451144991707161
0.5661751584451144991707161
>>> clsin(-1, z)
0.0
>>> clsin(-3, z)
0.0
It can also be expressed in closed form for even integer ,
providing a finite sum for series such as
:
>>> z = 1 + sqrt(2)
>>> clsin(0, z)
0.1903105029507513881275865
>>> cot(z/2)/2
0.1903105029507513881275865
>>> clsin(-2, z)
-0.1089406163841548817581392
>>> -cot(z/2)*csc(z/2)**2/4
-0.1089406163841548817581392
Evaluation for complex ,
in a nonconvergent case:
>>> s, z = -1-j, 1+2j
>>> clsin(s, z)
(-0.593079480117379002516034 + 0.9038644233367868273362446j)
>>> extraprec(20)(nsum)(lambda k: sin(k*z)/k**s, [1,inf])
(-0.593079480117379002516034 + 0.9038644233367868273362446j)
Computes the Clausen cosine function, defined formally by the series
This function is complementary to the Clausen sine function clsin(). In terms of the polylogarithm,
Examples
Evaluation for arbitrarily chosen and
:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> s, z = 3, 4
>>> clcos(s, z); nsum(lambda k: cos(z*k)/k**s, [1,inf])
-0.6518926267198991308332759
-0.6518926267198991308332759
Using instead of
gives an alternating series:
>>> s, z = 3, 0.5
>>> clcos(s, z+pi)
-0.8155530586502260817855618
>>> nsum(lambda k: (-1)**k*cos(z*k)/k**s, [1,inf])
-0.8155530586502260817855618
With , the sum can be expressed in closed form
using elementary functions:
>>> z = 1 + sqrt(3)
>>> clcos(1, z)
-0.6720334373369714849797918
>>> chop(-0.5*(log(1-exp(j*z))+log(1-exp(-j*z))))
-0.6720334373369714849797918
>>> -log(abs(2*sin(0.5*z))) # Equivalent to above when z is real
-0.6720334373369714849797918
>>> nsum(lambda k: cos(k*z)/k, [1,inf])
-0.6720334373369714849797918
It can also be expressed in closed form when is an even integer.
For example,
>>> clcos(2,z)
-0.7805359025135583118863007
>>> pi**2/6 - pi*z/2 + z**2/4
-0.7805359025135583118863007
The case gives the renormalized sum of
(which happens to be the same for
any value of
):
>>> clcos(0, z)
-0.5
>>> nsum(lambda k: cos(k*z), [1,inf])
-0.5
Also the sums
and
for higher integer powers can be done in closed form. They are zero
when
is positive and even (
negative and even):
>>> clcos(-1, z); 1/(2*cos(z)-2)
-0.2607829375240542480694126
-0.2607829375240542480694126
>>> clcos(-3, z); (2+cos(z))*csc(z/2)**4/8
0.1472635054979944390848006
0.1472635054979944390848006
>>> clcos(-2, z); clcos(-4, z); clcos(-6, z)
0.0
0.0
0.0
With , the series reduces to that of the Riemann zeta function
(more generally, if
, it is a finite sum over Hurwitz zeta
function values):
>>> clcos(2.5, 0); zeta(2.5)
1.34148725725091717975677
1.34148725725091717975677
>>> clcos(2.5, pi); -altzeta(2.5)
-0.8671998890121841381913472
-0.8671998890121841381913472
Evaluation for complex ,
in a nonconvergent case:
>>> s, z = -1-j, 1+2j
>>> clcos(s, z)
(0.9407430121562251476136807 + 0.715826296033590204557054j)
>>> extraprec(15)(nsum)(lambda k: cos(k*z)/k**s, [1,inf])
(0.9407430121562251476136807 + 0.7158262960335902045570541j)
Evaluates the polyexponential function, defined for arbitrary
complex ,
by the series
is constructed from the exponential function analogously
to how the polylogarithm is constructed from the ordinary
logarithm; as a function of
(with
fixed),
is an L-series
It is an entire function of both
and
.
The polyexponential function provides a generalization of the
Bell polynomials (see bell()) to noninteger orders
.
In terms of the Bell polynomials,
Note that and
are identical if
is a nonzero integer, but not otherwise. In particular, they differ
at
.
Examples
Evaluating a series:
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> nsum(lambda k: sqrt(k)/fac(k), [1,inf])
2.101755547733791780315904
>>> polyexp(0.5,1)
2.101755547733791780315904
Evaluation for arbitrary arguments:
>>> polyexp(-3-4j, 2.5+2j)
(2.351660261190434618268706 + 1.202966666673054671364215j)
Evaluation is accurate for tiny function values:
>>> polyexp(4, -100)
3.499471750566824369520223e-36
If is a nonpositive integer,
reduces to a special
instance of the hypergeometric function
:
>>> n = 3
>>> x = pi
>>> polyexp(-n,x)
4.042192318847986561771779
>>> x*hyper([1]*(n+1), [2]*(n+1), x)
4.042192318847986561771779