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