Refactor Jacobi and Newton-Raphson methods to standardize solution vector naming

nikoscham · nikoscham · commit fea4839e046d · 2025-07-11T11:11:05.000+03:00
diff --git a/src/methods/jacobiMethodScript.js b/src/methods/jacobiMethodScript.js
@@ -10,35 +10,35 @@
 
 /**
  * Function to solve a system of linear equations using the Jacobi iterative method
- * @param {array} A - The coefficient matrix (must be square)
- * @param {array} b - The right-hand side vector
- * @param {array} x0 - Initial guess for solution vector
+ * @param {array} jacobianMatrix - The coefficient matrix (must be square)
+ * @param {array} residualVector - The right-hand side vector
+ * @param {array} initialGuess - Initial guess for solution vector
  * @param {object} [options] - Options for the solver
  * @param {number} [options.maxIterations=1000] - Maximum number of iterations
  * @param {number} [options.tolerance=1e-6] - Convergence tolerance
  * @returns {object} An object containing:
- *  - solution: The solution vector
+ *  - solutionVector: The solution vector
  *  - iterations: The number of iterations performed
  *  - converged: Boolean indicating whether the method converged
  */
-export function jacobiMethod(A, b, x0, options = {}) {
+export function jacobiMethod(jacobianMatrix, residualVector, initialGuess, options = {}) {
   const { maxIterations = 1000, tolerance = 1e-6 } = options;
-  const n = A.length; // Size of the square matrix
-  let x = [...x0]; // Current solution (starts with initial guess)
+  const n = jacobianMatrix.length; // Size of the square matrix
+  let x = [...initialGuess]; // Current solution (starts with initial guess)
   let xNew = new Array(n); // Next iteration's solution
 
   for (let iteration = 0; iteration < maxIterations; iteration++) {
     // Perform one iteration
     for (let i = 0; i < n; i++) {
       let sum = 0;
-      // Calculate sum of A[i][j] * x[j] for j ≠ i
+      // Calculate sum of jacobianMatrix[i][j] * x[j] for j ≠ i
       for (let j = 0; j < n; j++) {
         if (j !== i) {
-          sum += A[i][j] * x[j];
+          sum += jacobianMatrix[i][j] * x[j];
         }
       }
       // Update xNew[i] using the Jacobi formula
-      xNew[i] = (b[i] - sum) / A[i][i];
+      xNew[i] = (residualVector[i] - sum) / jacobianMatrix[i][i];
     }
 
     // Check convergence
@@ -53,7 +53,7 @@ export function jacobiMethod(A, b, x0, options = {}) {
     // Successfully converged if maxDiff is less than tolerance
     if (maxDiff < tolerance) {
       return {
-        solution: x,
+        solutionVector: x,
         iterations: iteration + 1,
         converged: true,
       };
@@ -62,7 +62,7 @@ export function jacobiMethod(A, b, x0, options = {}) {
 
   // maxIterations were reached without convergence
   return {
-    solution: x,
+    solutionVector: x,
     iterations: maxIterations,
     converged: false,
   };
diff --git a/src/methods/linearSystemScript.js b/src/methods/linearSystemScript.js
@@ -54,7 +54,7 @@ export function solveLinearSystem(solverMethod, jacobianMatrix, residualVector,
       debugLog(`Jacobi method did not converge after ${jacobiResult.iterations} iterations`);
     }
 
-    solutionVector = jacobiResult.solution;
+    solutionVector = jacobiResult.solutionVector;
     converged = jacobiResult.converged;
     iterations = jacobiResult.iterations;
   } else {
diff --git a/src/methods/newtonRaphsonScript.js b/src/methods/newtonRaphsonScript.js
@@ -18,7 +18,7 @@ import { basicLog, debugLog, errorLog } from "./utilities/loggingScript.js";
  * @param {number} [maxIterations=100] - Maximum number of iterations
  * @param {number} [tolerance=1e-7] - Convergence tolerance
  * @returns {object} An object containing:
- *  - solution: The solution vector
+ *  - solutionVector: The solution vector
  *  - iterations: The number of iterations performed
  *  - converged: Boolean indicating whether the method converged
  */
@@ -28,21 +28,21 @@ export function newtonRaphson(assembleMat, context, maxIterations = 100, toleran
   let converged = false;
   let iterations = 0;
   let deltaX = [];
-  let solution = [];
+  let solutionVector = [];
   let jacobianMatrix = [];
   let residualVector = [];
   let nodesCoordinates = {};
 
   // Initialize solution and deltaX
   for (let i = 0; i < residualVector.length; i++) {
-    solution[i] = 0;
+    solutionVector[i] = 0;
     deltaX[i] = 0;
   }
 
-  while (iterations <= maxIterations && !converged) {
+  while (iterations < maxIterations && !converged) {
     // Update solution
-    for (let i = 0; i < solution.length; i++) {
-      solution[i] = solution[i] + deltaX[i];
+    for (let i = 0; i < solutionVector.length; i++) {
+      solutionVector[i] = solutionVector[i] + deltaX[i];
     }
 
     // Compute Jacobian and Residual matrices
@@ -80,7 +80,7 @@ export function newtonRaphson(assembleMat, context, maxIterations = 100, toleran
   debugLog(`Newton-Raphson ${converged ? "converged" : "did not converge"} in ${iterations} iterations`);
 
   return {
-    solution,
+    solutionVector,
     converged,
     iterations,
     jacobianMatrix,

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ export function solveLinearSystem(solverMethod, jacobianMatrix, residualVector,`
`54`	`54`	debugLog(`Jacobi method did not converge after ${jacobiResult.iterations} iterations`);
`55`	`55`	`}`
`56`	`56`
`57`		`- solutionVector = jacobiResult.solution;`
	`57`	`+ solutionVector = jacobiResult.solutionVector;`
`58`	`58`	`converged = jacobiResult.converged;`
`59`	`59`	`iterations = jacobiResult.iterations;`
`60`	`60`	`} else {`