def setUp(self):
self.matrix_proto = sor_pb2.SparseMatrix(matrix_name="a",
row_count=3,
column_count=3)
for i in range(0, 3):
value = self.matrix_proto.values.add()
value.row_index = i
value.column_index = i
value.value = (i + 1) * 3.9
self.negative_matrix_proto = sor_pb2.SparseMatrix(matrix_name="a-",
row_count=3,
column_count=3)
for i in range(0, 3):
value = self.negative_matrix_proto.values.add()
value.row_index = i
value.column_index = i
value.value = -(i + 1) * 2.1
self.vector_proto = sor_pb2.Vector(vector_name="b", length=3)
self.vector_proto.values.extend([1.0, 3.6, 9.1])
self.negative_vector_proto = sor_pb2.Vector(vector_name="b-", length=3)
self.negative_vector_proto.values.extend([-1.0, -3.6, -9.1])
self.input_file = 'testdata/io_test.in'
self.output_file = 'testdata/io_test.out'
def testValidateSparseMatrixProto_Success(self):
matrix_a_proto = sor_pb2.SparseMatrix(matrix_name='a',
row_count=3,
column_count=3)
for i in range(0, 3):
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i
value.value = (i + 1) * 2
def testValidateSparseMatrixProto_OutOfBounds(self):
matrix_a_proto = sor_pb2.SparseMatrix(matrix_name='a',
row_count=3,
column_count=3)
for i in range(0, 4):
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i
value.value = (i + 1) * 2
self.assertRaises(validation.ValidationError,
validation.ValidateSparseMatrixProto, matrix_a_proto)
def testSparseMatrix_FromDenseMatrix(self):
matrix_a_proto = sor_pb2.SparseMatrix(matrix_name="a",
row_count=3,
column_count=3)
expected = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
matrix_a = sparse_matrix.SparseMatrix(dense_matrix=expected)
self.assertEqual(expected, matrix_a.to_dense_matrix())
self.assertEqual([0, 2, 3, 5], matrix_a.rowStart)
self.assertEqual([0, 2, 1, 0, 2], matrix_a.cols)
self.assertEqual([1, 1, 1, 1, 1], matrix_a.vals)
expected = [[9, 7, 16], [0, 7.8, 0], [0, 0, 11.7]]
matrix_a = sparse_matrix.SparseMatrix(dense_matrix=expected)
self.assertEqual([0, 3, 4, 5], matrix_a.rowStart)
self.assertEqual([0, 1, 2, 1, 2], matrix_a.cols)
self.assertEqual([9, 7, 16, 7.8, 11.7], matrix_a.vals)
self.assertEqual(expected, matrix_a.to_dense_matrix())
def testSparseMatrix_FromProto(self):
matrix_a_proto = sor_pb2.SparseMatrix(matrix_name="a",
row_count=3,
column_count=3)
for i in range(0, 3):
# This creates and returns a pointer to a sor_pb2.SparseValue message.
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i
# This is just a made up float value.
value.value = (i + 1) * 3.9
matrix_a = sparse_matrix.SparseMatrix(matrix_a_proto)
expected = [[3.9, 0, 0], [0, 7.8, 0], [0, 0, 11.7]]
self.assertEqual(expected, matrix_a.to_dense_matrix())
self.assertEqual([0, 1, 2, 3], matrix_a.rowStart)
self.assertEqual([0, 1, 2], matrix_a.cols)
self.assertEqual([3.9, 7.8, 11.7], matrix_a.vals)
def _process_string_matrix_proto(string_matrix_proto):
string_segments = string_matrix_proto.split('values ')
head_segment = string_segments[0]
name = re.search(r'matrix_name: "([^"]+)"', head_segment).group(1)
rows = re.search(r'row_count: (\d+)', head_segment).group(1)
columns = re.search(r'column_count: (\d+)', head_segment).group(1)
sparse_matrix_proto = sor_pb2.SparseMatrix(matrix_name=name,
row_count=int(rows),
column_count=int(columns))
for segment in string_segments[1:]:
sparse_value = sparse_matrix_proto.values.add()
row_index = re.search(r'row_index: (\d+)', segment)
column_index = re.search(r'column_index: (\d+)', segment)
value = re.search(r'value: (-?[\d.]+)', segment).group(1)
if row_index:
sparse_value.row_index = int(row_index.group(1))
if column_index:
sparse_value.column_index = int(row_index.group(1))
sparse_value.value = float(value)
return sparse_matrix_proto
def testSparseSorSolver_MatrixProto(self):
matrix_a_proto = sor_pb2.SparseMatrix(matrix_name="a",
row_count=3,
column_count=3)
for i in range(0, 3):
# This creates and returns a pointer to a sor_pb2.SparseValue message.
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i
# This is just a made up float value.
value.value = (i + 1) * 3.9
matrix_a = sparse_matrix.SparseMatrix(matrix_a_proto)
vector_b = vector.Vector(name="b", number_list=[2, 3, 4])
sparse_sor_solver = sparse_sor.SparseSorSolver(matrix_a, vector_b, 10,
.0001, 1.0)
self.assertEqual(sparse_sor_solver.stopping_reason,
sor_pb2.SorReturnValue.RESIDUAL_CONVERGENCE)
while(i < 2.1):
sparse_sor_solver = sparse_sor.SparseSorSolver(
matrix, vector, maxits, 2**-20, i)
results.append(sparse_sor_solver.iteration)
i += 0.1
return(results)
index_list = [ x / 10 for x in range(1,21)]
# Experiment to see effect of very large matrix
print("--------------------------------------------------------------------")
print("Experiment with large, randomly generated diagonally dominant matrix")
print("--------------------------------------------------------------------")
# Create tridiagonal matrix
matrix_a_proto = sor_pb2.SparseMatrix(
matrix_name="a", row_count=5000, column_count=5000)
for i in range(0, 5000):
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i
value.value = random.randint(10,15)
for i in range(1, 5000):
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i-1
value.value = random.randint(2,4)
for i in range(0, 4999):
value = matrix_a_proto.values.add()
value.row_index = i
value.column_index = i+1
value.value = random.randint(-4,4)