Update-2 MatrixMultiplicationVerifier.java

Menil-dev · web-flow · commit 029ddaac9ad6 · 2025-05-12T01:58:30.000+05:30
I had used wrong format in for loop, changed that in my implementation
diff --git a/src/main/java/com/thealgorithms/randomized/MatrixMultiplicationVerifier.java b/src/main/java/com/thealgorithms/randomized/MatrixMultiplicationVerifier.java
@@ -3,7 +3,7 @@
 /*
    This class implements the Randomized Matrix Multiplication Verification.
    It generates a random vector and performs verification using Freivalds' Algorithm.
-   @author Menil-dev
+   Author: Menil-dev
  */
 public class MatrixMultiplicationVerifier {
 
@@ -20,10 +20,13 @@ private MatrixMultiplicationVerifier() {
         @returns matrix of calculated dot product.
     */
     static int[] multiply(int[][] matrix, int[] vector) {
-        int n = vector.length, result[] = new int[n];
-        for (int i = 0; i < n; i++)
-            for (int j = 0; j < n; j++)
+        int n = vector.length;
+        int[] result = new int[n];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
                 result[i] += matrix[i][j] * vector[j];
+            }
+        }
         return result;
     }
 
@@ -35,25 +38,34 @@ public static boolean verify(int[][] A, int[][] B, int[][] C, int iterations) {
         if (A.length == 0 || B.length == 0 || C.length == 0 || A[0].length == 0 || B[0].length == 0 || C[0].length == 0) {
             return A.length == B[0].length && B.length == C.length && C[0].length == A[0].length; // Basic dimension consistency check
         }
-        // Basic integrity checks on number of iterations.
+
         if (iterations <= 0) {
             throw new IllegalArgumentException("Number of iterations must be positive");
         }
+
         int n = A.length;
         if (iterations > 2 * n) {
             throw new IllegalArgumentException("Number of iterations should not exceed 2 * n where n is the matrix size");
         }
 
-        // Actual logic to verify the multiplication
         Random rand = new Random();
         for (int t = 0; t < iterations; t++) {
             int[] r = new int[n];
-            // This generates a random binary vector of the first dimension of C matrix (Output Matrix).
-            for (int i = 0; i < n; i++) r[i] = rand.nextInt(2);
-            int[] Br = multiply(B, r), ABr = multiply(A, Br), Cr = multiply(C, r);
-            for (int i = 0; i < n; i++)
-                if (ABr[i] != Cr[i]) return false; // If any product mismatches, return condition.
+            for (int i = 0; i < n; i++) {
+                r[i] = rand.nextInt(2);
+            }
+
+            int[] Br = multiply(B, r);
+            int[] ABr = multiply(A, Br);
+            int[] Cr = multiply(C, r);
+
+            for (int i = 0; i < n; i++) {
+                if (ABr[i] != Cr[i]) {
+                    return false;
+                }
+            }
         }
+
         return true;
     }
 
@@ -67,9 +79,11 @@ public static boolean verify(int[][] A, int[][] B, int[][] C, int iterations) {
     static double[] multiply(double[][] matrix, double[] vector) {
         int n = vector.length;
         double[] result = new double[n];
-        for (int i = 0; i < n; i++)
-            for (int j = 0; j < n; j++)
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
                 result[i] += matrix[i][j] * vector[j];
+            }
+        }
         return result;
     }
 
@@ -79,33 +93,36 @@ static double[] multiply(double[][] matrix, double[] vector) {
     */
     public static boolean verify(double[][] A, double[][] B, double[][] C, int iterations) {
         if (A.length == 0 || B.length == 0 || C.length == 0 || A[0].length == 0 || B[0].length == 0 || C[0].length == 0) {
-            return A.length == B[0].length && B.length == C.length && C[0].length == A[0].length; // Basic dimension consistency check
+            return A.length == B[0].length && B.length == C.length && C[0].length == A[0].length;
         }
-        // Basic integrity checks on number of iterations.
+
         if (iterations <= 0) {
             throw new IllegalArgumentException("Number of iterations must be positive");
         }
+
         int m = A.length;
         if (iterations > 2 * m) {
             throw new IllegalArgumentException("Number of iterations should not exceed 2 times m where n is the matrix size");
         }
 
-        // Actual logic to verify the multiplication
         Random rand = new Random();
         for (int t = 0; t < iterations; t++) {
             double[] randomizedVector = new double[m];
-            // This generates a random binary vector of the first dimension of C matrix (Output Matrix).
-            for (int i = 0; i < m; i++)
+            for (int i = 0; i < m; i++) {
                 randomizedVector[i] = rand.nextInt(2); // Random binary values 0 or 1
+            }
 
             double[] Br = multiply(B, randomizedVector);
             double[] ABr = multiply(A, Br);
             double[] Cr = multiply(C, randomizedVector);
 
-            for (int i = 0; i < m; i++)
-                if (Math.abs(ABr[i] - Cr[i]) > 1e-9) // Allowing a small tolerance for floating-point comparisons
-                    return false; // If any product mismatches, return false.
+            for (int i = 0; i < m; i++) {
+                if (Math.abs(ABr[i] - Cr[i]) > 1e-9) {
+                    return false;
+                }
+            }
         }
+
         return true;
     }
 }
