ziko 0.0.11 → 0.0.13

package/src/math/complex/index.js

@@ -0,0 +1,203 @@
+import ZikoMath from "../absract.js";
+import{
+    cos,
+    sin,
+    tan,
+    pow,
+    floor,
+    hypot,
+    cosh,
+    sinh,
+    sqrtn,
+    atan2,
+    sqrt,
+    ln
+  }from "../functions/index.js"
+import { Matrix } from "../matrix/index.js";
+import {sum,prod,deg2rad} from "../utils/index.js";
+class Complex extends ZikoMath{
+    constructor(a = 0, b = 0) {
+        super()
+        if(a instanceof Complex){
+            this.a=a.a;
+            this.b=a.b;
+        }
+        else if(typeof(a)==="object"){
+            if(("a" in b && "b" in a)){
+                this.a=a.a;
+                this.b=a.b;
+            }
+            else if(("a" in b && "z" in a)){
+                this.a=a.a;
+                this.b=sqrt((a.z**2)-(a.a**2));
+            }
+            else if(("a" in b && "phi" in a)){
+                this.a=a.a;
+                this.b=a.a*tan(a.phi);
+            }
+            else if(("b" in b && "z" in a)){
+                this.b=a.b;
+                this.a=sqrt((a.z**2)-(a.b**2));
+            }
+            else if(("b" in b && "phi" in a)){
+                this.b=b;
+                this.a=a.b/tan(a.phi);
+            }
+            else if(("z" in b && "phi" in a)){
+                this.a=a.z*cos(a.phi);
+                this.a=a.z*sin(a.phi);
+            }
+        }
+        else if(typeof(a)==="number"&&typeof(b)==="number"){
+            this.a = +a.toFixed(32);
+            this.b = +b.toFixed(32);
+        }
+    }
+    toString(){
+        let str = "";
+        if (this.a !== 0)
+          this.b >= 0
+            ? (str = `${this.a}+${this.b}*i`)
+            : (str = `${this.a}-${Math.abs(this.b)}*i`);
+        else
+          this.b >= 0
+            ? (str = `${this.b}*i`)
+            : (str = `-${Math.abs(this.b)}*i`);
+        return str;
+    }
+      
+    get clone() {
+        return new Complex(this.a, this.b);
+    }
+    get z(){
+        return hypot(this.a,this.b);    
+    }
+    get phi(){
+        return atan2(this.b , this.a);        
+    }
+    static Zero() {
+        return new Complex(0, 0);
+    }
+    get conj() {
+        return new Complex(this.a, -this.b);
+    }
+    get inv() {
+        return new Complex(this.a / (pow(this.a, 2) + pow(this.b, 2)), -this.b / (pow(this.a, 2) + pow(this.b, 2)));
+    }
+    add(...z) {
+        for (let i = 0; i < z.length; i++) {
+            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+        }
+        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);
+        }
+        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);
+        }
+        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(phi).toFixed(15)).toFixed(14);
+        this.b=+(Z*sin(phi).toFixed(15)).toFixed(14);    
+        return this;
+    }
+    div(...z) {
+        for (let i = 0; i < z.length; i++) {
+            if (typeof z[i] === "number") z[i] = new Complex(z[i], 0);
+        }
+        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(phi).toFixed(15)).toFixed(15);
+        this.b=+(Z*sin(phi).toFixed(15)).toFixed(15);
+        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(phi).toFixed(15)).toFixed(15);
+            this.b=+(z*sin(phi).toFixed(15)).toFixed(15);
+        }
+        return this;
+    }
+    static fromExpo(z, phi) {
+        return new Complex(
+            +(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);
+    }
+    static sub(c,...z) {
+        return c.clone.sub(...z);
+    }
+    static mul(c,...z) {
+        return c.clone.mul(...z);
+    }
+    static div(c,...z) {
+        return c.clone.div(...z);
+    }
+    static pow(z,n){
+        return z.clone.pow(n);
+    }
+    static xpowZ(x){
+        return complex((x**this.a)*cos(this.b*ln(x)),(x**this.a)*sin(this.b*ln(x)));
+    }
+    sqrtn(n=2){
+        return complex(sqrtn(this.z,n)*cos(this.phi/n),sqrtn(this.z,n)*sin(this.phi/n));
+    }
+    get sqrt(){
+        return this.sqrtn(2);
+    }
+    get log(){
+        return complex(this.z,this.phi);
+    }
+    get cos(){
+        return complex(cos(this.a)*cosh(this.b),sin(this.a)*sinh(this.b))
+    }
+    get sin(){
+        return complex(sin(this.a)*cosh(this.b),cos(this.a)*sinh(this.b))
+    }
+    get tan(){
+        const de=cos(this.a*2)+cosh(this.b*2);
+        return complex(sin(2*this.a)/de,sinh(2*this.b)/de);
+    }
+    printInConsole() {
+        let string = this.a + " + " + this.b + " * i";
+        console.log(string);
+        return string;
+    }
+    print() {
+        //return text(this.a + " + i * " + this.b);
+    }
+    UI() {
+        return "<span>" + this.a + " + i * " + this.b + "</span>";
+    }
+}
+const complex=(a,b)=>{
+    if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
+    if(a instanceof Matrix && b instanceof Matrix){
+        if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
+        const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]))
+        return new Matrix(a.rows,a.cols,...arr)
+    }
+    return new Complex(a,b)
+}
+export{complex,Complex}

