ziko 0.33.0 → 0.34.0

package/src/math/calculus/special-functions/beta.js

@@ -1,38 +0,0 @@
-import { mapfun } from "../../utils/index.js";
-const _beta=(x, y)=>{
-    const lowerLimit = 0;
-    const upperLimit = 1;
-    const intervals = 1000;
-    let result = 0;
-
-    const f = (t) => Math.pow(t, x - 1) * Math.pow(1 - t, y - 1);
-    const h = (upperLimit - lowerLimit) / intervals;
-
-    result += 0.5 * (f(lowerLimit) + f(upperLimit));
-
-    for (let i = 1; i < intervals; i++) {
-        const xi = lowerLimit + i * h;
-        result += f(xi);
-    }
-
-    return result * h;
-}
-const beta=(x,y)=>{
-    if(typeof x === "number"){
-        if(typeof x === "number")return _beta(x,y);
-        else console.warn("Not supported yet")
-    }
-    else if(x instanceof Array){
-        if(typeof y === "number") return mapfun(a=>_beta(a,y),...x);
-        else if(y instanceof Array){
-            const Z=[];
-            for(let i=0;i<x.length;i++){
-                Z.push(mapfun(a=>_beta(x[i],a),...y))
-            }
-            return Z;
-        }
-    }
-}
-export{
-    beta
-}

package/src/math/calculus/special-functions/gamma.js

@@ -1,30 +0,0 @@
-import { mapfun } from "../../utils/mapfun.js";
-const _gamma=x=>{
-    // Coefficients for the Lanczos approximation
-    const g = 7;
-    const p = [
-        0.99999999999980993,
-        676.5203681218851,
-        -1259.1392167224028,
-        771.32342877765313,
-        -176.61502916214059,
-        12.507343278686905,
-        -0.13857109526572012,
-        9.9843695780195716e-6,
-        1.5056327351493116e-7
-    ];
-    if (x < 0.5) {
-        return +(Math.PI / (Math.sin(Math.PI * x) * _gamma(1 - x))).toFixed(10);
-    }
-    x -= 1;
-    let a = p[0];
-    for (let i = 1; i < g + 2; i++) {
-        a += p[i] / (x + i);
-    }
-    const t = x + g + 0.5;
-    return +(Math.sqrt(2 * Math.PI) * Math.pow(t, (x + 0.5)) * Math.exp(-t) * a).toFixed(10);
-}
-const gamma=(...x)=>mapfun(_gamma,...x);
-export{
-    gamma
-}

package/src/math/calculus/special-functions/index.js

@@ -1,4 +0,0 @@
-export * from "./gamma.js";
-export * from "./bessel.js";
-export * from "./beta.js";
-

package/src/math/matrix/Decomposition.js

@@ -1,90 +0,0 @@
-import { Matrix } from "./Matrix.js";
-const luDecomposition=matrix=>{
-    if(matrix instanceof Matrix)matrix=matrix.arr;
-    const n = matrix.length;
-    const L = new Array(n).fill(0).map(() => new Array(n).fill(0));
-    const U = new Array(n).fill(0).map(() => new Array(n).fill(0));
-    for (let i = 0; i < n; i++) {
-        // Upper Triangular
-        for (let k = i; k < n; k++) {
-            // Summation of L(i, j) * U(j, k)
-            let sum = 0;
-            for (let j = 0; j < i; j++) {
-                sum += (L[i][j] * U[j][k]);
-            }
-            U[i][k] = matrix[i][k] - sum;
-        }
-        // Lower Triangular
-        for (let k = i; k < n; k++) {
-            if (i == k) {
-                L[i][i] = 1; // Diagonal as 1
-            } else {
-                // Summation of L(k, j) * U(j, i)
-                let sum = 0;
-                for (let j = 0; j < i; j++) {
-                    sum += (L[k][j] * U[j][i]);
-                }
-                // Evaluate L(k, i)
-                L[k][i] = (matrix[k][i] - sum) / U[i][i];
-            }
-        }
-    }
-    return [L, U].map(n=>new Matrix(n));
-}
-const dotProduct=(v1, v2)=>v1.reduce((sum, el, i) => sum + el * v2[i], 0);
-const magnitude=vector=>Math.sqrt(vector.reduce((sum, el) => sum + el * el, 0));
-const normalize=vector=>vector.map(el => el / magnitude(vector));
-const qrDecomposition=matrix=>{
-    if(matrix instanceof Matrix)matrix=matrix.arr;
-    const m = matrix.length;
-    const n = matrix[0].length;
-    const Q = [];
-    const R = [];
-    // Initialize R as an m x n matrix of zeroes
-    for (let i = 0; i < m; i++) {
-        R.push(new Array(n).fill(0));
-    }
-    for (let j = 0; j < n; j++) {
-        let v = matrix.map(row => row[j]);
-        for (let i = 0; i < j; i++) {
-            const q = Q[i];
-            const r_ij = dotProduct(q, matrix.map(row => row[j]));
-            for (let k = 0; k < m; k++) {
-                v[k] -= r_ij * q[k];
-            }
-            R[i][j] = r_ij;
-        }
-        const v_mag = magnitude(v);
-        Q.push(normalize(v));
-        R[j][j] = v_mag;
-    }
-    return [Q, R].map(n=>new Matrix(n));
-}
-
-const choleskyDecomposition=matrix=>{
-    if(matrix instanceof Matrix)matrix=matrix.arr;
-    const n = matrix.length;
-    const L = new Array(n).fill(0).map(() => new Array(n).fill(0));
-    for (let i = 0; i < n; i++) {
-        for (let j = 0; j <= i; j++) {
-            let sum = 0;
-            for (let k = 0; k < j; k++) {
-                sum += L[i][k] * L[j][k];
-            }
-
-            if (i === j) {
-                L[i][j] = Math.sqrt(matrix[i][i] - sum);
-            } else {
-                L[i][j] = (1.0 / L[j][j] * (matrix[i][j] - sum));
-            }
-        }
-    }
-    return new Matrix(L);
-}
-
-
-export { 
-    luDecomposition,
-    qrDecomposition,
-    choleskyDecomposition
- }

