def test_diag(self):
a = (100 * get_mat(5)).astype('f')
b = a.copy()
for k in range(5):
for l in range(k + 3, 5):
b[k, l] = 0
assert_equal(tril(a, k=2), b)
b = a.copy()
for k in range(5):
for l in range(max((k - 1, 0)), 5):
b[k, l] = 0
assert_equal(tril(a, k=-2), b)
def test_diag(self):
a = (100*get_mat(5)).astype('f')
b = a.copy()
for k in range(5):
for l in range(k+3,5):
b[k,l] = 0
assert_equal(tril(a,k=2),b)
b = a.copy()
for k in range(5):
for l in range(max((k-1,0)),5):
b[k,l] = 0
assert_equal(tril(a,k=-2),b)
def test_basic(self):
a = (100 * get_mat(5)).astype('l')
b = a.copy()
for k in range(5):
for l in range(k + 1, 5):
b[k, l] = 0
assert_equal(tril(a), b)
def iterative():
N, h, neighs, atoms, nc, nv, vl = pre.run2()
del atoms, nc, vl
lp = pro.laplace(N, h, neighs)
del neighs
A = lp.tolil()
del lp
B = np.zeros(N)
for i in range(N):
A[0, i] = 0.0
B[i] = -4 * np.pi * nv[i]
del nv
A[0, 0] = 1.0
A = A.toarray()
B[0] = 0.0
Au = la.triu(A)
Al = la.tril(A)
Ad = np.diag(np.diag(A))
## for i in range(N):
## for j in range(N):
## if A[i][j] != Au[i][j]+Al[i][j]-Ad[i][j]:
## print(i, j)
x = np.zeros(N)
T = 1000
RJ = np.dot(la.inv(Ad), A) + np.identity(N)
RGS = -np.dot(la.inv(Al - Ad), Au)
val, vec = la.eig(RGS)
maxx = 0.0
for i in range(len(val)):
if abs(val[i]) > maxx:
maxx = abs(val[i])
print(maxx)
def test_basic(self):
a = (100*get_mat(5)).astype('l')
b = a.copy()
for k in range(5):
for l in range(k+1,5):
b[k,l] = 0
assert_equal(tril(a),b)
def schur(self, A, schur_list, full_matrix=True):
"""
Setup the solver object to work in Schur complement mode
full_matrix: boolean, default True. If full_matrix is False
and a symmetric factorization is used, only the lower part of
the Schur matrix is stored in self.S
"""
self.A = A
self.spmA = spm.spmatrix(A)
if self.verbose:
self.spmA.printInfo()
self.schur_list = schur_list + self.spmA.findBase()
setSchurUnknownList(self.pastix_data, self.schur_list)
task_analyze(self.pastix_data, self.spmA)
task_numfact(self.pastix_data, self.spmA)
nschur = len(schur_list)
self.S = np.zeros((nschur, nschur), order='F', dtype=A.dtype)
getSchur(self.pastix_data, self.S)
if full_matrix and (self.factotype != factotype.LU):
self.S += la.tril(self.S, -1).T
def twogrid(FA,Fb,Fnu1,Fnu2,Fgamma,Fuu):
nn = len(Fb)
G = [[0.0] * (nn+1) for _ in [0.0]* (nn+1)]
# ltemp = 0
G = scipy.sparse.eye(nn,nn) - (inv(tril(FA))*FA)
# G = scipy.sparse.eye(nn,nn)
print G
# cG = inv(tril(FA))*Fb
return Fuu
def LU(A): (m,n) = A.shape U = deepcopy(A) P = np.eye(m) L = np.eye(m) for i in range(m): # do the pivot max_j = i + np.argmax(np.abs(U[i:,i])) # make the pivot matrix Pi = np.eye(m) Pi[i,i] = 0 Pi[max_j,max_j] = 0 Pi[i,max_j] = 1 Pi[max_j,i] = 1 # do the pivot U = Pi @ U # add the pivot to P P = P @ Pi # add the pivot to L L= Pi @ L @ Pi # make the eliminator Linv Li = np.eye(m) Li[(i+1):m,i] = -U[(i+1):m,i]/U[i,i] # make the inverse of the eliminator Linv = np.eye(m) Linv[(i+1):m,i] = U[(i+1):m,i]/U[i,i] # do the elimination (we already did the pivot) U = Li @ U # add the inverse-eliminator to L L = L @ Linv L = linalg.tril(L) U = linalg.triu(U) return (P,L,U)
def GaussSeidel(A, b, tolerance = 1.e-10, MaxSteps = 100):
"""Solve the linear system A x = b using the Gauss-Seidel method,
starting from the trivial initial guess."""
x = np.zeros_like(b)
Anorm = A.copy()
bnorm = b.copy()
n = len(b)
for i in range(n):
bnorm[i] /= A[i, i]
Anorm[i, :] /= A[i, i]
# Compute the split
D = np.eye(n)
AL = la.tril(D - Anorm)
AU = la.triu(D - Anorm)
N = np.eye(n) - AL
P = AU
# Compute the convergence matrix and check its spectral radius
M = np.dot(la.inv(N), P)
eigenvalues, eigenvectors = la.eig(M)
rho = np.amax(np.absolute(eigenvalues))
if (rho > 1):
print("Gauss-Seidel will not converge as the"\
" largest eigenvalue of the convergence matrix is {}".format(rho))
for j in range(MaxSteps):
x_old = x.copy()
for i in range(n):
x[i] = bnorm[i] + np.dot(AL[i, :], x) + np.dot(AU[i, :], x_old)
if (la.norm(x - x_old) < tolerance):
print("Gauss-Seidel converged in {} iterations.".format(j))
break
return x
def GaussSeidel(A, b, tolerance=1.e-10, MaxSteps=100):
"""Solve the linear system A x = b using the Gauss-Seidel method,
starting from the trivial initial guess."""
x = np.zeros_like(b)
Anorm = A.copy()
bnorm = b.copy()
n = len(b)
for i in range(n):
bnorm[i] /= A[i, i]
Anorm[i, :] /= A[i, i]
# Compute the split
D = np.eye(n)
AL = la.tril(D - Anorm)
AU = la.triu(D - Anorm)
N = np.eye(n) - AL
P = AU
# Compute the convergence matrix and check its spectral radius
M = np.dot(la.inv(N), P)
eigenvalues, eigenvectors = la.eig(M)
rho = np.amax(np.absolute(eigenvalues))
if (rho > 1):
print("Gauss-Seidel will not converge as the"\
" largest eigenvalue of the convergence matrix is {}".format(rho))
for j in range(MaxSteps):
x_old = x.copy()
for i in range(n):
x[i] = bnorm[i] + np.dot(AL[i, :], x) + np.dot(AU[i, :], x_old)
if (la.norm(x - x_old) < tolerance):
print("Gauss-Seidel converged in {} iterations.".format(j))
break
return x
def Jacobi(A, b, tolerance = 1.e-10, MaxSteps = 100):
"""Solve the linear system A x = b using Jacobi's method,
starting from the trivial initial guess."""
x = np.zeros_like(b)
Anorm = A.copy()
bnorm = b.copy()
n = len(b)
for i in range(n):
bnorm[i] /= A[i, i]
Anorm[i, :] /= A[i, i]
# Compute the split
N = np.eye(n)
P = N - Anorm
AL = la.tril(P)
AU = la.triu(P)
# Compute the convergence matrix and check its spectral radius
M = np.dot(la.inv(N), P)
eigenvalues, eigenvectors = la.eig(M)
rho = np.amax(np.absolute(eigenvalues))
if (rho > 1):
print("Jacobi will not converge as the"\
" largest eigenvalue of the convergence matrix is {}".format(rho))
for j in range(MaxSteps):
x_old = x.copy()
x = bnorm + np.dot(AL + AU, x)
if (la.norm(x - x_old) < tolerance):
print "Jacobi converged in ", j, " iterations."
break
return x
def Jacobi(A, b, tolerance=1.e-10, MaxSteps=100):
"""Solve the linear system A x = b using Jacobi's method,
starting from the trivial initial guess."""
x = np.zeros_like(b)
Anorm = A.copy()
bnorm = b.copy()
n = len(b)
for i in range(n):
bnorm[i] /= A[i, i]
Anorm[i, :] /= A[i, i]
# Compute the split
N = np.eye(n)
P = N - Anorm
AL = la.tril(P)
AU = la.triu(P)
# Compute the convergence matrix and check its spectral radius
M = np.dot(la.inv(N), P)
eigenvalues, eigenvectors = la.eig(M)
rho = np.amax(np.absolute(eigenvalues))
if (rho > 1):
print("Jacobi will not converge as the"\
" largest eigenvalue of the convergence matrix is {}".format(rho))
for j in range(MaxSteps):
x_old = x.copy()
x = bnorm + np.dot(AL + AU, x)
if (la.norm(x - x_old) < tolerance):
print "Jacobi converged in ", j, " iterations."
break
return x
x = np.linspace(0.0, 1.0, np1)
y = np.linspace(0.0, 1.0, np1)
F = np.zeros((nm1, nm1))
for i in range(nm1):
F[0, i] += left(y[i + 1]) / h2
F[nm2, i] += right(y[i + 1]) / h2
F[i, 0] += bottom(x[i + 1]) / h2
F[i, nm2] += top(x[i + 1]) / h2
for j in range(nm2):
F[i, j] += f(x[i + 1], y[i + 1])
F *= h2
D = np.ones((nm1, nm1))
D = 5 * np.eye(nm1) - sl.triu(sl.tril(D, 1), -1)
start = t.time()
U = sweep(nm1, D, F).transpose()
end = t.time()
print('time = ', end - start, sep='')
def ua(x, y):
return x * x * y + y * y * x
Ua = np.zeros((np1, np1))
for i in range(np1):
for j in range(np1):
Ua[i, j] = ua(x[i], y[j])
import numpy as np
import scipy.linalg as sl
A = np.arange(16).reshape(4, 4)
print('A: \n', A)
# k = 0 时，保留对角线元素，对角线上方的所有元素格式化为0
print('tril(A, 0): \n', sl.tril(A))
# k = -1 时，包括对角线元素都被格式化为0
print('tril(A, -1): \n', sl.tril(A, -1))
# k = 1 时，边界上移到对角线上方的一格
print('tril(A, 1): \n', sl.tril(A, 1))
# triu 与 tril相反
# k = 0 时，保留对角线元素，对角线下方的所有元素格式化为0
print('triu(A, 0): \n', sl.triu(A))
# k = 1 时，包括对角线元素都被格式化为0
print('triu(A, 1): \n', sl.triu(A, 1))
# k = -1 时，边界下移到对角线下方的一格
print('triu(A, -1): \n', sl.triu(A, -1))
# 不管是tril还是triu，k的正值永远是把边界往上移，为负时往下移
## Kronecker product ## ================= kron = linalg.kron(a, a_inv) print(kron) ## ## Others ## ====== # (1): tril # --- # Make a copy of a matrix with elements above the k-th diagonal zeroed. # k == 0 is the main diagonal, k < 0 subdiagonal and k > 0 superdiagonal. print(linalg.tril(kron)) print(linalg.tril(kron, k=-1)) print(linalg.tril(kron, k=1)) # (2): triu # --- # Make a copy of a matrix with elements above the k-th diagonal zeroed. # k == 0 is the main diagonal, k < 0 subdiagonal and k > 0 superdiagonal. print(linalg.triu(kron)) print(linalg.triu(kron, k=-1)) print(linalg.triu(kron, k=1)) ###################################################################################################
schurlist = np.arange(nschur) + spmA.findBase()
pastix.setSchurUnknownList(pastix_data, schurlist)
# Perform analyze
pastix.task_analyze(pastix_data, spmA)
# Perform numerical factorization
pastix.task_numfact(pastix_data, spmA)
# Get the Schur complement
S = np.array(np.zeros((nschur, nschur)), order='F', dtype=spmA.dtype)
pastix.getSchur(pastix_data, S)
# Store both sides for linalg
if factotype != pastix.factotype.LU:
S += la.tril(S, -1).T
# 1- Apply P to b
pastix.subtask_applyorder(pastix_data, pastix.dir.Forward, x)
if factotype == pastix.factotype.LU:
# 2- Forward solve on the non Schur complement part of the system
pastix.subtask_trsm(pastix_data, pastix.side.Left, pastix.uplo.Lower,
pastix.trans.NoTrans, pastix.diag.Unit, x)
# 3- Solve the Schur complement part
x[-nschur:] = la.solve(S, x[-nschur:], sym_pos=False)
# 4- Backward solve on the non Schur complement part of the system
pastix.subtask_trsm(pastix_data, pastix.side.Left, pastix.uplo.Upper,
pastix.trans.NoTrans, pastix.diag.NonUnit, x)
