def test_levin_2():
# [2] A. Sidi - "Pratical Extrapolation Methods" p.373
mp.dps = 17
z = mp.mpf(10)
eps = mp.mpf(mp.eps)
with mp.extraprec(2 * mp.prec):
L = mp.levin(method="sidi", variant="t")
n = 0
while 1:
s = (-1)**n * mp.fac(n) * z**(-n)
v, e = L.step(s)
n += 1
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(eps))
exact = mp.quad(lambda x: mp.exp(-x) / (1 + x / z), [0, mp.inf])
# there is also a symbolic expression for the integral:
# exact = z * mp.exp(z) * mp.expint(1,z)
err = abs(v - exact)
assert err < eps
w = mp.nsum(lambda n: (-1)**n * mp.fac(n) * z**(-n), [0, mp.inf],
method="sidi",
levin_variant="t")
assert err < eps
def test_gauss_quadrature_dynamic(verbose = False):
n = 5
A = mp.randmatrix(2 * n, 1)
def F(x):
r = 0
for i in xrange(len(A) - 1, -1, -1):
r = r * x + A[i]
return r
def run(qtype, FW, R, alpha = 0, beta = 0):
X, W = mp.gauss_quadrature(n, qtype, alpha = alpha, beta = beta)
a = 0
for i in xrange(len(X)):
a += W[i] * F(X[i])
b = mp.quad(lambda x: FW(x) * F(x), R)
c = mp.fabs(a - b)
if verbose:
print(qtype, c, a, b)
assert c < 1e-5
run("legendre", lambda x: 1, [-1, 1])
run("legendre01", lambda x: 1, [0, 1])
run("hermite", lambda x: mp.exp(-x*x), [-mp.inf, mp.inf])
run("laguerre", lambda x: mp.exp(-x), [0, mp.inf])
run("glaguerre", lambda x: mp.sqrt(x)*mp.exp(-x), [0, mp.inf], alpha = 1 / mp.mpf(2))
run("chebyshev1", lambda x: 1/mp.sqrt(1-x*x), [-1, 1])
run("chebyshev2", lambda x: mp.sqrt(1-x*x), [-1, 1])
run("jacobi", lambda x: (1-x)**(1/mp.mpf(3)) * (1+x)**(1/mp.mpf(5)), [-1, 1], alpha = 1 / mp.mpf(3), beta = 1 / mp.mpf(5) )
def test_levin_3():
mp.dps = 17
z = mp.mpf(2)
eps = mp.mpf(mp.eps)
with mp.extraprec(
7 * mp.prec
): # we need copious amount of precision to sum this highly divergent series
L = mp.levin(method="levin", variant="t")
n, s = 0, 0
while 1:
s += (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4**n))
n += 1
v, e = L.step_psum(s)
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.8 * mp.log(eps))
exact = mp.quad(lambda x: mp.exp(-x * x / 2 - z * x**4),
[0, mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
# there is also a symbolic expression for the integral:
# exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi))
err = abs(v - exact)
assert err < eps
w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) /
(mp.fac(n) * mp.fac(2 * n) * (4**n)), [0, mp.inf],
method="levin",
levin_variant="t",
workprec=8 * mp.prec,
steps=[2] + [1 for x in xrange(1000)])
err = abs(v - w)
assert err < eps
def __init__(self, npts):
# Form a suitable Legendre poly
Pn = sy.legendre_poly(npts - 1, x)
dPn = Pn.diff()
# Roots
roots = mp.polyroots(map(mp.mpf, sy.Poly(dPn).all_coeffs()))
self.points = [mp.mpf(-1)] + roots + [mp.mpf(1)]
# Weights
wts0 = mp.mpf(2)/(npts*(npts - 1))
wtsi = [2/(npts*(npts - 1)*Pn.evalf(mp.dps, subs={x: p})**2)
for p in self.points[1:-1]]
self.weights = [wts0] + wtsi + [wts0]
def lambdify_mpf(dims, exprs):
# Perform the initial lambdification
ls = [lambdastr(dims, ex.evalf(mp.dps)) for ex in exprs]
csf = {}
# Locate all numerical constants in these lambdified expressions
for l in ls:
for m in re.findall('([0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?)', l):
if m not in csf:
csf[m] = mp.mpf(m)
# Sort the keys by their length to prevent erroneous substitutions
cs = sorted(csf, key=len, reverse=True)
# Name these constants
csn = {s: '__c%d' % i for i, s in enumerate(cs)}
cnf = {n: csf[s] for s, n in csn.iteritems()}
# Substitute
lex = []
for l in ls:
for s in cs:
l = l.replace(s, csn[s])
lex.append(eval(l, cnf))
return lex
def test_levin_1():
mp.dps = 17
eps = mp.mpf(mp.eps)
with mp.extraprec(2 * mp.prec):
L = mp.levin(method = "levin", variant = "v")
A, n = [], 1
while 1:
s = mp.mpf(n) ** (2 + 3j)
n += 1
A.append(s)
v, e = L.update(A)
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(eps))
err = abs(v - mp.zeta(-2-3j))
assert err < eps
w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
err = abs(v - w)
assert err < eps
def test_gauss_quadrature_dynamic(verbose=False):
n = 5
A = mp.randmatrix(2 * n, 1)
def F(x):
r = 0
for i in xrange(len(A) - 1, -1, -1):
r = r * x + A[i]
return r
def run(qtype, FW, R, alpha=0, beta=0):
X, W = mp.gauss_quadrature(n, qtype, alpha=alpha, beta=beta)
a = 0
for i in xrange(len(X)):
a += W[i] * F(X[i])
b = mp.quad(lambda x: FW(x) * F(x), R)
c = mp.fabs(a - b)
if verbose:
print(qtype, c, a, b)
assert c < 1e-5
run("legendre", lambda x: 1, [-1, 1])
run("legendre01", lambda x: 1, [0, 1])
run("hermite", lambda x: mp.exp(-x * x), [-mp.inf, mp.inf])
run("laguerre", lambda x: mp.exp(-x), [0, mp.inf])
run("glaguerre",
lambda x: mp.sqrt(x) * mp.exp(-x), [0, mp.inf],
alpha=1 / mp.mpf(2))
run("chebyshev1", lambda x: 1 / mp.sqrt(1 - x * x), [-1, 1])
run("chebyshev2", lambda x: mp.sqrt(1 - x * x), [-1, 1])
run("jacobi",
lambda x: (1 - x)**(1 / mp.mpf(3)) * (1 + x)**(1 / mp.mpf(5)), [-1, 1],
alpha=1 / mp.mpf(3),
beta=1 / mp.mpf(5))
def test_levin_1():
mp.dps = 17
eps = mp.mpf(mp.eps)
with mp.extraprec(2 * mp.prec):
L = mp.levin(method="levin", variant="v")
A, n = [], 1
while 1:
s = mp.mpf(n)**(2 + 3j)
n += 1
A.append(s)
v, e = L.update(A)
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(eps))
err = abs(v - mp.zeta(-2 - 3j))
assert err < eps
w = mp.nsum(lambda n: n**(2 + 3j), [1, mp.inf],
method="levin",
levin_variant="v")
err = abs(v - w)
assert err < eps
def test_levin_2():
# [2] A. Sidi - "Pratical Extrapolation Methods" p.373
mp.dps = 17
z=mp.mpf(10)
eps = mp.mpf(mp.eps)
with mp.extraprec(2 * mp.prec):
L = mp.levin(method = "sidi", variant = "t")
n = 0
while 1:
s = (-1)**n * mp.fac(n) * z ** (-n)
v, e = L.step(s)
n += 1
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(eps))
exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
# there is also a symbolic expression for the integral:
# exact = z * mp.exp(z) * mp.expint(1,z)
err = abs(v - exact)
assert err < eps
w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
assert err < eps
def test_levin_3():
mp.dps = 17
z=mp.mpf(2)
eps = mp.mpf(mp.eps)
with mp.extraprec(7*mp.prec): # we need copious amount of precision to sum this highly divergent series
L = mp.levin(method = "levin", variant = "t")
n, s = 0, 0
while 1:
s += (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n))
n += 1
v, e = L.step_psum(s)
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.8 * mp.log(eps))
exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
# there is also a symbolic expression for the integral:
# exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi))
err = abs(v - exact)
assert err < eps
w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)), [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
err = abs(v - w)
assert err < eps
def test_levin_0():
mp.dps = 17
eps = mp.mpf(mp.eps)
with mp.extraprec(2 * mp.prec):
L = mp.levin(method = "levin", variant = "u")
S, s, n = [], 0, 1
while 1:
s += mp.one / (n * n)
n += 1
S.append(s)
v, e = L.update_psum(S)
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(eps))
err = abs(v - mp.pi ** 2 / 6)
assert err < eps
w = mp.nsum(lambda n: 1/(n * n), [1, mp.inf], method = "levin", levin_variant = "u")
err = abs(v - w)
assert err < eps
def test_levin_0():
mp.dps = 17
eps = mp.mpf(mp.eps)
with mp.extraprec(2 * mp.prec):
L = mp.levin(method="levin", variant="u")
S, s, n = [], 0, 1
while 1:
s += mp.one / (n * n)
n += 1
S.append(s)
v, e = L.update_psum(S)
if e < eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(eps))
err = abs(v - mp.pi**2 / 6)
assert err < eps
w = mp.nsum(lambda n: 1 / (n * n), [1, mp.inf],
method="levin",
levin_variant="u")
err = abs(v - w)
assert err < eps
def test_levin_nsum():
mp.dps = 17
with mp.extraprec(mp.prec):
z = mp.mpf(10)**(-10)
a = mp.nsum(lambda n: n**(-(1 + z)), [1, mp.inf], method="l") - 1 / z
assert abs(a - mp.euler) < 1e-10
eps = mp.exp(0.8 * mp.log(mp.eps))
a = mp.nsum(lambda n: (-1)**(n - 1) / n, [1, mp.inf], method="sidi")
assert abs(a - mp.log(2)) < eps
z = 2 + 1j
f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (
mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
v = mp.nsum(f, [0, mp.inf],
method="levin",
steps=[10 for x in xrange(1000)])
exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
assert abs(exact - v) < eps
def test_levin_nsum():
mp.dps = 17
with mp.extraprec(mp.prec):
z = mp.mpf(10) ** (-10)
a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "l") - 1 / z
assert abs(a - mp.euler) < 1e-10
eps = mp.exp(0.8 * mp.log(mp.eps))
a = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "sidi")
assert abs(a - mp.log(2)) < eps
z = 2 + 1j
f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
assert abs(exact - v) < eps
def pdf_gauss_mp(x, sigma, mean):
return mp.mpf(1.) / mp.sqrt(mp.mpf("2.") * sigma ** 2 * mp.pi) * mp.exp(
- (x - mean) ** 2 / (mp.mpf("2.") * sigma ** 2))
def mp_j1c(vec):
"""
Direct calculation using sympy multiprecision library.
"""
return [_mp_j1c(mp.mpf(x)) for x in vec]
def _mp_j1c(x):
"""
Helper funciton for mp_j1c
"""
return mp.mpf(3)*(mp.sin(x)/x - mp.cos(x))/(x*x)
def pdf_gauss_mp(x, sigma, mean):
return mp.mpf(1.) / mp.sqrt(mp.mpf("2.") * sigma**2 * mp.pi) * mp.exp(
-(x - mean)**2 / (mp.mpf("2.") * sigma**2))
def distributions_mp(sigma, q):
mu0 = lambda y: pdf_gauss_mp(y, sigma=sigma, mean=mp.mpf(0))
mu1 = lambda y: pdf_gauss_mp(y, sigma=sigma, mean=mp.mpf(1))
mu = lambda y: (1 - q) * mu0(y) + q * mu1(y)
return mu0, mu1, mu
def mp_form(vec, bits=500):
"""
Direct calculation using sympy multiprecision library.
"""
with mp.workprec(bits):
return [_mp_f(mp.mpf(x)) for x in vec]
def __init__(self, npts):
# Only points
self.points = [mp.mpf(-1) + mp.mpf(2*i)/(npts - 1)
for i in xrange(npts)]
def mp_j1c(vec):
"""
Direct calculation using sympy multiprecision library.
"""
return [_mp_j1c(mp.mpf(x)) for x in vec]
matplotlib.rcParams.update(params)
#Here we get Python's pi calculation to 30 digits
try:
# import version included with old SymPy
from sympy.mpmath import mp
except ImportError:
# import newer version
from mpmath import mp
mp.dps = 60 # set number of digits
print(mp.pi) # print ground truth pi
#Compare to Gregory formula
n_iter = 100
pi_gregory = []
sum = mp.mpf(0.0)
for i in range(0, n_iter):
sum = sum + (-1)**i / (mp.mpf(2 * i) + 1.0)
pi_gregory.append(sum * 4.0)
pi_arctan = []
sum1 = mp.mpf(0.0)
sum2 = mp.mpf(0.0)
for i in range(0, n_iter):
sum1 = sum1 + (-1)**i / (mp.mpf(2.0)**(2 * i + 1) * (2 * i + 1.0))
sum2 = sum2 + (-1)**i / (mp.mpf(3.0)**(2 * i + 1) * (2 * i + 1.0))
pi_arctan.append((sum1 + sum2) * 4.0)
pi_machin = []
sum1 = mp.mpf(0.0)
sum2 = mp.mpf(0.0)
def distributions_mp(sigma, q): mu0 = lambda y: pdf_gauss_mp(y, sigma=sigma, mean=mp.mpf(0)) mu1 = lambda y: pdf_gauss_mp(y, sigma=sigma, mean=mp.mpf(1)) mu = lambda y: (1 - q) * mu0(y) + q * mu1(y) return mu0, mu1, mu
def _mp_j1c(x):
"""
Helper funciton for mp_j1c
"""
return mp.mpf(3) * (mp.sin(x) / x - mp.cos(x)) / (x * x)
def mp_form(vec, bits=500):
"""
Direct calculation using sympy multiprecision library.
"""
with mp.workprec(bits):
return [_mp_f(mp.mpf(x)) for x in vec]
