numz 0.0.2 → 0.0.3

package/demo/index.html

@@ -5,10 +5,10 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Vite App</title>
-    <link
+    <!-- <link
       href="https://fonts.googleapis.com/css?family=Gloria+Hallelujah&display=swap"
       rel="stylesheet"
-    />
+    /> -->
     <!-- <style>
       body{
         font-family: "Gloria Hallelujah", cursive;

package/demo/main.js

@@ -1,4 +1,11 @@
-import { FileBasedRouting } from "ziko";
-FileBasedRouting(import.meta.glob("./src/pages/**/*.js"))
-// const pages = import.meta.glob("./src/pages/**/*.js")
-// console.log(Object.keys(pages))
+import { percentile } from "numz/stats";
+import { fft1d } from 'numz/signal'
+import { Complex } from "ziko/math/complex";
+
+console.log(
+    percentile([1,2,3,4,5,6,7,8,9,10], 50)
+)
+
+// console.log(fft1d([1, 2, 1, -1, 1.5]))
+
+// console.log(Complex)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",
@@ -29,6 +29,6 @@
     "rollup": "^4.24.0"
   },
   "dependencies": {
-    "ziko": "^0.54.2"
+    "ziko": "^0.54.4"
   }
 }

package/src/signal/fft/index.js

@@ -1,20 +1,24 @@
-function fft1d(arr) {
+import { Complex } from 'ziko/math/complex' 
+import {add, sub} from 'ziko/math/functions/arithmetic'
+export function fft1d(arr) {
     const N = arr.length;
     if (N === 1) return [arr[0]];
 
     const even = fft1d(arr.filter((_, i) => i % 2 === 0));
     const odd  = fft1d(arr.filter((_, i) => i % 2 === 1));
+    
+
 
     const out = new Array(N);
     for (let k = 0; k < N/2; k++) {
-        const t = Complex.Twiddle(N, k).mul(odd[k]);
-        out[k]        = even[k].add(t);
-        out[k + N/2]  = even[k].sub(t);
+        const t = Complex.Twidlle(N, k).mul(odd[k]);
+        out[k]        = add(even[k], t)
+        out[k + N/2]  = sub(even[k], t)
     }
     return out;
 }
 
-function fftnd(data) {
+export function fftnd(data) {
     if (data instanceof Matrix) data = data.toComplex();
 
     if (Array.isArray(data) && !Array.isArray(data[0])) {
@@ -41,7 +45,7 @@ function fftnd(data) {
     }
 
     if (Array.isArray(data)) {
-        return data.map(fftND);
+        return data.map(fftnd);
     }
 
     throw new Error("Invalid data type for FFT");

package/src/signal/functions/index.js

@@ -0,0 +1,3 @@
+export * from './pulse/index.js'
+export * from './sequence/index.js'
+export * from './periodic'

package/src/signal/functions/periodic/index.js

@@ -0,0 +1,69 @@
+// --------------------------
+// Corrected Periodic Functions with Duty
+// --------------------------
+
+// Square wave: amplitude A, period T, duty cycle, centered at t0
+export const square = (t, T = 1, A = 1, duty = 0.5, t0 = 0) => {
+    const f = (v) => {
+        const phase = ((v - t0) % T + T) % T; // normalize to [0,T)
+        return phase < duty * T ? A : -A;
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Triangle wave: amplitude A, period T, duty cycle, centered at t0
+export const triangle = (t, T = 1, A = 1, duty = 0.5, t0 = 0) => {
+    const f = (v) => {
+        const phase = ((v - t0) % T + T) % T;
+        if (phase < duty * T) {
+            return (A / (duty * T)) * phase * 2 - A; // rising slope
+        } else {
+            return A - (A / ((1 - duty) * T)) * (phase - duty * T) * 2; // falling slope
+        }
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Sawtooth wave: amplitude A, period T, duty cycle, centered at t0
+export const sawtoothPeriodic = (t, T = 1, A = 1, duty = 1, t0 = 0) => {
+    const f = (v) => {
+        const phase = ((v - t0) % T + T) % T;
+        if (phase < duty * T) {
+            return (A / (duty * T)) * phase - A; // rising part
+        } else {
+            return A - (A / ((1 - duty) * T)) * (phase - duty * T); // optional falling part
+        }
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Pulse train: amplitude A, period T, pulse width, centered at t0
+export const pulseTrain = (t, T = 1, width = 0.5, A = 1, t0 = 0) => {
+    const f = (v) => {
+        const phase = ((v - t0) % T + T) % T;
+        return phase < width ? A : 0;
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// PWM: amplitude A, period T, duty cycle, centered at t0
+export const pwm = (t, T = 1, duty = 0.5, A = 1, t0 = 0) => {
+    const f = (v) => {
+        const phase = ((v - t0) % T + T) % T;
+        return phase < duty * T ? A : -A;
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+
+// Sinusoidal wave
+export const sinusoid = (t, f = 1, A = 1, phase = 0) => {
+    const fcn = (v) => A * Math.sin(2 * Math.PI * f * v + phase);
+    if (Array.isArray(t)) return t.map(fcn);
+    return fcn(t);
+};

package/src/signal/functions/pulse/index.js

@@ -0,0 +1,116 @@
+export const noise = null
+// Sign function (signum)
+export const signum = (t, t0 = 0, A = 1) => {
+    if (Array.isArray(t)) return t.map(v => (v - t0) > 0 ? A : (v - t0) < 0 ? -A : 0);
+    return (t - t0) > 0 ? A : (t - t0) < 0 ? -A : 0;
+};
+
+// Ramp function
+export const rampe = (t, t0 = 0, A = 1) => {
+    if (Array.isArray(t)) return t.map(v => v < t0 ? 0 : A * (v - t0));
+    return t < t0 ? 0 : A * (t - t0);
+};
+
+// Rectangular pulse (width = 1 for simplicity, centered at t0)
+export const rect = (t, t0 = 0, A = 1, width = 1) => {
+    const half = width / 2;
+    if (Array.isArray(t)) return t.map(v => (v >= t0 - half && v <= t0 + half ? A : 0));
+    return (t >= t0 - half && t <= t0 + half ? A : 0);
+};
+
+// Triangular pulse (period T, centered at t0)
+export const tri = (t, T = 1, t0 = 0, A = 1) => {
+    const half = T / 2;
+    const x = t - t0;
+    if (Array.isArray(t)) {
+        return t.map(v => {
+            const y = v - t0;
+            return (Math.abs(y) <= half) ? A * (1 - 2 * Math.abs(y) / T) : 0;
+        });
+    }
+    return (Math.abs(x) <= half) ? A * (1 - 2 * Math.abs(x) / T) : 0;
+};
+
+
+// Dirac delta approximation
+// Since δ(t) is not a true function, we approximate with a narrow pulse
+export const dirac = (t, t0 = 0, eps = 1e-6, A = 1) => {
+    if (Array.isArray(t)) return t.map(v => Math.abs(v - t0) < eps ? A / eps : 0);
+    return Math.abs(t - t0) < eps ? A / eps : 0;
+};
+
+// Lorentzian (Cauchy) function
+// L(t) = (A / π) * (gamma / ((t - t0)^2 + gamma^2))
+export const lorentz = (t, t0 = 0, gamma = 1, A = 1) => {
+    const value = (v) => (A / Math.PI) * (gamma / ((v - t0) ** 2 + gamma ** 2));
+    if (Array.isArray(t)) return t.map(value);
+    return value(t);
+};
+
+// Sinc function: sin(pi*(t-t0)) / (pi*(t-t0))
+export const sinc = (t, t0 = 0, A = 1) => {
+    const f = (v) => {
+        const x = Math.PI * (v - t0);
+        return x === 0 ? A : A * Math.sin(x) / x;
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+
+// Gaussian pulse
+export const gaussian = (t, t0 = 0, sigma = 1, A = 1) => {
+    const f = (v) => A * Math.exp(-((v - t0) ** 2) / (2 * sigma ** 2));
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Exponential pulse (causal)
+export const expPulse = (t, t0 = 0, alpha = 1, A = 1) => {
+    const f = (v) => (v >= t0 ? A * Math.exp(-alpha * (v - t0)) : 0);
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Trapezoidal pulse
+export const trapezoid = (t, t0 = 0, rise = 0.5, width = 1, fall = 0.5, A = 1) => {
+    const f = (v) => {
+        const x = v - t0;
+        if (x < 0 || x > rise + width + fall) return 0;
+        if (x < rise) return A * (x / rise);
+        if (x < rise + width) return A;
+        return A * (1 - (x - rise - width) / fall);
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Hamming window (useful for DSP)
+export const hamming = (t, t0 = 0, T = 1, A = 1) => {
+    const f = (v) => {
+        const x = (v - t0) / T;
+        return (x >= 0 && x <= 1) ? A * (0.54 - 0.46 * Math.cos(2 * Math.PI * x)) : 0;
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Hanning window
+export const hanning = (t, t0 = 0, T = 1, A = 1) => {
+    const f = (v) => {
+        const x = (v - t0) / T;
+        return (x >= 0 && x <= 1) ? A * 0.5 * (1 - Math.cos(2 * Math.PI * x)) : 0;
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};
+
+// Dirichlet (periodic sinc) function
+export const dirichlet = (t, N = 5, t0 = 0, A = 1) => {
+    const f = (v) => {
+        const x = Math.PI * (v - t0);
+        return x === 0 ? A : A * Math.sin(N * x) / (N * Math.sin(x));
+    };
+    if (Array.isArray(t)) return t.map(f);
+    return f(t);
+};

package/src/signal/functions/sequence/index.js

@@ -0,0 +1,103 @@
+import { mapfun, nthr, pow } from "ziko/math/functions";
+
+export const zeros = n => new Array(n).fill(0);
+export const ones = n => new Array(n).fill(1);
+export const nums = (n, num) => new Array(n).fill(num);
+
+
+export const arange = (a, b, step, include = false) => {  
+    if(a instanceof Array && typeof b === 'number') return mapfun(x => arange(x, b, step, include), ...a);
+    if(b instanceof Array && typeof a === 'number') return mapfun(x => arange(a, x, step, include), ...b);
+    if(a instanceof Array && b instanceof Array){
+        if(a.length !== b.length) return TypeError('');
+        let res = new Array(a.length).fill(null)
+        return res.map((_, i) => arange(a[i], b[i], step, include))
+    }
+    if(typeof a === 'number' && typeof b === 'number'){
+        const values = [];
+         let i;
+        if(a<b){
+            for (i = a; include ? i<=b : i<b ; i += step) 
+                values.push((i * 10) / 10);
+        }
+        else{
+            for(i = a; include ? i>=b: i>b ; i -= step) 
+                values.push((i * 10) / 10);
+        }
+        return values
+    }
+}
+
+export const linspace = (a, b, n = Math.abs(b-a) + 1, endpoint = true) =>{
+    if(Math.floor(n) !== n) return TypeError('');
+    let c = [a, b].find(n => n.isComplex?.())
+    if(c){
+        let z1 = new c.constructor(a);
+        let z2 = new c.constructor(b)
+        if (!n) n = Math.abs(z1.a - z2.a) + 1;
+        const X = linspace(z1.a, z2.a, n, endpoint);
+        const Y = linspace(z1.a, z2.a, n, endpoint);
+        let Z = new Array(n).fill(null);
+        Z = Z.map((_, i) => new z1.constructor(X[i], Y[i]));
+        return Z;
+    }
+    if(a instanceof Array && typeof b === 'number') return mapfun(x => linspace(x, b, step, include), ...a);
+    if(b instanceof Array && typeof a === 'number') return mapfun(x => linspace(a, x, step, include), ...b);
+    if(a instanceof Array && b instanceof Array){
+        if(a.length !== b.length) return TypeError('');
+        let res = new Array(a.length).fill(null)
+        return res.map((_, i) => linspace(a[i], b[i], step, include))
+    }
+    if(typeof a === 'number' && typeof b === 'number'){
+        const [max, min] = [a, b].sort((a, b) => b-a);
+        let Y = [], step, i;
+        endpoint ? step = (max - min) / (n - 1) : step = (max - min) / n;
+        if(a < b)
+            for(i = 0; i < n; i++)
+                Y.push(+(min + step * i).toFixed(8))
+        else
+            for(i = 0; i < n; i++)
+                Y.push(+(max - step * i).toFixed(8))
+        return Y
+    }
+}
+
+export const logspace = (a, b, n = Math.abs(b-a) + 1, base = Math.E, endpoint = true) => {
+    const ls = linspace(a, b, n, endpoint);
+    return mapfun(x => pow(base, x), ...ls)
+}
+
+export const geomspace = (a, b, n = Math.abs(b-a) + 1, endpoint = true, precison = 8) =>{
+    if(Math.floor(n) !== n) return TypeError('n must be and integer');
+    let c = [a, b].find(n => n.isComplex?.())
+    if(c){
+        let z1 = new c.constructor(a);
+        let z2 = new c.constructor(b);
+        if (!n) n = Math.abs(z1.a - z2.a) + 1;
+        const ratio = nthr(z2.clone().div(z1.clone()), n-1);
+        let i;
+        const Y = [];
+        for(i = 0; i < n; i++){
+            Y[i] = z1.clone().mul(pow(ratio.clone(), i))
+        }
+
+        return Y.map(n => n.toFixed(precison))
+    }
+    if(a instanceof Array && typeof b === 'number') return mapfun(x => geomspace(x, b, n, endpoint, precison), ...a);
+    if(b instanceof Array && typeof a === 'number') return mapfun(x => geomspace(a, x, n, endpoint, precison), ...b);
+    if(a instanceof Array && b instanceof Array){
+        if(a.length !== b.length) return TypeError('');
+        let res = new Array(a.length).fill(null)
+        return res.map((_, i) => geomspace(a[i], b[i], n, endpoint, precison))
+    }
+    if(typeof a === 'number' && typeof b === 'number'){
+        const [max, min]= [a, b].sort((a, b) => b-a);
+        let base = endpoint ? nthr(max/min, n-1) : nthr(max/min, n);
+        const Y = [min];
+        let i;
+        for(i = 1; i < n; i++)
+            Y.push(Y[i-1] * base )
+        const Fixed = Y.map(n => + n.toFixed(precison))
+        return a < b ? Fixed : Fixed.reverse()
+    }
+}

package/src/signal/index.js

@@ -0,0 +1,2 @@
+export * from './functions/index.js'
+// export * from './fft/index.js'