package/src/math/matrix/LinearSystem.js

@@ -1,10 +0,0 @@
-import { Matrix } from "./Matrix.js";
-class LinearSystem {
-    static resolve(A, B) {
-        return A.inv
-            .dot(Matrix.fromVector(B))
-            .arr.flat(1)
-            .map((n) => +n.toFixed(10));
-    }
-}
-export { LinearSystem }

package/src/math/signal/__np.py.txt

@@ -1,40 +0,0 @@
-import numpy as np
-lin_R=np.linspace(1,10,10,)
-lin_C=np.linspace(10j+1,10+1j,10)
-print("Linspace")
-print(lin_R)
-print("-"*70)
-print(lin_C)
-log_R=np.logspace(1,10,10, base = 2)
-log_C=np.logspace(10j+1,10+1j,10 , base = 2)
-print("-"*70)
-print("Logspace")
-print(log_R)
-print("-"*70)
-print(log_C)
-geo_R=np.geomspace(1,512,10)
-geo_C=np.geomspace(1+1j,512+512j,10)
-print("-"*70)
-print("geomspace")
-print(geo_R)
-print("-"*70)
-print(geo_C)
-
-
-# // const logspace=(a,b,n=b-a+1,base=E,endpoint=true)=>{
-# //     if(a instanceof Complex||b instanceof Complex){
-# //         a=complex(a);
-# //         b=complex(b);
-# //         n=n??abs(b.a-a.a)
-# //         const X=linspace(a.a,b.a,n,base,endpoint);
-# //         const Y=linspace(a.b,b.b,n,base,endpoint);
-# //         const Z=new Array(X.length).fill(0)
-# //         const ZZ=Z.map((n,i) => pow(base,complex(X[i],Y[i])));
-# //         return ZZ;
-# //     }
-# //     const start=base**min(a,b);
-# //     const stop=base**max(a,b);
-# //     const y = linspace(ln(start) / ln(base), ln(stop) / ln(base), n, endpoint);
-# //     const result=y.map(n => pow(base, n));
-# //     return a<b?result:result.reverse();
-# // }

package/src/math/signal/conv.js

