def test_msvd():
output("""\
msvd_:{[b;x]
$[3<>count usv:.qml.msvd x;::;
not (.qml.mdim[u:usv 0]~2#d 0) and (.qml.mdim[v:usv 2]~2#d 1) and
.qml.mdim[s:usv 1]~d:.qml.mdim x;::;
not mortho[u] and mortho[v] and
all[0<=f:.qml.mdiag s] and mzero s _'til d 0;::;
not mzero x-.qml.mm[u] .qml.mm[s] flip v;::;
b;1b;(p*/:m#/:u;m#m#/:s;
(p:(f>.qml.eps*f[0]*max d)*1-2*0>m#u 0)*/:(m:min d)#/:v)]};""")
for A in subjects:
U, S, V = map(mp.matrix, mp.svd(mp.matrix(A)))
m = min(A.rows, A.cols)
p = mp.diag([mp.sign(s * u) for s, u in zip(mp.chop(S), U[0, :])])
U *= p
S = mp.diag(S)
V = V.T * p
test("msvd_[0b", A, (U, S, V))
reps(250)
for Aq in large_subjects:
test("msvd_[1b", qstr(Aq), qstr("1b"))
reps(10000)
def test_msvd():
output("""\
msvd_:{[b;x]
$[3<>count usv:.qml.msvd x;::;
not (.qml.mdim[u:usv 0]~2#d 0) and (.qml.mdim[v:usv 2]~2#d 1) and
.qml.mdim[s:usv 1]~d:.qml.mdim x;::;
not mortho[u] and mortho[v] and
all[0<=f:.qml.mdiag s] and mzero s _'til d 0;::;
not mzero x-.qml.mm[u] .qml.mm[s] flip v;::;
b;1b;(p*/:m#/:u;m#m#/:s;
(p:(f>.qml.eps*f[0]*max d)*1-2*0>m#u 0)*/:(m:min d)#/:v)]};""")
for A in subjects:
U, S, V = map(mp.matrix, mp.svd(mp.matrix(A)))
m = min(A.rows, A.cols)
p = mp.diag([mp.sign(s * u) for s, u in zip(mp.chop(S), U[0, :])])
U *= p
S = mp.diag(S)
V = V.T * p
test("msvd_[0b", A, (U, S, V))
reps(250)
for Aq in large_subjects:
test("msvd_[1b", qstr(Aq), qstr("1b"))
reps(10000)
def test_for_spec_a(self):
n = 2
A = mpmath.matrix([[0j, 1 + 0j], [1 + 0j, 0j]])
vs, Q = takagi_fact.symmetric_svd(A)
diag = mpmath.diag(vs)
qtaq = Q.T * A * Q
unit = mpmath.diag([1 for _ in range(n)])
qdaq = Q.H * Q
for i, j in itertools.product(range(n), repeat=2):
self.assertAlmostEqual(diag[i, j], qtaq[i, j])
self.assertAlmostEqual(unit[i, j], qdaq[i, j])
def Propagate_trunc2(M, p, dt, ddt=1):
E, EL, ER = mp.eig(M.T, left=True, right=True)
E, EL, ER = mp.eig_sort(E, EL, ER)
times = np.arange(0, dt, ddt) + dt
N = int(dt / ddt)
if len(p) == 1:
intermediate_populations = [p for i in range(N)]
return intermediate_populations
else:
R = [[0 for i in range(len(p))] for j in range(N)]
for i in range(N):
R[i][-2] = mp.exp(E[-2] * times[i])
R[i][-1] = 1
# print(M)
# print(ER)
print(E)
# print(R)
# print(EL)
# print(p)
# print(ER*mp.diag(R[0])*EL*p)
intermediate_populations = []
for i in range(N):
# print(mp.diag(R[i]))
A = ER * mp.diag(R[i]) * EL * p
intermediate_populations.append(
np.array((A.T).apply(mp.re).tolist()[0], dtype=float))
print(intermediate_populations)
return intermediate_populations
def Propagate_stationary(M, p, dt, ddt=1):
syst1 = time.time()
E, EL, ER = mp.eig(M.T, left=True, right=True)
E, EL, ER = mp.eig_sort(E, EL, ER)
times = range(ddt, dt + ddt, ddt)
UR = ER**-1
R = [0] * (len(E) - 1)
R.append(1)
# print(M.T)
# print(E)
intermediate_populations = []
print(time.time() - syst1)
# print(np.exp(time*np.diag(e)))
# E = np.real(np.dot(np.dot(U, np.diag(R)), Uinv))
for i in range(len(times)):
# print(mp.diag(R[i]))
A = ER * mp.diag(R) * UR * p
intermediate_populations.append(
np.array((A.T).apply(mp.re).tolist()[0], dtype=float))
# print(intermediate_populations)
print(time.time() - syst1)
# intermediate_populations = [np.array(((ER*mp.diag(R)*EL*p).T).apply(mp.re).tolist()[0], dtype=float) for t in times]
# print(intermediate_populations)
return intermediate_populations
def subspace_angle_V_M_mp(mu, lam, dps=100):
r"""Multiprecision implementation computing the subspace angle between V(mu) and M(lam)
"""
n = len(mu)
lam = np.atleast_1d(lam)
m = len(lam)
with mp.workdps(dps):
mu = mp.matrix(mu)
lam = mp.matrix(lam)
# Construct the Cauchy mass matrix
#M = mp.zeros(n,n)
#for i,j in product(range(n), range(n)):
# M[i,j] = (mu[i] + mu[j].conjugate())**(-1)
#ewL, QL = mp.eighe(M)
ewL, QL = cauchy_eigen(mu, dps)
# Construct the right hand side Mhat matrix
Mhat = mp.zeros(2 * m, 2 * m)
for i, j in product(range(m), range(m)):
Mhat[i, j] = (-lam[i] - lam[j].conjugate())**(-1)
Mhat[i, m + j] = (-lam[i] - lam[j].conjugate())**(-2)
Mhat[m + i, j] = (-lam[i] - lam[j].conjugate())**(-2).conjugate()
Mhat[m + i, m + j] = 2 * (-lam[i] - lam[j].conjugate())**(-3)
# Construct the interior matrix
A = mp.zeros(n, 2 * m)
for i, j in product(range(n), range(m)):
A[i, j] = (mu[i] - lam[j])**(-1)
A[i, m + j] = (mu[i] - lam[j])**(-2)
ewR, QR = mp.eighe(Mhat)
AA = mp.diag([1 / mp.sqrt(ewL[i])
for i in range(n)]) * (QL.H * A * QR) * mp.diag(
[1 / mp.sqrt(ewR[i]) for i in range(2 * m)])
U, s, VH = mp.svd(AA)
phi = np.array([float(mp.acos(si)) for si in s])
return phi
def multivariate_normalization(data, variables_size):
mpmath.mp.dps = 20
for j in range(0, len(data[0])):
means = []
ts_s = []
for u in range(0, variables_size):
means.append(numpy.mean(data[u][j]))
ts_s.append(data[u][j])
covariance_matrix = mpmath.matrix(numpy.cov(ts_s))
w, v = mpmath.eig(covariance_matrix)
diagonal = mpmath.diag(w)
try:
result = mpmath.sqrtm(diagonal)
except ZeroDivisionError as error:
print("j: ", j)
print("ts:", ts_s)
print("not invertible sqrtm")
print("covariance_matrix:", covariance_matrix)
sys.exit()
B = v * result
try:
inverse_B = B**-1
except ZeroDivisionError as error:
# Not invertible. Skip this one.
# Non invertable cases Uwave
print("j: ", j)
print("ts:", ts_s)
print("not invertible")
print("covariance_matrix:", covariance_matrix)
sys.exit()
except Exception as exception:
# Not invertible. Skip this one.
print("j: ", j)
print("ts:", ts_s)
print("not invertible")
print("covariance_matrix:", covariance_matrix)
sys.exit()
for i in range(0, len(data[0][j])):
atributes_together = []
for u in range(0, variables_size):
atributes_together.append(data[u][j][i])
atributes_together = mpmath.matrix(atributes_together)
result = atributes_together - mpmath.matrix(means)
result = inverse_B * result
for u in range(0, variables_size):
if type(result[u]) is mpmath.mpc:
data[u][j][i] = result[u].real
else:
data[u][j][i] = result[u]
return data
def test_takagi_fact(self):
N_REPEAT = 1000
N_DIM_UPPER = 2
for _ in range(N_REPEAT):
for n in range(2, N_DIM_UPPER + 1):
ar = mpmath.randmatrix(n)
ai = mpmath.randmatrix(n)
a = ar + 1j * ai
A = a + a.T
vs, Q = takagi_fact.takagi_fact(A)
diag = mpmath.diag(vs)
qtaq = Q.T * A * Q
unit = mpmath.diag([1 for _ in range(n)])
qdaq = Q.H * Q
for i, j in itertools.product(range(n), repeat=2):
self.assertAlmostEqual(mpmath.im(diag[i, j]), 0)
self.assertAlmostEqual(diag[i, j], qtaq[i, j])
self.assertAlmostEqual(unit[i, j], qdaq[i, j])
def psolve(M, b):
U, S, V = mp.svd(M)
if False:
print("V")
testHermitian(V)
print("U")
testHermitian(U)
sys.exit(1)
Mpinv = V.transpose_conj() * (mp.diag(S)**(-1)) * U.transpose_conj()
ws = Mpinv*mp.matrix(b)
return [ws[i] for i in range(len(ws))]
def testHermitian(M):
T = M * (M.transpose_conj()) - mp.diag([1.0 for i in range(max(M.rows, M.cols))])
#printM(T)
maxvalre = 0
maxvalim = 0
for j in range(T.rows):
for i in range(T.cols):
x = T[j,i]
maxvalre = max(abs(x.real), maxvalre)
maxvalim = max(abs(x.imag), maxvalim)
print("maxvalre: "+str(float(maxvalre)))
print("maxvalim: "+str(float(maxvalim)))
def Propagate(M, p, dt, ddt=1):
E, EL, ER = mp.eig(M.T, left=True, right=True)
UR = ER**-1
# E, EL, ER = mp.eig_sort(E, EL, ER) # time_series = np.arange(0, dt, ddt) + dt
# print(mp.nstr(EL*ER, n=3))
times = range(ddt, dt + ddt, ddt)
# print(E)
intermediate_populations = []
# print(np.exp(time*np.diag(e)))
# E = np.real(np.dot(np.dot(U, np.diag(R)), Uinv))
for i in range(len(times)):
R = [mp.exp(E[j] * times[i]) for j in range(len(E))]
# R = [mp.exp(E[j]*0) for j in range(len(E))]
A = ER * mp.diag(R) * UR * p
# print(R)
intermediate_populations.append(
np.array((A.T).apply(mp.re).tolist()[0], dtype=float))
# print(p)
# print(intermediate_populations[-1])
# intermediate_populations = [np.array(((ER*mp.diag(R)*EL*p).T).apply(mp.re).tolist()[0], dtype=float) for t in times]
# print(intermediate_populations)
return intermediate_populations
def solve_svd_mp(A, b):
"""
solve a linear system using svd decomposition using mpmath
:param ndarray A: The linear system
:param ndarray b: The right hand side
:return: ndarray
"""
A_mp = mpmath.matrix([list(row) for row in A])
b_mp = mpmath.matrix([list(row) for row in b])
u, s, v = svd_r(A_mp)
# x = V*((U'.b)./ diag(S))
# x = V*( c ./ diag(S))
# x = V*( g )
c = u.T * b_mp
w = mpmath.lu_solve(mpmath.diag(s), c)
x_mp = v.T * w
x = numpy.array(x_mp.tolist(), 'f8')
return x
def eqn42_solve( geom, Nmax ):
# eqn 4.2
NMAX = Nmax # where to truncate the infinite system of eqns
S = geom['S']
distanceqp = geom['distanceqp']
thetaqp = geom['thetaqp']
phiqp = geom['phiqp']
radii = geom['radii']
# coefficient matrix
if USEMPMATH:
CM = mpmath.zeros( S*NMAX*(2*NMAX+1) )
else:
CM = np.zeros( (S*NMAX*(2*NMAX+1), S*NMAX*(2*NMAX+1)) )
for sprimei,sprime in enumerate(range(S)):
for nprimei,nprime in enumerate(range(NMAX)):
for mprimei,mprime in enumerate(range(-nprime,nprime+1)):
# row index
ri = sprimei*NMAX*(2*NMAX+1) + nprimei*(2*NMAX+1) + mprimei
# row prefactors
prefac = (-1)**(nprime+mprime) * radii[sprimei]**(nprime+1) \
* 1./factorial(nprime+mprime)
for si,s in enumerate(range(S)):
if sprimei != si:
for ni,n in enumerate(range(NMAX)):
for mi,m in enumerate(range(-n,n+1)):
# column index
ci = si*NMAX*(2*NMAX+1) + ni*(2*NMAX+1) + mi
f1 = distanceqp[sprimei,si]**(-(n+1))
f2 = (radii[sprimei]/distanceqp[sprimei,si])**nprime
f3 = factorial(n-m+nprime+mprime)/factorial(n-m)
if USEMPMATH:
f4 = mpmath.legenp( n+nprime, m-mprime, \
np.cos(thetaqp[sprimei,si]) )
else:
f4 = scipy.special.lpmv( m-mprime, n+nprime, \
np.cos(thetaqp[sprimei,si]) )
f5 = np.exp( 1j*(m-mprime)*phiqp[sprimei,si] )
CM[ri,ci] = prefac*f1*f2*f3*f4*f5
if USEMPMATH:
CM += mpmath.diag(np.ones(S*NMAX*(2*NMAX+1)))
Qs = mpmath.zeros(S)
else:
CM += np.diag(np.ones(S*NMAX*(2*NMAX+1)))
Qs = np.zeros((S,S))
for si in range(S):
if USEMPMATH:
rhs = mpmath.zeros( S*NMAX*(2*NMAX+1), 1 )
else:
rhs = np.zeros((CM.shape[0],))
rhs[si*NMAX*(2*NMAX+1):(si*NMAX+1)*(2*NMAX+1)] = radii[si]
if USEMPMATH:
sol = mpmath.lu_solve( CM, rhs )
else:
sol = np.linalg.solve( CM, rhs )
#print sol[::(NMAX*(2*NMAX+1))]
Qs[si,:] = sol[::(NMAX*(2*NMAX+1))]
return Qs
def get_unary(self, item):
return {
**{
k: calc2.UnaryOperator(s, f, 80)
for k, s, f in [
('abs', 'abs', abs),
('fac', 'fac', mpmath.factorial),
('sqrt', 'sqrt', mpmath.sqrt),
('_/', 'sqrt', mpmath.sqrt),
('√', 'sqrt', mpmath.sqrt),
('ln', 'ln', mpmath.ln),
('lg', 'log10', mpmath.log10),
('exp', 'e^', mpmath.exp),
('floor', 'floor', mpmath.floor),
('ceil', 'ceil', mpmath.ceil),
('det', 'det', mpmath.det),
]
}, 'pcn':
calc2.UnaryOperator('a%', lambda x: x / 100, 80),
'+':
calc2.UnaryOperator('(+)', lambda x: x, 0),
'-':
calc2.UnaryOperator('+/-', lambda x: -x, 80),
'conj':
calc2.UnaryOperator(
'conj', lambda x: x.conjugate()
if isinstance(x, mpmath.matrix) else mpmath.conj(x), 80),
'~':
calc2.UnaryOperator(
'conj', lambda x: x.conjugate()
if isinstance(x, mpmath.matrix) else mpmath.conj(x), 80),
'O':
calc2.UnaryOperator(
'[O]', lambda x: mpmath.zeros(*OpList.__analyse_as_pair(x)),
80),
'I':
calc2.UnaryOperator(
'[I]', lambda x: mpmath.ones(*OpList.__analyse_as_pair(x)),
80),
'E':
calc2.UnaryOperator('[E]', lambda x: mpmath.eye(int(x)), 80),
'diag':
calc2.UnaryOperator(
'[diag]', lambda x: mpmath.diag(OpList.__analyse_list(x)), 80),
'log':
calc2.UnaryOperator(
'logbA', lambda x: OpList.__log(*OpList.__analyse_pair(x)),
80),
'tran':
calc2.UnaryOperator(
'[T]', lambda x: x.transpose()
if isinstance(x, mpmath.matrix) else x, 80),
**{
k: calc2.UnaryOperator(k, (lambda u: lambda x: u(self._drg2r(x)))(v), 80)
for k, v in {
'sin': mpmath.sinpi,
'cos': mpmath.cospi,
'tan': lambda x: mpmath.sinpi(x) / mpmath.cospi(x),
'cot': lambda x: mpmath.cospi(x) / mpmath.sinpi(x),
'sec': lambda x: 1 / mpmath.cospi(x),
'csc': lambda x: 1 / mpmath.sinpi(x),
}.items()
},
**{
k: calc2.UnaryOperator(k, (lambda u: lambda x: self._r2drg(1 / v(x)))(v), 80)
for k, v in {
'asin': mpmath.asin,
'acos': mpmath.acos,
'atan': mpmath.atan,
'acot': mpmath.acot,
'asec': mpmath.asec,
'acsc': mpmath.acsc
}.items()
},
**{
k: calc2.UnaryOperator(k, v, 80)
for k, v in {
'sinh': mpmath.sinh,
'cosh': mpmath.cosh,
'tanh': mpmath.tanh,
'coth': mpmath.coth,
'sech': mpmath.sech,
'csch': mpmath.csch,
'asinh': mpmath.asinh,
'acosh': mpmath.acosh,
'atanh': mpmath.atanh,
'acoth': mpmath.acoth,
'asech': mpmath.asech,
'acsch': mpmath.acsch
}.items()
}
}[item]
],
'agm': [
'primitive',
[lambda x, y: mp.agm(x) if y is None else mp.agm(x, y[0]), None]
],
#
'matrix': [
'primitive',
[
lambda x, y: mp.matrix(x) if isa(x, Vector) else mp.matrix(x)
if y is None else mp.matrix(x, y[0]), None
]
],
'matrix-ref': ['primitive', [lambda x, y: x[y[0], y[1], [0]], None]],
'matrix-set': [
'primitive',
[lambda x, y: matrix_set(x, y[0], y[1][0], y[1][1][0]), None]
],
'zeros': ['primitive', [lambda x, y: mp.zeros(x), None]],
'ones': ['primitive', [lambda x, y: mp.ones(x), None]],
'eye': ['primitive', [lambda x, y: mp.eye(x), None]],
'diag': ['primitive', [lambda x, y: mp.diag(x), None]],
'randmatrix': ['primitive', [lambda x, y: mp.randmatrix(x), None]],
'matrix-inv': ['primitive', [lambda x, y: x**(-1), None]],
'norm': [
'primitive',
[lambda x, y: mp.norm(x) if y is None else mp.norm(x, y[0]), None]
],
'mnorm': ['primitive', [lambda x, y: mp.mnorm(x, y[0]), None]],
}
