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))
