def decompose(self, matrix):
orthogonal_matrix = MatrixFactory.identity(size=matrix.row_count)
for j in range(matrix.column_count - 1):
e = numpy.zeros((matrix.column_count - j, 1))
e[0, 0] = 1
e = Matrix(e)
h = self.create_householder_reflection(
matrix.get_column_vector(j, j), e)
h = MatrixFactory.build_block_matrix(
d=h,
row_count=orthogonal_matrix.row_count,
col_count=orthogonal_matrix.row_count)
for i in range(j):
h.matrix_vectors[i, i] = 1
matrix = h * matrix
orthogonal_matrix = h * orthogonal_matrix
return orthogonal_matrix.transpose(), matrix
def create_orthonormal_vector(*vectors: Vector):
missing_column_vectors = vectors[0].row_count - len(vectors)
null_vectors = []
for i in range(missing_column_vectors):
null_vectors.append(VectorFactory.null_vector(vectors[0].row_count))
matrix = MatrixFactory.matrix_of_column_vectors(*vectors, *null_vectors)
qr_decomposition = QRDecomposition()
created_vector = qr_decomposition.solve(matrix.transpose(), 0)
return created_vector * (1 / Norm.euclidean_norm(created_vector))
def decompose(self, matrix: Matrix):
left = MatrixFactory().identity(matrix.row_count)
for j in range(0, matrix.column_count - 1):
elimination_matrix = LRDecomposition.create_column_elimination_matrix(
matrix, j)
matrix = elimination_matrix * matrix
left = left * LRDecomposition.invert_elimination_matrix(
elimination_matrix, j)
return left, matrix
def create_column_elimination_matrix(cls, matrix, column):
elimination_matrix = np.zeros((matrix.row_count, matrix.column_count),
dtype=matrix.dtype)
for i in range(column + 1, matrix.row_count):
print(matrix)
print(matrix[i, column], "/", matrix[column, column], " = ",
matrix[i, column] / matrix[column, column])
elimination_matrix[i, column] = matrix[i, column] / matrix[column,
column]
return MatrixFactory().identity(matrix.column_count) - Matrix(
elimination_matrix, dtype=matrix.dtype, preserve_dt=True)
def create_householder_matrix(to_project):
"""
:param to_project:
:return:
"""
i = MatrixFactory().identity(to_project.row_count)
unit_vector = VectorFactory.create_unit_vector(to_project.row_count, 0)
orthogonal_projection = to_project + numpy.sign(to_project[
0, 0]) * Norm.VectorNorm.euclidean_norm(to_project) * unit_vector
orthogonal_projection = orthogonal_projection * (
1 / Norm.VectorNorm.euclidean_norm(orthogonal_projection))
res = i - 2 * orthogonal_projection * orthogonal_projection.transpose()
return res
def test_block_matrix(self):
a = Matrix([[1, 2], [2, 3]])
b = Matrix([[3, 2, 6], [2, 3, -10]])
c = Matrix([[1, 2], [2, 3], [7, 7]])
d = Matrix([[1, 2, 9], [2, 3, 69], [56, 2, 67]])
res = MatrixFactory.build_block_matrix(a=a,
b=b,
c=c,
d=d,
row_count=5,
col_count=5)
res1 = Matrix([[1, 2, 3, 2, 6], [2, 3, 2, 3, -10], [1, 2, 1, 2, 9],
[2, 3, 2, 3, 69], [7, 7, 56, 2, 67]])
self.assertEqual(res, res1)
def solve(self, matrix, b, tolerance=0.01):
x_i = MatrixFactory.random(matrix.row_count, 1)
r_i = b - matrix * x_i
direction_i = r_i
for i in range(100):
z_i = matrix * direction_i
distance_i = self.calc_distance(r_i, direction_i, z_i)
x_i += distance_i * direction_i
r_i_new = r_i - distance_i * z_i
direction_i = self.calculate_new_direction(r_i_new, r_i,
direction_i)
r_i = r_i_new
n = Norm.euclidean_norm(r_i)
if n < tolerance:
break
return x_i
def _test_illegal(self, input_to_parse):
with self.assertRaises(ParseException):
MatrixFactory().parse(input_to_parse)
from src.Core.Lina.MatrixFactory import MatrixFactory from src.Core.Lina.VectorFactory import VectorFactory matrix_factory = MatrixFactory() vector_factory = VectorFactory()
def create_column_vector(self, matrix):
col_vectors = []
for i in range(matrix.column_count):
col_vectors.append(matrix.get_column_vector(i))
created_matrix = MatrixFactory.matrix_of_column_vectors(*col_vectors)
self.assertEqual(created_matrix, matrix)
def create_row_vector(self, matrix):
row_vectors = []
for i in range(matrix.row_count):
row_vectors.append(matrix.get_row_vector(i))
created_matrix = MatrixFactory.matrix_of_row_vectors()
self.assertEqual(created_matrix, matrix)
def test_create_identity(self):
for matrix in MatrixCollection.complete:
matrix = Matrix(matrix)
self.assertEqual(matrix,
MatrixFactory.identity(matrix.row_count) * matrix)