def sortJacobi(lam, x):
n = len(lam)
for i in range(n - 1):
index = i
val = lam[i]
for j in range(i + 1, n):
if lam[j] < val:
index = j
val = lam[j]
if index != i:
swap.swapRows(lam, i, index)
swap.swapCols(x, i, index)
def sortJacobi(lam,x):
n = len(lam)
for i in range(n-1):
index = i
val = lam[i]
for j in range(i+1,n):
if lam[j] < val:
index = j
val = lam[j]
if index != i:
swap.swapRows(lam,i,index)
swap.swapCols(x,i,index)
def gaussJordanPivot(a, tol=1.0e-9):
n = len(a)
seq = array(range(n))
# Set up scale factors
s = zeros((n), type=Float64)
for i in range(n):
s[i] = max(abs(a[i, :]))
for i in range(n):
# Row interchange, if needed
p = int(argmax(abs(a[i:n, i]) / s[i:n])) + i
if abs(a[p, i]) < tol: error.err('Matrix is singular')
if p != i:
swap.swapRows(s, i, p)
swap.swapRows(a, i, p)
swap.swapRows(seq, i, p)
# Elimination phase
temp = a[i, i]
a[i, i] = 1.0
a[i, 0:n] = a[i, 0:n] / temp
for k in range(n):
if k != i:
temp = a[k, i]
a[k, i] = 0.0
a[k, 0:n] = a[k, 0:n] - a[i, 0:n] * temp
# Rearrange columns in the right sequence
for i in range(n):
swap.swapCols(a, i, seq[i])
swap.swapRows(seq, i, seq[i])
return a
def gaussJordanPivot(a,tol=1.0e-9):
n = len(a)
seq = array(range(n))
# Set up scale factors
s = zeros((n),type=Float64)
for i in range(n):
s[i] = max(abs(a[i,:]))
for i in range(n):
# Row interchange, if needed
p = int(argmax(abs(a[i:n,i])/s[i:n])) + i
if abs(a[p,i]) < tol: error.err('Matrix is singular')
if p != i:
swap.swapRows(s,i,p)
swap.swapRows(a,i,p)
swap.swapRows(seq,i,p)
# Elimination phase
temp = a[i,i]
a[i,i] = 1.0
a[i,0:n] = a[i,0:n]/temp
for k in range(n):
if k != i:
temp = a[k,i]
a[k,i] = 0.0
a[k,0:n] = a[k,0:n] - a[i,0:n]*temp
# Rearrange columns in the right sequence
for i in range(n):
swap.swapCols(a,i,seq[i])
swap.swapRows(seq,i,seq[i])
return a
def LUdecomp(a, tol=1.0e-9):
n = len(a)
seq = array(range(n))
# Set up scale factors
s = zeros((n), dtype=float64)
for i in range(n):
s[i] = max(abs(a[i, :]))
for k in range(0, n - 1):
# Row interchange, if needed
p = int(argmax(abs(a[k:n, k]) / s[k:n])) + k
if abs(a[p, k]) < tol: error.err('Matrix is singular')
if p != k:
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
swap.swapRows(seq, k, p)
# Elimination
for i in range(k + 1, n):
if a[i, k] != 0.0:
lam = a[i, k] / a[k, k]
a[i, k + 1:n] = a[i, k + 1:n] - lam * a[k, k + 1:n]
a[i, k] = lam
return a, seq
def gaussPivot(a, b, tol=1.0e-12):
n = len(b)
# Set up scale factors
s = zeros((n), dtype=float64)
for i in range(n):
s[i] = max(abs(a[i, :]))
for k in range(0, n - 1):
# Row interchange, if needed
p = int(argmax(abs(a[k:n, k]) / s[k:n])) + k
if abs(a[p, k]) < tol: error.err('Matrix is singular')
if p != k:
swap.swapRows(b, k, p)
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
# Elimination
for i in range(k + 1, n):
if a[i, k] != 0.0:
lam = a[i, k] / a[k, k]
a[i, k + 1:n] = a[i, k + 1:n] - lam * a[k, k + 1:n]
b[i] = b[i] - lam * b[k]
if abs(a[n - 1, n - 1]) < tol: error.err('Matrix is singular')
# Back substitution
for k in range(n - 1, -1, -1):
b[k] = (b[k] - dot(a[k, k + 1:n], b[k + 1:n])) / a[k, k]
return b
def gaussPivot(a,b,tol=1.0e-12):
n = len(b)
# Set up scale factors
s = zeros((n),type=Float64)
for i in range(n):
s[i] = max(abs(a[i,:]))
for k in range(0,n-1):
# Row interchange, if needed
p = int(argmax(abs(a[k:n,k])/s[k:n])) + k
if abs(a[p,k]) < tol: error.err('Matrix is singular')
if p != k:
swap.swapRows(b,k,p)
swap.swapRows(s,k,p)
swap.swapRows(a,k,p)
# Elimination
for i in range(k+1,n):
if a[i,k] != 0.0:
lam = a[i,k]/a[k,k]
a[i,k+1:n] = a [i,k+1:n] - lam*a[k,k+1:n]
b[i] = b[i] - lam*b[k]
if abs(a[n-1,n-1]) < tol: error.err('Matrix is singular')
# Back substitution
for k in range(n-1,-1,-1):
b[k] = (b[k] - dot(a[k,k+1:n],b[k+1:n]))/a[k,k]
return b
def LUdecomp(a, tol=1.0e-9):
n = len(a)
seq = array(range(n))
# Set up scale factors
s = zeros((n), type=Float64)
for i in range(n):
s[i] = max(abs(a[i, :]))
for k in range(0, n - 1):
# Row interchange, if needed
p = int(argmax(abs(a[k:n, k]) / s[k:n])) + k
if abs(a[p, k]) < tol:
error.err("Matrix is singular")
if p != k:
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
swap.swapRows(seq, k, p)
# Elimination
for i in range(k + 1, n):
if a[i, k] != 0.0:
lam = a[i, k] / a[k, k]
a[i, k + 1 : n] = a[i, k + 1 : n] - lam * a[k, k + 1 : n]
a[i, k] = lam
return a, seq
def guassPivot(a,b,tol=1.0e-12):
n = len(b)
s = np.zeros(n)
for i in range(n):
s[i] = max(np.abs(a[i,:]))
for k in range(0,n-1):
p = np.argmax(np.abs(a[k:n,k]) / s[k:n]) + k
if abs(a[p,k]) < tol: error.err('Matrix is Singular'):
if p != k:
swap.swapRows(b, k, p)
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
for i in range(k+1,n):
if a[i,k] != 0.0:
lam = a[i,k]/a[k,k]
a[i,k+1:n] = a[i, k+1:n] - lam*a[k, k+1:n]
b[i] = b[i] - lam*b[k]
if abs(a[n-1,n-1)]) < tol: error.err('Matrix is Singular'):
b[n-1] = b[n-1]/a[n-1,n-1]
for k in range(n-1, -1,-1):
b[k] = (b[k]- np.dot(a[k,k+1:n], b[k+1:n]))/a[k,k]
def gaussPivot(a,b,tol=1.0e-12):
n = len(b)
# Mengatur faktor skala
s = np.zeros(n)
for i in range(n):
s[i] = max(np.abs(a[i,:]))
for k in range(0,n-1):
# menukar baris
p = np.argmax(np.abs(a[k:n,k])/s[k:n]) + k
if abs(a[p,k]) < tol: error.err('Tidak dapat dihitung : matriks singular')
if p != k:
swap.swapRows(b,k,p)
swap.swapRows(s,k,p)
swap.swapRows(a,k,p)
# Eliminasi
for i in range(k+1,n):
if a[i,k] != 0.0:
lam = a[i,k]/a[k,k]
a[i,k+1:n] = a[i,k+1:n] - lam*a[k,k+1:n]
b[i] = b[i] - lam*b[k]
if abs(a[n-1,n-1]) < tol: error.err('Tidak dapat dihitung : matriks singular')
# Substutisi kembali untuk mencari nilai variabel
b[n-1] = b[n-1]/a[n-1,n-1]
for k in range(n-2,-1,-1):
b[k] = (b[k] - np.dot(a[k,k+1:n],b[k+1:n]))/a[k,k]
return b
def LUpivotdecomp(a, tol=1.0e-9):
n = len(a)
seq = np.array(range(n))
# Set up scale factors
s = np.zeros(n)
for i in range(n):
s[i] = max(abs(a[i, :]))
for k in range(0, n - 1):
# Row interchange, if needed
p = np.argmax(abs(a[k:n, k]) / s[k:n]) + k
if abs(a[p, k]) < tol:
print('matrix is singular')
sys.exit()
if p != k:
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
swap.swapRows(seq, k, p)
# Elimination
for i in range(k + 1, n):
if a[i, k] != 0.0:
lam = a[i, k] / a[k, k]
a[i, k + 1:n] = a[i, k + 1:n] - lam * a[k, k + 1:n]
a[i, k] = lam
return a, seq
def gausspivot(a, b, tol=1.0e-12):
n = len(b)
# Set up scale factors
s = np.zeros(n)
for i in range(n):
s[i] = max(np.abs(a[i, :]))
for k in range(0, n - 1):
# Row interchange, if needed
p = np.argmax(np.abs(a[k:n, k]) / s[k:n]) + k
if abs(a[p, k]) < tol:
print('matrix is singular')
sys.exit()
if p != k:
swap.swapRows(b, k, p)
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
# Elimination
for i in range(k + 1, n):
if a[i, k] != 0.0:
lam = a[i, k] / a[k, k]
a[i, k + 1:n] = a[i, k + 1:n] - lam * a[k, k + 1:n]
b[i] = b[i] - lam * b[k]
if abs(a[n - 1, n - 1]) < tol:
print('matrix is singular')
sys.exit()
# Back substitution
b[n - 1] = b[n - 1] / a[n - 1, n - 1]
for k in range(n - 2, -1, -1):
b[k] = (b[k] - np.dot(a[k, k + 1:n], b[k + 1:n])) / a[k, k]
return b
def LUdecomp(a,tol=1.0e-9):
n = len(a)
seq = np.array(range(n))
# Set up scale factors
s = np.zeros((n))
for i in range(n):
s[i] = max(abs(a[i,:]))
for k in range(0,n-1):
# Row interchange, if needed
p = np.argmax(np.abs(a[k:n,k])/s[k:n]) + k
if abs(a[p,k]) < tol: error.err('Matrix is singular')
if p != k:
swap.swapRows(s,k,p)
swap.swapRows(a,k,p)
swap.swapRows(seq,k,p)
# Elimination using outer product
a[k+1:,k] /=a[k,k]
a[k+1:,k+1:] -= np.outer(a[k+1:,k],a[k,k+1:])
return a,seq
def gaussPivot(a, b, tol=1.0e-12):
n = len(b)
# Set up scale factors
s = np.zeros(n)
for i in range(n):
s[i] = max(np.abs(a[i, :]))
for k in range(0, n - 1):
# Row interchange, if needed
p = np.argmax(np.abs(a[k:n, k]) / s[k:n]) + k
if abs(a[p, k]) < tol: error.err('Matrix is singular')
if p != k:
swap.swapRows(b, k, p)
swap.swapRows(s, k, p)
swap.swapRows(a, k, p)
# Elimination
for i in range(k + 1, n):
if a[i, k] != 0.0:
lam = a[i, k] / a[k, k]
a[i, k + 1:n] = a[i, k + 1:n] - lam * a[k, k + 1:n]
b[i] = b[i] - lam * b[k]
if abs(a[n - 1, n - 1]) < tol: error.err('Matrix is singular')
# Back substitution
b[n - 1] = b[n - 1] / a[n - 1, n - 1]
for k in range(n - 2, -1, -1):
b[k] = (b[k] - np.dot(a[k, k + 1:n], b[k + 1:n])) / a[k, k]
return b
#A = np.array([[2.,-2.,6.],[-2.,4.,3.],[-1.,8.,4.]])
#B = np.array([16.,0.,-1.])
#X = gaussPivot(A,B)
#print('X = {0}'.format(X))
def LUpivot(a1, b1, tol=1.0e-9, modifyOriginal=True):
##def LUpivot(a1, modifyOriginal=True):
if modifyOriginal:
a = a1
else:
a = a1.copy()
n = len(a)
seq = array(range(n))
# Set up scale factors
s = zeros(n)
for i in range(n):
s[i] = max(abs(a[i,:]))
for k in range(0,n-1):
# Row interchange, if needed
p = argmax(abs(a[k:n,k])/s[k:n]) + k
if abs(a[p,k]) < tol: error.err('Matrix is singular')
if p != k:
swap.swapRows(s,k,p)
swap.swapRows(a,k,p)
swap.swapRows(seq,k,p)
# Elimination
for i in range(k+1,n):
if a[i,k] != 0.0:
lam = a[i,k]/a[k,k]
a[i,k+1:n] = a[i,k+1:n] - lam*a[k,k+1:n]
a[i,k] = lam
b = b1.copy()
for i in range(n):
b[i] = b1[seq[i]]
return a,b,seq
