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 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
def estimate_pi(): """ uses the infinte series given by Ramanujan to estimate the value of pi """ s = 0.0 k = 0 while True: s = s + factorial(4 * k) * (1103 + 26390 * k) / (pow(factorial(k), 4) * pow(396, 4 * k)) pi = 9801 / (2 * s * math.sqrt(2)) if abs(pi - math.pi) < 1e-21: break k += 1 print("The value of pi is (using Ramanujan's series) = {}".format(mp.pi)) print("The value of pi is (using Gaussian integral) = {}".format( mp.quad(lambda x: mp.exp(-x**2), [-mp.inf, mp.inf])**2))
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
def two_body_reference(self, t1, num_1 = 0, num_2 = 1): """ reference notations are same as Yoel's notes using a precision of 64 digits for max accuracy """ mp.dps = 64 self.load_data() t1 = mp.mpf(t1) m_1 = mp.mpf(self.planet_lst[num_1].mass) m_2 = mp.mpf(self.planet_lst[num_2].mass) x1_0 = mp.matrix(self.planet_lst[num_1].loc) x2_0 = mp.matrix(self.planet_lst[num_2].loc) v1_0 = mp.matrix(self.planet_lst[num_1].v) v2_0 = mp.matrix(self.planet_lst[num_2].v) M = m_1 + m_2 x_cm = (1/M)*((m_1*x1_0)+(m_2*x2_0)) v_cm = (1/M)*((m_1*v1_0)+(m_2*v2_0)) u1_0 = v1_0 - v_cm w = x1_0 - x_cm r_0 = mp.norm(w) alpha = mp.acos((np.inner(u1_0,w))/(mp.norm(u1_0)*mp.norm(w))) K = mp.mpf(self.G) * (m_2**3)/(M**2) u1_0 = mp.norm(u1_0) L = r_0 * u1_0 * mp.sin(alpha) cosgamma = ((L**2)/(K*r_0)) - 1 singamma = -((L*u1_0*mp.cos(alpha))/K) gamma = mp.atan2(singamma, cosgamma) e = mp.sqrt(((r_0*(u1_0**2)*(mp.sin(alpha)**2)/K)-1)**2 + \ (((r_0**2)*(u1_0**4)*(mp.sin(alpha)**2)*(mp.cos(alpha)**2))/(K**2)) ) r_theta = lambda theta: (L**2)/(K*(1+(e*mp.cos(theta - gamma)))) f = lambda x: r_theta(x)**2/L curr_theta = 0 max_it = 30 it = 1 converged = 0 while ((it < max_it) & (converged != 1)): t_val = mp.quad(f,[0,curr_theta]) - t1 dt_val = f(curr_theta) delta = t_val/dt_val if (abs(delta)<1.0e-6): converged = 1 curr_theta -= delta it += 1 x1_new = mp.matrix([r_theta(curr_theta)*mp.cos(curr_theta), r_theta(curr_theta)*mp.sin(curr_theta)]) # x2_new = -(m_1/m_2)*(x1_new) +(x_cm + v_cm*t1) x1_new = x1_new + (x_cm + v_cm*t1) return x1_new
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_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 Ht_complex(z, t): #may work well only for small to medium values of z part = mp.quad(lambda u: Ht_complex_integrand(u, z, t), [0, 10]) return part
def integrate(f, limx, limy, limz, method): if method == "mp-gl": if limz != 0: return mp.quad(f, limx, limy, limz, method="gauss-legendre") else: if limy != 0: return mp.quad(f, limx, limy, method="gauss-legendre") else: return mp.quad(f, limx, method="gauss-legendre") elif method == "mp-ts": if limz != 0: return mp.quad(f, limx, limy, limz, method="tanh-sinh") else: if limy != 0: return mp.quad(f, limx, limy, method="tanh-sinh") else: return mp.quad(f, limx, method="tanh-sinh") elif method == "fp-gl": if limz != 0: return fp.quad(f, limx, limy, limz, method="gauss-legendre") else: if limy != 0: return fp.quad(f, limx, limy, method="gauss-legendre") else: return fp.quad(f, limx, method="gauss-legendre") elif method == "fp-ts": if limz != 0: return fp.quad(f, limx, limy, limz, method="tanh-sinh") else: if limy != 0: return fp.quad(f, limx, limy, method="tanh-sinh") else: return fp.quad(f, limx, method="tanh-sinh") elif method == "sp-quad": if limz != 0: return spint.tplquad(f, limz[0], limz[1], limy[0], limy[1], limx[0], limx[1])[0] else: if limy != 0: return spint.dblquad(f, limy[0], limy[1], limx[0], limx[1])[0] else: return spint.quad(f, limx[0], limx[1])[0] elif method == "romberg": if not np.ndim(limx) == 0: limx = [float(limx[0]), float(limx[1])] if not np.ndim(limy) == 0: limy = [float(limy[0]), float(limy[1])] if not np.ndim(limz) == 0: limz = [float(limz[0]), float(limz[1])] reltol = 1e-16 abstol = 1e-16 if limz != 0: return spint.romberg(lambda z: spint.romberg( lambda y: spint.romberg(lambda x: float(f(x, y, z)), limx[0], limx[1], tol=abstol, rtol=reltol), limy[0], limy[1], tol=abstol, rtol=reltol), limz[0], limz[1], tol=abstol, rtol=reltol) else: if limy != 0: return spint.romberg( lambda y: spint.romberg(lambda x: float(f(x, y)), limx[0], limy[1], tol=abstol, rtol=reltol), limy[0], limy[1], tol=abstol, rtol=reltol) else: return spint.romberg(lambda x: float(f(x)), limx[0], limx[1], tol=abstol, rtol=reltol) #currently broken, but slow so unused elif method == "sp-gauss": if not np.ndim(limx) == 0: limx = [float(limx[0]), float(limx[1])] if not np.ndim(limy) == 0: limy = [float(limy[0]), float(limy[1])] if not np.ndim(limz) == 0: limz = [float(limz[0]), float(limz[1])] order = 7 if limz != 0: return spint.fixed_quad( lambda z: spint.fixed_quad(lambda y: spint.fixed_quad( lambda x: f(x, y, z), limx[0], limx[1], n=order)[0], limy[0], limy[1], n=order)[0], limz[0], limz[1], n=order)[0] else: if limy != 0: return spint.fixed_quad(lambda y: spint.romberg( lambda x: f(x, y), limx[0], limy[1], n=order)[0], limy[0], limy[1], n=order)[0] else: return spint.fixed_quad(lambda x: f(x), limx[0], limx[1], n=order)[0] elif method == "w-cumsum": if not np.ndim(limx) == 0: limx = [float(limx[0]), float(limx[1])] if not np.ndim(limy) == 0: limy = [float(limy[0]), float(limy[1])] if not np.ndim(limz) == 0: limz = [float(limz[0]), float(limz[1])] if limz != 0: dx = (limx[1] - limx[0]) / def_nodes dy = (limy[1] - limy[0]) / def_nodes dz = (limz[1] - limz[0]) / def_nodes loop = 0 lastres = 0 while True: xl = np.arange(limx[0], limx[1], dx) yl = np.arange(limy[0], limy[1], dy) zl = np.arange(limz[0], limz[1], dz) X, Y, Z = np.meshgrid(xl, yl, zl) fx = [] for i in range(0, len(X)): fy = [] for j in range(0, len(Y)): fz = [] for k in range(0, len(Z)): fz.append(f(X[i][j][k], Y[i][j][k], zl[k])) fy.append(spint.simps(fz, dx=dz)) fx.append(spint.simps(fy, dx=dy)) res = spint.simps(fx, dx=dx) if loop != 0: if np.abs(res - lastres) / res < err_rel: return res else: ad = (1 / 2)**loop #linear to begin with dx = dx * ad dy = dy * ad dz = dz * ad lastres = res if loop > maxloop: break loop += 1 else: if limy != 0: dx = def_dx dy = def_dx loop = 0 lastres = 0 while True: xl = np.arange(limx[0], limx[1], dx) yl = np.arange(limy[0], limy[1], dy) X, Y = np.meshgrid(xl, yl) fx = [] for i in range(0, len(X)): fy = [] for j in range(0, len(Y)): fy.append(f(X[i][j], yl[j])) fx.append(spint.simps(fy, dx=dy)) res = spint.simps(fx, dx=dx) if loop != 0: if np.abs(res - lastres) / res < err_rel: return res else: ad = (1 / 2)**loop #linear to begin with dx = dx * ad dy = dy * ad lastres = res if loop > maxloop: break loop += 1 else: dx = def_dx loop = 0 lastres = 0 while True: xl = np.arange(limx[0], limx[1], dx) fx = [] for i in range(0, len(X)): fx.append(f(xl[i])) res = spint.simps(fx, dx=dx) if loop != 0: if np.abs(res - lastres) / res < err_rel: return res else: ad = (1 / 2)**loop #linear to begin with dx = dx * ad lastres = res if loop > maxloop: break loop += 1 #still a bit broken but proved slower than mp-gl elif method == "monte-carlo": N = int(1e6) if limz != 0: N = int(round(N**(1 / 3))) x = np.random.rand(N) * (limx[1] - limx[0]) + limx[0] y = np.random.rand(N) * (limy[1] - limy[0]) + limy[0] z = np.random.rand(N) * (limz[1] - limy[0]) + limz[0] X, Y, Z = np.meshgrid(x, y, z) fxyz = [] for i in range(0, len(X)): fxy = [] for j in range(0, len(Y)): fx = [] for k in range(0, len(Z)): fx.append(f(X[i][j][k], Y[i][j][k], Z[i][j][k])) fxy.append(fx) fxyz.append(fxy) wmax = np.max(fxyz) wmin = np.min(fxyz) W = np.random.rand(N, N, N) * (wmax - wmin) + wmin est = 0 for i in range(0, len(fxyz)): for j in range(0, len(fxyz[i])): for k in range(0, len(fxyz[i][j])): if W[i][j][k] > 0 and W[i][j][k] < fxyz[i][j][k]: est = est + fxyz[i][j][k] elif W[i][j][k] < 0 and W[i][j][k] > fxyz[i][j][k]: est = est + fxyz[i][j][k] return (est / (N**3)) * (limx[1] - limx[0]) * ( limy[1] - limy[0]) * (limz[1] - limz[0]) * (wmax - wmin) else: if limy != 0: N = int(round(N**(1 / 2))) x = np.random.rand(N) * (limx[1] - limx[0]) + limx[0] y = np.random.rand(N) * (limy[1] - limy[0]) + limy[0] X, Y = np.meshgrid(x, y) fxy = [] for i in range(0, len(X)): fx = [] for j in range(0, len(Y)): fx.append(f(X[i][j], Y[i][j])) fxy.append(fx) zmax = np.max(fxy) zmin = np.min(fxy) Z = np.random.rand(N, N) * (zmax - zmin) + zmin est = 0 for i in range(0, len(fxy)): for j in range(0, len(fxy[i])): if Z[i][j] > 0 and Z[i][j] < fxy[i][j]: est = est + fxy[i][j] elif Z[i][j] < 0 and Z[i][j] > fxy[i][j]: est = est + fxy[i][j] return (est / (N**2)) * (limx[1] - limx[0]) * ( limy[1] - limy[0]) * (zmax - zmin) else: X = np.random.rand(N) * (limx[1] - limx[0]) + limx[0] fx = [] for i in range(0, len(X)): fx.append(f(X[i])) ymax = np.max(fx) ymin = np.min(fx) Y = np.random.rand(N) * (ymax - ymin) + ymin est = 0 for i in range(0, len(fx)): if Y[i] > 0 and Y[i] < fx[i]: est = est + fx[i] elif Y[i] < 0 and Y[i] > fx[i]: est = est + fx[i] return (est / N) * (limx[1] - limx[0]) * (ymax - ymin) #preallocated, expected to be slow elif method == "sp-simps": if limz != 0: dx = (limx[1] - limx[0]) / def_nodes dy = (limy[1] - limy[0]) / def_nodes dz = (limz[1] - limz[0]) / def_nodes loop = 0 lastres = 0 while True: xl = np.arange(limx[0], limx[1], dx) yl = np.arange(limy[0], limy[1], dy) zl = np.arange(limz[0], limz[1], dz) X, Y, Z = np.meshgrid(xl, yl, zl) fx = [] for i in range(0, len(X)): fy = [] for j in range(0, len(Y)): fz = [] for k in range(0, len(Z)): fz.append(f(X[i][j][k], Y[i][j][k], zl[k])) fy.append(spint.simps(fz, dx=dz)) fx.append(spint.simps(fy, dx=dy)) res = spint.simps(fx, dx=dx) if loop != 0: if np.abs(res - lastres) / res < err_rel: return res else: ad = (1 / 2)**loop #linear to begin with dx = dx * ad dy = dy * ad dz = dz * ad lastres = res if loop > maxloop: break loop += 1 else: if limy != 0: dx = def_dx dy = def_dx loop = 0 lastres = 0 while True: xl = np.arange(limx[0], limx[1], dx) yl = np.arange(limy[0], limy[1], dy) X, Y = np.meshgrid(xl, yl) fx = [] for i in range(0, len(X)): fy = [] for j in range(0, len(Y)): fy.append(f(X[i][j], yl[j])) fx.append(spint.simps(fy, dx=dy)) res = spint.simps(fx, dx=dx) if loop != 0: if np.abs(res - lastres) / res < err_rel: return res else: ad = (1 / 2)**loop #linear to begin with dx = dx * ad dy = dy * ad lastres = res if loop > maxloop: break loop += 1 else: dx = def_dx loop = 0 lastres = 0 while True: xl = np.arange(limx[0], limx[1], dx) fx = [] for i in range(0, len(X)): fx.append(f(xl[i])) res = spint.simps(fx, dx=dx) if loop != 0: if np.abs(res - lastres) / res < err_rel: return res else: ad = (1 / 2)**loop #linear to begin with dx = dx * ad lastres = res if loop > maxloop: break loop += 1 return res
return (target_eps, _compute_delta(log_moments, target_eps)) else: return (_compute_eps(log_moments, target_delta), target_delta) if __name__ == '__main__': # P=[2.0+0.1*x for x in range(11)] # B=[34.5000000000000,50.4690574808896,74.1372651027921,109.343102075613,159.103073582021,236.319021998160,352.299854402153,517.043176420742,775.844878124437,1168.10790884662,1728.25000000000] p = 2.0 b = 277 Eps = [] q = 1 / 250 T = 1 pdf_general = lambda z: mp.exp(-np.abs(z)**p / b) integral__, _ = mp.quad(pdf_general, [-mp.inf, mp.inf], error=True) parameters = [[q, b, T]] delta = 0.00001 max_lmbd = 19 lmbds = range(max_lmbd, max_lmbd + 1) log_moments = [] for lmbd in lmbds: log_moment = 0 for q, b, T in parameters: log_moment += compute_log_moment(q, b, T, lmbd) log_moments.append((lmbd, log_moment)) eps, delta = get_privacy_spent(log_moments, target_delta=delta) Eps.append(eps) # print (order) # print ('p,b:',p,b) print("eps, delta:", eps, delta)
#!/usr/bin/env python3 import sys from mpmath import mp if len(sys.argv) > 1: dp = int(sys.argv[1]) else: dp = 500 mp.dps = dp print("PI = {}".format(mp.quad(lambda x: mp.sqrt(1 - (x**2)), [0, 1]) * 4))
from mpmath import mp mp.dps = 50 # dokładność print( mp.quad(lambda x: (mp.cos(x) - mp.exp(x)) * mp.csc(x), [-0.9999999999999999, 1])) #Zakres nie zaczyna się od -1 ponieważ wartość funkcji w tym punkcie jest bardzo bliska 0 i program sie wypisuje #Natomiast zastępując liczbe -1 bardzo bliską -1 otrzymujemy wynik bardzo poprawny z dokładnościa większa niz 10 cyfr
def main(argv): global timing, tval, settings_short time_start = time.time() settings_short = None mp.dps = 50 print(mp.quad(lambda x: mp.exp(-x ** 2), [-mp.inf, mp.inf]) ** 2) try: # ........................................................................... # argparse command line argument handling # ........................................................................... parser = argparse.ArgumentParser(description='hpa : high precision approximation') parser.add_argument('-a', '--apa', action='store_true', default=True, help='toggle arbitrary precision') parser.add_argument('-p', '--pi', action='store_true', default=False, help='enable Pi matching') parser.add_argument('-i', '--phi', action='store_true', default=False, help='enable Phi matching') parser.add_argument('-b', '--tau', action='store_true', default=False, help='enable Tau matching') parser.add_argument('-e', '--e', action='store_true', default=False, help='enable e matching') parser.add_argument('-r', '--r', action='store_true', default=False, help='enable reciprocal matching') parser.add_argument('-s', '--s', action='store_true', default=False, help='show settings') parser.add_argument('-S', '--S', action='store_true', default=False, help='show verbose settings') parser.add_argument('-l', '--lic', action='store_true', default=False, help='show license and exit') parser.add_argument('-u', '--use', action='store_true', default=False, help='show usage and exit') parser.add_argument("-T", "--time",action="store_true", help="show run time") parser.add_argument('-A', '--prec', action='store', type=int, default=100, help='arbitrary precision digit count') parser.add_argument('-n', '--ndmx', action='store', type=int, default=1000, help='numerator and denominator limit') parser.add_argument('-2', '--sqrt', action='store', type=int, default=10, help='square root max integer value') parser.add_argument('-3', '--cbrt', action='store', type=int, default=10, help='cube root max integer value') parser.add_argument('-x', '--top', action='store', type=int, default=10, help='number of approximations') parser.add_argument('-t', '--thr', action='store', type=float, default=1e-9, help='sensitivity threshold value') parser.add_argument('-v', '--val', action='store', type=float, default=None, help='value to approximate') parser.add_argument('value', nargs='?', action='store', type=float, default=None, help='value to approximate') args = parser.parse_args() rargs = {} rargs['thr'] = args.thr rargs['ndmx'] = args.ndmx rargs['sm'] = args.sqrt rargs['cm'] = args.cbrt rargs['enable_pi'] = args.pi rargs['enable_phi'] = args.phi rargs['enable_e'] = args.e rargs['enable_tau'] = args.tau rargs['enable_recip'] = args.r rargs['settings'] = args.s rargs['verbose'] = args.S if args.use: parser.print_usage() sys.exit(0) if args.lic: print_license() sys.exit(0) # ........................................................................... # call hpa (via hpa_report() # ........................................................................... if args.val is None: args.val = args.value if args.val is None: args.val = math.pi target = args.val top_n = args.top hpa_report(target, top_n, **rargs) time_end = time.time() if args.time: print ( "\n {0:0.2f} seconds".format(time_end - time_start)) except: pass
def integral_inf_mp(fn): integral, _ = mp.quad(fn, [-mp.inf, mp.inf], error=True) return integral
def m(self, m=None, success=0.99999): d = self.d # if get_verbose() >= 1: # print "p_success", success p = self.p q = self.q w = {} r = {} E_c, E_w, V_c, V_w = self.RR(0), self.RR(0), self.RR(0), self.RR(0) for j in range(self.lower_bound, self.upper_bound+1): r[j] = (q**(d-1) - p[j])/(q**d - 1) w[j] = (log(p[j], 2) - log(r[j], 2)).n(prec=self.prec) E_c += w[j] * p[j] E_w += w[j] * r[j] for j in range(self.lower_bound, self.upper_bound+1): V_c += p[j] * (w[j] - E_c)**2 V_w += r[j] * (w[j] - E_w)**2 from mpmath import mp power = int(self.search_space**d - 1) if get_verbose() >= 1: print "exponent:", power mp.prec = self.prec def make_f(m): return lambda x: (0.5 * (1 + mp.erf( (x - E_w)/mp.sqrt(2*V_w/m) )))**power * 1/(mp.sqrt(2 * mp.pi * V_c/m)) * mp.exp( -(x-E_c)**2/(2*V_c/m) ) if m is None: m = 2 f = make_f(m) intgrl = mp.quad(f, [-mp.inf, mp.inf]) while intgrl < success: m *= 10 f = make_f(m) intgrl = mp.quad(f, [-mp.inf, mp.inf]) if get_verbose() >= 1: print "log_2(m): %6.2f, p_success: %s"%(log(m,2),intgrl) if m > 2**self.n: raise OverflowError while intgrl > success: m /= 2.0 f = make_f(m) intgrl = mp.quad(f, [-mp.inf, mp.inf]) if get_verbose() >= 1: print "log_2(m): %6.2f, p_success: %s"%(log(m,2),intgrl) m *= 2.0 else: f = make_f(m) if get_verbose() >= 1: print "log_2(m): %6.2f, p_success: %s"%(log(m,2),mp.quad(f, [-mp.inf, mp.inf])) V_w = V_w/m V_c = V_c/m if get_verbose() >= 1: print(" E_c: %.15f, V_c: %.24f, E_w: %.15f, V_w: %.24f"%(E_c, V_c, E_w, V_w)) return m
def XGEON_nBA(n, RA, RB, rh, l, pm1, Om, lam, sig, deltaphi=0): return -mp.quad( lambda y: XGEON_integrand_nBA(y, n, RA, RB, rh, l, pm1, Om, lam, sig, deltaphi), [-fp.inf, fp.inf])
def integrate_L(fL): return mp.quad(lambda x: mp.quad(lambda y: fL(float(x), float(y))[ 0], [-1 * ct.firstBZ(x), ct.firstBZ(x)], method="gauss-legendre"), [-3**(1 / 2) * ct.c / 2, 3**(1 / 2) * ct.c / 2], method="gauss-legendre")
def intnum(u_lowlim, u_uplim, integrand): return mp.quad(integrand, [u_lowlim, u_uplim])
def integral_bounded_mp(fn, lb, ub): integral, _ = mp.quad(fn, [lb, ub], error=True) return integral
from mpmath import mp mp.dps = 5000 print(mp.quad(lambda x: mp.exp(-x**2), [-mp.inf, mp.inf])**2)
# goji houteishiki solver from mpmath import mp mp.dps = 20 K = lambda k: mp.quad(lambda x: 1/(mp.sqrt(1 - (k**2)*(mp.sin(x)**2))), [0, mp.pi/2]) latparam = lambda k: mp.j*K(mp.sqrt(1-k**2))/K(k) J = lambda m, t: (phi5(t) + phi5m(t, 0))*(phi5m(t, 4) - phi5m(5, 1))*(phi5m(t, 3) - phi5m(t, 2)) inv_n = lambda n, t: -(1/(n + t)) phi = lambda t: kei = lambda R: (r*(5**(5/4)) + mp.sqrt((R**2)*mp.sqrt(5**5) - 16))/(r*(5**(5/4)) + mp.sqrt((R**2)*mp.sqrt(5**5) + 16))