ziko 0.0.18 → 0.0.20

package/src/math/functions/index.js

@@ -1,162 +1,162 @@
-import { Fixed } from "./helper.js";
-import { Complex } from "../complex/index.js";
-import { mapfun } from "../utils/mapfun.js";
-import { 
-    min,
-    max 
-}from "../statistics/index.js";
-import { 
-    gamma,
-    bessel,
-    beta 
-} from "../calculus/index.js";
-
-const abs=(...x)=>mapfun(Math.abs,...x);
-const sqrt=(...x)=>mapfun(Math.sqrt,...x);
-const pow=(x,n)=>{
-    if(typeof x === "number"){
-        if(typeof n === "number")return Math.pow(x,n);
-        else if(n instanceof Complex)return Complex.fromExpo(x**n.a,n.b*ln(x))
-        else return mapfun(a=>pow(x,a),...n);
-    }
-    else if(x instanceof Complex){
-        if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
-        else if(n instanceof Complex)return Complex.fromExpo(
-            x.z**n.a*e(-x.phi*n.b),
-            ln(x.z)*n.b+n.a*x.phi
-        )
-        else return mapfun(a=>pow(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun(a=>pow(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>pow(x[i],a),...n))
-            }
-            return Y;
-        }
-    }
-}
-const sqrtn=(x,n)=>{
-    if(typeof x === "number"){
-        if(typeof n === "number")return Math.pow(x,1/n);
-        else return mapfun(a=>sqrtn(x,a),...n);
-    }
-    else if(x instanceof Complex){
-        if(typeof n === "number")return Complex.fromExpo(sqrtn(x.z,n),x.phi/n);
-        else return mapfun(a=>sqrtn(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun(a=>sqrtn(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>sqrtn(x[i],a),...n))
-            }
-            return Y;
-        }
-    }
-}
-const e=(...x)=>mapfun(Math.exp,...x);
-const ln=(...x)=>mapfun(Math.log,...x);
-const cos=(...x)=>mapfun(Fixed.cos,...x);
-const sin=(...x)=>mapfun(Fixed.sin,...x);
-const tan=(...x)=>mapfun(Fixed.tan,...x);
-const sec=(...x)=>mapfun(Fixed.sec,...x);
-const sinc=(...x)=>mapfun(Fixed.sinc,...x)
-const csc=(...x)=>mapfun(Fixed.csc,...x);
-const cot=(...x)=>mapfun(Fixed.cot,...x);
-const acos=(...x)=>mapfun(Fixed.acos,...x);
-const asin=(...x)=>mapfun(Fixed.asin,...x);
-const atan=(...x)=>mapfun(Fixed.atan,...x);
-const acot=(...x)=>mapfun(Fixed.acot,...x);
-const cosh=(...x)=>mapfun(Fixed.cosh,...x);
-const sinh=(...x)=>mapfun(Fixed.sinh,...x);
-const tanh=(...x)=>mapfun(Fixed.tanh,...x);
-const coth=(...x)=>mapfun(Fixed.coth,...x);
-const acosh=(...x)=>mapfun(Fixed.acosh,...x);
-const asinh=(...x)=>mapfun(Fixed.asinh,...x);
-const atanh=(...x)=>mapfun(Fixed.atanh,...x);
-const ceil=(...x)=>mapfun(Math.ceil,...x);
-const floor=(...x)=>mapfun(Math.floor,...x);
-const round=(...x)=>mapfun(Math.round,...x);
-const atan2=(x,y,rad=true)=>{
-    if(typeof x === "number"){
-        if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;
-        else return mapfun(a=>atan2(x,a,rad),...y);
-    }
-    // else if(x instanceof Complex){
-    //     if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
-    //     else return mapfun(a=>pow(x,a),...n);
-    // }
-    else if(x instanceof Array){
-        if(typeof y === "number") return mapfun(a=>atan2(a,y,rad),...x);
-        else if(y instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun(a=>pow(x[i],a,rad),...y))
-            }
-            return Y;
-        }
-    }
-}
-const fact=(...x)=>mapfun(n=> {
-        let i,
-        y = 1;
-        if (n == 0) y = 1;
-        else if (n > 0) for (i = 1; i <= n; i++) y *= i;
-        else y = NaN;
-        return y;
-    },...x);
-const sign=(...x)=>mapfun(Math.sign,...x);
-
-const sig=(...x)=>mapfun(n=>1/(1+e(-n)),...x);
-
-const hypot=(...x)=>{
-    if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
-    if(x.every(n=>n instanceof Array))return mapfun(
-        Math.hypot,
-        ...x
-    )
-}
-
-export{
-    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,
-    gamma,
-    bessel,
-    beta
+import { Fixed } from "./helper.js";
+import { Complex } from "../complex/index.js";
+import { mapfun } from "../utils/mapfun.js";
+import { 
+    min,
+    max 
+}from "../statistics/index.js";
+import { 
+    gamma,
+    bessel,
+    beta 
+} from "../calculus/index.js";
+
+const abs=(...x)=>mapfun(Math.abs,...x);
+const sqrt=(...x)=>mapfun(Math.sqrt,...x);
+const pow=(x,n)=>{
+    if(typeof x === "number"){
+        if(typeof n === "number")return Math.pow(x,n);
+        else if(n instanceof Complex)return Complex.fromExpo(x**n.a,n.b*ln(x))
+        else return mapfun(a=>pow(x,a),...n);
+    }
+    else if(x instanceof Complex){
+        if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
+        else if(n instanceof Complex)return Complex.fromExpo(
+            x.z**n.a*e(-x.phi*n.b),
+            ln(x.z)*n.b+n.a*x.phi
+        )
+        else return mapfun(a=>pow(x,a),...n);
+    }
+    else if(x instanceof Array){
+        if(typeof n === "number") return mapfun(a=>pow(a,n),...x);
+        else if(n instanceof Array){
+            const Y=[];
+            for(let i=0;i<x.length;i++){
+                Y.push(mapfun(a=>pow(x[i],a),...n))
+            }
+            return Y;
+        }
+    }
+}
+const sqrtn=(x,n)=>{
+    if(typeof x === "number"){
+        if(typeof n === "number")return Math.pow(x,1/n);
+        else return mapfun(a=>sqrtn(x,a),...n);
+    }
+    else if(x instanceof Complex){
+        if(typeof n === "number")return Complex.fromExpo(sqrtn(x.z,n),x.phi/n);
+        else return mapfun(a=>sqrtn(x,a),...n);
+    }
+    else if(x instanceof Array){
+        if(typeof n === "number") return mapfun(a=>sqrtn(a,n),...x);
+        else if(n instanceof Array){
+            const Y=[];
+            for(let i=0;i<x.length;i++){
+                Y.push(mapfun(a=>sqrtn(x[i],a),...n))
+            }
+            return Y;
+        }
+    }
+}
+const e=(...x)=>mapfun(Math.exp,...x);
+const ln=(...x)=>mapfun(Math.log,...x);
+const cos=(...x)=>mapfun(Fixed.cos,...x);
+const sin=(...x)=>mapfun(Fixed.sin,...x);
+const tan=(...x)=>mapfun(Fixed.tan,...x);
+const sec=(...x)=>mapfun(Fixed.sec,...x);
+const sinc=(...x)=>mapfun(Fixed.sinc,...x)
+const csc=(...x)=>mapfun(Fixed.csc,...x);
+const cot=(...x)=>mapfun(Fixed.cot,...x);
+const acos=(...x)=>mapfun(Fixed.acos,...x);
+const asin=(...x)=>mapfun(Fixed.asin,...x);
+const atan=(...x)=>mapfun(Fixed.atan,...x);
+const acot=(...x)=>mapfun(Fixed.acot,...x);
+const cosh=(...x)=>mapfun(Fixed.cosh,...x);
+const sinh=(...x)=>mapfun(Fixed.sinh,...x);
+const tanh=(...x)=>mapfun(Fixed.tanh,...x);
+const coth=(...x)=>mapfun(Fixed.coth,...x);
+const acosh=(...x)=>mapfun(Fixed.acosh,...x);
+const asinh=(...x)=>mapfun(Fixed.asinh,...x);
+const atanh=(...x)=>mapfun(Fixed.atanh,...x);
+const ceil=(...x)=>mapfun(Math.ceil,...x);
+const floor=(...x)=>mapfun(Math.floor,...x);
+const round=(...x)=>mapfun(Math.round,...x);
+const atan2=(x,y,rad=true)=>{
+    if(typeof x === "number"){
+        if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;
+        else return mapfun(a=>atan2(x,a,rad),...y);
+    }
+    // else if(x instanceof Complex){
+    //     if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
+    //     else return mapfun(a=>pow(x,a),...n);
+    // }
+    else if(x instanceof Array){
+        if(typeof y === "number") return mapfun(a=>atan2(a,y,rad),...x);
+        else if(y instanceof Array){
+            const Y=[];
+            for(let i=0;i<x.length;i++){
+                Y.push(mapfun(a=>pow(x[i],a,rad),...y))
+            }
+            return Y;
+        }
+    }
+}
+const fact=(...x)=>mapfun(n=> {
+        let i,
+        y = 1;
+        if (n == 0) y = 1;
+        else if (n > 0) for (i = 1; i <= n; i++) y *= i;
+        else y = NaN;
+        return y;
+    },...x);
+const sign=(...x)=>mapfun(Math.sign,...x);
+
+const sig=(...x)=>mapfun(n=>1/(1+e(-n)),...x);
+
+const hypot=(...x)=>{
+    if(x.every(n=>typeof n === "number"))return Math.hypot(...x);
+    if(x.every(n=>n instanceof Array))return mapfun(
+        Math.hypot,
+        ...x
+    )
+}
+
+export{
+    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,
+    gamma,
+    bessel,
+    beta
   };

package/src/math/index.js

@@ -1,32 +1,32 @@
-import * as __Const__ from "./const.js"
-import * as __Functions__ from "./functions"
-import * as __Signal__ from "./const.js"
-import * as __Random__ from "./random"
-//import { Derivation } from "./Numeric";
-import * as __Complex__ from "./complex"
-import * as __Matrix__ from "./matrix"
-import * as __Discrect__ from "./discret"
-import * as __Utils__ from "./utils"
-import * as __Calculus__ from "./calculus"
-const Math = {
-    ...__Const__,
-    ...__Functions__,
-    ...__Complex__,
-    ...__Matrix__,
-    ...__Utils__,
-    ...__Discrect__,
-    ...__Signal__,
-    ...__Calculus__,
-}
-export * from "./const.js"
-export * from "./functions"
-export * from "./complex"
-export * from "./matrix"
-export * from "./discret"
-export * from "./numeric"
-export * from "./random"
-export * from "./signal"
-export * from "./utils"
-export * from "./statistics"
-export default Math;
-
+import * as __Const__ from "./const.js"
+import * as __Functions__ from "./functions"
+// import * as __Signal__ from "./const.js"
+import * as __Random__ from "./random"
+//import { Derivation } from "./Numeric";
+import * as __Complex__ from "./complex"
+import * as __Matrix__ from "./matrix"
+import * as __Discrect__ from "./discret"
+import * as __Utils__ from "./utils"
+import * as __Calculus__ from "./calculus"
+const Math = {
+    ...__Const__,
+    ...__Functions__,
+    ...__Complex__,
+    ...__Matrix__,
+    ...__Utils__,
+    ...__Discrect__,
+    // ...__Signal__,
+    ...__Calculus__,
+}
+export * from "./const.js"
+export * from "./functions"
+export * from "./complex"
+export * from "./matrix"
+export * from "./discret"
+export * from "./numeric"
+export * from "./random"
+// export * from "./signal"
+export * from "./utils"
+export * from "./statistics"
+export default Math;
+

package/src/math/matrix/Decomposition.js

@@ -1,90 +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
- }
+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

@@ -1,10 +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));
-    }
-}
+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 }