ziko 0.0.1

package/src/Math/Matrix/Decomposition.js

@@ -0,0 +1,90 @@
+import { Matrix } from "./Matrix";
+const luDecomposition=matrix=>{
+    if(matrix instanceof Matrix)matrix=matrix.arr;
+    const n = matrix.length;
+    const L = new Array(n).fill(0).map(() => new Array(n).fill(0));
+    const U = new Array(n).fill(0).map(() => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+        // Upper Triangular
+        for (let k = i; k < n; k++) {
+            // Summation of L(i, j) * U(j, k)
+            let sum = 0;
+            for (let j = 0; j < i; j++) {
+                sum += (L[i][j] * U[j][k]);
+            }
+            U[i][k] = matrix[i][k] - sum;
+        }
+        // Lower Triangular
+        for (let k = i; k < n; k++) {
+            if (i == k) {
+                L[i][i] = 1; // Diagonal as 1
+            } else {
+                // Summation of L(k, j) * U(j, i)
+                let sum = 0;
+                for (let j = 0; j < i; j++) {
+                    sum += (L[k][j] * U[j][i]);
+                }
+                // Evaluate L(k, i)
+                L[k][i] = (matrix[k][i] - sum) / U[i][i];
+            }
+        }
+    }
+    return [L, U].map(n=>new Matrix(n));
+}
+const dotProduct=(v1, v2)=>v1.reduce((sum, el, i) => sum + el * v2[i], 0);
+const magnitude=vector=>Math.sqrt(vector.reduce((sum, el) => sum + el * el, 0));
+const normalize=vector=>vector.map(el => el / magnitude(vector));
+const qrDecomposition=matrix=>{
+    if(matrix instanceof Matrix)matrix=matrix.arr;
+    const m = matrix.length;
+    const n = matrix[0].length;
+    const Q = [];
+    const R = [];
+    // Initialize R as an m x n matrix of zeroes
+    for (let i = 0; i < m; i++) {
+        R.push(new Array(n).fill(0));
+    }
+    for (let j = 0; j < n; j++) {
+        let v = matrix.map(row => row[j]);
+        for (let i = 0; i < j; i++) {
+            const q = Q[i];
+            const r_ij = dotProduct(q, matrix.map(row => row[j]));
+            for (let k = 0; k < m; k++) {
+                v[k] -= r_ij * q[k];
+            }
+            R[i][j] = r_ij;
+        }
+        const v_mag = magnitude(v);
+        Q.push(normalize(v));
+        R[j][j] = v_mag;
+    }
+    return [Q, R].map(n=>new Matrix(n));
+}
+
+const choleskyDecomposition=matrix=>{
+    if(matrix instanceof Matrix)matrix=matrix.arr;
+    const n = matrix.length;
+    const L = new Array(n).fill(0).map(() => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j <= i; j++) {
+            let sum = 0;
+            for (let k = 0; k < j; k++) {
+                sum += L[i][k] * L[j][k];
+            }
+
+            if (i === j) {
+                L[i][j] = Math.sqrt(matrix[i][i] - sum);
+            } else {
+                L[i][j] = (1.0 / L[j][j] * (matrix[i][j] - sum));
+            }
+        }
+    }
+    return new Matrix(L);
+}
+
+
+export { 
+    luDecomposition,
+    qrDecomposition,
+    choleskyDecomposition
+ }

package/src/Math/Matrix/LinearSystem.js

@@ -0,0 +1,10 @@
+import { Matrix } from "./Matrix";
+class LinearSystem {
+    static resolve(A, B) {
+        return A.inv
+            .dot(Matrix.fromVector(B))
+            .arr.flat(1)
+            .map((n) => +n.toFixed(10));
+    }
+}
+export { LinearSystem }