Update ChebyshevIteration.java

Author: Keykyrios

src/main/java/com/thealgorithms/maths/ChebyshevIteration.java

@@ -7,7 +7,7 @@
  * equations (Ax = b).
  *
  * This iterative method requires:
- *  - Matrix A to be symmetric positive definite (SPD)
+ *  - Matrix a to be symmetric positive definite (SPD)
  *  - Knowledge of minimum (lambdaMin) and maximum (lambdaMax) eigenvalues
  *
  * Reference: https://en.wikipedia.org/wiki/Chebyshev_iteration
@@ -20,9 +20,9 @@ private ChebyshevIteration() {
     }
 
     /**
-     * Solves Ax = b using Chebyshev Iteration.
+     * Solves ax = b using Chebyshev Iteration.
      *
-     * @param A             SPD matrix
+     * @param a             SPD matrix
      * @param b             vector b
      * @param x0            initial guess
      * @param lambdaMin     minimum eigenvalue
@@ -31,14 +31,13 @@ private ChebyshevIteration() {
      * @param tolerance     convergence tolerance
      * @return solution vector x
      */
-    public static double[] solve(double[][] A, double[] b, double[] x0,
-                                 double lambdaMin, double lambdaMax,
+    public static double[] solve(double[][] a, double[] b, double[] x0, double lambdaMin, double lambdaMax,
                                  int maxIterations, double tolerance) {
-        validateInputs(A, b, x0, lambdaMin, lambdaMax);
+        validateInputs(a, b, x0, lambdaMin, lambdaMax);
 
         int n = b.length;
         double[] x = Arrays.copyOf(x0, n);
-        double[] r = vectorSubtract(b, matrixVectorMultiply(A, x));
+        double[] r = vectorSubtract(b, matrixVectorMultiply(a, x));
         double[] p = new double[n];
         double alpha = 0.0;
         double beta = 0.0;
@@ -62,7 +61,7 @@ public static double[] solve(double[][] A, double[] b, double[] x0,
             }
 
             x = vectorAdd(x, vectorScale(p, alpha));
-            r = vectorSubtract(b, matrixVectorMultiply(A, x));
+            r = vectorSubtract(b, matrixVectorMultiply(a, x));
 
             if (vectorNorm(r) < tolerance) {
                 break;
@@ -72,25 +71,29 @@ public static double[] solve(double[][] A, double[] b, double[] x0,
         return x;
     }
 
-    private static void validateInputs(double[][] A, double[] b, double[] x0,
-                                       double lambdaMin, double lambdaMax) {
+    private static void validateInputs(double[][] a, double[] b, double[] x0, double lambdaMin, double lambdaMax) {
         int n = b.length;
-        if (n == 0) throw new IllegalArgumentException("Vectors cannot be empty.");
-        if (A.length != n || A[0].length != n)
-            throw new IllegalArgumentException("Matrix A must be square (n x n).");
-        if (x0.length != n)
+        if (n == 0) {
+            throw new IllegalArgumentException("Vectors cannot be empty.");
+        }
+        if (a.length != n || a[0].length != n) {
+            throw new IllegalArgumentException("Matrix a must be square (n x n).");
+        }
+        if (x0.length != n) {
             throw new IllegalArgumentException("Initial guess vector x0 must have length n.");
-        if (lambdaMin >= lambdaMax || lambdaMin <= 0)
+        }
+        if (lambdaMin >= lambdaMax || lambdaMin <= 0) {
             throw new IllegalArgumentException("Eigenvalues must satisfy 0 < lambdaMin < lambdaMax.");
+        }
     }
 
-    private static double[] matrixVectorMultiply(double[][] A, double[] x) {
-        int n = A.length;
+    private static double[] matrixVectorMultiply(double[][] a, double[] x) {
+        int n = a.length;
         double[] y = new double[n];
         for (int i = 0; i < n; i++) {
             double sum = 0.0;
             for (int j = 0; j < n; j++) {
-                sum += A[i][j] * x[j];
+                sum += a[i][j] * x[j];
             }
             y[i] = sum;
         }
@@ -100,27 +103,35 @@ private static double[] matrixVectorMultiply(double[][] A, double[] x) {
     private static double[] vectorAdd(double[] a, double[] b) {
         int n = a.length;
         double[] c = new double[n];
-        for (int i = 0; i < n; i++) c[i] = a[i] + b[i];
+        for (int i = 0; i < n; i++) {
+            c[i] = a[i] + b[i];
+        }
         return c;
     }
 
     private static double[] vectorSubtract(double[] a, double[] b) {
         int n = a.length;
         double[] c = new double[n];
-        for (int i = 0; i < n; i++) c[i] = a[i] - b[i];
+        for (int i = 0; i < n; i++) {
+            c[i] = a[i] - b[i];
+        }
         return c;
     }
 
     private static double[] vectorScale(double[] a, double scalar) {
         int n = a.length;
         double[] c = new double[n];
-        for (int i = 0; i < n; i++) c[i] = a[i] * scalar;
+        for (int i = 0; i < n; i++) {
+            c[i] = a[i] * scalar;
+        }
         return c;
     }
 
     private static double vectorNorm(double[] a) {
         double sum = 0.0;
-        for (double val : a) sum += val * val;
+        for (double val : a) {
+            sum += val * val;
+        }
         return Math.sqrt(sum);
     }
 }