Example #1
0
 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)
Example #2
0
    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)
Example #3
0
    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)
Example #4
0
    def mul_type_error_test(self):
        """Test for TypeError, if Matrix is multiplied with a String

        or a String is multiplied with a Matrix."""
        rows  = 3
        cols  = 2
        data  = [
                    [1, -2, 3],
                    [-4, 5, 6]
                ]
        mtrx = Matrix(cols, rows)
        mtrx.initialize(data, rowBased=False)
        try:
            mtrx * "Test"
        except TypeError:
            pass
        else:
            raise AssertionError  # pragma: no cover

        try:
            "Test" * mtrx
        except TypeError:
            pass
        else:
            raise AssertionError  # pragma: no cover
Example #5
0
    def gauss_jordan_switch_column_test(self):
        """Test the gauss jordan algorithm if the first values is zero.

        This test checks, if the lines are switched correctly.
        """
        rows = 3
        cols = 6
        data = [
                    [0, 2, 0, 1, 0, 0],
                    [2, 3, 0, 0, 1, 0],
                    [3, 4, 1, 0, 0, 1]
                ]
        mtrx = Matrix(cols, rows)
        mtrx.initialize(data, rowBased=True)

        exRes = [
                    [1.0, 0.0, 0.0],
                    [0.0, 1.0, 0.0],
                    [0.0, 0.0, 1.0],
                    [-0.75, 0.5, 0.25],
                    [0.5, 0.0, -1.5],
                    [0.0, 0.0, 1.0]
        ]

        res = mtrx.gauss_jordan()
        self.assertEqual(res.matrix, exRes)
Example #6
0
    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)
Example #7
0
 def matrix_to_multi_dim_timeseries_test(self):
     """Test to create a Timeseries from a Matrix."""
     rows = 5
     cols = 3
     data = [
                 [2.4, 4.5, 6.1],
                 [3.6, 3.2, 9.4],
                 [5.6, 3.2, 8.7],
                 [4.3, 7.1, 3.3],
                 [7.2, 9.6, 0.3]
             ]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, True)
     ts = mtrx.to_multi_dim_timeseries()
     tsData = [
                 [0, [2.4, 4.5, 6.1]],
                 [1, [3.6, 3.2, 9.4]],
                 [2, [5.6, 3.2, 8.7]],
                 [3, [4.3, 7.1, 3.3]],
                 [4, [7.2, 9.6, 0.3]]
             ]
     exTs = MDTS.from_twodim_list(tsData, dimensions=3)
     # expecting that TimeSeries.from_twodom_list() works properly
     self.assertEqual(ts, exTs)
     # Changing entries of the timeseries, should not affect matrix
     row = 3
     ts[row] = [row, 4, 3, 1]
     for col in xrange(cols):
         self.assertEqual(mtrx.get_value(col, row), data[row][col])
Example #8
0
 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)
Example #9
0
    def householder_test(self):
        """Test the householder transformation to get a matrix in bidiagonalization."""
        # set up test
        c = [
                [4, 3, 0],
                [2, 1, 2],
                [4, 4, 0]
        ]
        matrix = Matrix(3, 3)
        matrix.initialize(c, rowBased=True)

        # execute householder transformation
        u, bidiag, v = matrix.householder()

        # expect, that multiplication works correctly.
        res = u * bidiag * v
        # res should be equal with c (except some rounding errors)
        for row in range(res.get_height()):
            for col in range(res.get_width()):
                self.assertAlmostEqual(res.get_value(col, row), c[row][col], PRECISION)
        # bidiag matrix should have 0 values below the diagonal
        self.assertAlmostEqual(bidiag.get_value(0, 1), 0, PRECISION)
        self.assertAlmostEqual(bidiag.get_value(0, 2), 0, PRECISION)
        self.assertAlmostEqual(bidiag.get_value(1, 2), 0, PRECISION)

        self.assertAlmostEqual(bidiag.get_value(2, 0), 0, PRECISION)
