Merge pull request #7 from StephenGemin/update_matrix_ops

Update matrix ops

Within the matrix folder:

1. Removed init.py
2. Added pytests for matrix operations as it was difficult to see if things were working correctly just running it through print statements on the main file. There were edge cases that the algorithms did not account for.

Made the following changes to matrix_operation.py
1. added matrix subtraction to matrix_operation.py
2. added matrix size checks for addition and subtraction as there were previously no checks
3. fixed typo in matrix multiplication loop that was in Pull Request #898 on 
   TheAlgorithms/Python
4. PEP8 changes

Author: StephenGemin

matrix/__init__.py

@@ -1,76 +1,121 @@
 from __future__ import print_function
 
+
 def add(matrix_a, matrix_b):
-    rows = len(matrix_a)
-    columns = len(matrix_a[0])
+    try:
+        rows = [len(matrix_a), len(matrix_b)]
+        cols = [len(matrix_a[0]), len(matrix_b[0])]
+    except TypeError:
+        raise TypeError("Cannot input an integer value, it must be a matrix")
+
+    if rows[0] != rows[1] & cols[0] != cols[1]:
+        raise ValueError(f"operands could not be broadcast together with shapes "
+                         f"({rows[0],cols[0]}), ({rows[1], cols[1]})")
+
     matrix_c = []
-    for i in range(rows):
+    for i in range(rows[0]):
         list_1 = []
-        for j in range(columns):
+        for j in range(cols[0]):
             val = matrix_a[i][j] + matrix_b[i][j]
             list_1.append(val)
         matrix_c.append(list_1)
     return matrix_c
 
-def scalarMultiply(matrix , n):
+
+def subtract(matrix_a, matrix_b):
+    try:
+        rows = [len(matrix_a), len(matrix_b)]
+        cols = [len(matrix_a[0]), len(matrix_b)]
+    except TypeError:
+        raise TypeError("Cannot input an integer value, it must be a matrix")
+
+    if rows[0] != rows[1] & cols[0] != cols[1]:
+        raise ValueError(f"operands could not be broadcast together with shapes "
+                         f"({rows[0], cols[0]}), ({rows[1], cols[1]})")
+
+    matrix_c = []
+    for i in range(rows[0]):
+        list_1 = []
+        for j in range(cols[0]):
+            val = matrix_a[i][j] - matrix_b[i][j]
+            list_1.append(val)
+        matrix_c.append(list_1)
+    return matrix_c
+
+
+def scalar_multiply(matrix, n):
     return [[x * n for x in row] for row in matrix]
 
+
 def multiply(matrix_a, matrix_b):
     matrix_c = []
-    n = len(matrix_a)
-    for i in range(n):
+    num_rows_a = len(matrix_a)
+    num_cols_a = len(matrix_a[0])
+    num_rows_b = len(matrix_b)
+    num_cols_b = len(matrix_b[0])
+    
+    if num_cols_a != num_rows_b:
+        raise ValueError(f'Cannot multiply matrix of dimensions ({num_rows_a},{num_cols_a}) '
+                         f'and ({num_rows_b},{num_cols_b})')
+                      
+    for i in range(num_rows_a):
         list_1 = []
-        for j in range(n):
+        for j in range(num_cols_b):
             val = 0
-            for k in range(n):
+            for k in range(num_cols_b):
                 val = val + matrix_a[i][k] * matrix_b[k][j]
             list_1.append(val)
         matrix_c.append(list_1)
     return matrix_c
 
+
 def identity(n):
     return [[int(row == column) for column in range(n)] for row in range(n)] 
 
+
 def transpose(matrix):
-    return map(list , zip(*matrix))
+    return map(list, zip(*matrix))
+
 
 def minor(matrix, row, column):
     minor = matrix[:row] + matrix[row + 1:]
     minor = [row[:column] + row[column + 1:] for row in minor]
     return minor
 
+
 def determinant(matrix):
-    if len(matrix) == 1: return matrix[0][0]
+    if len(matrix) == 1:
+        return matrix[0][0]
 
     res = 0
     for x in range(len(matrix)):
-        res += matrix[0][x] * determinant(minor(matrix , 0 , x)) * (-1) ** x
+        res += matrix[0][x] * determinant(minor(matrix, 0, x)) * (-1) ** x
     return res
 
+
 def inverse(matrix):
     det = determinant(matrix)
-    if det == 0: return None
+    if det == 0:
+        return None
 
-    matrixMinor = [[] for _ in range(len(matrix))]
+    matrix_minor = [[] for _ in range(len(matrix))]
     for i in range(len(matrix)):
         for j in range(len(matrix)):
-            matrixMinor[i].append(determinant(minor(matrix , i , j)))
+            matrix_minor[i].append(determinant(minor(matrix, i, j)))
 
