ziko 0.0.5 → 0.0.6

package/core/Math/Signal/index.js

@@ -1,110 +0,0 @@
-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/core/Math/Statistics/Functions/index.js

@@ -1,100 +0,0 @@
-// 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/core/Math/Statistics/index.js

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

package/core/Math/Utils/arithmetic.js

@@ -1,139 +0,0 @@
-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/core/Math/Utils/checkers.js

@@ -1,11 +0,0 @@
-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/core/Math/Utils/comparaison.js

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

package/core/Math/Utils/conversions.js

@@ -1,7 +0,0 @@
-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/core/Math/Utils/discret.js

@@ -1,28 +0,0 @@
-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/core/Math/Utils/index.js

@@ -1,102 +0,0 @@
-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/core/Math/Utils/mapfun.js

@@ -1,43 +0,0 @@
-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/core/Math/absract.js

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

package/core/Math/const.js

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