Example #10
0
    def pseudoinverse_with_more_columns_test(self):
        """Test to calculate the pseudoinverse of a Matrix with more columns than rows."""
        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)
        # Expected result calculated with scipy
        exRes = [
                    [-0.0541328,   0.02473614],
                    [ 0.00705413, -0.06480734],
                    [-0.02269591,  0.05255596],
                    [ 0.03956448,  0.09492743]
                ]

        res = mtrx.pseudoinverse()
        # Pseudoinverse of a m x n Matrix has to be a n x m Matrix
        self.assertEqual(res.get_width(), rows)
        self.assertEqual(res.get_height(), cols)
        for row in range(cols):
            for col in range(rows):
                self.assertAlmostEqual(exRes[row][col], res.get_value(col, row))
Example #11
0
 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)
Example #12
0
    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)
Example #13
0
    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)
Example #14
0
 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
Example #15
0
    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)
Example #16
0
    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)
Example #17
0
 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)
Example #18
0
 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)
Example #19
0
 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)
Example #20
0
 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
Example #21
0
    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)
Example #22
0
 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)
Example #23
0
    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)
Example #24
0
    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)
Example #25
0
    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)
Example #26
0
    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)
Example #27
0
 def mul_with_number_test(self):
     """Test the multiplication with an integer."""
     rows = 3
     cols = 2
     data = [[1, -2, 3], [-4, 5, 6]]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, rowBased=False)
     multi = 2
     expRes = [[col * multi for col in row] for row in data]
     res = multi * mtrx
     self.assertEqual(res.matrix, expRes)
Example #28
0
 def matrix_string_representation_test(self):
     """Test the String representation of a Matrix instance."""
     matrix = Matrix(2, 2)
     a = [[1, 2], [-3, 4]]
     matrix.initialize(a, rowBased=True)
     rep = matrix.__str__()
     self.assertTrue(rep.find("  1.0") >= 0)
     self.assertTrue(rep.find(" -3.0") >= 0)
     # only one space before a negative number
     self.assertFalse(rep.find("  -3.0") >= 0)
     self.assertTrue(rep.find("Matrix") >= 0)
Example #29
0
 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)
Example #30
0
    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)
Example #31
0
 def div_matrix_test(self):
     """Test the division of a matrix by a number."""
     rows = 3
     cols = 2
     data = [[1, -2, 3], [-4, 5, 6]]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, rowBased=False)
     divider = 2
     expRes = [[col / float(divider) for col in row] for row in data]
     res = mtrx / divider
     self.assertEqual(res.matrix, expRes)
Example #32
0
    def get_array_test(self):
        """Test if get_array method returns an array with the correct values."""
        rows = 2
        cols = 3
        data = [[1, 2, 3], [4, 5, 6]]
        matrix = Matrix(cols, rows)
        matrix.initialize(data, rowBased=True)

        for row in xrange(rows):
            for col in xrange(cols):
                self.assertEqual(matrix.get_value(col, row), data[row][col])
Example #33
0
 def mult_associative_test(self):
     """Test if the multiplication with an integer is associative."""
     rows = 3
     cols = 2
     data = [[1, -2, 3], [-4, 5, 6]]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, rowBased=False)
     multi = 2
     res1 = multi * mtrx
     res2 = mtrx * multi
     self.assertEqual(res1.matrix, res2.matrix)
Example #34
0
 def matrix_string_representation_test(self):
     """Test the String representation of a Matrix instance."""
     matrix = Matrix(2, 2)
     a = [[1, 2], [-3, 4]]
     matrix.initialize(a, rowBased=True)
     rep = matrix.__str__()
     self.assertTrue(rep.find("  1.0") >= 0)
     self.assertTrue(rep.find(" -3.0") >= 0)
     # only one space before a negative number
     self.assertFalse(rep.find("  -3.0") >= 0)
     self.assertTrue(rep.find("Matrix") >= 0)
Example #35
0
    def gauss_jordan_test(self):
        """Test gauss_jordan algorithm for the calculation of the inverse."""
        rows = 3
        cols = 6
        data = [[1, 2, 0, 1, 0, 0], [2, 3, 0, 0, 1, 0], [3, 4, 1, 0, 0, 1]]
        mtrx = Matrix(cols, rows)
        mtrx.initialize(data, rowBased=True)

        exRes = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [-3, 2, 1], [2, -1, -2],
                 [0, 0, 1]]
        res = mtrx.gauss_jordan()
        self.assertEqual(res.matrix, exRes)