package/src/math/const.js

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

package/src/math/discret/Combinaison/index.js

@@ -0,0 +1,34 @@
+class Combinaison {
+    static withDiscount(comboOptions, comboLength) {
+        if (comboLength === 1) {
+            return comboOptions.map((comboOption) => [comboOption]);
+        }
+        const combos = [];
+        comboOptions.forEach((currentOption, optionIndex) => {
+            const smallerCombos = this.withDiscount(comboOptions.slice(optionIndex), comboLength - 1);
+            smallerCombos.forEach((smallerCombo) => {
+                combos.push([currentOption].concat(smallerCombo));
+            });
+        });
+        return combos;
+    }
+    static withoutDiscount(comboOptions, comboLength) {
+        if (comboLength === 1) {
+            return comboOptions.map((comboOption) => [comboOption]);
+        }
+        const combos = [];
+        comboOptions.forEach((currentOption, optionIndex) => {
+            const smallerCombos = this.withoutDiscount(comboOptions.slice(optionIndex + 1), comboLength - 1);
+            smallerCombos.forEach((smallerCombo) => {
+                combos.push([currentOption].concat(smallerCombo));
+            });
+        });
+
+        return combos;
+    }
+}
+const combinaison=(comboOptions, comboLength, discount=false)=>Combinaison[discount?"withDiscount":"withoutDiscount"](comboOptions, comboLength)
+export{ 
+    Combinaison,
+    combinaison
+ }

package/src/math/discret/Conversion/index.js

@@ -0,0 +1,86 @@
+import { Complex } from "../../complex/index.js";
+import { Matrix } from "../../matrix/Matrix.js";
+const Base={
+    _mode:Number,
+    _map:function(func,number,toBase){
+        if (number instanceof Matrix)
+            return new Matrix(
+                number.rows,
+                number.cols,
+                number.arr.flat(1).map(n=>func(n,toBase))
+            );
+        else if (number instanceof Complex) return new Complex(func(number.a,toBase),func(number.b,toBase));
+        else if (number instanceof Array) return number.map((n) =>func(n,toBase));
+    },
+    dec2base(dec,base){
+        base<=10?this._mode=Number:this._mode=String
+        //this._mode=String
+        if (typeof dec === "number") return this._mode((dec >>> 0).toString(base));
+          return this._map(this.dec2base,dec,base)
+    },
+    dec2bin(dec){
+        return this.dec2base(dec,2);
+    },
+    dec2oct(dec){
+        return this.dec2base(dec,8);
+    },
+    dec2hex(dec){
+        return this.dec2base(dec,16);
+    },
+    bin2base(bin, base) {
+        return this.dec2base(this.bin2dec(bin),base)
+    },
+    bin2dec(bin){
+        return this._mode("0b"+bin);
+    },
+    bin2oct(bin){
+        return this.bin2base(bin,8);
+    },
+    bin2hex(bin){
+        return this.bin2base(bin,16);
+    },
+    oct2dec(oct){
+        return this._mode("0o"+oct);
+    },
+    oct2bin(oct){
+        return this.dec2bin(this.oct2dec(oct))
+    },
+    oct2hex(oct){
+        return this.dec2hex(this.oct2dec(oct))
+    },
+    oct2base(oct, base) {
+        return this.dec2base(this.oct2dec(oct),base)
+    },
+    hex2dec(hex){
+        return this._mode("0x"+hex);
+    },
+    hex2bin(hex){
+        return this.dec2bin(this.hex2dec(hex))
+    },
+    hex2oct(hex){
+        return this.dec2oct(this.hex2dec(hex))
+    },
+    hex2base(hex, base) {
+        return this.dec2base(this.hex2dec(hex),base)
+    },
+    IEEE32toDec(Bin){
+        let IEEE32=Bin.split(" ").join("").padEnd(32,"0");
+        let s=IEEE32[0];
+        let e=2**(+("0b"+IEEE32.slice(1,9))-127)
+        let m=IEEE32.slice(9,32).split("").map(n=>+n)
+        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
+        let dec=(-1)**s*(1+M)*e;
+        return dec
+    },
+    IEEE64toDec(Bin){
+        let IEEE64=Bin.split(" ").join("").padEnd(64,"0");
+        let s=IEEE64[0];
+        let e=2**(+("0b"+IEEE64.slice(1,12))-1023)
+        let m=IEEE64.slice(13,64).split("").map(n=>+n)
+        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
+        let dec=(-1)**s*(1+M)*e;
+        return dec;
+    }
+}
+
+export{Base}

