def setUp(self): self.matrix_a = sparse_matrix.SparseMatrix( dense_matrix=[[7, 1, 0], [1, -7, 1], [0, 1, 8]]) self.positive_definite_symmetric = sparse_matrix.SparseMatrix( dense_matrix=[[2, -1, 0], [-1, 2, -1], [0, -1, 2]]) self.vector_b = vector.Vector(name="b", number_list=[1, 1, 1])
def testSparseMatrix_EmptyRows(self): expected = [[1, 0, 0], [0, 0, 0], [0, 0, 1]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=expected) self.assertEqual([0, 1, 1, 2], matrix_a.rowStart) self.assertEqual([0, 2], matrix_a.cols) self.assertEqual([1, 1], matrix_a.vals) self.assertEqual(expected, matrix_a.to_dense_matrix())
def testZeroOnDiagonal(self): zero_diagonal_mat = sparse_matrix.SparseMatrix( dense_matrix=[[4, 1], [1, 0]]) b_vector = vector.Vector(name="b", number_list=[2, 2]) sparse_sor_solver = sparse_sor.SparseSorSolver(zero_diagonal_mat, b_vector, 50, 10**-20, 1) self.assertEqual(sparse_sor_solver.stopping_reason, sor_pb2.SorReturnValue.ZERO_ON_DIAGONAL)
def testsparsematrix_bigsquarematrix(self): expected = [[9.1, 0, 0, 0, 1], [0, 0, 1, 0, 0], [0, 0, 5, 0, 0], [0, 0, 1, 0, 0], [1, 1, 1, 1, 1]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=expected) self.assertEqual([0, 2, 3, 4, 5, 10], matrix_a.rowStart) self.assertEqual([0, 4, 2, 2, 2, 0, 1, 2, 3, 4], matrix_a.cols) self.assertEqual([9.1, 1, 1, 5, 1, 1, 1, 1, 1, 1], matrix_a.vals) self.assertEqual(expected, matrix_a.to_dense_matrix())
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 testSparseSorSolverToProto(self): matrix_a = sparse_matrix.SparseMatrix( dense_matrix=[[3, -1, 1], [-1, 3, -1], [1, -1, 3]]) vector_b = vector.Vector(name="b", number_list=[-1, 7, -7]) sparse_sor_solver = sparse_sor.SparseSorSolver(matrix_a, vector_b, 10, .0001, 1.0) solution_proto = sparse_sor_solver.to_proto() self.assertEqual(type(solution_proto), sor_pb2.SorReturnValue)
def testIllConditionedHighRelaxation(self): matrix_ill_conditioned = sparse_matrix.SparseMatrix( dense_matrix=[[1.01, 1], [1, 1.01]]) vector_ill_conditioned = vector.Vector(name="b", number_list=[2, 2]) sparse_sor_solver = sparse_sor.SparseSorSolver(matrix_ill_conditioned, vector_ill_conditioned, 50, 10**-20, 1.5) print(sparse_sor_solver)
def testSparseSorSolver_SolvedExample(self): matrix_a = sparse_matrix.SparseMatrix( dense_matrix=[[3, -1, 1], [-1, 3, -1], [1, -1, 3]]) vector_b = vector.Vector(name="b", number_list=[-1, 7, -7]) sparse_sor_solver = sparse_sor.SparseSorSolver(matrix_a, vector_b, 10, .0001, 1.0) expected = [1, 2, -2] self.assertTrue( all( almost_equal(*values) for values in zip(expected, sparse_sor_solver.x)))
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 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)
def generate_option_price_grid(timesteps, strike_price, h, k, sigma, r, stock_price_array): """Generate the matrix of option prices for each price, timestep pair. Args: timesteps: The integer number of timesteps to run for. strike_price: The strike price of the option in question. h: h the number of intervals into which the price is broken. k: k the number of intervals into which each timestep is broken. sigma: The standard deviation r: The risk free rate. Returns: A list of lists matrix. The rows are for different stock prices and the columns are the different timesteps. """ option_price_grid = [[None for _ in range(h + 1)] for _ in range(timesteps + 1)] # row is across prices columns are over time option_price_grid[0] = start_prices(strike_price, stock_price_array) # A matrix will have N-2 * N-2 elements. Of which only 3 * N-2 are populated A = sparse_matrix.SparseMatrix( dense_matrix=generate_black_scholes_matrix(h - 1, k, sigma, r)) adjustment = generate_adjustment_term(strike_price, k, sigma, r) time_step = 1 while time_step < (timesteps + 1): # Need to create a new list here to avoid Python list mutability. f_vector = option_price_grid[time_step - 1][:] # Need to adjust 1st element by adding adjustment term. f_vector[1] += adjustment f = vector.Vector(number_list=f_vector[1:-1]) sparse_sor_solver = sparse_sor.SparseSorSolver(A, f, 100, .0001, 1.0) option_price_grid[time_step] = ( [strike_price] + sparse_sor_solver.get_solution().values + [0]) time_step += 1 return option_price_grid
#! /usr/bin/python3 """End to end demonstration script for sparse_sor.""" import data_io import vector import sparse_sor import sparse_matrix from proto_genfiles.protos import sor_pb2 import sys if __name__ == "__main__": # Remove one for the program itself. args = len(sys.argv) - 1 print("Number of additional command line args passed: %s" % args) # Default values input_filename = "nas_Sor.in" output_filename = "nas_Sor.out" if args > 2: raise Exception("Error: Too many command line args passed") elif args == 2: output_filename = sys.argv[2] if args >= 1: input_filename = sys.argv[1] print("Reading input data from file: %s" % input_filename) matrix_proto, vector_proto = data_io.read_input(input_filename) matrix_a = sparse_matrix.SparseMatrix(matrix_proto) vector_b = vector.Vector(vector_proto=vector_proto) solver = sparse_sor.SparseSorSolver(matrix_a, vector_b, 10, .0001, 1.0) solution_proto = solver.to_proto() print("Calculation complete. Writing solution to: %s" % output_filename) data_io.write_output(solution_proto, output_filename)
#! /usr/bin/python3 """This script is to experiment with different parameters on different parts of our program.""" import sparse_matrix import vector import sparse_sor import pandas from proto_genfiles.protos import sor_pb2 import random from matplotlib import pyplot # Create a number of matrices and vectors to experiment with positive_definite_symmetric = sparse_matrix.SparseMatrix( dense_matrix=[[2, -1, 0], [-1, 2, -1], [0, -1, 2]]) vector_b_1 = vector.Vector(name="b", number_list=[1, 1, 1]) diag_dominant_a = sparse_matrix.SparseMatrix( dense_matrix=[[7, 1, 0, 3, 0], [0, -7, 1, 0, 0], [1, 0, 8, 2, 0], [1, 0, 0, 7, 2], [-1, 0, -1, 0, 9]]) vector_b_2 = vector.Vector(name="b", number_list=[1, 1, 2, 2, 3]) diag_dominant_b = sparse_matrix.SparseMatrix(dense_matrix=[ [15, 1, 0, 0, 0, 4, 0, 0, 1, 0], [0, -14, 1, 0, 0, 3, 0, 0, 1, 2], [1, 0, 21, 0, 1, 0, 3, 2, 0, 0], [1, 0, 0, 20, 3, 0, 5, 2, 0, 0], [-1, 0, -1, 2, -19, 0, 0, 2, 0, 0], [0, 1, 0, 3, 0, -14, 4, 0, 1, 0], [0, -3, 1, 0, 0, 3, 23, 0, 1, 0], [1, 0, 0, 0, 1, 0, 3, 20, 0, 0], [1, 0, 0, 2, 3, 0, 0, 2, 19, 0], [-1, 0, 0, 0, -9, 0, 5, 2, 0, 29]
def testSparseMatrixIsStrictlyRowDiagonallyDominant_FailureNonDominant( self): non_dd_mat = [[8, 1, -10], [12, 9, -3], [1, -8, 10]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=non_dd_mat) self.assertFalse(matrix_a.is_strictly_row_diagonally_dominant())
def testSparseMatrixIsStrictlyRowDiagonallyDominant_Success(self): dd_mat = [[8, 1, -1], [2, 9, -3], [1, -8, 10]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=dd_mat) self.assertTrue(matrix_a.is_strictly_row_diagonally_dominant())
def testSparseMatrixMultiplyByVectorSquareMatrix(self): square_mat = [[8, 1, -1], [2, 9, -3], [1, -8, 10]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=square_mat) vector_b = vector.Vector(number_list=[1, 2, 3]) self.assertEqual([7, 11, 15], matrix_a.multiply_by_vector(vector_b))
def testSparseMatrixIsStrictlyRowDiagonallyDominant_FailureNonSquare(self): non_square_mat = [[8, 1, -1, 1], [2, 9, -3, 1], [1, -8, 10, 1]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=non_square_mat) self.assertFalse(matrix_a.is_strictly_row_diagonally_dominant())
def testSparseMatrixMultiplyByVectorNonSquareMatrix(self): non_square_mat = [[8, 1, -1, 1], [2, 9, -3, 1], [1, -8, 10, 1]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=non_square_mat) vector_b = vector.Vector(number_list=[1, 2, 3, 4]) self.assertEqual([11, 15, 19], matrix_a.multiply_by_vector(vector_b))
def testSparseMatrixOneNorm(self): square_mat = [[8, 1, -1], [2, 9, -3], [1, -8, 10]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=square_mat) self.assertEqual(18, matrix_a.one_norm())
def testSparseMatrixIsSquareMatrix_False(self): non_square_mat = [[8, 1, -1, 0], [2, 9, -3, 9], [1, -8, 10, 0]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=non_square_mat) self.assertFalse(matrix_a.is_square_matrix())
def testSparseMatrixIsSquareMatrix_True(self): square_mat = [[8, 1, -1], [2, 9, -3], [1, -8, 10]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=square_mat) self.assertTrue(matrix_a.is_square_matrix())
def testSparseMatrix_InfNorm(self): expected = [[9.1, 0, 0, 0, 1], [0, 0, 1, 0, 0], [0, 0, 5, 0, 0], [0, 0, 1, 0, 0], [6, 1, 1, 1, 1]] matrix_a = sparse_matrix.SparseMatrix(dense_matrix=expected) self.assertEqual(10.1, matrix_a.infinity_norm())