Example #36
0
 def initialize_from_matrix_value_error_test(self):
     """Test for IndexError when creating a Vector from a Matrix,
     which does not have the specified column.
     """
     rows = 3
     cols = 2
     data = [[1, -4], [-2, 5], [3, 6]]
     # build Matrix
     matrix = Matrix(cols, rows)
     matrix.initialize(data, rowBased=True)
     # Matrix does not have column with index 3 -> ValueError
     self.assertRaises(IndexError, Vector.initialize_from_matrix, matrix, 3)
Example #37
0
 def initialize_from_matrix_test(self):
     """Test to create a Vector from a specified column of a Matrix."""
     rows = 3
     cols = 2
     data = [[1, -4], [-2, 5], [3, 6]]
     # build Matrix
     matrix = Matrix(cols, rows)
     matrix.initialize(data, rowBased=True)
     # Create Vektor with the 2nd column of the matrix
     vector = Vector.initialize_from_matrix(matrix, 1)
     exRes = [[-4, 5, 6]]
     self.assertEqual(vector.matrix, exRes)
Example #38
0
    def gauss_jordan_linear_equation_system_test(self):
        """Test gauss_jordan algorithm to solve a linear equation system."""
        rows = 3
        cols = 4
        data = [[1, 1, 1, 0], [4, 2, 1, 1], [9, 3, 1, 3]]
        mtrx = Matrix(cols, rows)
        mtrx.initialize(data, rowBased=True)
        # 2-dimensional list exRes[column][rows]
        exRes = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0],
                 [0.5, -0.5, 0]]
        res = mtrx.gauss_jordan()

        self.assertEqual(res.matrix, exRes)
Example #39
0
    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)
Example #40
0
    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)
Example #41
0
    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)
Example #42
0
    def get_value_test(self):
        """Test if the correct value of the Matrix is returned."""
        rows = 2
        cols = 3
        data = [[1, 2, 3], [4, 5, 6]]
        matrix = Matrix(cols, rows)
        matrix.initialize(data, rowBased=True)

        val1 = matrix.get_value(1, 0)
        val2 = matrix.get_value(2, 1)

        self.assertEqual(val1, 2)
        self.assertEqual(val2, 6)
Example #43
0
    def get_array_test(self):
        """Test if get_array method returns an array with the correct values."""
        rows = 2
        cols = 3
        data = [
                    [1, 2, 3],
                    [4, 5, 6]
                ]
        matrix = Matrix(cols, rows)
        matrix.initialize(data, rowBased=True)

        for row in xrange(rows):
            for col in xrange(cols):
                self.assertEqual(matrix.get_value(col, row), data[row][col])
Example #44
0
    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)
Example #45
0
    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)
Example #46
0
 def div_matrix_test(self):
     """Test the division of a matrix by a number."""
     rows  = 3
     cols  = 2
     data  = [
                 [1, -2, 3],
                 [-4, 5, 6]
             ]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, rowBased=False)
     divider = 2
     expRes = [[col / float(divider) for col in row] for row in data]
     res = mtrx / divider
     self.assertEqual(res.matrix, expRes)
Example #47
0
    def initialization_with_row_based_list_test(self):
        """Test setting the matrix values using a row based list."""
        rows = 4
        cols = 5
        matrix = Matrix(cols, rows)
        data = [[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [3, 5, 4, 8, 6],
                [1, 6, 4, 3, 9]]
        matrix.initialize(data, rowBased=True)

        exRes = [[1, 4, 3, 1], [2, 5, 5, 6], [3, 6, 4, 4], [4, 7, 8, 3],
                 [5, 8, 6, 9]]
        dstArr = matrix.matrix

        self.assertEqual(exRes, dstArr)
Example #48
0
 def mult_associative_test(self):
     """Test if the multiplication with an integer is associative."""
     rows  = 3
     cols  = 2
     data  = [
                 [1, -2, 3],
                 [-4, 5, 6]
             ]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, rowBased=False)
     multi  = 2
     res1   = multi * mtrx
     res2   = mtrx * multi
     self.assertEqual(res1.matrix, res2.matrix)
