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