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)