Example #49
0
 def mul_with_number_test(self):
     """Test the multiplication with an integer."""
     rows  = 3
     cols  = 2
     data  = [
                 [1, -2, 3],
                 [-4, 5, 6]
             ]
     mtrx = Matrix(cols, rows)
     mtrx.initialize(data, rowBased=False)
     multi = 2
     expRes = [[col * multi for col in row] for row in data]
     res = multi * mtrx
     self.assertEqual(res.matrix, expRes)
Example #50
0
 def svd_test(self):
     """Test the Singular Value Decomposition."""
     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()
     # multiply result matrices should get the original matrix
     res = u * diag * v.transform()
     for row in range(res.get_height()):
         for col in range(res.get_width()):
             self.assertAlmostEqual(res.get_value(col, row), a[row][col],
                                    PRECISION)
Example #51
0
    def svd_diagional_test(self):
        """Test if the one Matrix of svd() is in diagonal form."""
        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()
        # test if Matrix is in diagonal form
        for row in range(diag.get_height()):
            for col in range(diag.get_width()):
                if row != col:
                    self.assertEqual(diag.get_value(col, row), 0.0)
Example #52
0
 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)
Example #53
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)
Example #54
0
    def gauss_jordan_switch_column_test(self):
        """Test the gauss jordan algorithm if the first values is zero.

        This test checks, if the lines are switched correctly.
        """
        rows = 3
        cols = 6
        data = [[0, 2, 0, 1, 0, 0], [2, 3, 0, 0, 1, 0], [3, 4, 1, 0, 0, 1]]
        mtrx = Matrix(cols, rows)
        mtrx.initialize(data, rowBased=True)

        exRes = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0],
                 [-0.75, 0.5, 0.25], [0.5, 0.0, -1.5], [0.0, 0.0, 1.0]]

        res = mtrx.gauss_jordan()
        self.assertEqual(res.matrix, exRes)
Example #55
0
 def initialize_from_matrix_test(self):
     """Test to create a Vector from a specified column of a Matrix."""
     rows = 3
     cols = 2
     data = [
                 [1, -4],
                 [-2, 5],
                 [3, 6]
             ]
     # build Matrix
     matrix = Matrix(cols, rows)
     matrix.initialize(data, rowBased=True)
     # Create Vektor with the 2nd column of the matrix
     vector = Vector.initialize_from_matrix(matrix, 1)
     exRes = [[-4, 5, 6]]
     self.assertEqual(vector.matrix, exRes)
Example #56
0
 def initialize_from_matrix_value_error_test(self):
     """Test for IndexError when creating a Vector from a Matrix,
     which does not have the specified column.
     """
     rows = 3
     cols = 2
     data =  [
                 [1, -4],
                 [-2, 5],
                 [3, 6]
             ]
     # build Matrix
     matrix = Matrix(cols, rows)
     matrix.initialize(data, rowBased=True)
     # Matrix does not have column with index 3 -> ValueError
     self.assertRaises(IndexError, Vector.initialize_from_matrix, matrix, 3)
Example #57
0
    def get_value_test(self):
        """Test if the correct value of the Matrix is returned."""
        rows = 2
        cols = 3
        data = [
                    [1, 2, 3],
                    [4, 5, 6]
                ]
        matrix = Matrix(cols, rows)
        matrix.initialize(data, rowBased=True)

        val1 = matrix.get_value(1, 0)
        val2 = matrix.get_value(2, 1)

        self.assertEqual(val1, 2)
        self.assertEqual(val2, 6)
Example #58
0
 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)
Example #59
0
 def svd_test(self):
     """Test the Singular Value Decomposition."""
     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()
     # multiply result matrices should get the original matrix
     res = u * diag * v.transform()
     for row in range(res.get_height()):
         for col in range(res.get_width()):
             self.assertAlmostEqual(res.get_value(col, row), a[row][col], PRECISION)
Example #60
0
    def svd_diagional_test(self):
        """Test if the one Matrix of svd() is in diagonal form."""
        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()
        # test if Matrix is in diagonal form
        for row in range(diag.get_height()):
            for col in range(diag.get_width()):
                if row != col:
                    self.assertEqual(diag.get_value(col, row), 0.0)