FEAScript
diff --git a/‎src/FEAScript.js
Copy file name to clipboardExpand all lines: src/FEAScript.js
+15Lines changed: 15 additions & 0 deletions b/‎src/FEAScript.js
Copy file name to clipboardExpand all lines: src/FEAScript.js
+15Lines changed: 15 additions & 0 deletions
diff --git a/‎src/methods/jacobiMethodScript.js
Copy file name to clipboard
+67Lines changed: 67 additions & 0 deletions b/‎src/methods/jacobiMethodScript.js
Copy file name to clipboard
+67Lines changed: 67 additions & 0 deletions
@@ -9,6 +9,7 @@
 //       Website: https://feascript.com/             \__|  //
 
 import { assembleSolidHeatTransferMat } from "./solvers/solidHeatTransferScript.js";
+import { jacobiMethod } from "./methods/jacobiMethodScript.js";
 import { basicLog, debugLog } from "./utilities/loggingScript.js";
 
 /**
@@ -77,6 +78,20 @@ export class FEAScriptModel {
     console.time("systemSolving");
     if (this.solverMethod === "lusolve") {
       solutionVector = math.lusolve(jacobianMatrix, residualVector);
+    } else if (this.solverMethod === "jacobi") {
+      // Create initial guess of zeros
+      const initialGuess = new Array(residualVector.length).fill(0);
+      // Call Jacobi method with desired max iterations and tolerance
+      const jacobiResult = jacobiMethod(jacobianMatrix, residualVector, initialGuess, 1000, 1e-6);
+      
+      // Log convergence information
+      if (jacobiResult.converged) {
+        debugLog(`Jacobi method converged in ${jacobiResult.iterations} iterations`);
+      } else {
+        debugLog(`Jacobi method did not converge after ${jacobiResult.iterations} iterations`);
+      }
+      
+      solutionVector = jacobiResult.solution;
     }
     console.timeEnd("systemSolving");
     basicLog("System solved successfully");
 
@@ -0,0 +1,67 @@
+//   ______ ______           _____           _       _     //
+//  |  ____|  ____|   /\    / ____|         (_)     | |    //
+//  | |__  | |__     /  \  | (___   ___ ____ _ ____ | |_   //
+//  |  __| |  __|   / /\ \  \___ \ / __|  __| |  _ \| __|  //
+//  | |    | |____ / ____ \ ____) | (__| |  | | |_) | |    //
+//  |_|    |______/_/    \_\_____/ \___|_|  |_|  __/| |    //
+//                                            | |   | |    //
+//                                            |_|   | |_   //
+//       Website: https://feascript.com/             \__|  //
+
+/**
+ * Solves a system of linear equations using the Jacobi iterative method
+ * @param {Array<Array<number>>} A - The coefficient matrix (must be square)
+ * @param {Array<number>} b - The right-hand side vector
+ * @param {Array<number>} x0 - Initial guess for solution vector
+ * @param {number} [maxIterations=100] - Maximum number of iterations
+ * @param {number} [tolerance=1e-7] - Convergence tolerance
+ * @returns {object} An object containing:
+ *  - solution: The solution vector
+ *  - iterations: The number of iterations performed
+ *  - converged: Boolean indicating whether the method converged
+ */
+export function jacobiMethod(A, b, x0, maxIterations = 100, tolerance = 1e-7) {
+    const n = A.length; // Size of the square matrix
+    let x = [...x0];    // 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
+            for (let j = 0; j < n; j++) {
+                if (j !== i) {
+                    sum += A[i][j] * x[j];
+                }
+            }
+            // Update xNew[i] using the Jacobi formula
+            xNew[i] = (b[i] - sum) / A[i][i];
+        }
+        
+        // Check convergence
+        let maxDiff = 0;
+        for (let i = 0; i < n; i++) {
+            maxDiff = Math.max(maxDiff, Math.abs(xNew[i] - x[i]));
+        }
+        
+        // Update x for next iteration
+        x = [...xNew];
+        
+        // If difference is small enough, we've converged
+        if (maxDiff < tolerance) {
+            return {
+                solution: x,
+                iterations: iteration + 1,
+                converged: true
+            };
+        }
+    }
+    
+    // If we reach here, we didn't converge within maxIterations
+    return {
+        solution: x,
+        iterations: maxIterations,
+        converged: false
+    };
+}