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())