@@ -1,175 +0,0 @@
-import { Matrix , matrix } from "../matrix/index.js";
-import { sqrt } from "../functions/index.js";
-const conv1d=(input, kernel , circular = true)=>{
-    const INPUT_LENGTH = input.length;
-    const KERNEL_LENGTH = kernel.length;
-    const output = [];
-    const LENGTH_OUT = circular ? Math.max(INPUT_LENGTH,KERNEL_LENGTH) : INPUT_LENGTH + KERNEL_LENGTH - 1;
-    for (let i = 0; i < LENGTH_OUT; i++) {
-        let sum = 0;
-        for (let j = 0; j < KERNEL_LENGTH; j++) {
-            const inputIndex = i + j - Math.floor(KERNEL_LENGTH / 2);
-            // Apply zero-padding for out-of-bounds indices
-            const inputValue = inputIndex >= 0 && inputIndex < INPUT_LENGTH
-                ? input[inputIndex]
-                : 0;
-            sum += inputValue * kernel[j];
-        }
-        output.push(sum);
-    }
-    return output;
-}
-
-const conv2d = (input, kernel, circular = true) => {
-    if(!(input instanceof Matrix)) input = matrix(input);
-    if(!(kernel instanceof Matrix)) kernel = matrix(kernel);
-    const INPUT_ROWS=input.rows;
-    const INPUT_COLS=input.cols;
-    const OUTPUT_ROWS = circular ? Math.max(input.rows,kernel.rows) : input.rows + kernel.rows-1;
-    const OUTPUT_COLS = circular ? Math.max(input.cols,kernel.cols) : input.cols + kernel.cols-1;
-    const KERNEL_SIZE = kernel.rows;
-    const output = [];
-    for (let i = 0; i < OUTPUT_ROWS ; i++) {
-        const row = [];
-        for (let j = 0; j < OUTPUT_COLS ; j++) {
-            let sum = 0;
-            for (let k = 0; k < KERNEL_SIZE; k++) {
-                for (let l = 0; l < KERNEL_SIZE; l++) {
-                    const rowIndex = i + k - Math.floor(KERNEL_SIZE / 2);
-                    const colIndex = j + l - Math.floor(KERNEL_SIZE / 2);
-                    // Apply zero-padding for out-of-bounds indices
-                    const inputValue = (rowIndex >= 0 && rowIndex < INPUT_ROWS &&
-                                        colIndex >= 0 && colIndex < INPUT_COLS)
-                        ? input[rowIndex][colIndex]
-                        : 0;
-                    sum += inputValue * kernel[k][l];
-                }
-            }
-            row.push(sum);
-        }
-        output.push(row);
-    }
-    return output;
-};
-
-var convolute=(parent,kernel = [0, -1, 0, -1, 5, -1, 0, -1, 0], x1 = 0, y1 = 0, x2 = parent.element.width, y2 = parent.element.height)=>{
-    if(kernel instanceof Matrix)kernel=kernel.arr.flat(1)
-    var opaque = 1;
-    var pixels = parent.ctx.getImageData(x1, y1, x2, y2);
-    var side = Math.round(sqrt(kernel.length));
-    var halfSide = Math.floor(side / 2);
-    var src = pixels.data;
-    var sw = pixels.width;
-    var sh = pixels.height;
-    // pad output by the convolution matrix
-    var w = sw;
-    var h = sh;
-    var output = parent.ctx.createImageData(w, h);
-    var dst = output.data;
-    // go through the destination image pixels
-    var alphaFac = opaque ? 1 : 0;
-    for (var y = 0; y < h; y++) {
-        for (var x = 0; x < w; x++) {
-            var sy = y;
-            var sx = x;
-            var dstOff = (y * w + x) * 4;
-            // calculate the weighed sum of the source image pixels that
-            // fall under the convolution matrix
-            var r = 0,
-                g = 0,
-                b = 0,
-                a = 0;
-            for (var cy = 0; cy < side; cy++) {
-                for (var cx = 0; cx < side; cx++) {
-                    var scy = sy + cy - halfSide;
-                    var scx = sx + cx - halfSide;
-                    if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
-                        var srcOff = (scy * sw + scx) * 4;
-                        var wt = kernel[cy * side + cx];
-                        r += src[srcOff] * wt;
-                        g += src[srcOff + 1] * wt;
-                        b += src[srcOff + 2] * wt;
-                        a += src[srcOff + 3] * wt;
-                    }
-                }
-            }
-            dst[dstOff] = r;
-            dst[dstOff + 1] = g;
-            dst[dstOff + 2] = b;
-            dst[dstOff + 3] = a + alphaFac * (255 - a);
-        }
-    }
-    return output;
-}
-
-convolute=(parent,kernel = [0, -1, 0, -1, 5, -1, 0, -1, 0], x1 = 0, y1 = 0, x2 = parent.element.width, y2 = parent.element.height)=>{
-    if(kernel instanceof Matrix)kernel=kernel.arr.flat(1)
-    var opaque = 1;
-    var pixels = parent.ctx.getImageData(x1, y1, x2, y2);
-    var side = Math.round(sqrt(kernel.length));
-    var halfSide = Math.floor(side / 2);
-    var src = pixels.data;
-    var sw = pixels.width;
-    var sh = pixels.height;
-    // pad output by the convolution matrix
-    var w = sw;
-    var h = sh;
-    var output = parent.ctx.createImageData(w, h);
-    var dst = output.data;
-    // go through the destination image pixels
-    var alphaFac = opaque ? 1 : 0;
-    for (var y = 0; y < h; y++) {
-        for (var x = 0; x < w; x++) {
-            var sy = y;
-            var sx = x;
-            var dstOff = (y * w + x) * 4;
-            // calculate the weighed sum of the source image pixels that
-            // fall under the convolution matrix
-            var r = 0,
-                g = 0,
-                b = 0,
-                a = 0;
-            for (var cy = 0; cy < side; cy++) {
-                for (var cx = 0; cx < side; cx++) {
-                    var scy = sy + cy - halfSide;
-                    var scx = sx + cx - halfSide;
-                    if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
-                        var srcOff = (scy * sw + scx) * 4;
-                        var wt = kernel[cy * side + cx];
-                        r += src[srcOff] * wt;
-                        g += src[srcOff + 1] * wt;
-                        b += src[srcOff + 2] * wt;
-                        a += src[srcOff + 3] * wt;
-                    }
-                }
-            }
-            dst[dstOff] = r;
-            dst[dstOff + 1] = g;
-            dst[dstOff + 2] = b;
-            dst[dstOff + 3] = a + alphaFac * (255 - a);
-        }
-    }
-    return output;
-}
-const conv=(input,kernel,circular)=>{
-    if(input instanceof Matrix || (input instanceof Array && input[0][0]))return conv2d(input,kernel,circular);
-    return conv1d(input,kernel,circular)
-}
-const circularConv=(input,kernel)=>conv(input,kernel,true);
-const linearConv=(input,kernel)=>conv(input,kernel,false);
-const circularConv1d=(input,kernel)=>conv1d(input,kernel,true);
-const circularConv2d=(input,kernel)=>conv2d(input,kernel,true);
-const linearConv1d=(input,kernel)=>conv1d(input,kernel,false);
-const linearConv2d=(input,kernel)=>conv2d(input,kernel,false);
-export{
-    conv1d,
-    conv2d,
-    conv,
-    circularConv,
-    linearConv,
-    circularConv1d,
-    linearConv1d,
-    circularConv2d,
-    linearConv2d,
-    convolute
-}