-    cofactors = [[x * (-1) ** (row + col) for col, x in enumerate(matrixMinor[row])] for row in range(len(matrix))]
+    cofactors = [[x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row])] for row in range(len(matrix))]
     adjugate = transpose(cofactors)
-    return scalarMultiply(adjugate , 1/det)
-
-def main():
-    matrix_a = [[12, 10], [3, 9]]
-    matrix_b = [[3, 4], [7, 4]]
-    matrix_c = [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
-    matrix_d = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
-    print('Add Operation, %s + %s = %s \n' %(matrix_a, matrix_b, (add(matrix_a, matrix_b))))
-    print('Multiply Operation, %s * %s = %s \n' %(matrix_a, matrix_b, multiply(matrix_a, matrix_b)))
-    print('Identity:  %s \n' %identity(5))
-    print('Minor of %s = %s \n' %(matrix_c, minor(matrix_c , 1 , 2)))
-    print('Determinant of %s = %s \n' %(matrix_b, determinant(matrix_b)))
-    print('Inverse of %s = %s\n'%(matrix_d, inverse(matrix_d)))
+    return scalar_multiply(adjugate, 1/det)
+
 
 if __name__ == '__main__':
-    main()
+    mat_a = [[12, 10], [3, 9]]
+    mat_b = [[3, 4], [7, 4]]
+    mat_c = [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
+    mat_d = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
+    print('Add Operation, %s + %s = %s \n' %(mat_a, mat_b, (add(mat_a, mat_b))))
+    print('Multiply Operation, %s * %s = %s \n' %(mat_a, mat_b, multiply(mat_a, mat_b)))
+    print('Identity:  %s \n' %identity(5))
+    print('Minor of %s = %s \n' %(mat_c, minor(mat_c , 1 , 2)))
+    print('Determinant of %s = %s \n' %(mat_b, determinant(mat_b)))
+    print('Inverse of %s = %s\n'%(mat_d, inverse(mat_d)))

matrix/matrix_operation.py

@@ -0,0 +1,4 @@
+# content of pytest.ini
+[pytest]
+markers =
+    mat_ops: mark a test as a matrix operations test

matrix/tests/pytest.ini

@@ -0,0 +1,81 @@
+"""
+Testing here assumes that numpy is ALWAYS correct!!!!
+
+If running from PyCharm you can place the following line in "Additional Arguments" for the pytest run configuration
+-vv -m mat_ops -p no:cacheprovider
+"""
+
+# standard libraries
+import numpy as np
+import pytest
+
+# Custom/local libraries
+from matrix import matrix_operation as matop
+
+mat_a = [[12, 10], [3, 9]]
+mat_b = [[3, 4], [7, 4]]
+mat_c = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
+mat_d = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
+mat_e = [[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
+mat_f = [1]
+mat_h = [2]
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
+                                            (mat_f, mat_h)])
+def test_addition(mat1, mat2):
+    # Catch when user enters a single integer value rather than a mat
+    # Check for known errors
+    if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
+        with pytest.raises(TypeError):
+            assert matop.add(mat1, mat2)
+    elif (np.array(mat1)).shape == (np.array(mat2)).shape:
+        act = (np.array(mat1) + np.array(mat2)).tolist()
+        theo = matop.add(mat1, mat2)
+        assert theo == act
+    else:
+        # matrices have different dimensions
+        # Check for known errors
+        with pytest.raises(ValueError):
+            assert matop.add(mat1, mat2)
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
+                                            (mat_f, mat_h)])
+def test_subtraction(mat1, mat2):
+    # Catch when user enters a single integer value rather than a mat
+    # Check for known errors
+    if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
+        with pytest.raises(TypeError):
+            assert matop.add(mat1, mat2)
+    elif (np.array(mat1)).shape == (np.array(mat2)).shape:
+        act = (np.array(mat1) - np.array(mat2)).tolist()
+        theo = matop.subtract(mat1, mat2)
+        assert theo == act
+    else:
+        # matrices have different dimensions
+        # Check for known errors
+        with pytest.raises(ValueError):
+            assert matop.subtract(mat1, mat2)
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
+                                            (mat_f, mat_h)])
+def test_multiplication(mat1, mat2):
+    # Catch when user enters a single integer value rather than a mat
+    # Check for known errors
+    if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
+        with pytest.raises(TypeError):
+            assert matop.add(mat1, mat2)
+    elif (np.array(mat1)).shape == (np.array(mat2)).shape:
+        act = (np.matmul(mat1, mat2)).tolist()
+        theo = matop.multiply(mat1, mat2)
+        assert theo == act
+    else:
+        # matrices have different dimensions
+        # Check for known errors
+        with pytest.raises(ValueError):
+            assert matop.subtract(mat1, mat2)