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_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_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_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_least_squares_QR(matrix,vector): (matrix_Q, matrix_R) = matrix_QR_factorization_mod(matrix) print(matrix_Q) print(matrix_R) matrix_Qtb = matrix_mult(matrix_transpose(matrix_Q), convert_vec_mat(vector)) print(matrix_Qtb) solution = matrix_solve_upper_tri(matrix_R, convert_vec_mat(matrix_Qtb)) print(solution) return solution
def matrix_power_iteration(matrix, tol, max_iter): error = tol * 10 count = 0 eigenvaluenew = 1 v_i = convert_vec_mat(matrix[0]) while error > tol and count < max_iter: eigenvalueold = eigenvaluenew v_i = matrix_mult(matrix, v_i) v_i = matrix_scal_mult(1 / vector_2norm(convert_vec_mat(v_i)), v_i) eigenvaluenew = matrix_mult(matrix_transpose(v_i), matrix_mult(matrix, v_i))[0][0] count += 1 error = abs(eigenvaluenew - eigenvalueold) return eigenvaluenew
def matrix_solve_gauss_seidel_test(): matrix1 = gen_rand_matrix(100) matrix2 = gen_sym_matrix(100) matrix3 = gen_diagdom_matrix(100) matrix4 = gen_diagdom_sym_matrix(100) matrices = [matrix1, matrix2, matrix3, matrix4] vector = [1] * len(matrix1) for i in range(len(matrices)): b = matrix_mult(matrices[i], convert_vec_mat(vector)) starttime = time.time() solution = matrix_solve_gauss_seidel(matrices[i], convert_vec_mat(b), 0.00001, 1000, getIterCount=True) print("Time: " + str(time.time() - starttime)) print("# of iterations: " + str(solution[1])) print(solution[0])
def steepest_descent_conjugate_gradient_compare(): n=100; random_matrix = gen_diagdom_sym_matrix(n) b = convert_vec_mat(matrix_mult(random_matrix,[[1]] * n)) #the solution should be a vector of 1s. (solution1,iterCount1) = matrix_solve_steepest_descent(random_matrix,b,0.0001,10000,True) (solution2, iterCount2) = matrix_solve_conjugate_gradient(random_matrix, b, 0.0001, 10000, True) print("Steepest Descent " + str(n) + "x" + str(n) + ": Absolute Error=" + str(abs_error_2norm([1] * n,solution1)) + " Iteration Count=" + str(iterCount1)) print("Conjugate Gradient " + str(n) + "x" + str(n) + ": Absolute Error=" + str(abs_error_2norm([1] * n,solution2)) + " Iteration Count=" + str(iterCount2))
def matrix_solve_jacobian_test(): matrix = gen_sqr_diagdom_matrix() vector = [1] * len(matrix) print("created matrix") starttime = time.time() solution = matrix_solve_jacobian(matrix, vector, 0.001, 10000) print("Time: " + str(time.time() - starttime)) print(matrix_mult(matrix, convert_vec_mat(solution)))
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 hilbert_matrix_steepest_descent_test(): selection = [4, 8, 16, 32] hilbert_matrix = [] solution = [] # Create the hilbert matrices and their corresponding Q factorization matrix. for n in selection: hilbert_matrix.append([[1 / (1 + i + j) for i in range(n)] for j in range(n)]) # Hilbert Matrix generator solution.append( matrix_solve_steepest_descent(hilbert_matrix[-1], [1] * n, 0.0001, 10000)) for i in range(0, len(selection)): # 4, 6, 8, 10 #print(matrix_mult(hilbert_matrix[i],convert_vec_mat(solution[i]))) print("Absolute error for " + str(selection[i]) + "x" + str(selection[i]) + ": " + str( abs_error_2norm([1] * selection[i], convert_vec_mat( matrix_mult(hilbert_matrix[i], convert_vec_mat( solution[i])))))) print(solution[i])
def steepest_descent_conjugate_gradient_gauss_seidel_compare(): n=100; random_matrix = gen_diagdom_sym_matrix(n) b = convert_vec_mat(matrix_mult(random_matrix,[[1]] * n)) #the solution should be a vector of 1s. start_time = time.time() (solution1,iterCount1) = matrix_solve_steepest_descent(random_matrix,b,0.00000000001,10000,True) time1 = time.time() - start_time start_time = time.time() (solution2, iterCount2) = matrix_solve_conjugate_gradient(random_matrix, b, 0.00000000001, 10000, True) time2 = time.time() - start_time start_time = time.time() (solution3, iterCount3) = matrix_solve_gauss_seidel(random_matrix, b, 0.00000000001, 10000, True) time3 = time.time() - start_time print("Steepest Descent " + str(n) + "x" + str(n) + ": Absolute Error=" + str(abs_error_2norm([1] * n,solution1)) + " Iteration Count=" + str(iterCount1) + " time=" + str(time1)) print("Conjugate Gradient " + str(n) + "x" + str(n) + ": Absolute Error=" + str(abs_error_2norm([1] * n,solution2)) + " Iteration Count=" + str(iterCount2) + " time=" + str(time2)) print("Gauss Seidel " + str(n) + "x" + str(n) + ": Absolute Error=" + str(abs_error_2norm([1] * n,solution3)) + " Iteration Count=" + str(iterCount3) + " time=" + str(time3))
def matrix_solve_least_square(matrix, vector): matrix_At_A = matrix_mult(matrix_transpose(matrix), matrix) vector_At_b = matrix_mult(matrix_transpose(matrix), convert_vec_mat(vector)) solution = matrix_solve(matrix_At_A, convert_vec_mat(vector_At_b)) return solution
def matrix_solve_least_squares_QR_householder(matrix, vector): (matrix_Q, matrix_R) = matrix_QR_factorization_householder(matrix) matrix_Qtb = matrix_mult(matrix_transpose(matrix_Q), convert_vec_mat(vector)) solution = matrix_solve_upper_tri(matrix_R, convert_vec_mat(matrix_Qtb)) return solution
def matrix_solve_QR_factorization(matrix, vector): (matrix_Q, matrix_R) = matrix_QR_factorization(matrix) matrix_Qtb = matrix_mult(matrix_transpose(matrix_Q), convert_vec_mat(vector)) solution = matrix_solve_upper_tri(matrix_R, convert_vec_mat(matrix_Qtb)) return solution