def flatten_test(self): a = Matrix(2, 2, [2, 2, 2, 2]) b = Matrix(2, 2, [a, a, a, a]) result = Matrix(4, 4, [2] * 16) calculated = b.flatten() self.assertTrue(calculated, result)
def blockwise_with_zero_expansion_test(self): a = Matrix(4, 4, [1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9, 0, 0, 0, 0, 0]) b = Matrix(4, 4, [1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9, 0, 0, 0, 0, 0]) calculated = a.matrix_multiplication_blockwise(b, 2) result = Matrix(4, 4, [ 30.000, 36.000, 42.000, 0, 66.000, 81.000, 96.000, 0, 102.000, 126.000, 150.000, 0, 0, 0, 0, 0 ]) self.assertEqual(result, calculated)
def matrix_multiplication_square_test(self): """Test the matrix_multiplication with a square matrix""" size = 33 array = [[1.0 for i in range(size)] for j in range(size)] matrix = Matrix(size, size) matrix2 = Matrix(size, size) matrix.initialize(array, rowBased=True) matrix2.initialize(array, rowBased=True) result = matrix * matrix2 expRes = [[size for i in range(size)] for j in range(size)] self.assertEqual(expRes, result.matrix)
def matrix_multiplication_test(self): """Test the matrixmultplication of two matrices.""" rows1 = 2 cols1 = 3 data1 = [[1, -2, 3], [-4, 5, 6]] data2 = [[3, 4], [5, -6], [7, 8]] exRes = [[14.0, 55.0], [40.0, 2.0]] mtrx1 = Matrix(cols1, rows1) mtrx2 = Matrix(rows1, cols1) mtrx1.initialize(data1, rowBased=True) mtrx2.initialize(data2, rowBased=True) res = mtrx1.matrix_multiplication(mtrx2) self.assertEqual(res.matrix, exRes)
def add_matrix_test(self): """Test addition of two matrices.""" rows = 2 cols = 3 data1 = [[1, -2, 3], [-4, 5, 6]] data2 = [[2, 4, -3], [5, -7, 3]] mtrx1 = Matrix(cols, rows) mtrx2 = Matrix(cols, rows) mtrx1.initialize(data1, rowBased=True) mtrx2.initialize(data2, rowBased=True) expRes = [[3, 1], [2, -2], [0, 9]] res = mtrx1 + mtrx2 self.assertEqual(res.matrix, expRes)
def blockwise_multiplication_test(self): data = range(1, 33) a = Matrix(4, 2, data[:8]) b = Matrix(6, 4, data[8:]) result = [ 210.000, 220.000, 230.000, 240.000, 250.000, 260.000, 498.000, 524.000, 550.000, 576.000, 602.000, 628.000 ] resultMatrix = Matrix(6, 2, result) calculated = a.matrix_multiplication_blockwise(b, 2) self.assertEqual(resultMatrix, calculated)
def sub_matrix_test(self): """Test subtraction of two matrices.""" rows = 2 cols = 3 data1 = [[1, -2, 3], [-4, 5, 6]] data2 = [[2, 4, -3], [5, -7, 3]] mtrx1 = Matrix(cols, rows) mtrx2 = Matrix(cols, rows) mtrx1.initialize(data1, rowBased=True) mtrx2.initialize(data2, rowBased=True) expRes = [[-1, -9], [-6, 12], [6, 3]] res = mtrx1 - mtrx2 self.assertEqual(res.matrix, expRes)
def lstsq_wrong_input_size_test(self): """Test for value error in lstsq method, if height of input matrices, does not match""" # Initialize input matrices volumes = [[24], [20], [20], [20], [21], [30]] promoted = [[1, 0, 0, 0, 1], [1, 0, 0, 0, 0]] volMatrix = Matrix(1, 6) volMatrix.initialize(volumes) proMatrix = Matrix(5, 2) proMatrix.initialize(promoted) # Least Square method should raise error, since number of rows # of proMatrix and volMatrix does not match self.assertRaises(ValueError, LinearRegression.lstsq, proMatrix, volMatrix)
def is_matrix_mult_possible_true_test(self): """Test if matrix_mult_possible() returns True, if matrices can be multiplied.""" rows1 = 2 cols1 = 3 rows2 = 3 cols2 = 2 mtrx1 = Matrix(cols1, rows1) mtrx2 = Matrix(cols2, rows2) data1 = [[1, -2, 3], [-4, 5, 6]] data2 = [[3, 4], [5, -6], [7, 8]] mtrx1.initialize(data1, rowBased=True) mtrx2.initialize(data2, rowBased=True) res = mtrx1.is_matrix_mult_possible(mtrx2) self.assertTrue(res)
def lstsq_value_error_test(self): """Test for the value error, if Matrix with dependent variable has more than 1 column""" volumes = [[23, 34], [12, 34], [14, 54]] promoted = [ [1, 0, 0, 0, 1], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], ] volMatrix = Matrix(2, 3) volMatrix.initialize(volumes) proMatrix = Matrix(5, 3) proMatrix.initialize(promoted) self.assertRaises(ValueError, LinearRegression.lstsq, proMatrix, volMatrix)
def matrix_string_representation_with_precision_test(self): """Test if the precision is set correctly and used when printing a Matrix. """ size = 2 data = [[1.0123343, -2.012341234123], [3.04674567566, 4.012341234120]] mtrx = Matrix(size, size) mtrx.initialize(data, rowBased=True) mtrx.set_string_precision(4) rep = mtrx.__str__() # should print the number with 4 digits after decimal point self.assertTrue(rep.find(" 3.0467 ") >= 0) self.assertTrue(rep.find(" -2.0123") >= 0) # but should not print the full number self.assertFalse(rep.find(" 3.04674567566") >= 0) self.assertFalse(rep.find(" -2.012341234123 ") >= 0) # change precision mtrx.set_string_precision(2) rep = mtrx.__str__() print mtrx # should print the number with 2 digits after decimal point # numbers should be rounded self.assertTrue(rep.find(" 3.05 ") >= 0) self.assertTrue(rep.find(" -2.01") >= 0)
def initialization_wrong_cols_test(self): """Test for :py:exc:`ValueError` in initialize() if data array has different number of columns.""" rows = 2 cols = 3 data = [[2, 3], [1, 2, 4]] matrix = Matrix(cols, rows) self.assertRaises(ValueError, matrix.initialize, data, True)
def column_based_initialization_with_wrong_columns_test(self): """Test for ValueError in initialize() if number of columns does not match.""" rows = 2 cols = 3 mtrx = Matrix(cols, rows) data = [[1, 2], [3, 4], [5, 6], [7, 9]] self.assertRaises(ValueError, mtrx.initialize, data, False)
def mul_matrix_test(self): """Test numeric multiplication on Matrices.""" # Only column of first matrix does match rows of second matrix rows1 = 3 cols1 = 2 rows2 = 2 cols2 = 4 mtrx1 = Matrix(cols1, rows1) mtrx2 = Matrix(cols2, rows2) data1 = [[1, -2], [-4, 5], [3, 6]] data2 = [[3, 4, 5, 6], [5, -6, 4, 5]] exRes = [[-7, 13, 39], [16, -46, -24], [-3, 0, 39], [-4, 1, 48]] mtrx1.initialize(data1, rowBased=True) mtrx2.initialize(data2, rowBased=True) res = mtrx1 * mtrx2 self.assertEqual(res.matrix, exRes)
def svd_unitary_test(self): """Test if matrices u and v are unitary.""" a = [[22., 10., 2., 3., 7.], [14., 7., 10., 0., 8.], [-1., 13., -1., -11., 3.], [-3., -2., 13., -2., 4.], [9., 8., 1., -2., 4.], [9., 1., -7., 5., -1.], [2., -6., 6., 5., 1.], [4., 5., 0., -2., 2.]] matrix = Matrix(5, 8) matrix.initialize(a, rowBased=True) u, diag, v = matrix.svd() # u and v should be unitary matrices. Matrixmultiplication withs its # transformation should be the identity Matrix. res = u.transform() * u res1 = v * v.transform() for row in range(res.get_height()): for col in range(res.get_width()): if row == col: # value should be 1 at diagonal self.assertAlmostEqual(res.get_value(col, row), 1, PRECISION) self.assertAlmostEqual(res1.get_value(col, row), 1, PRECISION) else: # value should be 0 otherwise. self.assertAlmostEqual(res.get_value(col, row), 0, PRECISION) self.assertAlmostEqual(res1.get_value(col, row), 0, PRECISION)
def row_based_initialization_wrong_rows_test(self): """Test for :py:exc:`ValueError` if datalist has less rows than the Matrix.""" rows = 4 cols = 5 matrix = Matrix(cols, rows) data = [[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [3, 5, 4, 8, 6]] self.assertRaises(ValueError, matrix.initialize, data, True)
def set_string_precision_error_value_test(self): """Test for :py:exc:`ValueError` when trying to set the precision to a negative value.""" size = 2 data = [[1, 2], [3, 4]] mtrx = Matrix(size, size) mtrx.initialize(data, rowBased=True) self.assertRaises(ValueError, mtrx.set_string_precision, -2)
def init_with_one_dimensional_row_based_array_test(self): """Test the initialization with a one dimensional row based array.""" data = [1, 2, 3, 4] mtrx = Matrix(2, 2, data, rowBased=True) exRes = [[1, 3], [2, 4]] res = mtrx.matrix self.assertEqual(exRes, res)
def init_with_one_dimensional_column_based_array_test(self): """Test the initialization with a one dimensional column based array.""" data = [1, 2, 3, 4] mtrx = Matrix(2, 2, data, rowBased=False) exRes = [[1, 2], [3, 4]] res = mtrx.matrix self.assertEqual(exRes, res)
def column_based_initialization_with_wrong_rows_test(self): """Test for ValueError if number of rows does not match.""" rows = 4 cols = 3 mtrx = Matrix(cols, rows) data = [[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [3, 5, 4, 8, 6]] self.assertRaises(ValueError, mtrx.initialize, data, False)
def invers_value_error_test(self): """Test if a :py:exc:`ValueError` is raised if Matrix is not regular""" rows = 2 cols = 3 data = [[1, 2, 3], [4, 5, 6]] matrix = Matrix(cols, rows) matrix.initialize(data, rowBased=True) self.assertRaises(ValueError, matrix.invers)
def get_matrix_from_list_test(self): """Test to create a Matrix from a one dimensional list.""" rows = 2 cols = 3 mtrx = Matrix(cols, rows) data = [1, 2, 3, 4, 5, 6] exRes = [[1, 2, 3], [4, 5, 6]] newMtrx = mtrx.get_matrix_from_list(rows, cols, data, rowBased=True) self.assertEqual(newMtrx.get_array(rowBased=True), exRes)
def sub_matrix_value_error_test(self): """Test for ValueError, when subtracting matrices of different size.""" rows1 = 2 cols1 = 3 rows2 = 3 cols2 = 3 data1 = [[1, -2, 3], [-4, 5, 6]] data2 = [[2, 4, -3], [5, -7, 3], [5, -7, 3]] mtrx1 = Matrix(cols1, rows1) mtrx2 = Matrix(cols2, rows2) mtrx1.initialize(data1, rowBased=True) mtrx2.initialize(data2, rowBased=True) try: mtrx1 - mtrx2 except ValueError: pass else: raise AssertionError # pragma: no cover
def invers_test(self): """Test the calculation of the inverse.""" size = 2 data = [[1.0, 2.0], [3.0, 4.0]] exRes = [[-2.0, 1.5], [1.0, -0.5]] matrix = Matrix(size, size) matrix.initialize(data, rowBased=True) res = matrix.invers() self.assertEqual(res.matrix, exRes)
def gauss_jordan_non_singular_matrix_test(self): """Test for ValueError, if the Matrix is not invertible.""" rows = 3 cols = 6 data = [[0, 2, 0, 1, 0, 0], [0, 3, 0, 0, 1, 0], [3, 4, 1, 0, 0, 1]] mtrx = Matrix(cols, rows) mtrx.initialize(data, rowBased=True) self.assertRaises(ValueError, mtrx.gauss_jordan)
def gauss_jordan_value_error_test(self): """Test for ValueError in gauss_jordan(), if matrix has wrong size.""" rows = 3 cols = 3 data = [[0, 2, 0], [2, 3, 0], [3, 4, 1]] mtrx = Matrix(cols, rows) mtrx.initialize(data, rowBased=False) self.assertRaises(ValueError, mtrx.gauss_jordan)
def init_test(self): """Test the initialization of a matrix.""" rows = random.randint(1, 1000) cols = random.randint(1, 1000) matrix = Matrix(cols, rows) if not matrix.get_height() == rows: raise AssertionError # pragma: no cover if not matrix.get_width() == cols: raise AssertionError # pragma: no cover
def initialization_with_column_based_list_test(self): """Test setting the matrix values using a row based list.""" rows = 5 cols = 4 mtrx = Matrix(cols, rows) data = [[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [3, 5, 4, 8, 6], [1, 6, 4, 3, 9]] mtrx.initialize(data, rowBased=False) self.assertEqual(data, mtrx.matrix)
def transform_test(self): """Test matrix transformation.""" rows = 3 cols = 2 data = [[1, -2, 3], [-4, 5, 6]] exRes = [[1, -4], [-2, 5], [3, 6]] mtrx = Matrix(cols, rows) mtrx.initialize(data, rowBased=False) res = mtrx.transform() self.assertEqual(res.matrix, exRes)
def svd_value_error_test(self): """Test for ValueError in svd(), if Matrix has more columns than rows. May be removed if algorithm also works with these matrices. """ rows = 2 cols = 4 data = [[-11, 2, -5.0, 7.0], [2, -4, 3.4, 5.4]] mtrx = Matrix(cols, rows) mtrx.initialize(data, rowBased=True) self.assertRaises(ValueError, mtrx.svd)