ziko 0.0.12 → 0.0.13

package/src/math/index.js

@@ -0,0 +1,189 @@
+import {PI,E,EPSILON} from "./const.js"
+import { Signal } from "./signal/index.js";
+import{
+    cos,
+    sin,
+    tan,
+    sinc,
+    cot,
+    sec,
+    csc,
+    abs,
+    sqrt,
+    pow,
+    sqrtn,
+    e,
+    ln,
+    acos,
+    asin,
+    atan,
+    acot,
+    cosh,
+    sinh,
+    tanh,
+    coth,
+    acosh,
+    asinh,
+    atanh,
+    min,
+    max,
+    sign,
+    floor,
+    ceil,
+    round,
+    fact,
+    hypot,
+    sig,
+    atan2,
+  } from "./functions/index.js";
+import {Random} from "./random/index.js";
+//import { Derivation } from "./Numeric";
+import {complex,Complex} from "./complex/index.js";
+import{Matrix,LinearSystem,matrix,matrix2,matrix3,matrix4}from "./matrix/index.js"
+import Discret from "./discret/index.js";
+import {Logic,Base,Permutation,Combinaison,powerSet,subSet} from "./discret/index.js";
+import {
+    Utils,
+    zeros,
+    ones,
+    nums,
+    sum,
+    prod,
+    add,
+    mul,
+    div,
+    sub,
+    modulo,
+    rad2deg,
+    deg2rad,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    norm,
+    lerp,
+    map,
+    clamp,
+    pgcd,
+    ppcm,
+    isApproximatlyEqual,
+    inRange,
+    cartesianProduct,
+    mapfun
+  }from "./utils/index.js"
+const Math={
+    PI,
+    E,
+    EPSILON,
+    Random,
+    complex,
+    Complex,
+    Matrix,
+    LinearSystem,
+    matrix,
+    matrix2,
+    matrix3,
+    matrix4,
+    cos,
+    sin,
+    tan,
+    sinc,
+    sec,
+    csc,
+    cot,
+    abs,
+    sqrt,
+    pow,
+    sqrtn,
+    e,
+    ln,
+    acos,
+    asin,
+    atan,
+    acot,
+    cosh,
+    sinh,
+    tanh,
+    coth,
+    acosh,
+    asinh,
+    atanh,
+    min,
+    max,
+    sign,
+    floor,
+    ceil,
+    round,
+    fact,
+    hypot,
+    sig,
+    atan2,
+   // Derivation,
+    Utils,
+    mapfun,
+    nums,
+    zeros,
+    ones,
+    sum,
+    prod,
+    add,
+    mul,
+    div,
+    sub,
+    modulo,
+    rad2deg,
+    deg2rad,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    norm,
+    lerp,
+    map,
+    clamp,
+    pgcd,
+    ppcm,
+    isApproximatlyEqual,
+    inRange,
+    cartesianProduct,
+    Discret,
+    Logic,
+    Base,
+    Permutation,
+    Combinaison,
+    powerSet,
+    subSet,
+    Signal,
+    ExtractAll: function () {
+        const keys = Object.keys(this);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key !== 'ExtractAll' && key !== 'RemoveAll') {
+                globalThis[key] = this[key];
+            }
+        }
+        return this;
+    },
+    RemoveAll: function () {
+        const keys = Object.keys(this);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key !== 'RemoveAll') {
+                delete globalThis[key];
+            }
+        }
+        return this;
+    }
+}
+export * from "./const.js"
+export * from "./functions/index.js"
+export * from "./complex/index.js"
+export * from "./matrix/index.js"
+export * from "./discret/index.js"
+export * from "./numeric/index.js"
+export * from "./random/index.js"
+export * from "./signal/index.js"
+export * from "./utils/index.js"
+export * from "./statistics/index.js"
+export default Math;
+

package/src/math/matrix/Decomposition.js

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