clean the code

Author: Nishitha0730

src/main/java/com/thealgorithms/matrix/MatrixMultiplication.java

@@ -7,9 +7,9 @@ private MatrixMultiplication() {
     /**
      * Multiplies two matrices.
      *
-     * @param matrixA the first matrix     rowsA x colsA
-     * @param matrixB the second matrix    rowsB x colsB
-     * @return the product of the two matrices    rowsA x colsB
+     * @param matrixA the first matrix rowsA x colsA
+     * @param matrixB the second matrix rowsB x colsB
+     * @return the product of the two matrices rowsA x colsB
      * @throws IllegalArgumentException if the matrices cannot be multiplied
      */
     public static double[][] multiply(double[][] matrixA, double[][] matrixB) {
@@ -19,8 +19,10 @@ public static double[][] multiply(double[][] matrixA, double[][] matrixB) {
         }
 
         // Check for empty matrices
-        if (matrixA.length == 0 || matrixB.length == 0 ||
-                matrixA[0].length == 0 || matrixB[0].length == 0) {
+        if (matrixA.length == 0
+                || matrixB.length == 0
+                || matrixA[0].length == 0
+                || matrixB[0].length == 0) {
             throw new IllegalArgumentException("Input matrices must not be empty");
         }
 

src/test/java/com/thealgorithms/matrix/MatrixMultiplicationTest.java

@@ -2,31 +2,27 @@
 
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import static org.junit.jupiter.api.Assertions.*;
-
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class MatrixMultiplicationTest {
 
     private static final double EPSILON = 1e-9; // for floating point comparison
 
-
     @Test
-    void testMultiply2by2(){
-        double[][] matrixA = {{1.0,2.0},{3.0,4.0}};
-        double[][] matrixB = {{5.0,6.0},{7.0,8.0}};
+    void testMultiply2by2() {
+        double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}};
+        double[][] matrixB = {{5.0, 6.0}, {7.0, 8.0}};
         double[][] expected = {{19.0, 22.0}, {43.0, 50.0}};
 
         double[][] result = MatrixMultiplication.multiply(matrixA, matrixB);
-        assertMatrixEquals(expected, result);   // Because assertEquals can fails due to floating point precision issues, Therfore use assertMatrixEquals
+        assertMatrixEquals(expected, result); // Use custom method due to floating point issues
     }
 
     @Test
-    void testMultiply3by2and2by1(){
-        double[][] matrixA = {{1.0,2.0},{3.0,4.0},{5.0,6.0}};
-        double[][] matrixB = {{7.0},{8.0}};
+    void testMultiply3by2and2by1() {
+        double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
+        double[][] matrixB = {{7.0}, {8.0}};
         double[][] expected = {{23.0}, {53.0}, {83.0}};
 
         double[][] result = MatrixMultiplication.multiply(matrixA, matrixB);
@@ -35,61 +31,51 @@ void testMultiply3by2and2by1(){
 
     @Test
     void testNullMatrixA() {
-        double[][] B = {{1, 2}, {3, 4}};
-        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, B));
+        double[][] b = {{1, 2}, {3, 4}};
+        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(null, b));
     }
 
     @Test
     void testNullMatrixB() {
-        double[][] A = {{1, 2}, {3, 4}};
-        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, null));
+        double[][] a = {{1, 2}, {3, 4}};
+        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, null));
     }
 
-
     @Test
-    void testMultiplyNull(){
-        double[][] matrixA = {{1.0,2.0},{3.0,4.0}};
+    void testMultiplyNull() {
+        double[][] matrixA = {{1.0, 2.0}, {3.0, 4.0}};
         double[][] matrixB = null;
 
-        Exception exception = assertThrows(IllegalArgumentException.class, () -> {
-            MatrixMultiplication.multiply(matrixA, matrixB);
-        });
+        Exception exception = assertThrows(IllegalArgumentException.class,
+                () -> MatrixMultiplication.multiply(matrixA, matrixB));
 
         String expectedMessage = "Input matrices cannot be null";
         String actualMessage = exception.getMessage();
 
         assertTrue(actualMessage.contains(expectedMessage));
     }
 
-
     @Test
     void testIncompatibleDimensions() {
-        double[][] A = {
-                {1.0, 2.0}
-        };
-        double[][] B = {
-                {1.0, 2.0}
-        };
-        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B));
+        double[][] a = {{1.0, 2.0}};
+        double[][] b = {{1.0, 2.0}};
+        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b));
     }
 
     @Test
     void testEmptyMatrices() {
-        double[][] A = new double[0][0];
-        double[][] B = new double[0][0];
-        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(A, B));
+        double[][] a = new double[0][0];
+        double[][] b = new double[0][0];
+        assertThrows(IllegalArgumentException.class, () -> MatrixMultiplication.multiply(a, b));
     }
 
-
     private void assertMatrixEquals(double[][] expected, double[][] actual) {
         assertEquals(expected.length, actual.length, "Row count mismatch");
         for (int i = 0; i < expected.length; i++) {
-            assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i);   // Check if the number of columns in each row matches
+            assertEquals(expected[i].length, actual[i].length, "Column count mismatch at row " + i);
             for (int j = 0; j < expected[i].length; j++) {
-                assertEquals(expected[i][j], actual[i][j], EPSILON,
-                        "Mismatch at (" + i + "," + j + ")");
+                assertEquals(expected[i][j], actual[i][j], EPSILON, "Mismatch at (" + i + "," + j + ")");
             }
         }
     }
-
 }