ziko 0.0.1

package/src/Math/Signal/index.js

@@ -0,0 +1,110 @@
+import { mapfun } from "../Utils";
+import { abs , sinc , sign , sin } from "../Functions/index.js"
+import { Random } from "../Random/index.js";
+import { 
+    zeros,
+    ones,
+    nums,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    map,
+    norm,
+    lerp,
+    clamp,
+} from "./functions.js";
+import{
+    fft,
+    ifft
+} from "./fft.js"
+import { 
+    conv,
+    conv1d, 
+    conv2d,
+    circularConv,
+    linearConv,
+    circularConv1d,
+    linearConv1d,
+    circularConv2d,
+    linearConv2d
+} from "./conv.js";
+import { 
+    filter
+ } from "./filter.js";
+//import { Matrix } from "../Matrix/index.js";
+const Signal={
+    zeros,
+    ones,
+    nums,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    map,
+    norm,
+    lerp,
+    clamp,
+    noise(n,min = 0,max = 1){
+        return Random.floats(n,min,max);
+    },
+    echelon(t,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t];
+        const Y = mapfun(n=>n>=t0?1:0,...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    rampe(t,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t]
+        const Y = mapfun(n=>n>=t0?n-t0:0,...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    sign(t,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t]
+        const Y = mapfun(n=>Math.sign(n-t0),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    rect(t,T,t0 = 0, A = 1){
+        if(!(t instanceof Array))t=[t];
+        const Y = mapfun(n=>((t0-T/2 < n) && (t0+T/2 > n)? 1 - 2 * abs(n/T) : 0),...t)
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    tri(t,T,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n=>((t0-T/2 < n) && (t0+T/2 > n)? 1 - 2 * abs(n/T) : 0),...t)
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    dirac(t,t0){
+        return mapfun(n=>n===t0?Infinity:0,...t);
+    },
+    lorentz(t , t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n => 1/(1+(n-t0)**2),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    sinc(t , t0 , A = 1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n=>sinc(n-t0),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    square(t,T=1,A=1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n=>sign(sin(n*2*Math.PI/T)),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    sawtooth(){
+
+    },
+    conv,
+    conv1d,
+    conv2d,
+    circularConv,
+    linearConv,
+    circularConv1d,
+    linearConv1d,
+    circularConv2d,
+    linearConv2d,
+    fft,
+    ifft,
+    filter,
+}
+export{Signal}

package/src/Math/Statistics/Functions/index.js

@@ -0,0 +1,100 @@
+// Mixed calcul
+const sum=(...x)=>{
+    if(x.every(n=>typeof n==="number")){
+        let s = x[0];
+        for (let i = 1; i < x.length; i++) s += x[i];
+        return s;
+    }
+    const Y=[];
+    for(let i=0;i<x.length;i++){
+        if(x[i] instanceof Array)Y.push(sum(...x[i]));
+        else if(x[i] instanceof Object){
+            Y.push(sum(...Object.values(x[i])))
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const prod=(...x)=>{
+    if(x.every(n=>typeof n==="number")){
+        let p = x[0];
+        for (let i = 1; i < x.length; i++) p *= x[i];
+        return p;
+    }
+    const Y=[];
+    for(let i=0;i<x.length;i++){
+        if(x[i] instanceof Array)Y.push(prod(...x[i]));
+        else if(x[i] instanceof Object){
+            Y.push(prod(...Object.values(x[i])))
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const min=(...num)=>{
+    if(num.every(n=>typeof n==="number"))return Math.min(...num);
+    const Y=[];
+    for(let i=0;i<num.length;i++){
+        if(num[i] instanceof Array)Y.push(min(...num[i]));
+        else if(num[i] instanceof Object){
+            Y.push(
+                    Object.fromEntries(
+                        [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
+                    )
+                )
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const max=(...num)=>{
+    if(num.every(n=>typeof n==="number"))return Math.max(...num);
+    const Y=[];
+    for(let i=0;i<num.length;i++){
+        if(num[i] instanceof Array)Y.push(min(...num[i]));
+        else if(num[i] instanceof Object){
+            Y.push(
+                    Object.fromEntries(
+                        [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+                    )
+                )
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+const accum=(...num)=>{
+    if(num.every(n=>typeof n==="number")){
+        let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
+        acc.shift();
+        return acc;
+    }
+    const Y=[];
+    for(let i=0;i<num.length;i++){
+        if(num[i] instanceof Array)Y.push(accum(...num[i]));
+        else if(num[i] instanceof Object){
+            Y.push(null
+                    // Object.fromEntries(
+                    //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
+                    // )
+                )
+        }
+    }
+    return Y.length===1?Y[0]:Y;
+}
+
+// sort
+
+export{
+    sum,
+    prod,
+    min,
+    max,
+    accum
+}
+
+//moy
+//med
+//variance
+//std
+//mode
+//acccum
+//min2max
+//max2min
+//percentile

package/src/Math/Statistics/index.js

@@ -0,0 +1,16 @@
+import {
+    sum,
+    prod,
+    min,
+    max,
+    accum
+} from "./Functions"
+const Stats={
+    sum,
+    prod,
+    min,
+    max,
+    accum,
+}
+export default Stats;
+export * from "./Functions"

package/src/Math/Utils/arithmetic.js

@@ -0,0 +1,139 @@
+import { Complex,complex} from "../Complex";
+import { Matrix  } from "../Matrix";
+const _add=(a,b)=>{
+    if(typeof(a)==="number"){
+        if (typeof b == "number") return a + b;
+        else if (b instanceof Complex)return complex(a + b.a, b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).add(b);
+        else if (b instanceof Array)return b.map(n=>add(n,a));                 
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.add(n));
+        return a.clone.add(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(a.length === b.length)return a.map((n,i)=>add(n,b[i]))
+        }
+        else {
+            return a.map(n=>add(n,b));
+        }
+    }
+}
+const _sub=(a,b)=>{
+    if(typeof(a)==="number"){
+        if (typeof b == "number") return a - b;
+        else if (b instanceof Complex)return complex(a - b.a, -b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).sub(b);
+        else if (b instanceof Array)return b.map(n=>sub(n,a));                 
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.sub(n));
+        return a.clone.sub(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(b instanceof Array){
+                if(a.length === b.length)return a.map((n,i)=>sub(n,b[i]))
+            }
+        }
+        else {
+            return a.map(n=>sub(n,b));
+        }
+    }
+}
+const _mul=(a,b)=>{
+    if(typeof(a)==="number"){
+    if (typeof b == "number") return a * b;
+        else if (b instanceof Complex)return complex(a * b.a,a * b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).mul(b);
+        else if (b instanceof Array)return b.map(n=>mul(a,n)); 
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.mul(n));
+        return a.clone.mul(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(b instanceof Array){
+                if(a.length === b.length)return a.map((n,i)=>mul(n,b[i]))
+            }
+        }
+        else {
+            return a.map(n=>mul(n,b));
+        }
+    }
+}
+const _div=(a,b)=>{
+    if(typeof(a)==="number"){
+    if (typeof b == "number") return a / b;
+        else if (b instanceof Complex)return complex(a / b.a,a / b.b);
+        else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).div(b);
+        else if (b instanceof Array)return b.map(n=>div(a,n));
+    }
+    else if(a instanceof Complex||a instanceof Matrix){
+        if(b instanceof Array)return b.map(n=>a.clone.div(n));
+        return a.clone.div(b);
+    }
+    else if(a instanceof Array){
+        if(b instanceof Array){
+            if(b instanceof Array){
+                if(a.length === b.length)return a.map((n,i)=>div(n,b[i]))
+            }
+        }
+        else {
+            return a.map(n=>div(n,b));
+        }
+    }
+}
+const _modulo=(a,b)=>{
+    if(typeof(a)==="number"){
+        if (typeof b == "number") return a % b;
+            else if (b instanceof Complex)return complex(a % b.a,a % b.b);
+            else if (b instanceof Matrix) return Matrix.nums(b.rows, b.cols, a).modulo(b);
+            else if (b instanceof Array)return b.map(n=>div(a,n));
+        }
+        else if(a instanceof Complex||a instanceof Matrix){
+            if(b instanceof Array)return b.map(n=>a.clone.div(n));
+            return a.clone.div(b);
+        }
+        else if(a instanceof Array){
+            if(b instanceof Array){
+            }
+            else {
+                return a.map(n=>add(n,b));
+            }
+        }
+}
+const add=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_add(res,b[i])
+    return res;
+}
+const sub=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_sub(res,b[i])
+    return res;
+}
+const mul=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_mul(res,b[i])
+    return res;
+}
+const div=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_div(res,b[i])
+    return res;
+}
+const modulo=(a,...b)=>{
+    var res=a;
+    for(let i=0;i<b.length;i++)res=_modulo(res,b[i])
+    return res;
+}
+export{
+    add,
+    sub,
+    mul,
+    div,
+    modulo
+}

package/src/Math/Utils/checkers.js

@@ -0,0 +1,11 @@
+const inRange=(x,a,b)=>{
+    const [min,max]=[Math.min(a,b),Math.max(a,b)]
+    return x>=min && x<=max
+}
+const isApproximatlyEqual=(a,b,Err=0.0001)=>{
+    return Math.abs(a-b)<=Err;
+}
+export{
+    inRange,
+    isApproximatlyEqual
+}

package/src/Math/Utils/comparaison.js

@@ -0,0 +1 @@
+// approximatly equal

package/src/Math/Utils/conversions.js

@@ -0,0 +1,7 @@
+import { mapfun } from "./mapfun.js";
+const deg2rad=(...deg)=>mapfun(x=>x*Math.PI/180,...deg);
+const rad2deg=(...rad)=>mapfun(x=>x/Math.PI*180,...rad);
+export{
+    deg2rad,
+    rad2deg
+}

package/src/Math/Utils/discret.js

@@ -0,0 +1,28 @@
+import { floor } from "../Functions";
+const cartesianProduct=(a, b)=>a.reduce((p, x) => [...p, ...b.map((y) => [x, y])], []);
+const pgcd=(n1, n2)=>{
+    let i,
+        pgcd = 1;
+    if (n1 == floor(n1) && n2 == floor(n2)) {
+        for (i = 2; i <= n1 && i <= n2; ++i) {
+            if (n1 % i == 0 && n2 % i == 0) pgcd = i;
+        }
+        return pgcd;
+    } else console.log("error");
+}
+const ppcm=(n1, n2)=>{
+    let ppcm;
+    if (n1 == floor(n1) && n2 == floor(n2)) {
+        ppcm = n1 > n2 ? n1 : n2;
+        while (true) {
+            if (ppcm % n1 == 0 && ppcm % n2 == 0) break;
+            ++ppcm;
+        }
+        return ppcm;
+    } else console.log("error");
+}
+export{
+    cartesianProduct,
+    ppcm,
+    pgcd
+}

package/src/Math/Utils/index.js

@@ -0,0 +1,102 @@
+import { mapfun } from "./mapfun.js";
+import { 
+    add,
+    sub,
+    mul,
+    div,
+    modulo
+ } from "./arithmetic.js";
+import {
+    zeros,
+    ones,
+    nums,
+    norm,
+    lerp,
+    map,
+    clamp,
+    arange,
+    linspace,
+    logspace,
+    geomspace
+} from "../Signal/functions.js"
+import {
+    deg2rad,
+    rad2deg
+} from "./conversions.js"
+import{
+    sum,
+    prod,
+    accum
+} from "../Statistics"
+import{
+    inRange,
+    isApproximatlyEqual
+} from "./checkers.js"
+import{
+    cartesianProduct,
+    ppcm,
+    pgcd
+} from "./discret.js"
+const Utils={
+    add,
+    sub,
+    mul,
+    div,
+    modulo,
+
+    zeros,
+    ones,
+    nums,
+    norm,
+    lerp,
+    map,
+    clamp,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+
+    sum,
+    prod,
+    accum,
+
+    cartesianProduct,
+    ppcm,
+    pgcd,
+
+    deg2rad,
+    rad2deg,
+
+    inRange,
+    isApproximatlyEqual
+}
+export {
+    mapfun,
+    Utils,
+    zeros,
+    ones,
+    nums,
+    sum,
+    prod,
+    add,
+    mul,
+    sub,
+    div,
+    modulo,
+    rad2deg,
+    deg2rad,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    norm,
+    lerp,
+    map,
+    clamp,
+    pgcd,
+    ppcm,
+    isApproximatlyEqual,
+    inRange,
+    cartesianProduct,
+  };
+ 

package/src/Math/Utils/mapfun.js

@@ -0,0 +1,43 @@
+import { Matrix } from "../Matrix";
+import { Complex , complex } from "../Complex/index.js";
+import {ln,e,cos,sin,sqrt,cosh,sinh} from "../Functions/index.js";
+import { Fixed } from "../Functions/index.js";
+const mapfun=(fun,...X)=>{
+    const Y=X.map(x=>{
+        if(x===null)return fun(null);
+        if(["number","string","boolean","bigint","undefined"].includes(typeof x))return fun(x);
+        if(x instanceof Array)return x.map(n=>mapfun(fun,n));
+        if(ArrayBuffer.isView(x))return x.map(n=>fun(n));
+        if(x instanceof Set)return new Set(mapfun(fun,...[...x]));
+        if(x instanceof Map)return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
+        if(x instanceof Matrix){
+            return new Matrix(x.rows,x.cols,mapfun(x.arr.flat(1)))
+        }
+        if(x instanceof Complex){
+            const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
+            switch(fun){
+                case Math.log:return complex(ln(z),phi); // Done
+                case Math.exp:return complex(e(a)*cos(b),e(a)*sin(b)); // Done
+                case Math.abs:return z; // Done
+                case Math.sqrt:return complex(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2)); // Done
+                case Fixed.cos:return complex(cos(a)*cosh(b),-(sin(a)*sinh(b)));
+                case Fixed.sin:return complex(sin(a)*cosh(b),cos(a)*sinh(b));
+                case Fixed.tan:{
+                    const DEN=cos(2*a)+cosh(2*b);
+                    return complex(sin(2*a)/DEN,sinh(2*b)/DEN);
+                }
+                case Fixed.cosh:return complex(cosh(a)*cos(b),sinh(a)*sin(b));
+                case Fixed.sinh:return complex(sinh(a)*cos(b),cosh(a)*sin(b));
+                case Fixed.tanh:{
+                    const DEN=cosh(2*a)+cos(2*b);
+                    return complex(sinh(2*a)/DEN,sin(2*b)/DEN)
+                }
+                //default : return fun(x)
+            }
+        }
+        else if(x instanceof Object)return Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
+
+    });
+   return Y.length==1?Y[0]:Y; 
+}
+export {mapfun}

package/src/Math/absract.js

@@ -0,0 +1 @@
+export default class AbstractZikoMath {}

package/src/Math/const.js

@@ -0,0 +1,3 @@
+const { PI, E } = Math;
+const EPSILON=Number.EPSILON
+export{PI,E,EPSILON}