ziko 0.54.0 → 0.54.2

package/dist/ziko.cjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Fri Dec 05 2025 11:33:57 GMT+0100 (UTC+01:00)
+  Date : Sun Dec 07 2025 10:51:21 GMT+0100 (UTC+01:00)
   Git-Repo : https://github.com/zakarialaoui10/ziko.js
   Git-Wiki : https://github.com/zakarialaoui10/ziko.js/wiki
   Released under MIT License
@@ -10,712 +10,46 @@
 
 'use strict';
 
-const { PI: PI$2, E } = Math;
+const { PI: PI$1, E } = Math;
 const EPSILON=Number.EPSILON;
 
-const {PI: PI$1, cos: cos$3, sin: sin$3, tan: tan$1, atan: atan$1, cosh: cosh$2, sinh: sinh$2, tanh: tanh$1, acosh: acosh$1, asinh: asinh$1, atanh: atanh$1, log: log$1} = Math;
-let Fixed={
-    cos : x=> {
-        if(x.isComplex?.()) return new x.constructor(
-            cos$3(x.a)*cosh$2(x.b),
-            -(sin$3(x.a)*sinh$2(x.b))
-        );
-        return cos$3(x)
-    },
-    sin : x=>{
-        if(x?.isComplex) return new x.constructor(
-            sin$3(x.a)*cosh$2(x.b),
-            cos$3(x.a)*sinh$2(x.b)
-        );
-        return sin$3(x)
-    },
-    tan : x=>{
-        if(x?.isComplex){
-            const DEN = cos$3(2*x.a)+cosh$2(2*x.b);
-            return new x.constructor(
-                sin$3(2*x.a)/DEN,
-                sinh$2(2*x.b)/DEN
-            );
-        } 
-        return tan$1(x) 
-    },
-    sinc: x => sin$3(PI$1*x)/(PI$1*x),
-    sec: x => 1/cos$3(x),
-    csc: x => 1/sin$3(x),
-    cot: x => 1/tan$1(x),
-    acos: x=>{
-        if(x?.isComplex) return 
-        return sin$3(x)
-    },
-    asin: x=>{
-        if(x?.isComplex) return 
-        return sin$3(x)
-    },
-    atan: x=>{
-        if(x?.isComplex) return 
-        return sin$3(x)
-    },
-    acot: x => PI$1/2-atan$1(x),
-    cosh: x=>{
-        if(x?.isComplex) return new x.constructor(
-            cosh$2(x.a)*cos$3(x.b),
-            sinh$2(x.a)*sin$3(x.b)
-        ); 
-        return cosh$2(x)
-    },
-    sinh: x=>{
-        if(x?.isComplex) return new x.constructor(
-            sinh$2(x.a)*cos$3(x.b),
-            cosh$2(x.a)*sin$3(x.b)
-        ); 
-        return sinh$2(x)
-    },
-    tanh: x=>{
-        if(x?.isComplex){
-            const DEN=cosh$2(2*a)+cos$3(2*b);
-            return new x.constructor(
-                sinh$2(2*a)/DEN,
-                sin$3(2*b)/DEN
-            )
-        } 
-        return tanh$1(x)
-    },
-    coth: n => (1/2*log$1((1+n)/(1-n))),
-    acosh: acosh$1,
-    asinh: asinh$1,
-    atanh: atanh$1,
-};
-
-// Fixed = new Proxy(Fixed, {
-//     get(target, prop) {
-//         if(prop in target){
-//             return x => + target[prop](x).toFixed(15);
-//         }
-//         return undefined;
-//     }
-// })
-
-const mapfun$1=(fun,...X)=>{
-    const Y=X.map(x=>{
-        if(
-            x===null||
-            ["number","string","boolean","bigint","undefined"].includes(typeof x)||
-            x?.__mapfun__
-        ) return fun(x)
-        if(x instanceof Array) return x.map(n=>mapfun$1(fun,n));
-        if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
-        if(x instanceof Set) return new Set(mapfun$1(fun,...[...x]));
-        if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun$1(fun,n[1])]));
-        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun$1(x.arr.flat(1)))
-        // if(x.isComplex?.()){
-        //     const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
-        //     switch(fun){
-        //         // Moved to Fixed to avoid Circular Dep
-        //         // case Math.log: return new x.constructor(ln(z),phi); // Done
-        //         // case Math.exp: return new x.constructor(e(a)*cos(b),e(a)*sin(b)); // Done
-        //         // case Math.abs: return z; // Done
-        //         // case Math.sqrt: return new x.constructor(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2)); // Done
-        //         // case Fixed.cos: return new x.constructor(cos(a)*cosh(b),-(sin(a)*sinh(b)));
-        //         // case Fixed.sin: return new x.constructor(sin(a)*cosh(b),cos(a)*sinh(b));
-        //         // case Fixed.tan:{
-        //         //     const DEN = cos(2*a)+cosh(2*b);
-        //         //     return new x.constructor(sin(2*a)/DEN,sinh(2*b)/DEN);
-        //         // }
-        //         // case Fixed.cosh:return new x.constructor(cosh(a)*cos(b),sinh(a)*sin(b));
-        //         // case Fixed.sinh:return new x.constructor(sinh(a)*cos(b),cosh(a)*sin(b));
-        //         // case Fixed.tanh:{
-        //         //     const DEN=cosh(2*a)+cos(2*b);
-        //         //     return new x.constructor(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$1(fun,n[1])]))
-            // return fun(Object) || Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
-        }
-    });
-   return Y.length==1? Y[0]: Y; 
-};
-
-// 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;
-};
-
-//moy
-//med
-//variance
-//std
-//mode
-//acccum
-//min2max
-//max2min
-//percentile
-
-const abs=(...x)=>mapfun$1(Math.abs,...x);
-const sqrt$2=(...x)=>mapfun$1(Math.sqrt,...x);
-const pow$1=(x,n)=>{
-    if(typeof x === "number"){
-        if(typeof n === "number")return Math.pow(x,n);
-        else if(n?.isComplex?.())return n.constructor.fromExpo(x**n.a,n.b*ln(x))
-        else return mapfun$1(a=>pow$1(x,a),...n);
-    }
-    else if(x.isComplex?.()){
-        if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
-        else if(n.isComplex?.())return x.constructor.fromExpo(
-            x.z**n.a*e(-x.phi*n.b),
-            ln(x.z)*n.b+n.a*x.phi
-        )
-        else return mapfun$1(a=>pow$1(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun$1(a=>pow$1(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun$1(a=>pow$1(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$1(a=>sqrtn(x,a),...n);
-    }
-    else if(x.isComplex?.()){
-        if(typeof n === "number")return x.constructor.fromExpo(sqrtn(x.z,n),x.phi/n);
-        else return mapfun$1(a=>sqrtn(x,a),...n);
-    }
-    else if(x instanceof Array){
-        if(typeof n === "number") return mapfun$1(a=>sqrtn(a,n),...x);
-        else if(n instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun$1(a=>sqrtn(x[i],a),...n));
-            }
-            return Y;
-        }
-    }
-};
-const e=(...x) => mapfun$1(Math.exp,...x);
-const ln=(...x) => mapfun$1(Math.log,...x);
-const cos$2=(...x) => mapfun$1(Fixed.cos,...x);
-const sin$2=(...x) => mapfun$1(Fixed.sin,...x);
-const tan=(...x) => mapfun$1(Fixed.tan,...x);
-const sec=(...x) => mapfun$1(Fixed.sec,...x);
-const sinc=(...x) => mapfun$1(Fixed.sinc,...x);
-const csc=(...x) => mapfun$1(Fixed.csc,...x);
-const cot=(...x) => mapfun$1(Fixed.cot,...x);
-const acos$1=(...x) => mapfun$1(Fixed.acos,...x);
-const asin=(...x) => mapfun$1(Fixed.asin,...x);
-const atan=(...x) => mapfun$1(Fixed.atan,...x);
-const acot=(...x) => mapfun$1(Fixed.acot,...x);
-const cosh$1=(...x) => mapfun$1(Fixed.cosh,...x);
-const sinh$1=(...x) => mapfun$1(Fixed.sinh,...x);
-const tanh=(...x) => mapfun$1(Fixed.tanh,...x);
-const coth=(...x) => mapfun$1(Fixed.coth,...x);
-const acosh=(...x) => mapfun$1(Fixed.acosh,...x);
-const asinh=(...x) => mapfun$1(Fixed.asinh,...x);
-const atanh=(...x) => mapfun$1(Fixed.atanh,...x);
-const ceil=(...x) => mapfun$1(Math.ceil,...x);
-const floor=(...x) => mapfun$1(Math.floor,...x);
-const round=(...x) => mapfun$1(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$1(a=>atan2(x,a,rad),...y);
-    }
-    // else if(x.isComplex?.()){
-    //     if(typeof n === "number")return x.constructor.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$1(a=>atan2(a,y,rad),...x);
-        else if(y instanceof Array){
-            const Y=[];
-            for(let i=0;i<x.length;i++){
-                Y.push(mapfun$1(a=>pow$1(x[i],a),...y));
-            }
-            return Y;
-        }
-    }
-};
-const fact=(...x)=>mapfun$1(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$1(Math.sign,...x);
-
-const sig=(...x)=>mapfun$1(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$1(
-        Math.hypot,
-        ...x
-    )
-};
-
-const _add=(a,b)=>{
-    if(typeof(a)==="number"){
-        if (typeof b == "number") return a + b;
-        else if (b.isComplex?.())return new b.constructor(a + b.a, b.b);
-        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).add(b);
-        else if (b instanceof Array)return b.map(n=>add(n,a));                 
-    }
-    else if(a.isComplex?.()||a.isMatrix?.()){
-        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.isComplex?.())return new b.constructor(a - b.a, -b.b);
-        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).sub(b);
-        else if (b instanceof Array)return b.map(n=>sub(n,a));                 
-    }
-    else if(a.isComplex?.()||a.isMatrix?.()){
-        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.isComplex?.())return new b.constructor(a * b.a,a * b.b);
-        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).mul(b);
-        else if (b instanceof Array)return b.map(n=>mul(a,n)); 
-    }
-    else if(a.isComplex?.()||a.isMatrix?.()){
-        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.isComplex?.())return new b.constructor(a / b.a,a / b.b);
-        else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).div(b);
-        else if (b instanceof Array)return b.map(n=>div(a,n));
-    }
-    else if(a.isComplex?.()||a.isMatrix?.()){
-        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.isComplex?.())return new b.constructor(a % b.a,a % b.b);
-            else if (b.isMatrix?.()) return b.constructor.nums(b.rows, b.cols, a).modulo(b);
-            else if (b instanceof Array)return b.map(n=>div(a,n));
-        }
-        else if(a.isComplex?.()||a.isMatrix?.()){
-            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;
-};
-
-const zeros=(n)=>new Array(n).fill(0);
-const ones=(n)=>new Array(n).fill(1);
-const nums=(num,n)=>new Array(n).fill(num);
-const norm=(value, min, max)=>{
-    if (typeof value === "number") return min !== max ? (value - min) / (max - min) : 0;
-    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, norm(value.arr.flat(1), min, max));
-    else if (value.isComplex?.()) return new value.constructor(norm(value.a, min, max), norm(value.b, min, max));
-    else if (value instanceof Array) {
-        if (value.every((n) => typeof (n === "number"))) {
-            return value.map((n) => norm(n, min, max));
-        } else {
-            let y = new Array(value.length);
-            for (let i = 0; i < value.length; i++) {
-                y[i] = norm(value[i]);
-            }
-        }
-    }
-};
-const lerp=(value, min, max)=>{
-    if (typeof value === "number") return (max - min) * value + min;
-    else if (value.isMatrix?.()) return new value.constructor(value.rows, value.cols, lerp(value.arr.flat(1), min, max));
-    else if (value.isComplex?.()) return new value.constructor(lerp(value.a, min, max), lerp(value.b, min, max));
-    else if (value instanceof Array) {
-        if (value.every((n) => typeof (n === "number"))) {
-            return value.map((n) => lerp(n, min, max));
-        } else {
-            let y = new Array(value.length);
-            for (let i = 0; i < value.length; i++) {
-                y[i] = lerp(value[i]);
-            }
-        }
-    }
-};
-const map$1=(x, a, b, c, d)=>{
-    if (typeof x === "number") return lerp(norm(x, a, b), c, d);
-    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, map$1(x.arr.flat(1), a, b, c, d));
-    else if (x.isComplex?.()) return new x.constructor(map$1(x.a, b, c, d), map$1(x.b, a, b, c, d));
-    else if (x instanceof Array) {
-        if (x.every((n) => typeof (n === "number"))) {
-            return x.map((n) => map$1(n, a, b, c, d));
-        } else {
-            let y = new Array(x.length);
-            for (let i = 0; i < x.length; i++) {
-                y[i] = map$1(x[i], a, b, c, d);
-            }
-        }
-    }
-};
-const clamp=(x, a , b)=>{
-    const [min_value,max_value]=[min(a,b),max(a,b)];
-    if (typeof x === "number") return min(max(x, min_value), max_value);
-    else if (x.isMatrix?.()) return new x.constructor(x.rows, x.cols, clamp(x.arr.flat(1), min_value, max_value));
-    else if (x.isComplex?.()) return new x.constructor(clamp(x.a, min_value, max_value), clamp(x.b, min_value, max_value));
-    else if (x instanceof Array) {
-        if (x.every((n) => typeof (n === "number"))) {
-            return x.map((n) => clamp(n, min_value, max_value));
-        } else {
-            let y = new Array(x.length);
-            for (let i = 0; i < x.length; i++) {
-                y[i] = clamp(x[i], min_value, max_value);
-            }
-        }
-    }
-};
-const arange=(a, b, step , include = false)=>{
-    let tab = [];
-    if(a<b){
-        for (let i = a; include?i<=b:i<b; i += step) tab.push((i * 10) / 10);
-    }
-    else {
-        for(let i = a; include?i>=b:i>b; i -= step) tab.push((i * 10) / 10);
-    }
-    return tab;
-};
-const linspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
-    if(Math.floor(n)!==n)return;
-    if([a,b].every(n=>typeof n==="number")){
-        const [max,min]=[a,b].sort((a,b)=>b-a);
-        var Y = [];
-        let step ;
-        endpoint ? step = (max - min) / (n - 1) : step = (max - min) / n;
-        for (var i = 0; i < n; i++) {
-            a<b?Y.push(min+step*i):Y.push(max-step*i);
-        }
-        return Y
-    }
-
-    if([a,b].some(n=>n.isComplex?.())){
-        const z1 = new n.constructor(a);
-        const z2 = new n.constructor(b);
-        n=n||Math.abs(z1.a-z2.a)+1;
-        const X=linspace(z1.a,z2.a,n,endpoint);
-        const Y=linspace(z1.b,z2.b,n,endpoint);
-        let Z=new Array(n).fill(null);
-        Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
-        return Z;
-    }
-};
-const logspace=(a,b,n=b-a+1,base=E,endpoint=true)=>{
-    return linspace(a,b,n,endpoint).map(n=>pow$1(base,n))
-};
-const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
-    if(Math.floor(n)!==n)return;
-    if([a,b].every(n=>typeof n==="number")){
-        const [max,min]=[a,b].sort((a,b)=>b-a);
-        let base;
-        endpoint ? base = sqrtn(max/min,n-1) : base = sqrtn(max/min,n) ;
-        const Y = [min];
-        for (let i = 1; i < n; i++) {
-            Y.push(Y[i-1]*base);
-        }
-        return a<b?Y:Y.reverse()
-    }
-
-    if([a,b].some(n=>n.isComplex?.())){
-        const z1 = new n.constructor(a);
-        const z2 = new n.constructor(b);
-        n=n||Math.abs(z1.a-z2.a)+1;
-        let base;
-        endpoint ? base = sqrtn(z2.div(z1),n-1) : base = sqrtn(z2.div(z1),n) ;
-        const Y = [z1];
-        for (let i = 1; i < n; i++) {
-            Y.push(mul(Y[i-1],base));
-        } 
-        return Y;
-    }
-};
-
-/** @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);
-
-/** @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;
-};
-
-/** @module Math */
-
-/**
- * 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;
+const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
+
+const mapfun=(fun,...X)=>{
+    const Y=X.map(x=>{
+        if(is_primitive(x) || x?.__mapfun__) 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.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
+        else if(x instanceof Object){
+            return Object.fromEntries(
+                Object.entries(x).map(
+                    n=>n=[n[0],mapfun(fun,n[1])]
+                )
+            )
         }
-        return pgcd;
-    } else console.log("error");
+    });
+   return Y.length==1? Y[0]: Y; 
 };
 
-/**
- * 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");
-};
-
-const Utils={
-    add,
-    sub,
-    mul,
-    div,
-    modulo,
-
-    zeros,
-    ones,
-    nums,
-    norm,
-    lerp,
-    map: map$1,
-    clamp,
-    arange,
-    linspace,
-    logspace,
-    geomspace,
-
-    sum,
-    prod,
-    accum,
-
-    cartesianProduct,
-    ppcm,
-    pgcd,
-
-    deg2rad,
-    rad2deg,
-
-    inRange,
-    isApproximatlyEqual
+const apply_fun = (x, fn) => {
+    if (x.isComplex?.()) return new x.constructor(
+        fn(x.a),
+        fn(x.b)
+    )
+    if (x.isMatrix?.()) return new x.constructor(
+        x.rows,
+        x.cols,
+        x.arr.flat(1).map(fn)
+    )
+    if (x instanceof Array) mapfun(fn, ...x);
+    return fn(x)
 };
 
+// import {sum,prod,deg2rad} from "../utils/index.js";
+// Should avoid CD
 class Complex{
     constructor(a = 0, b = 0) {
         if(a instanceof Complex){
@@ -724,33 +58,33 @@ class Complex{
         }
         else if(typeof(a)==="object"){
             if(("a" in a && "b" in a)){
-                this.a=a.a;
-                this.b=a.b;
+                this.a = a.a;
+                this.b = a.b;
             }
             else if(("a" in a && "z" in a)){
-                this.a=a.a;
-                this.b=sqrt$2((a.z**2)-(a.a**2));
+                this.a = a.a;
+                this.b = Math.sqrt((a.z**2)-(a.a**2));
             }
             else if(("a" in a && "phi" in a)){
-                this.a=a.a;
-                this.b=a.a*tan(a.phi);
+                this.a = a.a;
+                this.b = a.a * Math.tan(a.phi);
             }
             else if(("b" in a && "z" in a)){
-                this.b=a.b;
-                this.a=sqrt$2((a.z**2)-(a.b**2));
+                this.b = a.b;
+                this.a = Math.sqrt((a.z**2)-(a.b**2));
             }
             else if(("b" in a && "phi" in a)){
-                this.b=b;
-                this.a=a.b/tan(a.phi);
+                this.b = b;
+                this.a = a.b / Math.tan(a.phi);
             }
             else if(("z" in a && "phi" in a)){
-                this.a=a.z*cos$2(a.phi);
-                this.a=a.z*sin$2(a.phi);
+                this.a = + a.z * Math.cos(a.phi).toFixed(15);
+                this.b = + a.z * Math.sin(a.phi).toFixed(15);
             }
         }
-        else if(typeof(a)==="number"&&typeof(b)==="number"){
-            this.a = +a.toFixed(32);
-            this.b = +b.toFixed(32);
+        else if(typeof(a)==="number" && typeof(b)==="number"){
+            this.a = + a.toFixed(32);
+            this.b = + b.toFixed(32);
         }
     }
     get __mapfun__(){
@@ -772,14 +106,14 @@ class Complex{
         return str;
     }
       
-    get clone() {
+    clone() {
         return new Complex(this.a, this.b);
     }
     get z(){
-        return hypot(this.a,this.b);    
+        return Math.hypot(this.a,this.b);    
     }
     get phi(){
-        return atan2(this.b , this.a);        
+        return Math.atan2(this.b , this.a);        
     }
     static Zero() {
         return new Complex(0, 0);
@@ -788,102 +122,109 @@ class Complex{
         return new Complex(this.a, -this.b);
     }
     get inv() {
-        return new Complex(this.a / (pow$1(this.a, 2) + pow$1(this.b, 2)), -this.b / (pow$1(this.a, 2) + pow$1(this.b, 2)));
+        return new Complex(
+            this.a / Math.hypot(this.a, this.b),
+            -this.b / Math.hypot(this.a, this.b)
+        );
     }
-    add(...z) {
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    add(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a += c[i].a;
+            this.b += c[i].b;
         }
-        let re = z.map((n) => n.a);
-        let im = z.map((n) => n.b);
-        this.a+=+sum(...re).toFixed(15);
-        this.b+=+sum(...im).toFixed(15);
         return this;
     }
-    sub(...z) {
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    sub(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a -= c[i].a;
+            this.b -= c[i].b;
         }
-        let re = z.map((n) => n.a);
-        let im = z.map((n) => n.b);
-        this.a-=+sum(...re).toFixed(15);
-        this.b-=+sum(...im).toFixed(15);
         return this;
     }
-    mul(...z){
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    mul(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z *= c[i].z;
+            phi += c[i].z;
         }
-        let Z=+prod(this.z,...z.map(n=>n.z)).toFixed(15);
-        let phi=+sum(this.phi,...z.map(n=>n.phi)).toFixed(15);
-        this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(14);
-        this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(14);    
+        this.a = z*Math.cos(phi);
+        this.b = z*Math.sin(phi);  
         return this;
     }
-    div(...z) {
-        for (let i = 0; i < z.length; i++) {
-            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+    div(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z /= c[i].z;
+            phi -= c[i].z;
         }
-        let Z=+(this.z/prod(...z.map(n=>n.z))).toFixed(15);
-        let phi=+(this.phi-sum(...z.map(n=>n.phi))).toFixed(15);
-        this.a=+(Z*cos$2(phi).toFixed(15)).toFixed(15);
-        this.b=+(Z*sin$2(phi).toFixed(15)).toFixed(15);
+        this.a = z*Math.cos(phi);
+        this.b = z*Math.sin(phi);  
         return this;
     }
-    pow(n) {
-        if (floor(n) === n && n > 0) {
-            let z=+(this.z**n).toFixed(15);
-            let phi=+(this.phi*n).toFixed(15);
-            this.a=+(z*cos$2(phi).toFixed(15)).toFixed(15);
-            this.b=+(z*sin$2(phi).toFixed(15)).toFixed(15);
+    modulo(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a %= c[i].a;
+            this.b %= c[i].b;
         }
         return this;
     }
     static fromExpo(z, phi) {
         return new Complex(
-            +(z * cos$2(phi)).toFixed(13), 
-            +(z * sin$2(phi)).toFixed(13)
+            +(z * cos(phi)).toFixed(13), 
+            +(z * sin(phi)).toFixed(13)
             );
     }
     get expo() {
         return [this.z, this.phi];
     }
     static add(c,...z) {
-        return c.clone.add(...z);
+        return c.clone().add(...z);
     }
     static sub(c,...z) {
-        return c.clone.sub(...z);
+        return c.clone().sub(...z);
     }
     static mul(c,...z) {
-        return c.clone.mul(...z);
+        return c.clone().mul(...z);
     }
     static div(c,...z) {
-        return c.clone.div(...z);
-    }
-    static pow(z,n){
-        return z.clone.pow(n);
+        return c.clone().div(...z);
     }
-    static xpowZ(x){
-        return complex((x**this.a)*cos$2(this.b*ln(x)),(x**this.a)*sin$2(this.b*ln(x)));
-    }
-    sqrtn(n=2){
-        return complex(sqrtn(this.z,n)*cos$2(this.phi/n),sqrtn(this.z,n)*sin$2(this.phi/n));
+
+    nthr(n=2){
+        return complex({z: this.z ** (1/n), phi: this.phi / n});
     }
     get sqrt(){
-        return this.sqrtn(2);
+        return this.nrth(2);
+    }
+    get cbrt(){
+        return this.nrth(3);
     }
     get log(){
-        return complex(this.z,this.phi);
+        return complex(this.z, this.phi);
     }
     get cos(){
-        return complex(cos$2(this.a)*cosh$1(this.b),sin$2(this.a)*sinh$1(this.b))
+        return complex(
+            Math.cos(this.a) * Math.cosh(this.b),
+            Math.sin(this.a) * Math.sinh(this.b)
+        )
     }
     get sin(){
-        return complex(sin$2(this.a)*cosh$1(this.b),cos$2(this.a)*sinh$1(this.b))
+        return complex(
+            Math.sin(this.a) * Math.cosh(this.b),
+            Math.cos(this.a) * Math.sinh(this.b)
+        )
     }
     get tan(){
-        const de=cos$2(this.a*2)+cosh$1(this.b*2);
-        return complex(sin$2(2*this.a)/de,sinh$1(2*this.b)/de);
+        const D=cos(this.a*2)+cosh(this.b*2);
+        return complex(
+            Math.sin(2 * this.a) / D,
+            Math.sinh(2 * this.b) / D
+        );
     }
 }
 const complex=(a,b)=>{
@@ -896,6 +237,554 @@ const complex=(a,b)=>{
     return new Complex(a,b)
 };
 
+const abs = (...x) => mapfun(
+    x =>{
+        if(x.isComplex?.()) return x.z;
+        return Math.abs(x)
+    },
+    ...x
+);
+
+const pow$1 = (...x) => {
+    const n = x.pop();
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) {
+                if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x.z) - n.b * x.phi),
+                    phi: n.b * Math.log(x.z) + n.a * x.phi
+                })
+                return new x.constructor({z: x.z ** n, phi: x.phi * n});
+            }
+            if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x)),
+                    phi: n.b * Math.log(x)
+            })
+            return Math.pow(x, n)
+        },
+        ...x
+    )
+};
+
+const sqrt$2 = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/2), phi: x.phi/2});
+        if(x < 0) return complex(0, Math.sqrt(-x)) 
+        return Math.sqrt(x);
+    },
+    ...x
+);
+
+const cbrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/3), phi: x.phi/3})
+        return Math.cbrt(x);
+    },
+    ...x
+);
+
+const nthr = (...x) => {
+    const n = x.pop();
+    if(typeof n !== 'number') throw Error('nthr expects a real number n');
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return new x.constructor({z: x.z ** (1/n), phi: x.phi / n});
+            if(x<0) return n%2===2 ? complex(0, (-x)**(1/n)) : -1 * (-x)**(1/n)                
+            return x**(1/n)
+        },
+        ...x
+    )
+};
+
+const croot = (...x) =>{
+    const c = x.pop();
+    if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
+    return mapfun(
+        x => {
+            if(typeof x === 'number') x = new c.constructor(x, 0);
+            const {a : c_a, b : c_b} = c;
+            const {z, phi} = x;
+            const D = Math.hypot(c_a, c_b);
+            const A = Math.exp((Math.log(z)*c_a + phi*c_b)/D);
+            const B = (phi*c_a - Math.log(z)*c_b)/D;
+            return new c.constructor(
+                A * Math.cos(B),
+                A * Math.sin(B)
+            )
+        },
+        ...x
+    )
+};
+
+const exp$1 = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.exp(x.a) * Math.cos(x.b),
+            Math.exp(x.a) * Math.sin(x.b)
+        );
+        return Math.exp(x)
+    }
+    ,...x
+);
+
+const ln = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.log(x.z),
+            x.phi
+        );
+        return Math.log(x)
+    }
+    ,...x
+);
+
+const sign = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()){
+            const {z, phi} = x;
+            if(z===0) return new x.constructor(0, 0);
+            return new x.constructor({z:1, phi})
+        }
+        return Math.sign(x)
+    }
+    ,...x
+);
+
+const floor = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.floor(x.a),
+            Math.floor(x.b)
+        )
+        return Math.floor(x)
+    },
+    ...x
+);
+const ceil = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.ceil(x.a),
+            Math.ceil(x.b)
+        )
+        return Math.ceil(x)
+    },
+    ...x
+);
+const round = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.round(x.a),
+            Math.round(x.b)
+        )
+        return Math.round(x)
+    },
+    ...x
+);
+
+const trunc = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.trunc(x.a),
+            Math.trunc(x.b)
+        )
+        return Math.trunc(x)
+    },
+    ...x
+);
+
+const fract = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            x.a - Math.trunc(x.a),
+            x.b - Math.trunc(x.b)
+        )
+        return x - Math.trunc(x)
+    },
+    ...x
+);
+
+const cos$3 = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.cos(x.a) * Math.cosh(x.b),
+            -Math.sin(x.a) * Math.sinh(x.b)
+        );
+        return Math.cos(x)
+    }
+    ,...x
+);
+
+const sin$3 = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.sin(x.a) * Math.cosh(x.b),
+            Math.cos(x.a) * Math.sinh(x.b)
+        );
+        return Math.sin(x)
+    }
+    , ...x
+);
+
+const tan = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
+            return new x.constructor(
+                Math.sin(2*x.a) / D,
+                Math.sinh(2*x.b) / D
+            );
+        } 
+        return Math.tan(x) 
+    },
+    ...x
+);
+
+const sec = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) ;
+        return 1 / Math.cos(x)
+    }
+    ,...x
+);
+
+const acos$1 = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            globalThis.Rp = Rp;
+            globalThis.Rm = Rm;
+            return new x.constructor(
+                Math.acos((Rp - Rm) / 2),
+                -Math.acosh((Rp + Rm) / 2),
+            )
+        } 
+        return Math.acos(x) 
+    },
+    ...x
+);
+
+const asin = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            return new x.constructor(
+                Math.asin((Rp - Rm) / 2), 
+                Math.acosh((Rp + Rm) / 2)
+            );
+        }
+        return Math.asin(x);
+    },
+    ...x
+);
+
+const atan = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan((a*2/(1-a**2-b**2)))/2,
+                Math.log((a**2 + (1+b)**2)/(a**2 + (1-b)**2))/4
+            )
+        }
+        return Math.atan(x);
+    },
+    ...x
+);
+
+const acot = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan(2*a/(a**2+(b-1)*(b+1)))/2,
+                Math.log((a**2 + (b-1)**2)/(a**2 + (b+1)**2))/4   
+            )
+        }
+        return Math.PI/2 - Math.atan(x);
+    },
+    ...x
+);
+
+
+const cosh$2 = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.cosh(x.a) * Math.cos(x.b),
+            Math.sinh(x.a) * Math.sin(x.b)
+        ); 
+        return Math.cosh(x)
+    },
+    ...x
+);
+const sinh$1 = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.sinh(x.a) * Math.cos(x.b),
+            Math.cosh(x.a) * Math.sin(x.b)
+        ); 
+        return Math.sinh(x)
+    },
+    ...x
+);
+const tanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D = Math.cosh(2*a) + Math.cos(2*b);
+            return new x.constructor(
+                Math.sinh(2*a) / D,
+                Math.sin(2*b) / D
+            )
+        } 
+        return Math.tanh(x)
+    },
+    ...x
+);
+
+const coth = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const {a, b} = x;
+            const D = (Math.sinh(a)**2)*(Math.cos(b)**2) + (Math.cosh(a)**2)*(Math.sin(b)**2); 
+            return new x.constructor(
+                Math.cosh(a) * Math.sinh(a) / D,
+                - Math.sin(b) * Math.cos(b) / D
+            )
+        } 
+        return 1/Math.tanh(x)
+    },
+    ...x
+);
+
+const acosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt$2(x.clone().mul(x.clone()).sub(1))))
+        } 
+        return Math.acosh(x)
+    },
+    ...x
+);
+
+const asinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt$2(x.clone().mul(x.clone()).add(1))))
+        } 
+        return Math.asinh(x)
+    },
+    ...x
+);
+
+const atanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex); 
+        return Math.atanh(x)
+    },
+    ...x
+);
+
+const sig = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex); 
+        return 1/(1+Math.exp(-x))
+    },
+    ...x
+);
+
+const _add = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x + y;
+        if(y.isComplex?.()) {
+            return y.clone().add(x);
+        }
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().add(y);
+    }
+};
+
+const _sub = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x - y;
+        if(y.isComplex?.()) return new y.constructor(x - y.a, y.b);
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().sub(y);
+    }
+};
+
+const _mul = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x * y;
+        if(y.isComplex?.()) return y.clone().mul(x);
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().mul(y);
+    }
+};
+
+const _div = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x / y;
+        if(y.isComplex?.()) return new y.constructor(x, 0).div(y)
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().mul(y);
+    }
+};
+
+const _modulo = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x % y;
+        if(y.isComplex?.()) return new y.constructor(x, 0).modulo(y)
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return new x.clone().modulo(y);
+    }
+};
+
+const add=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _add(res, b[i]);
+    return res;
+};
+const sub=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _sub(res, b[i]);
+    return res;
+};
+const mul=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _mul(res, b[i]);
+    return res;
+};
+const div=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _div(res, b[i]);
+    return res;
+};
+const modulo=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _modulo(res, b[i]);
+    return res;
+};
+
+const min$1 = (...x) => Math.min(...x);
+const max$1 = (...x) => Math.max(...x);
+
+const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
+
+const norm = (x, min, max) => apply_fun(
+    x, 
+    v => min !== max ? (v - min) / (max - min) : 0
+);
+const lerp = (x, min, max) => apply_fun(
+    x, 
+    v => (max - min) * v + min
+);
+const clamp = (x, min, max) => apply_fun(
+    x, 
+    v => Math.min(Math.max(v, min), max)
+);
+const map$1 = (x, a, b, c, d) => apply_fun(
+    x, 
+    v => lerp(norm(v, a, b), c, d)
+);
+
+
+// export const norm = (x, min, max) => {
+//     if(x.isComplex?.()) return new x.constructor(
+//         norm(x.a, min, max),
+//         norm(x.b, min, max)
+//     )
+//     if(x.isMatrix?.()) return new x.constructor(
+//         x.rows, 
+//         x.cols, 
+//         norm(x.arr.flat(1), min, max)
+//     );
+//     if(x instanceof Array) return mapfun(n => norm(n, min, max), ...x);
+//     return min !== max ? (x - min) / (max - min) : 0;
+// }
+
+
+// export const lerp = (x, min, max) => {
+//     if(x.isComplex?.()) return new x.constructor(
+//         lerp(x.a, min, max),
+//         lerp(x.b, min, max)
+//     )
+//     if(x.isMatrix?.()) return new x.constructor(
+//         x.rows, 
+//         x.cols, 
+//         lerp(x.arr.flat(1), min, max)
+//     );
+//     if(x instanceof Array) return mapfun(n => lerp(n, min, max), ...x);
+//     return (max - min) * x + min;
+// }
+
+// export const map = (x, a, b, c, d) => {
+//     if(x.isComplex?.()) return new x.constructor(
+//         map(x.a, a, b, c, d),
+//         map(x.b, a, b, c, d)
+//     )
+//     if(x.isMatrix?.()) return new x.constructor(
+//         x.rows, 
+//         x.cols, 
+//         map(x.arr.flat(1), a, b, c, d)
+//     );
+//     if(x instanceof Array) return mapfun(n => map(n, a, b, c, d), ...x);
+//     return lerp(norm(x, a, b), c, d);
+// }
+
+// export const clamp = (x, min, max) => {
+//     if(x.isComplex?.()) return new x.constructor(
+//         clamp(x.a, min, max),
+//         clamp(x.b, min, max)
+//     )
+//     if(x.isMatrix?.()) return new x.constructor(
+//         x.rows, 
+//         x.cols, 
+//         clamp(x.arr.flat(1), min, max)
+//     );
+//     if(x instanceof Array) return mapfun(n => clamp(n, min, max), ...x);
+//     return Math.min(Math.max(x, min), max)
+// }
+
+const hypot = (...x) => {
+  const c0 = x.find(a => a.isComplex?.());
+  if (c0) {
+    const W = x.map(n => n.isComplex?.() ? n : new c0.constructor(n, 0));
+    return Math.hypot(...W.map(c => c.z));
+  }
+  return Math.hypot(...x);
+};
+
+
+const atan2 = (y, x, rad = true) => {
+    if (y instanceof Array && !(x instanceof Array))
+        return mapfun(n => atan2(n, x, rad), ...y);
+
+    if (x instanceof Array && !(y instanceof Array))
+        return mapfun(n => atan2(y, n, rad), ...x);
+
+    if (y instanceof Array && x instanceof Array)
+        return y.map((v, i) => atan2(v, x[i], rad));
+
+    const phi = Math.atan2(y, x);
+    return rad ? phi : phi * 180 / Math.PI;
+};
+
 const preload=(url)=>{
     const xhr = new XMLHttpRequest();
     xhr.open("GET", url, false); 
@@ -1525,9 +1414,9 @@ function unmount(delay = 0) {
 }
 
 var LifecycleMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mount: mount,
-    unmount: unmount
+   __proto__: null,
+   mount: mount,
+   unmount: unmount
 });
 
 if(!globalThis.__Ziko__) __init__global__();
@@ -1694,11 +1583,11 @@ function setContentEditable(bool = true) {
 }
 
 var AttrsMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getAttr: getAttr,
-    removeAttr: removeAttr,
-    setAttr: setAttr,
-    setContentEditable: setContentEditable
+   __proto__: null,
+   getAttr: getAttr,
+   removeAttr: removeAttr,
+   setAttr: setAttr,
+   setContentEditable: setContentEditable
 });
 
 function append(...ele) {
@@ -1755,15 +1644,15 @@ function before(ui){
 }
 
 var DomMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    after: after,
-    append: append,
-    before: before,
-    clear: clear,
-    insertAt: insertAt,
-    prepend: prepend,
-    remove: remove,
-    replaceElementWith: replaceElementWith
+   __proto__: null,
+   after: after,
+   append: append,
+   before: before,
+   clear: clear,
+   insertAt: insertAt,
+   prepend: prepend,
+   remove: remove,
+   replaceElementWith: replaceElementWith
 });
 
 const EventsMap = {
@@ -2477,11 +2366,11 @@ function find(condition) {
 }
 
 var IndexingMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    at: at,
-    find: find,
-    forEach: forEach,
-    map: map
+   __proto__: null,
+   at: at,
+   find: find,
+   forEach: forEach,
+   map: map
 });
 
 function style(styles){
@@ -2518,12 +2407,12 @@ function animate(keyframe, {duration=1000, iterations=1, easing="ease"}={}){
 }
 
 var StyleMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    animate: animate,
-    hide: hide,
-    show: show,
-    size: size,
-    style: style
+   __proto__: null,
+   animate: animate,
+   hide: hide,
+   show: show,
+   size: size,
+   style: style
 });
 
 // import { 
@@ -3197,7 +3086,7 @@ const svg2img=(svg,render=true)=>tags.img(svg2imgUrl(svg)).mount(render);
 //   };
 
 const obj2str=(obj)=>JSON.stringify(
-  mapfun$1(n=>{
+  mapfun(n=>{
     if(["number","string","boolean","bigint"].includes(typeof n)) return String(n);
     if(n instanceof Complex || n instanceof Matrix) return n.toString();
     if(n instanceof Array) return arr2str(n)
@@ -3983,6 +3872,277 @@ const powerSet=originalSet=>{
     return subSets;
 };
 
+const zeros=(n)=>new Array(n).fill(0);
+const ones=(n)=>new Array(n).fill(1);
+const nums=(num,n)=>new Array(n).fill(num);
+
+const arange=(a, b, step , include = false)=>{
+    let tab = [];
+    if(a<b){
+        for (let i = a; include?i<=b:i<b; i += step) tab.push((i * 10) / 10);
+    }
+    else {
+        for(let i = a; include?i>=b:i>b; i -= step) tab.push((i * 10) / 10);
+    }
+    return tab;
+};
+const linspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
+    if(Math.floor(n)!==n)return;
+    if([a,b].every(n=>typeof n==="number")){
+        const [max,min]=[a,b].sort((a,b)=>b-a);
+        var Y = [];
+        let step ;
+        endpoint ? step = (max - min) / (n - 1) : step = (max - min) / n;
+        for (var i = 0; i < n; i++) {
+            a<b?Y.push(min+step*i):Y.push(max-step*i);
+        }
+        return Y
+    }
+
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a);
+        const z2 = new n.constructor(b);
+        n=n||Math.abs(z1.a-z2.a)+1;
+        const X=linspace(z1.a,z2.a,n,endpoint);
+        const Y=linspace(z1.b,z2.b,n,endpoint);
+        let Z=new Array(n).fill(null);
+        Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
+        return Z;
+    }
+};
+const logspace=(a,b,n=b-a+1,base=E,endpoint=true)=>{
+    return linspace(a,b,n,endpoint).map(n=>pow$1(base,n))
+};
+const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
+    if(Math.floor(n)!==n)return;
+    if([a,b].every(n=>typeof n==="number")){
+        const [max,min]=[a,b].sort((a,b)=>b-a);
+        let base;
+        endpoint ? base = nthr(max/min,n-1) : base = nthr(max/min,n) ;
+        const Y = [min];
+        for (let i = 1; i < n; i++) {
+            Y.push(Y[i-1]*base);
+        }
+        return a<b?Y:Y.reverse()
+    }
+
+    if([a,b].some(n=>n.isComplex?.())){
+        const z1 = new n.constructor(a);
+        const z2 = new n.constructor(b);
+        n=n||Math.abs(z1.a-z2.a)+1;
+        let base;
+        endpoint ? base = nthr(z2.div(z1),n-1) : base = nthr(z2.div(z1),n) ;
+        const Y = [z1];
+        for (let i = 1; i < n; i++) {
+            Y.push(mul(Y[i-1],base));
+        } 
+        return Y;
+    }
+};
+
+// 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;
+};
+
+//moy
+//med
+//variance
+//std
+//mode
+//acccum
+//min2max
+//max2min
+//percentile
+
+/** @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;
+};
+
+/** @module Math */
+
+/**
+ * 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");
+};
+
+// import { mapfun } from "../mapfun/index.js";
+// import { 
+//     add,
+//     sub,
+//     mul,
+//     div,
+//     modulo
+//  } from "./arithmetic.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
+};
+
 // const subSet = (...arr) => {
 //     let list = arange(0, 2 ** arr.length, 1);
 //     let bin = list.map((n) => n.toString(2).padStart(arr.length, '0')).map((n) => n.split("").map((n) => +n));
@@ -4346,14 +4506,14 @@ class Random {
     // }
 }
 
-const { PI, sqrt: sqrt$1, cos: cos$1, sin: sin$1, acos, pow } = Math;
+const { PI, sqrt: sqrt$1, cos: cos$2, sin: sin$2, acos, pow } = Math;
 
 const linear = t => t;
 
 // --- Sin ---
-const in_sin = t => 1 - cos$1((t * PI) / 2);
-const out_sin = t => sin$1((t * PI) / 2);
-const in_out_sin = t => -(cos$1(PI * t) - 1) / 2;
+const in_sin = t => 1 - cos$2((t * PI) / 2);
+const out_sin = t => sin$2((t * PI) / 2);
+const in_out_sin = t => -(cos$2(PI * t) - 1) / 2;
 
 // --- Quad ---
 const in_quad = t => t ** 2;
@@ -4400,14 +4560,14 @@ const in_out_circ = t =>
         : (sqrt$1(1 - (-2 * t + 2) ** 2) + 1) / 2;
 
 // --- Arc ---
-const arc = t => 1 - sin$1(acos(t));
+const arc = t => 1 - sin$2(acos(t));
 
 // --- Back ---
 const back = (t, x = 1) => (t ** 2) * ((x + 1) * t - x);
 
 // --- Elastic ---
 const elastic = t =>
-    -2 * pow(2, 10 * (t - 1)) * cos$1((20 * PI * t) / 3 * t);
+    -2 * pow(2, 10 * (t - 1)) * cos$2((20 * PI * t) / 3 * t);
 
 // --- Back variations ---
 const in_back = (t, c1 = 1.70158, c3 = c1 + 1) =>
@@ -4427,14 +4587,14 @@ const in_elastic = (t, c4 = (2 * PI) / 3) =>
         ? 0
         : t === 1
         ? 1
-        : -pow(2, 10 * t - 10) * sin$1((t * 10 - 10.75) * c4);
+        : -pow(2, 10 * t - 10) * sin$2((t * 10 - 10.75) * c4);
 
 const out_elastic = (t, c4 = (2 * PI) / 3) =>
     t === 0
         ? 0
         : t === 1
         ? 1
-        : pow(2, -10 * t) * sin$1((t * 10 - 0.75) * c4) + 1;
+        : pow(2, -10 * t) * sin$2((t * 10 - 0.75) * c4) + 1;
 
 const in_out_elastic = (t, c5 = (2 * PI) / 4.5) =>
     t === 0
@@ -4442,8 +4602,8 @@ const in_out_elastic = (t, c5 = (2 * PI) / 4.5) =>
         : t === 1
         ? 1
         : t < 0.5
-        ? -(pow(2, 20 * t - 10) * sin$1((20 * t - 11.125) * c5)) / 2
-        : (pow(2, -20 * t + 10) * sin$1((20 * t - 11.125) * c5)) / 2 + 1;
+        ? -(pow(2, 20 * t - 10) * sin$2((20 * t - 11.125) * c5)) / 2
+        : (pow(2, -20 * t + 10) * sin$2((20 * t - 11.125) * c5)) / 2 + 1;
 
 // --- Bounce ---
 const in_bounce = (t, n1 = 7.5625, d1 = 2.75) =>
@@ -5140,7 +5300,7 @@ function useDerived(deriveFn, sources) {
     })
 }
 
-const useReactive = (nested_value) => mapfun$1(
+const useReactive = (nested_value) => mapfun(
     n => {
         const state = useState(n);
         return {
@@ -5439,7 +5599,7 @@ tags.p("Test useRoot ").style({
 
 */
 
