diff --git a/matrix/count_islands_in_matrix.py b/matrix/count_islands_in_matrix.py
index 64c595e8499d..a94d362ea6c3 100644
--- a/matrix/count_islands_in_matrix.py
+++ b/matrix/count_islands_in_matrix.py
@@ -1,15 +1,46 @@
 # An island in matrix is a group of linked areas, all having the same value.
 # This code counts number of islands in a given matrix, with including diagonal
 # connections.
-
-
 class Matrix:  # Public class to implement a graph
+    """This public class represents the 2-Dimensional matrix to count
+    the number of islands.An island is the connected group of 1s,including the top,
+    down, right, left as well as the diagonal connections.
+    >>> matrix1 = Matrix(3, 3, [[1, 1, 0], [0, 1, 0], [1, 0, 1]])
+    >>> matrix1.count_islands()
+    1
+    >>> matrix2 = Matrix(2, 2, [[1, 1], [1, 1]])
+    >>> matrix2.count_islands()
+    1
+    """
+
     def __init__(self, row: int, col: int, graph: list[list[bool]]) -> None:
+        """Initializes the matrix with the given number of rows, columns and matrix.
+        Args:
+            row (int): number of rows in the matrix
+            col (int): number of columns in the matrix
+            graph (list[list[bool]]): 2-D list of 0s and 1s representing the matrix
+        """
         self.ROW = row
         self.COL = col
         self.graph = graph
 
     def is_safe(self, i: int, j: int, visited: list[list[bool]]) -> bool:
+        """This checks if the current cell can be included in the current island.
+        Args:
+            i (int): row index
+            j (int): column index
+            visited (list[list[bool]]): 2D list tracking the visited cells
+        Returns:
+            bool: True if the cell is valid and part of the island
+            (1 for True and ) for False)
+        >>> visited = [[False, False], [False, False]]
+        >>> graph = [[1, 0], [0, 1]]
+        >>> m = Matrix(2, 2, graph)
+        >>> m.is_safe(0, 0, visited)
+        1
+        >>> m.is_safe(0, 1, visited)
+        0
+        """
         return (
             0 <= i < self.ROW
             and 0 <= j < self.COL
@@ -18,6 +49,19 @@ def is_safe(self, i: int, j: int, visited: list[list[bool]]) -> bool:
         )
 
     def diffs(self, i: int, j: int, visited: list[list[bool]]) -> None:
+        """This is the recursive function to mark all the cells visited which
+        are connected to (i, j) indices.
+        Args:
+            i (int): row index
+            j (int): column index
+            visited (list[list[bool]]): 2D list tracking the visited cells
+        >>> visited = [[False, False], [False, False]]
+        >>> graph = [[1, 1], [0, 1]]
+        >>> m = Matrix(2, 2, graph)
+        >>> m.diffs(0, 0, visited)
+        >>> visited
+        [[True, True], [False, True]]
+        """
         # Checking all 8 elements surrounding nth element
         row_nbr = [-1, -1, -1, 0, 0, 1, 1, 1]  # Coordinate order
         col_nbr = [-1, 0, 1, -1, 1, -1, 0, 1]
@@ -27,6 +71,18 @@ def diffs(self, i: int, j: int, visited: list[list[bool]]) -> None:
                 self.diffs(i + row_nbr[k], j + col_nbr[k], visited)
 
     def count_islands(self) -> int:  # And finally, count all islands.
+        """
+        This counts all the islands in the given matrix.
+        Returns:
+            int: the number of islands in the given matrix.
+        Example -
+        >>> mat = Matrix(1, 1, [[1]])
+        >>> mat.count_islands()
+        1
+        >>> mat2 = Matrix(2, 2, [[0, 0], [0, 0]])
+        >>> mat2.count_islands()
+        0
+        """
         visited = [[False for j in range(self.COL)] for i in range(self.ROW)]
         count = 0
         for i in range(self.ROW):
diff --git a/matrix/matrix_class.py b/matrix/matrix_class.py
index dee9247282f9..5efe0b0e09f3 100644
--- a/matrix/matrix_class.py
+++ b/matrix/matrix_class.py
@@ -204,9 +204,11 @@ def cofactors(self) -> Matrix:
         return Matrix(
             [
                 [
-                    self.minors().rows[row][column]
-                    if (row + column) % 2 == 0
-                    else self.minors().rows[row][column] * -1
+                    (
+                        self.minors().rows[row][column]
+                        if (row + column) % 2 == 0
+                        else self.minors().rows[row][column] * -1
+                    )
                     for column in range(self.minors().num_columns)
                 ]
                 for row in range(self.minors().num_rows)