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)]
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 _mp_j1c(x): """ Helper funciton for mp_j1c """ return mp.mpf(3) * (mp.sin(x) / x - mp.cos(x)) / (x * x)