-let {sqrt, cos, sin, exp, log, cosh, sinh} = Math;
+let {sqrt, cos: cos$1, sin: sin$1, exp, log, cosh: cosh$1, sinh} = Math;
 // Math.abs = new Proxy(Math.abs, {
 //   apply(target, thisArg, args) {
 //     const x = args[0]
@@ -5470,20 +5630,20 @@ for (const key of Object.getOwnPropertyNames(Math)) {
             const complex = (a, b) => new x.constructor(a, b);
             switch(target.name){
                 case 'abs' : return x.z;
-                case 'sqrt' : return complex(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2));
+                case 'sqrt' : return complex(sqrt(z)*cos$1(phi/2),sqrt(z)*sin$1(phi/2));
                 case 'log' : return complex(log(z), phi);
-                case 'exp' : return complex(exp(a)*cos(b),exp(a)*sin(b));
-                case 'cos' : return complex(cos(a)*cosh(b),-(sin(a)*sinh(b)));
-                case 'sin' : return complex(sin(a)*cosh(b),cos(a)*sinh(b));
+                case 'exp' : return complex(exp(a)*cos$1(b),exp(a)*sin$1(b));
+                case 'cos' : return complex(cos$1(a)*cosh$1(b),-(sin$1(a)*sinh(b)));
+                case 'sin' : return complex(sin$1(a)*cosh$1(b),cos$1(a)*sinh(b));
                 case 'tan' : {
-                    const DEN = cos(2*a)+cosh(2*b);
-                    return complex(sin(2*a) /DEN, sinh(2*b)/DEN);
+                    const DEN = cos$1(2*a)+cosh$1(2*b);
+                    return complex(sin$1(2*a) /DEN, sinh(2*b)/DEN);
                 }
-                case 'cosh' : return complex(cosh(a)*cos(b),sinh(a)*sin(b));
-                case 'sinh' : return complex(sinh(a)*cos(b),cosh(a)*sin(b));
+                case 'cosh' : return complex(cosh$1(a)*cos$1(b),sinh(a)*sin$1(b));
+                case 'sinh' : return complex(sinh(a)*cos$1(b),cosh$1(a)*sin$1(b));
                 case 'tanh' : {
-                    const DEN=cosh(2*a)+cos(2*b);
-                    return complex(sinh(2*a)/DEN,sin(2*b)/DEN)
+                    const DEN=cosh$1(2*a)+cos$1(2*b);
+                    return complex(sinh(2*a)/DEN,sin$1(2*b)/DEN)
                 }
                 default : return target.apply(thisArg, args)
              }
