699 lines
27 KiB
Python
699 lines
27 KiB
Python
from mpmath import *
|
|
from mpmath.libmp import round_up, from_float, mpf_zeta_int
|
|
|
|
def test_zeta_int_bug():
|
|
assert mpf_zeta_int(0, 10) == from_float(-0.5)
|
|
|
|
def test_bernoulli():
|
|
assert bernfrac(0) == (1,1)
|
|
assert bernfrac(1) == (-1,2)
|
|
assert bernfrac(2) == (1,6)
|
|
assert bernfrac(3) == (0,1)
|
|
assert bernfrac(4) == (-1,30)
|
|
assert bernfrac(5) == (0,1)
|
|
assert bernfrac(6) == (1,42)
|
|
assert bernfrac(8) == (-1,30)
|
|
assert bernfrac(10) == (5,66)
|
|
assert bernfrac(12) == (-691,2730)
|
|
assert bernfrac(18) == (43867,798)
|
|
p, q = bernfrac(228)
|
|
assert p % 10**10 == 164918161
|
|
assert q == 625170
|
|
p, q = bernfrac(1000)
|
|
assert p % 10**10 == 7950421099
|
|
assert q == 342999030
|
|
mp.dps = 15
|
|
assert bernoulli(0) == 1
|
|
assert bernoulli(1) == -0.5
|
|
assert bernoulli(2).ae(1./6)
|
|
assert bernoulli(3) == 0
|
|
assert bernoulli(4).ae(-1./30)
|
|
assert bernoulli(5) == 0
|
|
assert bernoulli(6).ae(1./42)
|
|
assert str(bernoulli(10)) == '0.0757575757575758'
|
|
assert str(bernoulli(234)) == '7.62772793964344e+267'
|
|
assert str(bernoulli(10**5)) == '-5.82229431461335e+376755'
|
|
assert str(bernoulli(10**8+2)) == '1.19570355039953e+676752584'
|
|
|
|
mp.dps = 50
|
|
assert str(bernoulli(10)) == '0.075757575757575757575757575757575757575757575757576'
|
|
assert str(bernoulli(234)) == '7.6277279396434392486994969020496121553385863373331e+267'
|
|
assert str(bernoulli(10**5)) == '-5.8222943146133508236497045360612887555320691004308e+376755'
|
|
assert str(bernoulli(10**8+2)) == '1.1957035503995297272263047884604346914602088317782e+676752584'
|
|
|
|
mp.dps = 1000
|
|
assert bernoulli(10).ae(mpf(5)/66)
|
|
|
|
mp.dps = 50000
|
|
assert bernoulli(10).ae(mpf(5)/66)
|
|
|
|
mp.dps = 15
|
|
|
|
def test_bernpoly_eulerpoly():
|
|
mp.dps = 15
|
|
assert bernpoly(0,-1).ae(1)
|
|
assert bernpoly(0,0).ae(1)
|
|
assert bernpoly(0,'1/2').ae(1)
|
|
assert bernpoly(0,'3/4').ae(1)
|
|
assert bernpoly(0,1).ae(1)
|
|
assert bernpoly(0,2).ae(1)
|
|
assert bernpoly(1,-1).ae('-3/2')
|
|
assert bernpoly(1,0).ae('-1/2')
|
|
assert bernpoly(1,'1/2').ae(0)
|
|
assert bernpoly(1,'3/4').ae('1/4')
|
|
assert bernpoly(1,1).ae('1/2')
|
|
assert bernpoly(1,2).ae('3/2')
|
|
assert bernpoly(2,-1).ae('13/6')
|
|
assert bernpoly(2,0).ae('1/6')
|
|
assert bernpoly(2,'1/2').ae('-1/12')
|
|
assert bernpoly(2,'3/4').ae('-1/48')
|
|
assert bernpoly(2,1).ae('1/6')
|
|
assert bernpoly(2,2).ae('13/6')
|
|
assert bernpoly(3,-1).ae(-3)
|
|
assert bernpoly(3,0).ae(0)
|
|
assert bernpoly(3,'1/2').ae(0)
|
|
assert bernpoly(3,'3/4').ae('-3/64')
|
|
assert bernpoly(3,1).ae(0)
|
|
assert bernpoly(3,2).ae(3)
|
|
assert bernpoly(4,-1).ae('119/30')
|
|
assert bernpoly(4,0).ae('-1/30')
|
|
assert bernpoly(4,'1/2').ae('7/240')
|
|
assert bernpoly(4,'3/4').ae('7/3840')
|
|
assert bernpoly(4,1).ae('-1/30')
|
|
assert bernpoly(4,2).ae('119/30')
|
|
assert bernpoly(5,-1).ae(-5)
|
|
assert bernpoly(5,0).ae(0)
|
|
assert bernpoly(5,'1/2').ae(0)
|
|
assert bernpoly(5,'3/4').ae('25/1024')
|
|
assert bernpoly(5,1).ae(0)
|
|
assert bernpoly(5,2).ae(5)
|
|
assert bernpoly(10,-1).ae('665/66')
|
|
assert bernpoly(10,0).ae('5/66')
|
|
assert bernpoly(10,'1/2').ae('-2555/33792')
|
|
assert bernpoly(10,'3/4').ae('-2555/34603008')
|
|
assert bernpoly(10,1).ae('5/66')
|
|
assert bernpoly(10,2).ae('665/66')
|
|
assert bernpoly(11,-1).ae(-11)
|
|
assert bernpoly(11,0).ae(0)
|
|
assert bernpoly(11,'1/2').ae(0)
|
|
assert bernpoly(11,'3/4').ae('-555731/4194304')
|
|
assert bernpoly(11,1).ae(0)
|
|
assert bernpoly(11,2).ae(11)
|
|
assert eulerpoly(0,-1).ae(1)
|
|
assert eulerpoly(0,0).ae(1)
|
|
assert eulerpoly(0,'1/2').ae(1)
|
|
assert eulerpoly(0,'3/4').ae(1)
|
|
assert eulerpoly(0,1).ae(1)
|
|
assert eulerpoly(0,2).ae(1)
|
|
assert eulerpoly(1,-1).ae('-3/2')
|
|
assert eulerpoly(1,0).ae('-1/2')
|
|
assert eulerpoly(1,'1/2').ae(0)
|
|
assert eulerpoly(1,'3/4').ae('1/4')
|
|
assert eulerpoly(1,1).ae('1/2')
|
|
assert eulerpoly(1,2).ae('3/2')
|
|
assert eulerpoly(2,-1).ae(2)
|
|
assert eulerpoly(2,0).ae(0)
|
|
assert eulerpoly(2,'1/2').ae('-1/4')
|
|
assert eulerpoly(2,'3/4').ae('-3/16')
|
|
assert eulerpoly(2,1).ae(0)
|
|
assert eulerpoly(2,2).ae(2)
|
|
assert eulerpoly(3,-1).ae('-9/4')
|
|
assert eulerpoly(3,0).ae('1/4')
|
|
assert eulerpoly(3,'1/2').ae(0)
|
|
assert eulerpoly(3,'3/4').ae('-11/64')
|
|
assert eulerpoly(3,1).ae('-1/4')
|
|
assert eulerpoly(3,2).ae('9/4')
|
|
assert eulerpoly(4,-1).ae(2)
|
|
assert eulerpoly(4,0).ae(0)
|
|
assert eulerpoly(4,'1/2').ae('5/16')
|
|
assert eulerpoly(4,'3/4').ae('57/256')
|
|
assert eulerpoly(4,1).ae(0)
|
|
assert eulerpoly(4,2).ae(2)
|
|
assert eulerpoly(5,-1).ae('-3/2')
|
|
assert eulerpoly(5,0).ae('-1/2')
|
|
assert eulerpoly(5,'1/2').ae(0)
|
|
assert eulerpoly(5,'3/4').ae('361/1024')
|
|
assert eulerpoly(5,1).ae('1/2')
|
|
assert eulerpoly(5,2).ae('3/2')
|
|
assert eulerpoly(10,-1).ae(2)
|
|
assert eulerpoly(10,0).ae(0)
|
|
assert eulerpoly(10,'1/2').ae('-50521/1024')
|
|
assert eulerpoly(10,'3/4').ae('-36581523/1048576')
|
|
assert eulerpoly(10,1).ae(0)
|
|
assert eulerpoly(10,2).ae(2)
|
|
assert eulerpoly(11,-1).ae('-699/4')
|
|
assert eulerpoly(11,0).ae('691/4')
|
|
assert eulerpoly(11,'1/2').ae(0)
|
|
assert eulerpoly(11,'3/4').ae('-512343611/4194304')
|
|
assert eulerpoly(11,1).ae('-691/4')
|
|
assert eulerpoly(11,2).ae('699/4')
|
|
# Potential accuracy issues
|
|
assert bernpoly(10000,10000).ae('5.8196915936323387117e+39999')
|
|
assert bernpoly(200,17.5).ae(3.8048418524583064909e244)
|
|
assert eulerpoly(200,17.5).ae(-3.7309911582655785929e275)
|
|
|
|
def test_gamma():
|
|
mp.dps = 15
|
|
assert gamma(0.25).ae(3.6256099082219083119)
|
|
assert gamma(0.0001).ae(9999.4228832316241908)
|
|
assert gamma(300).ae('1.0201917073881354535e612')
|
|
assert gamma(-0.5).ae(-3.5449077018110320546)
|
|
assert gamma(-7.43).ae(0.00026524416464197007186)
|
|
#assert gamma(Rational(1,2)) == gamma(0.5)
|
|
#assert gamma(Rational(-7,3)).ae(gamma(mpf(-7)/3))
|
|
assert gamma(1+1j).ae(0.49801566811835604271 - 0.15494982830181068512j)
|
|
assert gamma(-1+0.01j).ae(-0.422733904013474115 + 99.985883082635367436j)
|
|
assert gamma(20+30j).ae(-1453876687.5534810 + 1163777777.8031573j)
|
|
# Should always give exact factorials when they can
|
|
# be represented as mpfs under the current working precision
|
|
fact = 1
|
|
for i in range(1, 18):
|
|
assert gamma(i) == fact
|
|
fact *= i
|
|
for dps in [170, 600]:
|
|
fact = 1
|
|
mp.dps = dps
|
|
for i in range(1, 105):
|
|
assert gamma(i) == fact
|
|
fact *= i
|
|
mp.dps = 100
|
|
assert gamma(0.5).ae(sqrt(pi))
|
|
mp.dps = 15
|
|
assert factorial(0) == fac(0) == 1
|
|
assert factorial(3) == 6
|
|
assert isnan(gamma(nan))
|
|
assert gamma(1100).ae('4.8579168073569433667e2866')
|
|
assert rgamma(0) == 0
|
|
assert rgamma(-1) == 0
|
|
assert rgamma(2) == 1.0
|
|
assert rgamma(3) == 0.5
|
|
assert loggamma(2+8j).ae(-8.5205176753667636926 + 10.8569497125597429366j)
|
|
assert loggamma('1e10000').ae('2.302485092994045684017991e10004')
|
|
assert loggamma('1e10000j').ae(mpc('-1.570796326794896619231322e10000','2.302485092994045684017991e10004'))
|
|
|
|
def test_fac2():
|
|
mp.dps = 15
|
|
assert [fac2(n) for n in range(10)] == [1,1,2,3,8,15,48,105,384,945]
|
|
assert fac2(-5).ae(1./3)
|
|
assert fac2(-11).ae(-1./945)
|
|
assert fac2(50).ae(5.20469842636666623e32)
|
|
assert fac2(0.5+0.75j).ae(0.81546769394688069176-0.34901016085573266889j)
|
|
assert fac2(inf) == inf
|
|
assert isnan(fac2(-inf))
|
|
|
|
def test_gamma_quotients():
|
|
mp.dps = 15
|
|
h = 1e-8
|
|
ep = 1e-4
|
|
G = gamma
|
|
assert gammaprod([-1],[-3,-4]) == 0
|
|
assert gammaprod([-1,0],[-5]) == inf
|
|
assert abs(gammaprod([-1],[-2]) - G(-1+h)/G(-2+h)) < 1e-4
|
|
assert abs(gammaprod([-4,-3],[-2,0]) - G(-4+h)*G(-3+h)/G(-2+h)/G(0+h)) < 1e-4
|
|
assert rf(3,0) == 1
|
|
assert rf(2.5,1) == 2.5
|
|
assert rf(-5,2) == 20
|
|
assert rf(j,j).ae(gamma(2*j)/gamma(j))
|
|
assert rf('-255.5815971722918','-0.5119253100282322').ae('-0.1952720278805729485') # issue 421
|
|
assert ff(-2,0) == 1
|
|
assert ff(-2,1) == -2
|
|
assert ff(4,3) == 24
|
|
assert ff(3,4) == 0
|
|
assert binomial(0,0) == 1
|
|
assert binomial(1,0) == 1
|
|
assert binomial(0,-1) == 0
|
|
assert binomial(3,2) == 3
|
|
assert binomial(5,2) == 10
|
|
assert binomial(5,3) == 10
|
|
assert binomial(5,5) == 1
|
|
assert binomial(-1,0) == 1
|
|
assert binomial(-2,-4) == 3
|
|
assert binomial(4.5, 1.5) == 6.5625
|
|
assert binomial(1100,1) == 1100
|
|
assert binomial(1100,2) == 604450
|
|
assert beta(1,1) == 1
|
|
assert beta(0,0) == inf
|
|
assert beta(3,0) == inf
|
|
assert beta(-1,-1) == inf
|
|
assert beta(1.5,1).ae(2/3.)
|
|
assert beta(1.5,2.5).ae(pi/16)
|
|
assert (10**15*beta(10,100)).ae(2.3455339739604649879)
|
|
assert beta(inf,inf) == 0
|
|
assert isnan(beta(-inf,inf))
|
|
assert isnan(beta(-3,inf))
|
|
assert isnan(beta(0,inf))
|
|
assert beta(inf,0.5) == beta(0.5,inf) == 0
|
|
assert beta(inf,-1.5) == inf
|
|
assert beta(inf,-0.5) == -inf
|
|
assert beta(1+2j,-1-j/2).ae(1.16396542451069943086+0.08511695947832914640j)
|
|
assert beta(-0.5,0.5) == 0
|
|
assert beta(-3,3).ae(-1/3.)
|
|
assert beta('-255.5815971722918','-0.5119253100282322').ae('18.157330562703710339') # issue 421
|
|
|
|
def test_zeta():
|
|
mp.dps = 15
|
|
assert zeta(2).ae(pi**2 / 6)
|
|
assert zeta(2.0).ae(pi**2 / 6)
|
|
assert zeta(mpc(2)).ae(pi**2 / 6)
|
|
assert zeta(100).ae(1)
|
|
assert zeta(0).ae(-0.5)
|
|
assert zeta(0.5).ae(-1.46035450880958681)
|
|
assert zeta(-1).ae(-mpf(1)/12)
|
|
assert zeta(-2) == 0
|
|
assert zeta(-3).ae(mpf(1)/120)
|
|
assert zeta(-4) == 0
|
|
assert zeta(-100) == 0
|
|
assert isnan(zeta(nan))
|
|
assert zeta(1e-30).ae(-0.5)
|
|
assert zeta(-1e-30).ae(-0.5)
|
|
# Zeros in the critical strip
|
|
assert zeta(mpc(0.5, 14.1347251417346937904)).ae(0)
|
|
assert zeta(mpc(0.5, 21.0220396387715549926)).ae(0)
|
|
assert zeta(mpc(0.5, 25.0108575801456887632)).ae(0)
|
|
assert zeta(mpc(1e-30,1e-40)).ae(-0.5)
|
|
assert zeta(mpc(-1e-30,1e-40)).ae(-0.5)
|
|
mp.dps = 50
|
|
im = '236.5242296658162058024755079556629786895294952121891237'
|
|
assert zeta(mpc(0.5, im)).ae(0, 1e-46)
|
|
mp.dps = 15
|
|
# Complex reflection formula
|
|
assert (zeta(-60+3j) / 10**34).ae(8.6270183987866146+15.337398548226238j)
|
|
# issue #358
|
|
assert zeta(0,0.5) == 0
|
|
assert zeta(0,0) == 0.5
|
|
assert zeta(0,0.5,1).ae(-0.34657359027997265)
|
|
# see issue #390
|
|
assert zeta(-1.5,0.5j).ae(-0.13671400162512768475 + 0.11411333638426559139j)
|
|
|
|
def test_altzeta():
|
|
mp.dps = 15
|
|
assert altzeta(-2) == 0
|
|
assert altzeta(-4) == 0
|
|
assert altzeta(-100) == 0
|
|
assert altzeta(0) == 0.5
|
|
assert altzeta(-1) == 0.25
|
|
assert altzeta(-3) == -0.125
|
|
assert altzeta(-5) == 0.25
|
|
assert altzeta(-21) == 1180529130.25
|
|
assert altzeta(1).ae(log(2))
|
|
assert altzeta(2).ae(pi**2/12)
|
|
assert altzeta(10).ae(73*pi**10/6842880)
|
|
assert altzeta(50) < 1
|
|
assert altzeta(60, rounding='d') < 1
|
|
assert altzeta(60, rounding='u') == 1
|
|
assert altzeta(10000, rounding='d') < 1
|
|
assert altzeta(10000, rounding='u') == 1
|
|
assert altzeta(3+0j) == altzeta(3)
|
|
s = 3+4j
|
|
assert altzeta(s).ae((1-2**(1-s))*zeta(s))
|
|
s = -3+4j
|
|
assert altzeta(s).ae((1-2**(1-s))*zeta(s))
|
|
assert altzeta(-100.5).ae(4.58595480083585913e+108)
|
|
assert altzeta(1.3).ae(0.73821404216623045)
|
|
assert altzeta(1e-30).ae(0.5)
|
|
assert altzeta(-1e-30).ae(0.5)
|
|
assert altzeta(mpc(1e-30,1e-40)).ae(0.5)
|
|
assert altzeta(mpc(-1e-30,1e-40)).ae(0.5)
|
|
|
|
def test_zeta_huge():
|
|
mp.dps = 15
|
|
assert zeta(inf) == 1
|
|
mp.dps = 50
|
|
assert zeta(100).ae('1.0000000000000000000000000000007888609052210118073522')
|
|
assert zeta(40*pi).ae('1.0000000000000000000000000000000000000148407238666182')
|
|
mp.dps = 10000
|
|
v = zeta(33000)
|
|
mp.dps = 15
|
|
assert str(v-1) == '1.02363019598118e-9934'
|
|
assert zeta(pi*1000, rounding=round_up) > 1
|
|
assert zeta(3000, rounding=round_up) > 1
|
|
assert zeta(pi*1000) == 1
|
|
assert zeta(3000) == 1
|
|
|
|
def test_zeta_negative():
|
|
mp.dps = 150
|
|
a = -pi*10**40
|
|
mp.dps = 15
|
|
assert str(zeta(a)) == '2.55880492708712e+1233536161668617575553892558646631323374078'
|
|
mp.dps = 50
|
|
assert str(zeta(a)) == '2.5588049270871154960875033337384432038436330847333e+1233536161668617575553892558646631323374078'
|
|
mp.dps = 15
|
|
|
|
def test_polygamma():
|
|
mp.dps = 15
|
|
psi0 = lambda z: psi(0,z)
|
|
psi1 = lambda z: psi(1,z)
|
|
assert psi0(3) == psi(0,3) == digamma(3)
|
|
#assert psi2(3) == psi(2,3) == tetragamma(3)
|
|
#assert psi3(3) == psi(3,3) == pentagamma(3)
|
|
assert psi0(pi).ae(0.97721330794200673)
|
|
assert psi0(-pi).ae(7.8859523853854902)
|
|
assert psi0(-pi+1).ae(7.5676424992016996)
|
|
assert psi0(pi+j).ae(1.04224048313859376 + 0.35853686544063749j)
|
|
assert psi0(-pi-j).ae(1.3404026194821986 - 2.8824392476809402j)
|
|
assert findroot(psi0, 1).ae(1.4616321449683622)
|
|
assert psi0(1e-10).ae(-10000000000.57722)
|
|
assert psi0(1e-40).ae(-1.000000000000000e+40)
|
|
assert psi0(1e-10+1e-10j).ae(-5000000000.577215 + 5000000000.000000j)
|
|
assert psi0(1e-40+1e-40j).ae(-5.000000000000000e+39 + 5.000000000000000e+39j)
|
|
assert psi0(inf) == inf
|
|
assert psi1(inf) == 0
|
|
assert psi(2,inf) == 0
|
|
assert psi1(pi).ae(0.37424376965420049)
|
|
assert psi1(-pi).ae(53.030438740085385)
|
|
assert psi1(pi+j).ae(0.32935710377142464 - 0.12222163911221135j)
|
|
assert psi1(-pi-j).ae(-0.30065008356019703 + 0.01149892486928227j)
|
|
assert (10**6*psi(4,1+10*pi*j)).ae(-6.1491803479004446 - 0.3921316371664063j)
|
|
assert psi0(1+10*pi*j).ae(3.4473994217222650 + 1.5548808324857071j)
|
|
assert isnan(psi0(nan))
|
|
assert isnan(psi0(-inf))
|
|
assert psi0(-100.5).ae(4.615124601338064)
|
|
assert psi0(3+0j).ae(psi0(3))
|
|
assert psi0(-100+3j).ae(4.6106071768714086321+3.1117510556817394626j)
|
|
assert isnan(psi(2,mpc(0,inf)))
|
|
assert isnan(psi(2,mpc(0,nan)))
|
|
assert isnan(psi(2,mpc(0,-inf)))
|
|
assert isnan(psi(2,mpc(1,inf)))
|
|
assert isnan(psi(2,mpc(1,nan)))
|
|
assert isnan(psi(2,mpc(1,-inf)))
|
|
assert isnan(psi(2,mpc(inf,inf)))
|
|
assert isnan(psi(2,mpc(nan,nan)))
|
|
assert isnan(psi(2,mpc(-inf,-inf)))
|
|
mp.dps = 30
|
|
# issue #534
|
|
assert digamma(-0.75+1j).ae(mpc('0.46317279488182026118963809283042317', '2.4821070143037957102007677817351115'))
|
|
mp.dps = 15
|
|
|
|
def test_polygamma_high_prec():
|
|
mp.dps = 100
|
|
assert str(psi(0,pi)) == "0.9772133079420067332920694864061823436408346099943256380095232865318105924777141317302075654362928734"
|
|
assert str(psi(10,pi)) == "-12.98876181434889529310283769414222588307175962213707170773803550518307617769657562747174101900659238"
|
|
|
|
def test_polygamma_identities():
|
|
mp.dps = 15
|
|
psi0 = lambda z: psi(0,z)
|
|
psi1 = lambda z: psi(1,z)
|
|
psi2 = lambda z: psi(2,z)
|
|
assert psi0(0.5).ae(-euler-2*log(2))
|
|
assert psi0(1).ae(-euler)
|
|
assert psi1(0.5).ae(0.5*pi**2)
|
|
assert psi1(1).ae(pi**2/6)
|
|
assert psi1(0.25).ae(pi**2 + 8*catalan)
|
|
assert psi2(1).ae(-2*apery)
|
|
mp.dps = 20
|
|
u = -182*apery+4*sqrt(3)*pi**3
|
|
mp.dps = 15
|
|
assert psi(2,5/6.).ae(u)
|
|
assert psi(3,0.5).ae(pi**4)
|
|
|
|
def test_foxtrot_identity():
|
|
# A test of the complex digamma function.
|
|
# See http://mathworld.wolfram.com/FoxTrotSeries.html and
|
|
# http://mathworld.wolfram.com/DigammaFunction.html
|
|
psi0 = lambda z: psi(0,z)
|
|
mp.dps = 50
|
|
a = (-1)**fraction(1,3)
|
|
b = (-1)**fraction(2,3)
|
|
x = -psi0(0.5*a) - psi0(-0.5*b) + psi0(0.5*(1+a)) + psi0(0.5*(1-b))
|
|
y = 2*pi*sech(0.5*sqrt(3)*pi)
|
|
assert x.ae(y)
|
|
mp.dps = 15
|
|
|
|
def test_polygamma_high_order():
|
|
mp.dps = 100
|
|
assert str(psi(50, pi)) == "-1344100348958402765749252447726432491812.641985273160531055707095989227897753035823152397679626136483"
|
|
assert str(psi(50, pi + 14*e)) == "-0.00000000000000000189793739550804321623512073101895801993019919886375952881053090844591920308111549337295143780341396"
|
|
assert str(psi(50, pi + 14*e*j)) == ("(-0.0000000000000000522516941152169248975225472155683565752375889510631513244785"
|
|
"9377385233700094871256507814151956624433 - 0.00000000000000001813157041407010184"
|
|
"702414110218205348527862196327980417757665282244728963891298080199341480881811613j)")
|
|
mp.dps = 15
|
|
assert str(psi(50, pi)) == "-1.34410034895841e+39"
|
|
assert str(psi(50, pi + 14*e)) == "-1.89793739550804e-18"
|
|
assert str(psi(50, pi + 14*e*j)) == "(-5.2251694115217e-17 - 1.81315704140701e-17j)"
|
|
|
|
def test_harmonic():
|
|
mp.dps = 15
|
|
assert harmonic(0) == 0
|
|
assert harmonic(1) == 1
|
|
assert harmonic(2) == 1.5
|
|
assert harmonic(3).ae(1. + 1./2 + 1./3)
|
|
assert harmonic(10**10).ae(23.603066594891989701)
|
|
assert harmonic(10**1000).ae(2303.162308658947)
|
|
assert harmonic(0.5).ae(2-2*log(2))
|
|
assert harmonic(inf) == inf
|
|
assert harmonic(2+0j) == 1.5+0j
|
|
assert harmonic(1+2j).ae(1.4918071802755104+0.92080728264223022j)
|
|
|
|
def test_gamma_huge_1():
|
|
mp.dps = 500
|
|
x = mpf(10**10) / 7
|
|
mp.dps = 15
|
|
assert str(gamma(x)) == "6.26075321389519e+12458010678"
|
|
mp.dps = 50
|
|
assert str(gamma(x)) == "6.2607532138951929201303779291707455874010420783933e+12458010678"
|
|
mp.dps = 15
|
|
|
|
def test_gamma_huge_2():
|
|
mp.dps = 500
|
|
x = mpf(10**100) / 19
|
|
mp.dps = 15
|
|
assert str(gamma(x)) == (\
|
|
"1.82341134776679e+5172997469323364168990133558175077136829182824042201886051511"
|
|
"9656908623426021308685461258226190190661")
|
|
mp.dps = 50
|
|
assert str(gamma(x)) == (\
|
|
"1.82341134776678875374414910350027596939980412984e+5172997469323364168990133558"
|
|
"1750771368291828240422018860515119656908623426021308685461258226190190661")
|
|
|
|
def test_gamma_huge_3():
|
|
mp.dps = 500
|
|
x = 10**80 // 3 + 10**70*j / 7
|
|
mp.dps = 15
|
|
y = gamma(x)
|
|
assert str(y.real) == (\
|
|
"-6.82925203918106e+2636286142112569524501781477865238132302397236429627932441916"
|
|
"056964386399485392600")
|
|
assert str(y.imag) == (\
|
|
"8.54647143678418e+26362861421125695245017814778652381323023972364296279324419160"
|
|
"56964386399485392600")
|
|
mp.dps = 50
|
|
y = gamma(x)
|
|
assert str(y.real) == (\
|
|
"-6.8292520391810548460682736226799637356016538421817e+26362861421125695245017814"
|
|
"77865238132302397236429627932441916056964386399485392600")
|
|
assert str(y.imag) == (\
|
|
"8.5464714367841748507479306948130687511711420234015e+263628614211256952450178147"
|
|
"7865238132302397236429627932441916056964386399485392600")
|
|
|
|
def test_gamma_huge_4():
|
|
x = 3200+11500j
|
|
mp.dps = 15
|
|
assert str(gamma(x)) == \
|
|
"(8.95783268539713e+5164 - 1.94678798329735e+5164j)"
|
|
mp.dps = 50
|
|
assert str(gamma(x)) == (\
|
|
"(8.9578326853971339570292952697675570822206567327092e+5164"
|
|
" - 1.9467879832973509568895402139429643650329524144794e+51"
|
|
"64j)")
|
|
mp.dps = 15
|
|
|
|
def test_gamma_huge_5():
|
|
mp.dps = 500
|
|
x = 10**60 * j / 3
|
|
mp.dps = 15
|
|
y = gamma(x)
|
|
assert str(y.real) == "-3.27753899634941e-227396058973640224580963937571892628368354580620654233316839"
|
|
assert str(y.imag) == "-7.1519888950416e-227396058973640224580963937571892628368354580620654233316841"
|
|
mp.dps = 50
|
|
y = gamma(x)
|
|
assert str(y.real) == (\
|
|
"-3.2775389963494132168950056995974690946983219123935e-22739605897364022458096393"
|
|
"7571892628368354580620654233316839")
|
|
assert str(y.imag) == (\
|
|
"-7.1519888950415979749736749222530209713136588885897e-22739605897364022458096393"
|
|
"7571892628368354580620654233316841")
|
|
mp.dps = 15
|
|
|
|
def test_gamma_huge_7():
|
|
mp.dps = 100
|
|
a = 3 + j/mpf(10)**1000
|
|
mp.dps = 15
|
|
y = gamma(a)
|
|
assert str(y.real) == "2.0"
|
|
# wrong
|
|
#assert str(y.imag) == "2.16735365342606e-1000"
|
|
assert str(y.imag) == "1.84556867019693e-1000"
|
|
mp.dps = 50
|
|
y = gamma(a)
|
|
assert str(y.real) == "2.0"
|
|
#assert str(y.imag) == "2.1673536534260596065418805612488708028522563689298e-1000"
|
|
assert str(y.imag) == "1.8455686701969342787869758198351951379156813281202e-1000"
|
|
|
|
def test_stieltjes():
|
|
mp.dps = 15
|
|
assert stieltjes(0).ae(+euler)
|
|
mp.dps = 25
|
|
assert stieltjes(1).ae('-0.07281584548367672486058637587')
|
|
assert stieltjes(2).ae('-0.009690363192872318484530386035')
|
|
assert stieltjes(3).ae('0.002053834420303345866160046543')
|
|
assert stieltjes(4).ae('0.002325370065467300057468170178')
|
|
mp.dps = 15
|
|
assert stieltjes(1).ae(-0.07281584548367672486058637587)
|
|
assert stieltjes(2).ae(-0.009690363192872318484530386035)
|
|
assert stieltjes(3).ae(0.002053834420303345866160046543)
|
|
assert stieltjes(4).ae(0.0023253700654673000574681701775)
|
|
|
|
def test_barnesg():
|
|
mp.dps = 15
|
|
assert barnesg(0) == barnesg(-1) == 0
|
|
assert [superfac(i) for i in range(8)] == [1, 1, 2, 12, 288, 34560, 24883200, 125411328000]
|
|
assert str(superfac(1000)) == '3.24570818422368e+1177245'
|
|
assert isnan(barnesg(nan))
|
|
assert isnan(superfac(nan))
|
|
assert isnan(hyperfac(nan))
|
|
assert barnesg(inf) == inf
|
|
assert superfac(inf) == inf
|
|
assert hyperfac(inf) == inf
|
|
assert isnan(superfac(-inf))
|
|
assert barnesg(0.7).ae(0.8068722730141471)
|
|
assert barnesg(2+3j).ae(-0.17810213864082169+0.04504542715447838j)
|
|
assert [hyperfac(n) for n in range(7)] == [1, 1, 4, 108, 27648, 86400000, 4031078400000]
|
|
assert [hyperfac(n) for n in range(0,-7,-1)] == [1,1,-1,-4,108,27648,-86400000]
|
|
a = barnesg(-3+0j)
|
|
assert a == 0 and isinstance(a, mpc)
|
|
a = hyperfac(-3+0j)
|
|
assert a == -4 and isinstance(a, mpc)
|
|
|
|
def test_polylog():
|
|
mp.dps = 15
|
|
zs = [mpmathify(z) for z in [0, 0.5, 0.99, 4, -0.5, -4, 1j, 3+4j]]
|
|
for z in zs: assert polylog(1, z).ae(-log(1-z))
|
|
for z in zs: assert polylog(0, z).ae(z/(1-z))
|
|
for z in zs: assert polylog(-1, z).ae(z/(1-z)**2)
|
|
for z in zs: assert polylog(-2, z).ae(z*(1+z)/(1-z)**3)
|
|
for z in zs: assert polylog(-3, z).ae(z*(1+4*z+z**2)/(1-z)**4)
|
|
assert polylog(3, 7).ae(5.3192579921456754382-5.9479244480803301023j)
|
|
assert polylog(3, -7).ae(-4.5693548977219423182)
|
|
assert polylog(2, 0.9).ae(1.2997147230049587252)
|
|
assert polylog(2, -0.9).ae(-0.75216317921726162037)
|
|
assert polylog(2, 0.9j).ae(-0.17177943786580149299+0.83598828572550503226j)
|
|
assert polylog(2, 1.1).ae(1.9619991013055685931-0.2994257606855892575j)
|
|
assert polylog(2, -1.1).ae(-0.89083809026228260587)
|
|
assert polylog(2, 1.1*sqrt(j)).ae(0.58841571107611387722+1.09962542118827026011j)
|
|
assert polylog(-2, 0.9).ae(1710)
|
|
assert polylog(-2, -0.9).ae(-90/6859.)
|
|
assert polylog(3, 0.9).ae(1.0496589501864398696)
|
|
assert polylog(-3, 0.9).ae(48690)
|
|
assert polylog(-3, -4).ae(-0.0064)
|
|
assert polylog(0.5+j/3, 0.5+j/2).ae(0.31739144796565650535 + 0.99255390416556261437j)
|
|
assert polylog(3+4j,1).ae(zeta(3+4j))
|
|
assert polylog(3+4j,-1).ae(-altzeta(3+4j))
|
|
# issue 390
|
|
assert polylog(1.5, -48.910886523731889).ae(-6.272992229311817)
|
|
assert polylog(1.5, 200).ae(-8.349608319033686529 - 8.159694826434266042j)
|
|
assert polylog(-2+0j, -2).ae(mpf(1)/13.5)
|
|
assert polylog(-2+0j, 1.25).ae(-180)
|
|
|
|
def test_bell_polyexp():
|
|
mp.dps = 15
|
|
# TODO: more tests for polyexp
|
|
assert (polyexp(0,1e-10)*10**10).ae(1.00000000005)
|
|
assert (polyexp(1,1e-10)*10**10).ae(1.0000000001)
|
|
assert polyexp(5,3j).ae(-607.7044517476176454+519.962786482001476087j)
|
|
assert polyexp(-1,3.5).ae(12.09537536175543444)
|
|
# bell(0,x) = 1
|
|
assert bell(0,0) == 1
|
|
assert bell(0,1) == 1
|
|
assert bell(0,2) == 1
|
|
assert bell(0,inf) == 1
|
|
assert bell(0,-inf) == 1
|
|
assert isnan(bell(0,nan))
|
|
# bell(1,x) = x
|
|
assert bell(1,4) == 4
|
|
assert bell(1,0) == 0
|
|
assert bell(1,inf) == inf
|
|
assert bell(1,-inf) == -inf
|
|
assert isnan(bell(1,nan))
|
|
# bell(2,x) = x*(1+x)
|
|
assert bell(2,-1) == 0
|
|
assert bell(2,0) == 0
|
|
# large orders / arguments
|
|
assert bell(10) == 115975
|
|
assert bell(10,1) == 115975
|
|
assert bell(10, -8) == 11054008
|
|
assert bell(5,-50) == -253087550
|
|
assert bell(50,-50).ae('3.4746902914629720259e74')
|
|
mp.dps = 80
|
|
assert bell(50,-50) == 347469029146297202586097646631767227177164818163463279814268368579055777450
|
|
assert bell(40,50) == 5575520134721105844739265207408344706846955281965031698187656176321717550
|
|
assert bell(74) == 5006908024247925379707076470957722220463116781409659160159536981161298714301202
|
|
mp.dps = 15
|
|
assert bell(10,20j) == 7504528595600+15649605360020j
|
|
# continuity of the generalization
|
|
assert bell(0.5,0).ae(sinc(pi*0.5))
|
|
|
|
def test_primezeta():
|
|
mp.dps = 15
|
|
assert primezeta(0.9).ae(1.8388316154446882243 + 3.1415926535897932385j)
|
|
assert primezeta(4).ae(0.076993139764246844943)
|
|
assert primezeta(1) == inf
|
|
assert primezeta(inf) == 0
|
|
assert isnan(primezeta(nan))
|
|
|
|
def test_rs_zeta():
|
|
mp.dps = 15
|
|
assert zeta(0.5+100000j).ae(1.0730320148577531321 + 5.7808485443635039843j)
|
|
assert zeta(0.75+100000j).ae(1.837852337251873704 + 1.9988492668661145358j)
|
|
assert zeta(0.5+1000000j, derivative=3).ae(1647.7744105852674733 - 1423.1270943036622097j)
|
|
assert zeta(1+1000000j, derivative=3).ae(3.4085866124523582894 - 18.179184721525947301j)
|
|
assert zeta(1+1000000j, derivative=1).ae(-0.10423479366985452134 - 0.74728992803359056244j)
|
|
assert zeta(0.5-1000000j, derivative=1).ae(11.636804066002521459 + 17.127254072212996004j)
|
|
# Additional sanity tests using fp arithmetic.
|
|
# Some more high-precision tests are found in the docstrings
|
|
def ae(x, y, tol=1e-6):
|
|
return abs(x-y) < tol*abs(y)
|
|
assert ae(fp.zeta(0.5-100000j), 1.0730320148577531321 - 5.7808485443635039843j)
|
|
assert ae(fp.zeta(0.75-100000j), 1.837852337251873704 - 1.9988492668661145358j)
|
|
assert ae(fp.zeta(0.5+1e6j), 0.076089069738227100006 + 2.8051021010192989554j)
|
|
assert ae(fp.zeta(0.5+1e6j, derivative=1), 11.636804066002521459 - 17.127254072212996004j)
|
|
assert ae(fp.zeta(1+1e6j), 0.94738726251047891048 + 0.59421999312091832833j)
|
|
assert ae(fp.zeta(1+1e6j, derivative=1), -0.10423479366985452134 - 0.74728992803359056244j)
|
|
assert ae(fp.zeta(0.5+100000j, derivative=1), 10.766962036817482375 - 30.92705282105996714j)
|
|
assert ae(fp.zeta(0.5+100000j, derivative=2), -119.40515625740538429 + 217.14780631141830251j)
|
|
assert ae(fp.zeta(0.5+100000j, derivative=3), 1129.7550282628460881 - 1685.4736895169690346j)
|
|
assert ae(fp.zeta(0.5+100000j, derivative=4), -10407.160819314958615 + 13777.786698628045085j)
|
|
assert ae(fp.zeta(0.75+100000j, derivative=1), -0.41742276699594321475 - 6.4453816275049955949j)
|
|
assert ae(fp.zeta(0.75+100000j, derivative=2), -9.214314279161977266 + 35.07290795337967899j)
|
|
assert ae(fp.zeta(0.75+100000j, derivative=3), 110.61331857820103469 - 236.87847130518129926j)
|
|
assert ae(fp.zeta(0.75+100000j, derivative=4), -1054.334275898559401 + 1769.9177890161596383j)
|
|
|
|
def test_siegelz():
|
|
mp.dps = 15
|
|
assert siegelz(100000).ae(5.87959246868176504171)
|
|
assert siegelz(100000, derivative=2).ae(-54.1172711010126452832)
|
|
assert siegelz(100000, derivative=3).ae(-278.930831343966552538)
|
|
assert siegelz(100000+j,derivative=1).ae(678.214511857070283307-379.742160779916375413j)
|
|
|
|
|
|
|
|
def test_zeta_near_1():
|
|
# Test for a former bug in mpf_zeta and mpc_zeta
|
|
mp.dps = 15
|
|
s1 = fadd(1, '1e-10', exact=True)
|
|
s2 = fadd(1, '-1e-10', exact=True)
|
|
s3 = fadd(1, '1e-10j', exact=True)
|
|
assert zeta(s1).ae(1.000000000057721566490881444e10)
|
|
assert zeta(s2).ae(-9.99999999942278433510574872e9)
|
|
z = zeta(s3)
|
|
assert z.real.ae(0.57721566490153286060)
|
|
assert z.imag.ae(-9.9999999999999999999927184e9)
|
|
mp.dps = 30
|
|
s1 = fadd(1, '1e-50', exact=True)
|
|
s2 = fadd(1, '-1e-50', exact=True)
|
|
s3 = fadd(1, '1e-50j', exact=True)
|
|
assert zeta(s1).ae('1e50')
|
|
assert zeta(s2).ae('-1e50')
|
|
z = zeta(s3)
|
|
assert z.real.ae('0.57721566490153286060651209008240243104215933593992')
|
|
assert z.imag.ae('-1e50')
|