def kron_solve(B, A, Y):
from scipy.linalg.lapack import dgetrf, dgetrs
V = Y.space
X = StencilVector(V)
[s1, s2] = V.starts
[e1, e2] = V.ends
[p1, p2] = V.pads
n1 = e1 - s1 + 1
n2 = e2 - s2 + 1
Vt = StencilVectorSpace([n2, n1], [p2, p1], [False, False])
Xt = StencilVector(Vt)
# A is n1xn1 matrix
# B is n2xn2 matrix
A_arr = A.toarray()
B_arr = B.toarray()
A_lu, A_piv, A_finfo = dgetrf(A_arr)
B_lu, B_piv, B_finfo = dgetrf(B_arr)
for i2 in range(n2):
Xt[i2, 0:n1], A_sinfo = dgetrs(A_lu, A_piv, Y[0:n1, i2])
for i1 in range(n1):
X[i1, 0:n2], B_infos = dgetrs(B_lu, B_piv, Xt[0:n2, i1])
return X
def _lu(A):
'''
Computes the LU factorization of `A` using the routine `dgetrf`
Parameters
----------
A : (n, n) float array
Returns
-------
(n, n) float array
LU factorization
(n,) int array
pivots
'''
# handle rank zero matrix
if A.shape == (0, 0):
return (np.zeros((0, 0), dtype=float), np.zeros((0, ), dtype=np.int32))
# get the LU factorization
fac, piv, info = dgetrf(A)
if info < 0:
raise ValueError('the %s-th argument had an illegal value' % -info)
elif info > 0:
raise np.linalg.LinAlgError(
'U(%s, %s) is exactly zero. The factorization has been completed, but '
'the factor U is exactly singular, and division by zero will occur if '
'it is used to solve a system of equations. ' % (info, info))
return fac, piv
def solve(A, b):
'''
Solves the system of equations *Ax = b* using the LU routines
*dgetrf* and *dgetrs*.
Parameters
----------
A : (N,N) float array
b : (N,*) float array
'''
if any(i == 0 for i in b.shape):
return np.zeros(b.shape)
lu, piv, info = dgetrf(A)
# I am too lazy to look up the error codes
if info != 0:
raise np.linalg.LinAlgError(
'LAPACK routine *dgetrf* exited with error code %s' % info)
x, info = dgetrs(lu, piv, b)
if info != 0:
raise np.linalg.LinAlgError(
'LAPACK routine *dgetrs* exited with error code %s' % info)
return x
def g09_calculate_fock(c, s, nbf, e):
# Calculate the Fock matrix
sc_temp = blas.dgemm(1.0, np.array(c), np.array(s), 1.0)
sc = np.asmatrix(sc_temp)
sce = np.matlib.zeros((nbf, nbf))
for i in range(nbf):
sce[i, :] = e[0, i] * sc[i, :]
c_lu, ipiv, info = lapack.dgetrf(c)
ic_lu, info = lapack.dgetri(c_lu, ipiv)
f_temp = blas.dgemm(1.0, np.array(ic_lu), np.array(sce), 1.0)
f = np.asmatrix(f_temp)
return f
def _lu(A):
'''
Computes the LU factorization of `A` using `dgetrf`
'''
if A.shape == (0, 0):
return (np.zeros((0, 0), dtype=float), np.zeros((0, ), dtype=np.int32))
fac, piv, info = dgetrf(A)
if info < 0:
raise ValueError('the %s-th argument had an illegal value' % -info)
elif info > 0:
raise np.linalg.LinAlgError('Singular matrix')
return fac, piv
def invsp(x):
"""This is a function to inverse a symetric postive definite matrix."""
try:
from numpy.linalg import inv
return inv(x)
except:
try:
from scipy.linalg.lapack import dgetrf, dgetri
d, e = dgetrf(x)[:2]
return dgetri(d, e)[0]
except:
from ..IO.output import printError
printError("There is no `inv` function found.")
return None
def _lapack_solve(A, b):
'''
Solves the system of equations Ax=b, using the lapack LU routines.
This is faster than np.linalg.solve because it does fewer checks. A
and b must be double precision numpy arrays
'''
lu, piv, info = dgetrf(A, overwrite_a=True)
if info != 0:
raise np.linalg.LinAlgError(
'LAPACK routine dgetrf exited with error code %s' % info)
x, info = dgetrs(lu, piv, b, overwrite_b=True)
if info != 0:
raise np.linalg.LinAlgError(
'LAPACK routine dgetrs exited with error code %s' % info)
return x
def compute_cov_inv(data):
if (data.cov is None):
data.cov_det = None
data.cov_inv = None
else:
# Compute the log determinant of the covariance matrix
cov_copy, pivots, info = lapack.dgetrf(data.cov)
abs_element = np.fabs(np.diagonal(cov_copy))
data.cov_det = np.sum(np.log(abs_element))
# Invert the covariance matrix
identity = np.eye(len(data.x))
cov_lu, pivots, cov_inv, info = lapack.dgesv(data.cov, identity)
data.cov_inv = cov_inv
return data
def calc_eq_g(l, B):
L = B.shape[0]
order = (np.arange(L) + l) % L
Q, jpvt, tau, work, info = dgeqp3(B[order[0]] if L % 2 ==
1 else np.dot(B[order[1]], B[order[0]]))
d = Q.diagonal().copy()
d[d == 0.0] = 1.0
T = ((np.triu(Q).T / d).T)[:, jpvt.argsort()]
for m in range((1 if L % 2 == 1 else 2), L, 2):
W, work, info = dormqr("R", "N", Q, tau,
np.dot(B[order[m + 1]], B[order[m]]),
work.shape[0])
W *= d
jpvt = (W * W).sum(0).argsort()[::-1]
Q, tau, work, info = dgeqrf(W[:, jpvt])
d[...] = Q.diagonal()
d[d == 0.0] = 1.0
T = np.dot((np.triu(Q).T / d).T, T[jpvt, :])
N = B.shape[1]
invDb = np.zeros((N, N))
for i in range(N):
invDb[i, i] = 1.0 / d[i] if np.abs(d[i]) > 1.0 else 1.0
invDbQT, work, info = dormqr("R", "T", Q, tau, invDb, work.shape[0])
for i in range(N):
if np.abs(d[i]) <= 1.0:
T[i, :] *= d[i]
T += invDbQT
T_LU, piv, info = dgetrf(T)
sign = 1
for i in range(N):
if (T_LU[i, i] < 0) ^ (piv[i] != i) ^ (invDb[i, i] < 0) ^ (tau[i] > 0):
sign *= -1
G, info = dgetrs(T_LU, piv, invDbQT)
return G, sign
print("input matrix:")
print(mat)
print("--- demo of frovedis wrapper with input as numpy matrix ---")
from frovedis.linalg import *
frov_rf = dgetrf(mat)
print("lu factor: ")
print(frov_rf[0])
frov_ri = dgetri(frov_rf[0], frov_rf[1])
print("inverse: ")
print(frov_ri[0])
print(
"--- demo of frovedis wrapper with input as FrovedisBlockcyclicMatrix ---")
frov_rf = dgetrf(bmat)
print("lu factor: ")
print(frov_rf[0].to_numpy_matrix())
frov_ri = dgetri(frov_rf[0], frov_rf[1])
print("inverse: ")
print(frov_ri[0].to_numpy_matrix())
print("--- demo of native scipy.linalg routines ---")
from scipy.linalg import lapack
lpck_rf = lapack.dgetrf(mat)
print("lu factor: ")
print(lpck_rf[0])
lpck_ri = lapack.dgetri(lpck_rf[0], lpck_rf[1])
print("inverse: ")
print(lpck_ri[0])
things. We are going to compare the low-level LAPACK functions degtrf and dgetrs to the built in scipy LU routines. """ from numpy import array from scipy.linalg import lu_solve, lu_factor from scipy.linalg.lapack import dgetrf, dgetrs from numpy.random import random import time # Make arrays NUM_ITER = 10 N = 1024 A = random((N,N)) b = random((N,1)) # Solve using scipy.linalg start = time.time() for it in range(NUM_ITER): (LU_and_piv) = lu_factor(A) (x) = lu_solve(LU_and_piv, b) stop = time.time() print "Time for scipy routine is", (stop - start)/NUM_ITER # Solve using scipy.linalg.lapack start = time.time() for it in range(NUM_ITER): (LU, piv, info) = dgetrf(A) (x) = dgetrs(LU, piv, b) stop = time.time() print "Time for LAPACK routine is", (stop - start)/NUM_ITER
