numz 0.0.0

package/src-dep/conv.js

@@ -0,0 +1,174 @@
+import { Matrix , matrix, sqrt } from "ziko";
+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-dep/fft.js

@@ -0,0 +1,59 @@
+import{
+  Complex,
+  complex,
+  PI,
+  cos,
+  sin
+} from "ziko"
+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-dep/filter.js

@@ -0,0 +1,39 @@
+import { complex } from "ziko";
+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
+}

package/src-dep/index.js

@@ -0,0 +1,85 @@
+import { mapfun, abs , sinc , sign , sin, Random } from "ziko";
+import{
+    fft,
+    ifft
+} from "./fft.js"
+import { 
+    conv,
+    conv1d, 
+    conv2d,
+    circularConv,
+    linearConv,
+    circularConv1d,
+    linearConv1d,
+    circularConv2d,
+    linearConv2d
+} from "./conv.js";
+import { 
+    filter
+ } from "./filter.js";
+//import { Matrix } from "../Matrix/index.js";
+const Signal={
+
+    noise(n,min = 0,max = 1){
+        return Random.floats(n,min,max);
+    },
+    echelon(t,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t];
+        const Y = mapfun(n=>n>=t0?1:0,...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    rampe(t,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t]
+        const Y = mapfun(n=>n>=t0?n-t0:0,...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    sign(t,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t]
+        const Y = mapfun(n=>Math.sign(n-t0),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    rect(t,T,t0 = 0, A = 1){
+        if(!(t instanceof Array))t=[t];
+        const Y = mapfun(n=>((t0-T/2 < n) && (t0+T/2 > n)? 1 - 2 * abs(n/T) : 0),...t)
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A
+    },
+    tri(t,T,t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n=>((t0-T/2 < n) && (t0+T/2 > n)? 1 - 2 * abs(n/T) : 0),...t)
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    dirac(t,t0){
+        return mapfun(n=>n===t0?Infinity:0,...t);
+    },
+    lorentz(t , t0 = 0 , A = 1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n => 1/(1+(n-t0)**2),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    sinc(t , t0 , A = 1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n=>sinc(n-t0),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    square(t,T=1,A=1){
+        if(!(t instanceof Array))t=[t] 
+        const Y = mapfun(n=>sign(sin(n*2*Math.PI/T)),...t);
+        return Y instanceof Array ? Y.map(n=>n*A) : Y*A;
+    },
+    sawtooth(){
+
+    },
+    conv,
+    conv1d,
+    conv2d,
+    circularConv,
+    linearConv,
+    circularConv1d,
+    linearConv1d,
+    circularConv2d,
+    linearConv2d,
+    fft,
+    ifft,
+    filter,
+}
+export{Signal}