package/src/math/discret/Logic/index.js

@@ -0,0 +1,46 @@
+import { Complex } from "../../complex/index.js";
+import { Matrix } from "../../matrix/Matrix.js";
+const Logic={
+    _mode:Number,
+    _map:function(func,a,b){
+        if (a instanceof Matrix)
+            return new Matrix(
+                a.rows,
+                a.cols,
+                a.arr.flat(1).map((n) => func(n, b))
+            );
+        else if (a instanceof Complex) return new Complex(func(a.a, b), func(a.b, b));
+        else if (a instanceof Array) return a.map((n) => func(n, b));      
+    },
+    not:function(input){
+        if(["number","boolean"].includes(typeof input)) return Logic._mode(!input);
+        else return this._map(this.not,input)
+    },
+    and:function(a, ...b){
+        if(["number","boolean"].includes(typeof a))return Logic._mode(b.reduce((n, m) => (n &= m), a));
+        else return this._map(this.and,a,b)
+    },
+    or:function(a, ...b) {
+        if(["number","boolean"].includes(typeof a)) return Logic._mode(b.reduce((n, m) => (n |= m), a));
+        else return this._map(this.or,a,b);
+    },
+    nand:function(a, ...b) {
+        return this.not(this.and(a, b));
+    },
+    nor:function(a, ...b) {
+        return this.not(this.or(a, b));
+    },
+    xor:function(a,...b){
+        let arr=[a,...b]
+        if(["number","boolean"].includes(typeof a))return this._mode(arr.reduce((length,cur)=>{
+            if(+cur===1)length+=1;
+            return length;
+        },0)===1);
+        else return this._map(this.xor,a,b);
+    },
+    xnor:function(a,...b){
+        return Logic.not(Logic.xor(a,b))
+    }
+    
+}
+export{Logic}

package/src/math/discret/Permutation/index.js

@@ -0,0 +1,31 @@
+class Permutation {
+    static withDiscount(arr, l = arr.length) {
+        if (l === 1) return arr.map((n) => [n]);
+        const permutations = [];
+        let smallerPermutations;
+        smallerPermutations = this.withDiscount(arr, l - 1);
+        arr.forEach((currentOption) => {
+            smallerPermutations.forEach((smallerPermutation) => {
+                permutations.push([currentOption].concat(smallerPermutation));
+            });
+        });
+        return permutations;
+    }
+    static withoutDiscount(arr) {
+        const l = arr.length;
+        if (l === 1) return arr.map((n) => [n]);
+        const permutations = [];
+        const smallerPermutations = this.withoutDiscount(arr.slice(1));
+        const firstOption = arr[0];
+        for (let i = 0; i < smallerPermutations.length; i++) {
+            const smallerPermutation = smallerPermutations[i];
+            for (let j = 0; j <= smallerPermutation.length; j++) {
+                const permutationPrefix = smallerPermutation.slice(0, j);
+                const permutationSuffix = smallerPermutation.slice(j);
+                permutations.push(permutationPrefix.concat([firstOption], permutationSuffix));
+            }
+        }
+        return permutations;
+    }
+}
+export { Permutation }

package/src/math/discret/Set/index.js

@@ -0,0 +1,2 @@
+export * from "./power-set.js";
+export * from "./sub-set.js";

package/src/math/discret/Set/power-set.js

@@ -0,0 +1,15 @@
+const powerSet=originalSet=>{
+    const subSets = [];
+    const NUMBER_OF_COMBINATIONS = 2 ** originalSet.length;
+    for (let i = 0; i < NUMBER_OF_COMBINATIONS; i += 1) {
+        const subSet = [];
+        for (let j = 0; j < originalSet.length; j += 1) {
+            if (i & (1 << j)) {
+                subSet.push(originalSet[j]);
+            }
+        }
+        subSets.push(subSet);
+    }
+    return subSets;
+}
+export{powerSet}

package/src/math/discret/Set/sub-set.js

@@ -0,0 +1,10 @@
+import { arange } from "../../utils/index.js";
+
+// 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));
+//     let sub = bin.map((n) => n.map((m, i) => (m === 1 ? arr[i] : null))).map((n) => n.filter((x) => x !== null));
+//     return sub;
+// };
+const subSet = null
+export { subSet };

package/src/math/discret/index.js

@@ -0,0 +1,23 @@
+import { powerSet , subSet } from "./Set/index.js";
+import { Base } from "./Conversion/index.js";
+import { Logic } from "./Logic/index.js";
+import {
+    Permutation,
+} from "./Permutation/index.js"
+import {
+    Combinaison,
+    combinaison,
+} from "./Combinaison/index.js"
+
+
+const Discret={
+    Logic,
+    Base,
+    Permutation,
+    Combinaison,
+    combinaison,
+    powerSet,
+    subSet
+}
+export default Discret;
+export{Logic,Base,Permutation,Combinaison,powerSet,subSet}

package/src/math/functions/index.js

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