package/src/math/signal/fft.js

@@ -1,55 +0,0 @@
-import { Complex , complex } from "../complex";
-import { PI } from "../const";
-import { cos , sin  } from "../functions";
-const fft=x=>{
-    const output = [];
-    const N = x.length;
-    if(!(x[0]instanceof Complex))x=x.map((n)=>complex(n,0));
-    for (let k = 0; k < N; k++) {
-      let re = 0,im=0;
-      for (let n = 0; n < N; n++) {
-        const phi = (2*PI * k * n) / N;
-        re += x[n].a*cos(phi)+x[n].b*sin(phi);
-        im += -x[n].a*sin(phi)+x[n].b*cos(phi);
-      }
-      re = re / N;
-      im = im / N;
-      output[k] = complex(re,im);
-    }
-    return {
-        output,
-        re:output.map(n=>n.a),
-        im:output.map(n=>n.b),
-        z:output.map(n=>n.z),
-        phi:output.map(n=>n.phi)
-    }
-  }
-  const ifft=x=>{
-    const output = [];
-    const N = x.length;
-      if(!(x[0]instanceof Complex))x=x.map((n)=>complex(n,0));
-    for (let k = 0; k < N; k++) {
-      let re=0,im=0;
-      for (let n = 0; n < N; n++) {
-        const phi = (2*PI * k * n) / N;
-        re += x[n].a*cos(phi)+x[n].b*sin(phi);
-        im += x[n].a*sin(phi)+x[n].b*cos(phi);
-      }
-      re = re / N;
-      im = im / N;
-  
-      output[k] = complex(re,im);
-    }
-    return {
-        output,
-        re:output.map(n=>n.a),
-        im:output.map(n=>n.b),
-        z:output.map(n=>n.z),
-        phi:output.map(n=>n.phi)
-    };
-  }
-
-export{
-    fft,
-    ifft
-}

package/src/math/signal/filter.js

@@ -1,39 +0,0 @@
-import { complex } from "../complex/index.js";
-import {fft,ifft} from "./fft.js";
-// should be processed in other thread
-class Filter{
-    constructor(input){
-        this.input=input;
-        this.input_fft=fft(this.input);
-        this.output_fft=[]
-    }
-    // get length(){
-    //     return this.input.length;
-    // }
-    lowPass(fc){
-        this.input_fft.output.forEach((n,i)=>{
-            n=n.z<fc
-            ? this.output_fft[i]=this.input_fft.output[i]
-            : this.output_fft[i]=complex(0,0)
-        })
-        return ifft(this.output_fft).re;
-    }
-    highPass(fc){
-        this.input_fft.output.forEach((n,i)=>{
-            n=n.z>fc
-            ? this.output_fft[i]=this.input_fft.output[i]
-            : this.output_fft[i]=complex(0,0)
-        })
-        return ifft(this.output_fft).re;
-    }
-    bandePass(){
-
-    }
-    bandeCoupe(){
-
-    }
-}
-const filter=input=>new Filter(input);
-export{
-    filter
-}