ziko 0.0.12 → 0.0.14

package/src/math/signal/index.js

@@ -0,0 +1,110 @@
+import { mapfun } from "../utils/index.js";
+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/index.js"
+const Stats={
+    sum,
+    prod,
+    min,
+    max,
+    accum,
+}
+export default Stats;
+export * from "./Functions/index.js"

package/src/math/utils/arithmetic.js

@@ -0,0 +1,139 @@
+import { Complex,complex} from "../complex/index.js";
+import { Matrix  } from "../matrix/index.js";
+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,29 @@
+/** @module Math */
+/**
+ * Checks if a value is within the specified range.
+ * @function
+ * @param {number} x - The value to check.
+ * @param {number} a - The start of the range.
+ * @param {number} b - The end of the range.
+ * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
+ */
+const inRange = (x, a, b) => {
+    const [min, max] = [Math.min(a, b), Math.max(a, b)];
+    return x >= min && x <= max;
+}
+
+/**
+ * Checks if two numbers are approximately equal within a given error margin.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @param {number} [Err=0.0001] - The maximum acceptable difference between the two numbers.
+ * @returns {boolean} Returns true if the two numbers are approximately equal within the specified error margin, otherwise false.
+ */
+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,19 @@
+/** @module Math */
+/**
+ * Converts degrees to radians.
+ * @param {...number} deg - Degrees to convert.
+ * @returns {number|number[]} Returns an array of radians corresponding to the input degrees.
+ */
+const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+
+/**
+ * Converts radians to degrees.
+ * @param {...number} rad - Radians to convert.
+ * @returns {number|number[]} Returns an array of degrees corresponding to the input radians.
+ */
+const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
+
+export {
+    deg2rad,
+    rad2deg
+}

package/src/math/utils/discret.js

@@ -0,0 +1,51 @@
+/** @module Math */
+import { floor } from "../functions/index.js";
+
+/**
+ * Computes the cartesian product of two arrays.
+ * @param {Array} a - The first array.
+ * @param {Array} b - The second array.
+ * @returns {Array} Returns an array representing the cartesian product of the input arrays.
+ */
+const cartesianProduct = (a, b) => a.reduce((p, x) => [...p, ...b.map((y) => [x, y])], []);
+
+/**
+ * Computes the greatest common divisor (GCD) of two numbers.
+ * @param {number} n1 - The first number.
+ * @param {number} n2 - The second number.
+ * @returns {number} Returns the greatest common divisor of the two input numbers.
+ */
+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");
+}
+
+/**
+ * Computes the least common multiple (LCM) of two numbers.
+ * @param {number} n1 - The first number.
+ * @param {number} n2 - The second number.
+ * @returns {number} Returns the least common multiple of the two input numbers.
+ */
+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/index.js"
+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,50 @@
+/** @module Math */
+import { Matrix } from "../matrix/index.js";
+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";
+ /**
+ * map a function to ...X
+ * @param {function} fun
+ * @param {...any} X
+ * @returns {any|any[]}
+ */
+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/reactivity/events/Global/Click.js

@@ -0,0 +1,56 @@
+import { ZikoEvent , EVENT_CONTROLLER } from "../ZikoEvent.js";
+function click_controller(e){
+    EVENT_CONTROLLER.call(this,e,"click",null,null)
+}
+function dbclick_controller(e){
+    EVENT_CONTROLLER.call(this,e,"dbclick",null,null)
+}
+class ZikoEventClick extends ZikoEvent{
+    constructor(target){
+        super(target);
+        this.event=null;
+        this.cache={
+            prefixe:"",
+            preventDefault:{
+                click:false,
+                dbclick:false,
+            },
+            paused:{
+                click:false,
+                dbclick:false,      
+            },
+            stream:{
+                enabled:{
+                    click:false,
+                    dbclick:false,
+                },
+                clear:{
+                    click:false, 
+                    dbclick:false,         
+                },
+                history:{
+                    click:[],
+                    dbclick:[],
+                }
+            },
+            callbacks:{
+                click:[],
+                dbclick:[],
+            }
+        }
+        this.__controller={
+            click:click_controller.bind(this),
+            dbclick:dbclick_controller.bind(this),
+        }
+    }
+    onClick(...callbacks){
+        this.__onEvent("click",{},...callbacks)
+        return this;
+     }
+    onDbClick(...callbacks){
+        this.__onEvent("dbclick",{},...callbacks)
+        return this;
+     }     
+}
+const useClickEvent=target=>new ZikoEventClick(target);
+export default useClickEvent;