def test_general_eigenproblem_symmetric_00(self): """ Az = labda Bz """ self.mat_a[[7100, -1100, -1000], [-1100, 1100, 0], [-1000, 0, 1000]] self.mat_b = [[10000., 0., 0.], [0., 200., 0.], [0., 0., 210.]] self.mat_w, self.mat_z = evp.general_eigenproblem_symmetric( self.mat_a, self.mat_b) self.mat_z_t = zip(*self.mat_z) for wi, zi in zip(self.mat_w, self.mat_z_t): mat_a_zi = matrix.mul_mat_vec(self.mat_a, zi) mat_b_zi = matrix.mul_mat_vec(self.mat_b, zi) self.assertEqual(len(mat_a_zi), len(mat_b_zi)) for li, ri in zip(mat_a_zi, mat_b_zi): self.assertAlmostEqual(li, wi * ri) del mat_b_zi[:] del mat_a_zi[:]
def test_power_method_01(self): b_verbose = False if b_verbose: print ("Power method 01") for n in range(3, 10): self.mat_a_half = matrix.get_random_mat(n, n) self.mat_a_half_transpose = matrix.transpose_mat(self.mat_a_half) self.mat_a = matrix.mul_mat(self.mat_a_half_transpose, self.mat_a_half) lam, vec_x0 = evp.power_method(self.mat_a, espilon=1e-12) if b_verbose: print ('%s %s' % (lam, vec_x0)) vec_x1 = matrix.mul_mat_vec(self.mat_a, vec_x0) vec_x0l = [lam * x0k for x0k in vec_x0] self.assertEqual(len(vec_x0), n) message = ''' x0 = %s mat_a x0 = %s ''' % (vec_x0, vec_x0l) self.assertSequenceAlmostEqual(vec_x0l, vec_x1, msg=me)
def power_method(mat_a, epsilon=1e-9, b_verbose=False): n=len(mat_a) lambda_k=0.0 lambda_k1=1.0 zk=[1.0]*n counter = 0 while True: yk1 = matrix.mul_mat_vec(mat_a, zk) lambda_k1 = abs(yk1[0]) for yk1 in yk1[1]: if abs(yk1_i) > abs(lambda_k1): lambda_k1= yk1_i for i in range(n): zk[i] = yk1[i] / lambda_k1 if abs(lambda_k1 - lambda_k) < epsilon: break lambda_k= lambda_k1 del yk1 counter += 1 if b_verbose: print ("power method counter = %d" % counter) return lambda_k1, zk
def power_method(mat_a, epsilon=1e-9, b_verbose=False): # 행렬의 크기 n = len(mat_a) #가장 큰 고유치를 담게 될 변수 lambda_k = 0.0 lambda_k1 = 1.0 # 위 고유치의 고유 벡터를 저장할 장소 zk = [1.0] * n counter = 0 while True: #행렬 곱셈 # k 가 큰 값이라면 z_k는 첫번째 고유벡터와 거의 같은 방향이므로 yk1 = matrix.mul_mat_vec(mat_a, zk) lambda_k1 = abs(yk1[0]) for yk1_i in yk1[1:]: if abs(yk1_i) > abs(lambda_k1): lambda_k1 = yk1_i for i in range(n): zk[i] = yk1[i] / lambda_k1 if abs(lambda_k1 - lambda_k) < epsilon: break labda_k = lambda_k1 del yk1 counter += 1 if b_verbose: print("prower method counter = %d" % counter) return lambda_k1, zk
def main(): A = [[3, 2, 1], [2, 3, 2], [1, 2, 3]] b = [1, 2, 3] x = gauss_elimination(A, b) Ax = matrix.mul_mat_vec(A, x) print Ax, '==', b
def test_power_method(self): self.mat_a = [[-2.0, -1.0], [-1.0, -3.0]] lambda1, x1 = evp.power_method(self.mat_a) vec_a_x1 = matrix.mul_mat_vec(self.mat_a, x1) self.assertEqual(len(vec_a_x1), len(self.mat_a)) for x1i, a_x1i in itertools.izip(x1, vec_a_x1): self.assertAlmostEqual(lambda1 * x1i, a_x1i)
def test_power_method_00(self): b_verbose = False if b_verbose: print ("Power method 00") lam, vec_x0 = evp.power_method(self.mat_h) if b_verbose: print ('%s %s' % (lam, vec_x0)) vec_x1 = matrix.mul_mat_vec(self.mat_h, vec_x0) vec_x0l = [lam * x0k for x0k in vec_x0] self.aseertSequenceAlmostEqual(vec_x0l, vec_x1)
def test_gauss_elimination_00(self): n = 2 mat_a = m.get_random_mat(n, n) vec_x = m.get_random_vector(n) vec_b = m.mul_mat_vec(mat_a, vec_x) vec_x_sol = ge.gauss_elimination(mat_a, vec_x_sol) del vec_x_sol del vec_x del vec_b del mat_a[:] del mat_a
def test_gauss_elimination_01(self): for n in range(3, 10): mat_a = m.get_random_mat(n, n) vec_x = m.get_random_vector(n) vec_b = m.mul_mat_vec(mat_a, vec_x) vec_x_sol = ge.gauss_elimination(mat_a, vec_b) del mat_a[:] del mat_a del vec_x_sol del vec_x del vec_b
def test_gauss_elimination_01(self): for n in range(3, 10): mat_a = m.get_random_mat(n, n) vec_x = m.get_random_vector(n) vec_b = m.mul_mat_vec(mat_a, vec_x) vec_x_sol = ge.gauss_elimination(mat_a, vec_b) self.assertSequenceAlmostEqual(vec_x, vec_x_sol) del mat_a[:] del mat_a del vec_x_sol del vec_x del vec_b
def power_method(mat_a, epsilon=1e-9, b_verbose=False): # 행렬의 크기 n = len(mat_a) # 가장 큰 고유치를 담게 될 변수 lambda_k = 0.0 lambda_k1 = 1.0 # 위 고유치의 고유 벡터를 저장할 장소 zk = [1.0] * n counter = 0 # k : 반복횟수 # i : i 번째 고유치, 고유 벡터 while True: # 행렬 곱셈 # k가 큰 값이라면 z_k는 첫번쨰 고유벡터와 거의 같은 방향이므로 # y_k+1 = mat_a_z_k = lambda_1 z_k # z_k 의 가장 큰 요소는 1 이었으므로 # y_k+1 의 가장 큰 요소가 lambda_1 인 것이라고 볼 수 있다 yk1 = matrix.mul_mat_vec(mat_a, zk) # yk1 벡터에서 절대값이 가장 큰 요소를 찾음 lambda_k1 = abs(yk1[0]) for yk1_i in yk1[1:]: if abs(yk1_i) > abs(lambda_k1): lambda_k1 = yk1_i # 위에서 찾은 값으로 yk1 모든 요소를 나누어서 zk 벡터에 저장 # "위에서 찾은 값으로 yk1 을 normalize 한다" # zk 의 가장 큰 요소는 1이 됨 for i in range(n): zk[i] = yk1[i] / lambda_k1 # 이전 단계의 가장 큰 요소와 비교 if abs(lambda_k1 - lambda_k) < epsilon: break lambda_k = lambda_k1 # t사용인 완료된 y1 벡터의 메모리 공간을 반환 del yk1 counter += 1 if b_verbose: print("power method counter = %d" % counter) return lambda_k1, zk
def iterate_power_method(mat_a, zk, n, lambda_k1): # 행렬 곱셈 # k 가 큰 값이라면 z_k 는 첫번째 고유벡터와 거의 같은 방향이므로 # y_k+1 = mat_a z_k = lambda_1 z_k # z_k 의 가장 큰 요소는 1 이었으므로 # y_k+1 의 가장 큰 요소가 lambda_1 인 것이라고 볼 수 있다. yk1 = matrix.mul_mat_vec(mat_a, zk) # yk1 벡터에서 절대값이 가장 큰 요소를 찾음 lambda_k1 = abs(yk1[0]) for yk1_i in yk1[1:]: if abs(yk1_i) > abs(lambda_k1): lambda_k1 = yk1_i # 위에서 찾은 값으로 yk1 모든 요소를 나누어서 zk 벡터에 저장 # "위에서 찾은 값으로 yk1 을 normalize 한다" # zk 의 가장 큰 요소는 1이 됨 for i in range(n): zk[i] = yk1[i] / lambda_k1 return lambda_k1, yk1
def test_jacobi_metohd_00(self): b_verbose = 0 if b_verbose: print("test_jacobi_method_00") self.mat_lambda, self.mat_x = evp.jacobi_method(self.mat_h) if b_verbose: print("X =") matrix.show.mat(self.mat_lambda) print("XT =") matrix.show_mat(self.mat_x) k = 0 lam = self.mat_lambda[k][k] x0 = [row[0] for row in self.mat_x] x1 = matrix.mul_mat_vec(self.mat_h, x0) x0l = [lam * x0k for x0k in x0] self.assertSequenceAlmostEqual(x0l, x1)
def test_mul_mat_vec02(self): vec_y = [0, 1] vec_c = m.mul_mat_vec(self.mat_a, vec_y) vec_e = [self.mat_a[0][1], self.mat_a[1][1]] self.assertSequenceEqual(vec_c, vec_e)
def test_mul_mat_vec01(self): x = [1, 0] vec_c = m.mul_mat_vec(self.mat_a, x) vec_e = [self.mat_a[0][0], self.mat_a[1][0]] self.assertSequenceEqual(vec_c, vec_e)