From b9c03b5d5fa1cb282b6ad381a472099b2e681770 Mon Sep 17 00:00:00 2001 From: Niklas Birk Date: Mon, 25 Dec 2023 19:25:33 +0100 Subject: [PATCH] Reformat constructor of class Matrix in matrix.py to match to non-None values instead of instance checking; More implementation of operators in class Matrix --- src/matrix.py | 77 ++++++++++++++++++++------- test/test_matrix.py | 125 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 184 insertions(+), 18 deletions(-) diff --git a/src/matrix.py b/src/matrix.py index 356efda..3da103b 100644 --- a/src/matrix.py +++ b/src/matrix.py @@ -33,18 +33,11 @@ class Matrix: :rtype: Matrix """ - if isinstance(data, numpy.ndarray): - try: - data.shape[1] - except IndexError: - self.__shape__ = (data.shape[0], 1) - else: - self.__shape__ = data.shape - self.__data__ = data - elif isinstance(data, list) and isinstance(shape, tuple): - self.__shape__ = shape - self.__data__ = numpy.array(data).reshape(shape) - elif isinstance(data, list) and isinstance(structure, str) and isinstance(n, int): + # Case Matrix(str, int) + if n is not None and model is not None: + ... # TODO: what shall one do here? + # Case: Matrix(list, str, int) + elif n is not None and structure is not None and data is not None: if structure == "unity": ... # TODO: what does it mean? elif structure == "diagonal": @@ -57,8 +50,19 @@ class Matrix: tridiag = numpy.diag([data[0]] * (n-1), -1) + numpy.diag([data[1]] * n, 0) + numpy.diag([data[2]] * (n-1), 1) self.__data__ = tridiag self.__shape__ = tridiag.shape - elif isinstance(model, str) and isinstance(n, int): - ... # TODO: what shall one do here? + # Case: Matrix(list, str, int) + elif shape is not None and data is not None: + self.__shape__ = shape + self.__data__ = numpy.array(data).reshape(shape) + # Case: Matrix(numpy.ndarray) + elif data is not None: + try: + data.shape[1] + except IndexError: + self.__shape__ = (data.shape[0], 1) + else: + self.__shape__ = data.shape + self.__data__ = data else: raise ValueError("Only following signatures are allowed: (numpy.ndarray), (list, tuple), (list, str, int), (str, int)") @@ -85,16 +89,53 @@ class Matrix: Return ``self==value`` :param other: The object to compare to; must be either a ``Matrix``, a ``list`` or a ``numpy.ndarray`` - :return: True if data in the matrix is totally equal to the given data in other, otherwise False + :return: True if data in the matrix are equal to the given data in other for each component, otherwise False """ if isinstance(other, Matrix): - return (self.__data__ == other.__data__).all() + to_compare = other.__data__ elif isinstance(other, list): - return (self.__data__ == numpy.array(other)).all() + to_compare = numpy.array(other) elif isinstance(other, numpy.ndarray): - return (self.__data__ == other).all() + to_compare = other else: raise ValueError("Matrix type is not comparable to type of given ``other``") + return (self.__data__ == to_compare).all() def __str__(self): return str(self.__data__) + + def __neg__(self): + return Matrix(-self.__data__) + + def __add__(self, other): + if isinstance(other, Matrix): + if self.__shape__ != other.__shape__: + raise ValueError("The shape of the operands must be the same") + return self.__data__ + other.__data__ + elif isinstance(other, int) or isinstance(other, float): + return self.__data__ + other + else: + raise ValueError("Only a number or another ``Matrix`` can be added to a ``Matrix``") + + def __radd__(self, other): + return self + other + + def __sub__(self, other): + return self + (-other) + + def __rsub__(self, other): + return -self + other + + def __truediv__(self, other): + if isinstance(other, int) or isinstance(other, float): + return self.__data__ / other + else: + raise ValueError("A ``Matrix`` can only be divided ba a number") + + def __mul__(self, other): + if isinstance(other, Matrix): + if self.__shape__[1] != other.__shape__[0]: + raise ValueError("The amount of columns of the first operand must match the amount of rows of the second operand") + return Matrix(self.__data__ * other.__data__) + elif isinstance(other, int) or isinstance(other, float): + ... diff --git a/test/test_matrix.py b/test/test_matrix.py index 303e378..8d415cd 100644 --- a/test/test_matrix.py +++ b/test/test_matrix.py @@ -86,6 +86,18 @@ class TestMatrix(TestCase): expected = [[1, -1, 0, 0], [-1, 1, -1, 0], [0, -1, 1, -1], [0, 0, -1, 1]] self.assertEqual(expected, actual) + def test_matrices_should_be_equal(self): + m1 = Matrix([1, 2, 3, 4], (2, 2)) + m2 = Matrix([1, 2, 3, 4], (2, 2)) + + self.assertEqual(m1, m2) + + def test_matrices_should_not_be_equal(self): + m1 = Matrix([1, 2, 3, 4], (2, 2)) + m2 = Matrix([1, 2, 3, 3], (2, 2)) + + self.assertNotEqual(m1, m2) + def test_should_transpose_matrix(self): data = [1, 2, 3, 4, 5, 6, 7, 8, 9] actual = Matrix(data, (3, 3)) @@ -93,3 +105,116 @@ class TestMatrix(TestCase): actual = actual.transpose() expected = [[1, 4, 7], [2, 5, 8], [3, 6, 9]] self.assertEqual(expected, actual) + + def test_should_negate_matrix(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + + actual = -m + expected = Matrix([-1, -2, -3, -4], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_add_two_matrices(self): + m1 = Matrix([1, 2, 3, 4], (2, 2)) + m2 = Matrix([4, 3, 2, 1], (2, 2)) + + actual = m1 + m2 + expected = Matrix([5, 5, 5, 5], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_add_scalar_to_matrix(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + s = 5 + + actual = m + s + expected = Matrix([6, 7, 8, 9], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_radd_scalar_to_matrix(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + s = 5 + + actual = s + m + expected = Matrix([6, 7, 8, 9], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_raise_shape_missmatch_error_while_adding_vectors(self): + m1 = Matrix([1, 2, 3, 4], (2, 2)) + m2 = Matrix([1, 2], (2, 1)) + + self.assertRaises(ValueError, lambda: m1 + m2) + + def test_should_raise_value_missmatch_error_while_adding_vectors(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + o = "" + + self.assertRaises(ValueError, lambda: m + o) + + def test_should_sub_two_matrices(self): + m1 = Matrix([1, 2, 3, 4], (2, 2)) + m2 = Matrix([4, 3, 2, 1], (2, 2)) + + actual = m1 - m2 + expected = Matrix([-3, -1, 1, 3], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_sub_scalar_of_matrix(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + s = 5 + + actual = m - s + expected = Matrix([-4, -3, -2, -1], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_rsub_scalar_of_matrix(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + s = 5 + + actual = s - m + expected = Matrix([4, 3, 2, 1], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_div_matrix_by_scalar(self): + m = Matrix([5, 10, 15, 20], (2, 2)) + s = 5 + + actual = m / s + expected = Matrix([1, 2, 3, 4], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_raise_value_missmatch_error_while_dividing_with_other_than_scalar(self): + m = Matrix([1, 2, 3, 4], (2, 2)) + o = "" + + self.assertRaises(ValueError, lambda: m / o) + + def test_should_mul_matrices_1(self): + m1 = Matrix([1, 2], (2, 1)) + m2 = Matrix([3, 4], (1, 2)) + + actual = m1 * m2 + expected = Matrix([3, 4, 6, 8], (2, 2)) + + self.assertEqual(expected, actual) + + def test_should_mul_matrices_2(self): + m1 = Matrix([1, 2], (1, 2)) + m2 = Matrix([3, 4], (2, 1)) + + actual = m1 * m2 + expected = Matrix([11], (1, 1)) + + self.assertEqual(expected, actual) + + def test_should_raise_shape_missmatch_error_while_multiplying_matrices(self): + m1 = Matrix([1, 2], (2, 1)) + m2 = Matrix([3, 4], (2, 1)) + + self.assertRaises(ValueError, lambda: m1 * m2)