def matrix_solve_conjugate_gradient(matrix,
vector_b,
tol,
max_iter,
getIterCount=False):
error = tol * 10
count = 0
x_i = vector_b.copy() # x_0
residual = vector_add(
vector_b,
vector_scal_mult(
-1, convert_vec_mat(matrix_mult(matrix, convert_vec_mat(x_i)))))
direction = residual
d1new = vector_dot(residual, residual)
while error > tol and count < max_iter:
s = convert_vec_mat(matrix_mult(matrix, convert_vec_mat(direction)))
d1old = d1new
alpha = d1old / vector_dot(direction, s)
x_i = vector_add(x_i, vector_scal_mult(alpha, direction))
residual = vector_add(residual, vector_scal_mult(-alpha, s))
d1new = vector_dot(residual, residual)
direction = vector_add(residual,
vector_scal_mult(d1new / d1old, direction))
count += 1
error = vector_2norm(residual)
if getIterCount == True:
return x_i, count
else:
return x_i
def matrix_solve_steepest_descent(matrix,
vector_b,
tol,
max_iter,
getIterCount=False):
error = tol * 10
count = 0
x_i = vector_b.copy() #x_0
while error > tol and count < max_iter:
#print(count)# used for testing
#print(error)# used for testing
count += 1
residual = vector_add(
vector_b,
vector_scal_mult(
-1, convert_vec_mat(matrix_mult(matrix,
convert_vec_mat(x_i)))))
d1 = vector_dot(residual, residual)
d2 = vector_dot(
residual,
convert_vec_mat(matrix_mult(matrix, convert_vec_mat(residual))))
alpha = d1 / d2
x_i = vector_add(x_i, vector_scal_mult(alpha, residual))
error = vector_2norm(residual)
if getIterCount == True:
return x_i, count
else:
return x_i
def matrix_rayleigh_quotient_iteration(matrix,
tol,
max_iter,
getIterCount=False):
error = tol * 10
count = 0
v_i = matrix[0]
v_i = vector_scal_mult(1 / vector_2norm(v_i), v_i)
eigenvaluenew = matrix_mult(matrix_transpose(convert_vec_mat(v_i)),
matrix_mult(matrix,
convert_vec_mat(v_i)))[0][0]
I = [[int(i == j) for i in range(len(matrix))] for j in range(len(matrix))]
while error > tol and count < max_iter:
eigenvalueold = eigenvaluenew
v_i = matrix_solve_LU(
matrix_add(matrix, matrix_scal_mult(-eigenvaluenew, I)), v_i)
v_i = vector_scal_mult(1 / vector_2norm(v_i), v_i)
eigenvaluenew = matrix_mult(matrix_transpose(convert_vec_mat(v_i)),
matrix_mult(matrix,
convert_vec_mat(v_i)))[0][0]
error = abs(eigenvaluenew - eigenvalueold)
count += 1
if getIterCount == True:
return eigenvaluenew, count
else:
return eigenvaluenew
def matrix_QR_factorization(matrix):
matrix_columns = [[matrix[i][j] for i in range(len(matrix))] for j in range(len(matrix[0]))]
u_vectors = [[matrix[i][j] for i in range(len(matrix))] for j in range(len(matrix[0]))]
for j in range(len(matrix[0])):
for i in range(j):
u_vectors[j] = vector_add(u_vectors[j],vector_scal_mult(-1 * vector_dot(matrix_columns[j], u_vectors[i]), u_vectors[i]))
u_vectors[j] = vector_scal_mult(1 / vector_2norm(u_vectors[j]), u_vectors[j])
matrix_Q = [[u_vectors[i][j] for i in range(len(u_vectors))] for j in range(len(u_vectors[0]))]
matrix_R = matrix_mult(matrix_transpose(matrix_Q), matrix)
return [matrix_Q,matrix_R]
def matrix_ref(matrix):
n = len(matrix)
#m = len(matrix[0])
solution = copy.deepcopy(matrix)
for i in range(0, n):
for j in range(i + 1, n):
if solution[i][i] != 0:
solution[j] = vector_add(
solution[j],
vector_scal_mult(-solution[j][i] / solution[i][i],
solution[i]))
solution[i] = vector_scal_mult(1 / solution[i][i], solution[i])
return solution
def matrix_solve_jacobian(matrix, vector_b, tol, max_iter, getIterCount=False):
xnew = [0 for i in range(len(matrix))]
error = tol * 10
count = 0
while error > tol and count < max_iter:
# print(count) used for testing
# print(error) used for testing
count += 1
xold = xnew.copy()
xnew = vector_b.copy()
for i in range(len(matrix)):
for j in range(i):
xnew[i] = xnew[i] - matrix[i][j] * xold[j]
for j in range(i + 1, len(xnew)):
xnew[i] = xnew[i] - matrix[i][j] * xold[j]
xnew[i] = xnew[i] / matrix[i][i]
error = vector_2norm(
vector_add(
convert_vec_mat(matrix_mult(matrix, convert_vec_mat(xnew))),
vector_scal_mult(-1, vector_b)))
if getIterCount == True:
return xnew, count
else:
return xnew
def matrix_QR_factorization_householder(matrix):
matrix_R = [[matrix[j][i] for i in range(len(matrix[0]))]
for j in range(len(matrix))] #HA starts by being A
matrix_Q = [[0 for j in range(len(matrix))] for k in range(len(matrix))
] #Q starts by being the identity matrix
for j in range(len(matrix)):
matrix_Q[j][j] = 1
for i in range(len(matrix[0]) - 1):
a = [
matrix_R[j][i] for j in range(len(matrix_R))
] #a is the i'th column of matrix_R, with 0s inserted above the diagonal
for j in range(i):
a[j] = 0
r = [0] * len(
a
) #r is just a 0 vector, with the i'th column being the magnitude of a
r[i] = vector_2norm(a)
u = vector_add(a, vector_scal_mult(-1, r))
i_ = [[0 for j in range(len(matrix))] for k in range(len(matrix))]
for j in range(len(matrix)):
i_[j][j] = 1
if vector_dot(u, u) != 0:
h = matrix_add(i_,
matrix_scal_mult(-2 / vector_dot(u, u),
matrix_outer(u, u))) #computer h_i
else: #if u ends up being the 0 matrix, then h is just the identity matrix
h = i_
matrix_Q = matrix_mult(matrix_Q, h)
matrix_R = matrix_mult(h, matrix_R)
return [matrix_Q, matrix_R]
def matrix_inverse_power_iteration(matrix,
alpha,
tol,
max_iter,
getIterCount=False):
error = tol * 10
count = 0
eigenvaluenew = 0
I = [[-int(i == j) * alpha for i in range(len(matrix))]
for j in range(len(matrix))]
v_i = matrix[0]
while error > tol and count < max_iter:
eigenvalueold = eigenvaluenew
v_i = matrix_solve_LU(matrix_add(matrix, I), v_i)
v_i = vector_scal_mult(1 / vector_2norm(v_i), v_i)
eigenvaluenew = matrix_mult(matrix_transpose(convert_vec_mat(v_i)),
matrix_mult(matrix,
convert_vec_mat(v_i)))[0][0]
count += 1
error = abs(eigenvaluenew - eigenvalueold)
if getIterCount == True:
return eigenvaluenew, count
else:
return eigenvaluenew
def matrix_solve_jacobian_smart(matrix,
vector_b,
tol,
max_iter,
getIterCount=False):
matrix_mod = matrix_mult(matrix_transpose(matrix), matrix)
vector_mod = convert_vec_mat(
matrix_mult(matrix_transpose(matrix), convert_vec_mat(vector_b)))
alpha = 0
#This code finds the right valu for alpha to garintee that matrix_mod is diagonoly dominant.
for i in range(len(matrix_mod)):
tempVal = 0
for j in range(len(matrix_mod[0])):
if j != i:
tempVal += matrix_mod[i][j]
else:
tempVal -= matrix_mod[i][j]
alpha = max(alpha, tempVal)
xnew = [0 for i in range(len(matrix_mod))]
error = tol * 10
count = 0
while error > tol and count < max_iter:
count += 1
xold = xnew.copy()
xnew = [(vector_mod[i] + alpha * xold[i]) for i in range(len(xold))]
for i in range(len(matrix_mod)):
for j in range(i):
xnew[i] = xnew[i] - matrix_mod[i][j] * xold[j]
for j in range(i + 1, len(xnew)):
xnew[i] = xnew[i] - matrix_mod[i][j] * xold[j]
for j in range(len(xnew)):
xnew[j] = xnew[j] / (matrix_mod[j][j] + alpha)
error = vector_2norm(
vector_add(
convert_vec_mat(matrix_mult(matrix, convert_vec_mat(xnew))),
vector_scal_mult(-1, vector_b)))
if getIterCount == True:
return xnew, count
else:
return xnew
def abs_error_2norm(true_vector, appr_vector):
abs_error = vector_2norm(
vector_add(true_vector, vector_scal_mult(-1, appr_vector)))
return abs_error
def abs_error_1norm(true_vector, appr_vector):
error_vector = vector_add(true_vector, vector_scal_mult(-1, appr_vector))
abs_error = vector_1norm(error_vector)
return abs_error
def vector_SAXPY(scalar, vector1, vector2):
return vector_add(vector_scal_mult(scalar, vector1), vector2)
def abs_error_infnorm(true_vector, appr_vector):
error_vector = vector_add(true_vector, vector_scal_mult(-1, appr_vector))
for i in range(len(error_vector)):
error_vector[i] = abs(error_vector[i])
abs_error = vector_infnorm(error_vector)
return abs_error