@@ -5514,7 +5674,7 @@ exports.Flex = Flex;
 exports.HTMLWrapper = HTMLWrapper;
 exports.Logic = Logic$1;
 exports.Matrix = Matrix;
-exports.PI = PI$2;
+exports.PI = PI$1;
 exports.Permutation = Permutation;
 exports.Random = Random;
 exports.SPA = SPA;
@@ -5549,6 +5709,7 @@ exports.acosh = acosh;
 exports.acot = acot;
 exports.add = add;
 exports.animation = animation;
+exports.apply_fun = apply_fun;
 exports.arange = arange;
 exports.arc = arc;
 exports.arr2str = arr2str;
@@ -5570,16 +5731,16 @@ exports.bind_touch_event = bind_touch_event;
 exports.bind_view_event = bind_view_event;
 exports.bind_wheel_event = bind_wheel_event;
 exports.cartesianProduct = cartesianProduct;
+exports.cbrt = cbrt;
 exports.ceil = ceil;
 exports.clamp = clamp;
 exports.clock = clock;
 exports.combinaison = combinaison;
 exports.complex = complex;
-exports.cos = cos$2;
-exports.cosh = cosh$1;
-exports.cot = cot;
+exports.cos = cos$3;
+exports.cosh = cosh$2;
 exports.coth = coth;
