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

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)