def log(self):
"""
Logaritmo de un intervalo: 'self.log()'
NOTA: Si el intervalo contiene al 0, pero no es estrictamente negativo,
se calcula el logaritmo de la intersecci\'on del intervalo con el dominio
natural del logaritmo, i.e., [0,+inf].
"""
if 0 in self:
domainNatural = Intervalo(0, mpf('inf'))
intervalRestricted = self.intersection(domainNatural)
txt_warning = "\nWARNING: Interval {} contains 0 or negative numbers.\n".format(
self)
print txt_warning
txt_warning = "Restricting to the intersection "\
"with the natural domain of log(x), i.e. {}\n".format(intervalRestricted)
print txt_warning
return Intervalo(mp.log(intervalRestricted.lo),
mp.log(intervalRestricted.hi))
elif 0 > self.hi:
txt_error = 'Interval {} < 0\nlog(x) cannot be computed '\
'for negative numbers.'.format(self)
raise ValueError(txt_error)
else:
return Intervalo(mp.log(self.lo), mp.log(self.hi))
def log(self):
"""
Logaritmo de un intervalo: 'self.log()'
NOTA: Si el intervalo contiene al 0, pero no es estrictamente negativo,
se calcula el logaritmo de la intersecci\'on del intervalo con el dominio
natural del logaritmo, i.e., [0,+inf].
"""
if 0 in self:
domainNatural = Intervalo( 0, mpf('inf') )
intervalRestricted = self.intersection( domainNatural )
txt_warning = "\nWARNING: Interval {} contains 0 or negative numbers.\n".format(self)
print txt_warning
txt_warning = "Restricting to the intersection "\
"with the natural domain of log(x), i.e. {}\n".format(intervalRestricted)
print txt_warning
return Intervalo( mp.log(intervalRestricted.lo), mp.log(intervalRestricted.hi) )
elif 0 > self.hi:
txt_error = 'Interval {} < 0\nlog(x) cannot be computed '\
'for negative numbers.'.format(self)
raise ValueError( txt_error )
else:
return Intervalo( mp.log(self.lo), mp.log(self.hi) )
def test_svd_test_case():
# a test case from Golub and Reinsch
# (see wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).)
eps = mp.exp(0.8 * mp.log(mp.eps))
a = [[22, 10, 2, 3, 7],
[14, 7, 10, 0, 8],
[-1, 13, -1, -11, 3],
[-3, -2, 13, -2, 4],
[ 9, 8, 1, -2, 4],
[ 9, 1, -7, 5, -1],
[ 2, -6, 6, 5, 1],
[ 4, 5, 0, -2, 2]]
a = mp.matrix(a)
b = mp.matrix([mp.sqrt(1248), 20, mp.sqrt(384), 0, 0])
S = mp.svd_r(a, compute_uv = False)
S -= b
assert mp.mnorm(S) < eps
S = mp.svd_c(a, compute_uv = False)
S -= b
assert mp.mnorm(S) < eps
def compute_b_mp(sigma, q, lmbd, verbose=False):
lmbd_int = int(math.ceil(lmbd))
if lmbd_int == 0:
return 1.0
mu0, _, mu = distributions_mp(sigma, q)
b_lambda_fn = lambda z: mu0(z) * (mu0(z) / mu(z)) ** lmbd_int
b_lambda = integral_inf_mp(b_lambda_fn)
m = sigma ** 2 * (mp.log((2 - q) / (1 - q)) + 1 / (2 * (sigma ** 2)))
b_fn = lambda z: ((mu0(z) / mu(z)) ** lmbd_int -
(mu(-z) / mu0(z)) ** lmbd_int)
if verbose:
print "M =", m
print "f(-M) = {} f(M) = {}".format(b_fn(-m), b_fn(m))
assert b_fn(-m) < 0 and b_fn(m) < 0
b_lambda_int1_fn = lambda z: mu0(z) * (mu0(z) / mu(z)) ** lmbd_int
b_lambda_int2_fn = lambda z: mu0(z) * (mu(z) / mu0(z)) ** lmbd_int
b_int1 = integral_bounded_mp(b_lambda_int1_fn, -m, m)
b_int2 = integral_bounded_mp(b_lambda_int2_fn, -m, m)
a_lambda_m1 = compute_a_mp(sigma, q, lmbd - 1)
b_bound = a_lambda_m1 + b_int1 - b_int2
if verbose:
print "B by numerical integration", b_lambda
print "B must be no more than ", b_bound
assert b_lambda < b_bound + 1e-5
return _to_np_float64(b_lambda)
def run_eigsy(A, verbose = False):
if verbose:
print("original matrix:\n", str(A))
D, Q = mp.eigsy(A)
B = Q * mp.diag(D) * Q.transpose()
C = A - B
E = Q * Q.transpose() - mp.eye(A.rows)
if verbose:
print("eigenvalues:\n", D)
print("eigenvectors:\n", Q)
NC = mp.mnorm(C)
NE = mp.mnorm(E)
if verbose:
print("difference:", NC, "\n", C, "\n")
print("difference:", NE, "\n", E, "\n")
eps = mp.exp( 0.8 * mp.log(mp.eps))
assert NC < eps
assert NE < eps
return NC
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 compute_b_mp(sigma, q, lmbd, verbose=False):
lmbd_int = int(math.ceil(lmbd))
if lmbd_int == 0:
return 1.0
mu0, _, mu = distributions_mp(sigma, q)
b_lambda_fn = lambda z: mu0(z) * (mu0(z) / mu(z))**lmbd_int
b_lambda = integral_inf_mp(b_lambda_fn)
m = sigma**2 * (mp.log((2 - q) / (1 - q)) + 1 / (2 * (sigma**2)))
b_fn = lambda z: ((mu0(z) / mu(z))**lmbd_int - (mu(-z) / mu0(z))**lmbd_int)
if verbose:
print("M =", m)
print("f(-M) = {} f(M) = {}".format(b_fn(-m), b_fn(m)))
assert b_fn(-m) < 0 and b_fn(m) < 0
b_lambda_int1_fn = lambda z: mu0(z) * (mu0(z) / mu(z))**lmbd_int
b_lambda_int2_fn = lambda z: mu0(z) * (mu(z) / mu0(z))**lmbd_int
b_int1 = integral_bounded_mp(b_lambda_int1_fn, -m, m)
b_int2 = integral_bounded_mp(b_lambda_int2_fn, -m, m)
a_lambda_m1 = compute_a_mp(sigma, q, lmbd - 1)
b_bound = a_lambda_m1 + b_int1 - b_int2
if verbose:
print("B by numerical integration", b_lambda)
print("B must be no more than ", b_bound)
assert b_lambda < b_bound + 1e-5
return _to_np_float64(b_lambda)
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_eigsy(A, verbose=False):
if verbose:
print("original matrix:\n", str(A))
D, Q = mp.eigsy(A)
B = Q * mp.diag(D) * Q.transpose()
C = A - B
E = Q * Q.transpose() - mp.eye(A.rows)
if verbose:
print("eigenvalues:\n", D)
print("eigenvectors:\n", Q)
NC = mp.mnorm(C)
NE = mp.mnorm(E)
if verbose:
print("difference:", NC, "\n", C, "\n")
print("difference:", NE, "\n", E, "\n")
eps = mp.exp(0.8 * mp.log(mp.eps))
assert NC < eps
assert NE < eps
return NC
def run_eig(A, verbose=0):
if verbose > 1:
print("original matrix (eig):\n", A)
n = A.rows
E, EL, ER = mp.eig(A, left=True, right=True)
if verbose > 1:
print("E:\n", E)
print("EL:\n", EL)
print("ER:\n", ER)
eps = mp.exp(0.8 * mp.log(mp.eps))
err0 = 0
for i in xrange(n):
B = A * ER[:, i] - E[i] * ER[:, i]
err0 = max(err0, mp.mnorm(B))
B = EL[i, :] * A - EL[i, :] * E[i]
err0 = max(err0, mp.mnorm(B))
err0 /= n * n
if verbose > 0:
print("difference (E):", err0)
assert err0 < eps
def run_hessenberg(A, verbose=0):
if verbose > 1:
print("original matrix (hessenberg):\n", A)
n = A.rows
Q, H = mp.hessenberg(A)
if verbose > 1:
print("Q:\n", Q)
print("H:\n", H)
B = Q * H * Q.transpose_conj()
eps = mp.exp(0.8 * mp.log(mp.eps))
err0 = 0
for x in xrange(n):
for y in xrange(n):
err0 += abs(A[y, x] - B[y, x])
err0 /= n * n
err1 = 0
for x in xrange(n):
for y in xrange(x + 2, n):
err1 += abs(H[y, x])
if verbose > 0:
print("difference (H):", err0, err1)
if verbose > 1:
print("B:\n", B)
assert err0 < eps
assert err1 == 0
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 test_cohen_alt_0():
mp.dps = 17
AC = mp.cohen_alt()
S, s, n = [], 0, 1
while 1:
s += -((-1) ** n) * mp.one / (n * n)
n += 1
S.append(s)
v, e = AC.update_psum(S)
if e < mp.eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(mp.eps))
err = abs(v - mp.pi ** 2 / 12)
assert err < eps
def test_cohen_alt_0():
mp.dps = 17
AC = mp.cohen_alt()
S, s, n = [], 0, 1
while 1:
s += -((-1)**n) * mp.one / (n * n)
n += 1
S.append(s)
v, e = AC.update_psum(S)
if e < mp.eps:
break
if n > 1000: raise RuntimeError("iteration limit exceeded")
eps = mp.exp(0.9 * mp.log(mp.eps))
err = abs(v - mp.pi**2 / 12)
assert err < eps
def run_schur(A, verbose=0):
if verbose > 1:
print("original matrix (schur):\n", A)
n = A.rows
Q, R = mp.schur(A)
if verbose > 1:
print("Q:\n", Q)
print("R:\n", R)
B = Q * R * Q.transpose_conj()
C = Q * Q.transpose_conj()
eps = mp.exp(0.8 * mp.log(mp.eps))
err0 = 0
for x in xrange(n):
for y in xrange(n):
err0 += abs(A[y, x] - B[y, x])
err0 /= n * n
err1 = 0
for x in xrange(n):
for y in xrange(n):
if x == y:
C[y, x] -= 1
err1 += abs(C[y, x])
err1 /= n * n
err2 = 0
for x in xrange(n):
for y in xrange(x + 1, n):
err2 += abs(R[y, x])
if verbose > 0:
print("difference (S):", err0, err1, err2)
if verbose > 1:
print("B:\n", B)
assert err0 < eps
assert err1 < eps
assert err2 == 0
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_svd_test_case():
# a test case from Golub and Reinsch
# (see wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).)
eps = mp.exp(0.8 * mp.log(mp.eps))
a = [[22, 10, 2, 3, 7], [14, 7, 10, 0, 8], [-1, 13, -1, -11, 3],
[-3, -2, 13, -2, 4], [9, 8, 1, -2, 4], [9, 1, -7, 5, -1],
[2, -6, 6, 5, 1], [4, 5, 0, -2, 2]]
a = mp.matrix(a)
b = mp.matrix([mp.sqrt(1248), 20, mp.sqrt(384), 0, 0])
S = mp.svd_r(a, compute_uv=False)
S -= b
assert mp.mnorm(S) < eps
S = mp.svd_c(a, compute_uv=False)
S -= b
assert mp.mnorm(S) < eps
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_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_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 run_svd_r(A, full_matrices = False, verbose = True):
m, n = A.rows, A.cols
eps = mp.exp(0.8 * mp.log(mp.eps))
if verbose:
print("original matrix:\n", str(A))
print("full", full_matrices)
U, S0, V = mp.svd_r(A, full_matrices = full_matrices)
S = mp.zeros(U.cols, V.rows)
for j in xrange(min(m, n)):
S[j,j] = S0[j]
if verbose:
print("U:\n", str(U))
print("S:\n", str(S0))
print("V:\n", str(V))
C = U * S * V - A
err = mp.mnorm(C)
if verbose:
print("C\n", str(C), "\n", err)
assert err < eps
D = V * V.transpose() - mp.eye(V.rows)
err = mp.mnorm(D)
if verbose:
print("D:\n", str(D), "\n", err)
assert err < eps
E = U.transpose() * U - mp.eye(U.cols)
err = mp.mnorm(E)
if verbose:
print("E:\n", str(E), "\n", err)
assert err < eps
def run_svd_r(A, full_matrices=False, verbose=True):
m, n = A.rows, A.cols
eps = mp.exp(0.8 * mp.log(mp.eps))
if verbose:
print("original matrix:\n", str(A))
print("full", full_matrices)
U, S0, V = mp.svd_r(A, full_matrices=full_matrices)
S = mp.zeros(U.cols, V.rows)
for j in xrange(min(m, n)):
S[j, j] = S0[j]
if verbose:
print("U:\n", str(U))
print("S:\n", str(S0))
print("V:\n", str(V))
C = U * S * V - A
err = mp.mnorm(C)
if verbose:
print("C\n", str(C), "\n", err)
assert err < eps
D = V * V.transpose() - mp.eye(V.rows)
err = mp.mnorm(D)
if verbose:
print("D:\n", str(D), "\n", err)
assert err < eps
E = U.transpose() * U - mp.eye(U.cols)
err = mp.mnorm(E)
if verbose:
print("E:\n", str(E), "\n", err)
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_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 log(a):
try:
return a.log()
except:
return mp.log(a)
def log(a):
try:
return a.log()
except:
return mp.log(a)