-exports.csc = csc;
+exports.croot = croot;
 exports.csv2arr = csv2arr;
 exports.csv2json = csv2json;
 exports.csv2matrix = csv2matrix;
@@ -5591,11 +5752,11 @@ exports.define_wc = define_wc;
 exports.deg2rad = deg2rad;
 exports.discret = discret;
 exports.div = div;
-exports.e = e;
 exports.elastic = elastic;
 exports.event_controller = event_controller;
-exports.fact = fact;
+exports.exp = exp$1;
 exports.floor = floor;
+exports.fract = fract;
 exports.geomspace = geomspace;
 exports.getEvent = getEvent;
 exports.hypot = hypot;
@@ -5637,16 +5798,17 @@ exports.ln = ln;
 exports.logspace = logspace;
 exports.loop = loop;
 exports.map = map$1;
-exports.mapfun = mapfun$1;
+exports.mapfun = mapfun;
 exports.matrix = matrix;
 exports.matrix2 = matrix2;
 exports.matrix3 = matrix3;
 exports.matrix4 = matrix4;
-exports.max = max;
-exports.min = min;
+exports.max = max$1;
+exports.min = min$1;
 exports.modulo = modulo;
 exports.mul = mul;
 exports.norm = norm;
+exports.nthr = nthr;
 exports.nums = nums;
 exports.obj2str = obj2str;
 exports.ones = ones;
@@ -5671,12 +5833,10 @@ exports.round = round;
 exports.sec = sec;
 exports.sig = sig;
 exports.sign = sign;
-exports.sin = sin$2;
-exports.sinc = sinc;
+exports.sin = sin$3;
 exports.sinh = sinh$1;
 exports.sleep = sleep;
 exports.sqrt = sqrt$2;
-exports.sqrtn = sqrtn;
 exports.step = step;
 exports.step_fps = step_fps;
 exports.sub = sub;
@@ -5696,6 +5856,7 @@ exports.timeTaken = timeTaken;
 exports.time_memory_Taken = time_memory_Taken;
 exports.timeout = timeout;
 exports.toggle_event_listener = toggle_event_listener;
+exports.trunc = trunc;
 exports.useDerived = useDerived;
 exports.useEventEmitter = useEventEmitter;
 exports.useIPC = useIPC;