numz 0.0.2 → 0.1.0

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.1.0",
   "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/calculus/derivative/index.js

@@ -0,0 +1,16 @@
+export const derivative = (f, x, h = 1e-8) => (f(x + h) - f(x - h)) / (2 * h);
+export const derivative_n = (f, x, n = 1, h = 1e-8) => {
+    if (n === 0) return f(x);
+    const df = (x0) => derivative(f, x0, h);
+    return derivative_n(df, x, n - 1, h);
+};
+
+
+export const partial_derivative = (f, vars, varIndex, h = 1e-8) => {
+    const x1 = [...vars]; 
+    const x2 = [...vars];
+    x1[varIndex] += h; 
+    x2[varIndex] -= h;
+    return (f(...x1) - f(...x2)) / (2 * h);
+};
+export const gradient = (f, vars, h = 1e-8) => vars.map((_, i) => partial_derivative(f, vars, i, h));

package/src/calculus/index.js

@@ -0,0 +1,22 @@
+export * from './derivative/index.js'
+export * from './integral/index.js'
+import { factorial } from "../discret";
+export const taylor_series = (f, x0, n=5, h=1e-5) => {
+    let sum=0;
+    for(let i=0;i<=n;i++){
+        sum += derivative_n(f,x0,i,h) / factorial(i)*(x0**i);
+    }
+    return sum;
+};
+
+export const newton_raphson = (f, x0, tol=1e-8, maxIter=100) => {
+    let x=x0;
+    for(let i=0;i<maxIter;i++){
+        const fx=f(x), dfx=derivative(f,x);
+        if(Math.abs(dfx)<1e-12) break;
+        const dx=fx/dfx;
+        x-=dx;
+        if(Math.abs(dx)<tol) break;
+    }
+    return x;
+};

package/src/calculus/integral/index.js

@@ -0,0 +1,21 @@
+export const integral_simpson = (f, a, b, n=1000) => {
+    if(n%2===1) n+=1;
+    const h=(b-a)/n;
+    let s=f(a)+f(b);
+    for(let i=1;i<n;i++){
+        s+=f(a+i*h)*(i%2===0?2:4);
+    }
+    return s*h/3;
+};
+export const integral_trapezoid = (f, a, b, n=1000) => {
+    const h=(b-a)/n;
+    let s=(f(a)+f(b))/2;
+    for(let i=1;i<n;i++) s+=f(a+i*h);
+    return s*h;
+};
+export const integral_midpoint = (f, a, b, n=1000)=>{
+    const h=(b-a)/n;
+    let s=0;
+    for(let i=0;i<n;i++) s+=f(a+(i+0.5)*h);
+    return s*h;
+};

package/src/discret/bitwise/index.js

@@ -0,0 +1,34 @@
+
+
+export const bitmasks = (n) => {
+  const res = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const mask = [];
+    for (let j = 0; j < n; j++) mask.push((i >> j) & 1);
+    res.push(mask);
+  }
+  return res;
+};
+export const subsets_by_mask = (arr) => {
+  const n = arr.length,
+    res = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const subset = [];
+    for (let j = 0; j < n; j++) if ((i >> j) & 1) subset.push(arr[j]);
+    res.push(subset);
+  }
+  return res;
+};
+export const gray_code = (n) => {
+  if (n === 0) return [0];
+  const prev = gray_code(n - 1);
+  return [...prev, ...prev.map((x) => x | (1 << (n - 1)))];
+};
+export const hamming_weight = (x) => {
+  let count = 0;
+  while (x) {
+    x &= x - 1;
+    count++;
+  }
+  return count;
+};

package/src/discret/combination/index.js

@@ -0,0 +1,86 @@
+export const combinations = (arr, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (!repetition) {
+    const back = (start, cur) => {
+      if (cur.length) result.push([...cur]);
+      for (let i = start; i < n; i++) {
+        cur.push(arr[i]);
+        back(i + 1, cur);
+        cur.pop();
+      }
+    };
+    back(0, []);
+    return result;
+  }
+  const back = (start, cur) => {
+    if (cur.length) result.push([...cur]);
+    for (let i = start; i < n; i++) {
+      cur.push(arr[i]);
+      back(i, cur);
+      cur.pop();
+    }
+  };
+  back(0, []);
+  return result;
+};
+
+
+
+export const k_combinations = (arr, k, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (!repetition) {
+    const back = (start, cur) => {
+      if (cur.length === k) result.push([...cur]);
+      else
+        for (let i = start; i < n; i++) {
+          cur.push(arr[i]);
+          back(i + 1, cur);
+          cur.pop();
+        }
+    };
+    back(0, []);
+    return result;
+  }
+  const back = (start, cur) => {
+    if (cur.length === k) result.push([...cur]);
+    else
+      for (let i = start; i < n; i++) {
+        cur.push(arr[i]);
+        back(i, cur);
+        cur.pop();
+      }
+  };
+  back(0, []);
+  return result;
+};
+
+export const multiset_combinations = (arr, k) => {
+  const counter = {},
+    unique = [];
+  for (const x of arr) {
+    if (!counter[x]) {
+      counter[x] = 0;
+      unique.push(x);
+    }
+    counter[x]++;
+  }
+  const result = [];
+  const back = (i, cur, remaining) => {
+    if (cur.length === k) {
+      result.push([...cur]);
+      return;
+    }
+    if (i >= unique.length) return;
+    const u = unique[i],
+      max_use = Math.min(counter[u], k - cur.length);
+    for (let use = 0; use <= max_use; use++) {
+      for (let j = 0; j < use; j++) cur.push(u);
+      back(i + 1, cur, remaining - use);
+      for (let j = 0; j < use; j++) cur.pop();
+    }
+  };
+  back(0, [], k);
+  return result;
+};

package/src/discret/index-dep.js

@@ -0,0 +1,110 @@
+// ==========================================
+// Discrete Mathematics / Combinatorics
+// ==========================================
+// ------------------------------
+// Binomial & Multichoose
+// ------------------------------
+export const binomial = (n, k) => {
+  if (n !== Math.floor(n) || k !== Math.floor(k))
+    return TypeError("n,k must be integers");
+  if (k < 0 || k > n) return 0;
+  k = Math.min(k, n - k);
+  let r = 1;
+  for (let i = 1; i <= k; i++) r = (r * (n - (k - i))) / i;
+  return r;
+};
+export const comb_repetition = (n, k) => binomial(n + k - 1, k);
+export const multichoose = comb_repetition;
+
+// Comb // Perm
+export const power_set = (arr) => {
+  const n = arr.length,
+    result = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const subset = [];
+    for (let j = 0; j < n; j++) if ((i >> j) & 1) subset.push(arr[j]);
+    result.push(subset);
+  }
+  return result;
+};
+
+export const cartesian = (...sets) => {
+  let result = [[]];
+  for (const set of sets) {
+    const temp = [];
+    for (const x of result) for (const y of set) temp.push([...x, y]);
+    result = temp;
+  }
+  return result;
+};
+
+// ------------------------------
+// Counting / Sequences
+// ------------------------------
+export const derangement = (n) => {
+  if (n !== Math.floor(n)) return TypeError("n must be integer");
+  let r = 1;
+  for (let i = 1; i <= n; i++) {
+    r = i * r + (i % 2 === 0 ? 1 : -1);
+  }
+  return Math.round(r / Math.E);
+};
+
+export const catalan = (n) => binomial(2 * n, n) / (n + 1);
+
+export const stirling2 = (n, k) => {
+  if (k < 0 || k > n) return 0;
+  let S = Array(k + 1).fill(0);
+  S[0] = 1;
+  for (let i = 1; i <= n; i++)
+    for (let j = k; j > 0; j--) S[j] = j * S[j] + S[j - 1];
+  return S[k];
+};
+
+export const bell = (n) => {
+  let B = [1];
+  for (let i = 1; i <= n; i++) {
+    B[i] = 0;
+    for (let j = 0; j < i; j++) B[i] += binomial(i - 1, j) * B[j];
+  }
+  return B[n];
+};
+
+export const lah = (n, k) => {
+  if (n < 0 || k < 0 || k > n) return 0;
+  return (binomial(n - 1, k - 1) * factorial(n)) / factorial(k);
+};
+
+// // Eulerian numbers: number of permutations with exactly k ascents
+export const eulerian = (n,k)=>{
+  if(k<0||k>=n) return 0;
+  let dp=[Array(k+2).fill(0)];
+  dp[0][0]=1;
+  for(let i=1;i<=n;i++){
+    const ndp=Array(k+2).fill(0);
+    for(let j=0;j<=Math.min(i-1,k);j++){
+      ndp[j]= (i-j)*dp[i-1]?[j]??0:
+      ndp[j+1]= (j+1)*dp[i-1][j];
+    }
+    dp=ndp;
+  } 
+  return dp[k];
+};
+
+// Partition numbers
+export const partition_number = (n) => {
+  if (n === 0) return 1;
+  let p = [1];
+  for (let i = 1; i <= n; i++) {
+    let s = 0;
+    for (let k = 1; ; k++) {
+      let j1 = i - (k * (3 * k - 1)) / 2;
+      let j2 = i - (k * (3 * k + 1)) / 2;
+      if (j1 < 0 && j2 < 0) break;
+      if (j1 >= 0) s += (k % 2 === 0 ? -1 : 1) * p[j1];
+      if (j2 >= 0) s += (k % 2 === 0 ? -1 : 1) * p[j2];
+    }
+    p.push(s);
+  }
+  return p[n];
+};

package/src/discret/index.js

@@ -0,0 +1,4 @@
+export * from './combination/index.js'
+export * from './permutation/index.js'
+export * from './sequences'
+export * from './bitwise'

package/src/discret/permutation/index.js

@@ -0,0 +1,89 @@
+export const permutations = (arr, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (repetition) {
+    const back = (cur) => {
+      if (cur.length === n) result.push([...cur]);
+      else
+        for (let i = 0; i < n; i++) {
+          cur.push(arr[i]);
+          back(cur);
+          cur.pop();
+        }
+    };
+    back([]);
+    return result;
+  }
+  const back = (cur, used) => {
+    if (cur.length === n) result.push([...cur]);
+    else
+      for (let i = 0; i < n; i++) {
+        if (used[i]) continue;
+        used[i] = true;
+        cur.push(arr[i]);
+        back(cur, used);
+        cur.pop();
+        used[i] = false;
+      }
+  };
+  back([], Array(n).fill(false));
+  return result;
+};
+
+
+export const k_permutations = (arr, k, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (repetition) {
+    const back = (cur) => {
+      if (cur.length === k) result.push([...cur]);
+      else
+        for (let i = 0; i < n; i++) {
+          cur.push(arr[i]);
+          back(cur);
+          cur.pop();
+        }
+    };
+    back([]);
+    return result;
+  }
+  const back = (cur, used) => {
+    if (cur.length === k) result.push([...cur]);
+    else
+      for (let i = 0; i < n; i++) {
+        if (used[i]) continue;
+        used[i] = true;
+        cur.push(arr[i]);
+        back(cur, used);
+        cur.pop();
+        used[i] = false;
+      }
+  };
+  back([], Array(n).fill(false));
+  return result;
+};
+
+export const multiset_permutations = (arr) => {
+  const result = [],
+    counter = {};
+  for (const x of arr) counter[x] = (counter[x] || 0) + 1;
+  const unique = Object.keys(counter);
+  const n = arr.length;
+  const back = (cur) => {
+    if (cur.length === n) {
+      result.push([...cur]);
+      return;
+    }
+    for (const u of unique) {
+      if (counter[u] > 0) {
+        cur.push(u);
+        counter[u]--;
+        back(cur);
+        cur.pop();
+        counter[u]++;
+      }
+    }
+  };
+  back([]);
+  return result;
+};

package/src/discret/sequences/index.js

@@ -0,0 +1,30 @@
+export const factorial = (n) => {
+  if (n < 0 || n !== Math.floor(n))
+    return TypeError("n must be non-negative integer");
+  let r = 1;
+  for (let i = 2; i <= n; i++) r *= i;
+  return r;
+};
+export const double_factorial = (n) => {
+  if (n < 0 || n !== Math.floor(n))
+    return TypeError("n must be non-negative integer");
+  let r = 1;
+  for (let i = n; i > 1; i -= 2) r *= i;
+  return r;
+};
+export const falling = (n, k) => {
+  if (n !== Math.floor(n) || k !== Math.floor(k))
+    return TypeError("n,k must be integers");
+  if (k < 0) return 0;
+  let r = 1;
+  for (let i = 0; i < k; i++) r *= n - i;
+  return r;
+};
+export const rising = (n, k) => {
+  if (n !== Math.floor(n) || k !== Math.floor(k))
+    return TypeError("n,k must be integers");
+  if (k < 0) return 0;
+  let r = 1;
+  for (let i = 0; i < k; i++) r *= n + i;
+  return r;
+};

package/src/index.js

@@ -1 +1,6 @@
-export * from './stats/index.js'
+export * from './ufunc/index.js'
+export * from './calculus/index.js'
+export * from './signal/index.js'
+export * from './stats/index.js'
+
+

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'

package/src/stats/distributions/continuos/index.js

@@ -0,0 +1,35 @@
+export const dist_normal = (x, mean = 0, std = 1) => {
+    const coeff = 1 / (std * Math.sqrt(2 * Math.PI));
+    const expPart = Math.exp(-((x - mean) ** 2) / (2 * std ** 2));
+    return coeff * expPart;
+};
+
+export const dist_uniform = (x, a = 0, b = 1) => (x < a || x > b ? 0 : 1 / (b - a));
+
+export const dist_exponential = (x, lambda = 1) => (x < 0 ? 0 : lambda * Math.exp(-lambda * x));
+
+export const dist_gamma = (x, k, theta = 1) => {
+    if (x < 0) return 0;
+    const gamma = (n) => {
+        if (n <= 1) return 1;
+        return (n - 1) * gamma(n - 1);
+    };
+    return Math.pow(x, k - 1) * Math.exp(-x / theta) / (gamma(k) * Math.pow(theta, k));
+};
+
+export const dist_beta = (x, alpha, beta) => {
+    if (x < 0 || x > 1) return 0;
+    const gamma = (n) => (n <= 1 ? 1 : (n - 1) * gamma(n - 1));
+    const B = (alpha, beta) => gamma(alpha) * gamma(beta) / gamma(alpha + beta);
+    return Math.pow(x, alpha - 1) * Math.pow(1 - x, beta - 1) / B(alpha, beta);
+};
+
+export const dist_cauchy = (x, x0 = 0, gamma = 1) => 1 / (Math.PI * gamma * (1 + ((x - x0) / gamma) ** 2));
+
+export const dist_chi2 = (x, k) => dist_gamma(x, k / 2, 2);
+
+export const dist_student_t = (x, nu) => {
+    const gamma = (n) => (n <= 1 ? 1 : (n - 1) * gamma(n - 1));
+    const coeff = gamma((nu + 1) / 2) / (Math.sqrt(nu * Math.PI) * gamma(nu / 2));
+    return coeff * Math.pow(1 + (x ** 2) / nu, -(nu + 1) / 2);
+};

package/src/stats/distributions/discret/index.js

@@ -0,0 +1,45 @@
+// ------------------------------
+// Discrete Distributions
+// ------------------------------
+export const dist_binomial = (k, n, p) => {
+    if (k < 0 || k > n) return 0;
+    const comb = (n, k) => {
+        if (k === 0 || k === n) return 1;
+        let res = 1;
+        for (let i = 1; i <= k; i++) res *= (n - i + 1) / i;
+        return res;
+    };
+    return comb(n, k) * Math.pow(p, k) * Math.pow(1 - p, n - k);
+};
+
+export const dist_poisson = (k, lambda) => {
+    if (k < 0) return 0;
+    const factorial = (n) => (n <= 1 ? 1 : n * factorial(n - 1));
+    return Math.pow(lambda, k) * Math.exp(-lambda) / factorial(k);
+};
+
+export const dist_geometric = (k, p) => (k < 1 ? 0 : p * Math.pow(1 - p, k - 1));
+
+export const dist_negative_binomial = (k, r, p) => {
+    if (k < 0) return 0;
+    const comb = (n, k) => {
+        if (k === 0 || k === n) return 1;
+        let res = 1;
+        for (let i = 1; i <= k; i++) res *= (n - i + 1) / i;
+        return res;
+    };
+    return comb(k + r - 1, k) * Math.pow(p, r) * Math.pow(1 - p, k);
+};
+
+export const dist_hypergeometric = (k, N, K, n) => {
+    if (k < 0 || k > n || k > K) return 0;
+    const comb = (n, k) => {
+        if (k === 0 || k === n) return 1;
+        let res = 1;
+        for (let i = 1; i <= k; i++) res *= (n - i + 1) / i;
+        return res;
+    };
+    return (comb(K, k) * comb(N - K, n - k)) / comb(N, n);
+};
+
+export const dist_bernoulli = (k, p) => (k === 0 ? 1 - p : k === 1 ? p : 0);

package/src/stats/distributions/index.js

@@ -0,0 +1,3 @@
+export * from './continuos/index.js'
+export * from './discret/index.js'
+export * from './multivar/index.js'

package/src/stats/distributions/multivar/index.js

@@ -0,0 +1,40 @@
+// ------------------------------
+// Multivariate Distributions
+// ------------------------------
+export const dist_multinomial = (kArray, n, pArray) => {
+    const factorial = (x) => (x <= 1 ? 1 : x * factorial(x - 1));
+    const comb = factorial(n) / kArray.reduce((acc, k) => acc * factorial(k), 1);
+    const prob = kArray.reduce((acc, ki, i) => acc * Math.pow(pArray[i], ki), 1);
+    return comb * prob;
+};
+
+export const dist_multivariate_normal = (xArray, meanArray, covMatrix) => {
+    const n = xArray.length;
+    const det = (m) => {
+        if (n === 1) return m[0][0];
+        if (n === 2) return m[0][0] * m[1][1] - m[0][1] * m[1][0];
+        throw new Error('Only 1x1 and 2x2 supported for now');
+    };
+    const inv = (m) => {
+        if (n === 1) return [[1 / m[0][0]]];
+        if (n === 2) {
+            const [[a,b],[c,d]] = m;
+            const detM = a*d-b*c;
+            return [[d/detM,-b/detM],[-c/detM,a/detM]];
+        }
+        throw new Error('Only 1x1 and 2x2 supported for now');
+    };
+    const diff = xArray.map((xi, i) => xi - meanArray[i]);
+    const covInv = inv(covMatrix);
+    const exponent = -0.5 * diff.reduce((sum, _, i) =>
+        sum + diff[i] * (covInv[i][0] * diff[0] + covInv[i][1] * diff[1] || 0), 0);
+    const denom = Math.sqrt((2 * Math.PI) ** n * det(covMatrix));
+    return Math.exp(exponent) / denom;
+};
+
+export const dist_dirichlet = (xArray, alphaArray) => {
+    const gamma = (n) => (n <= 1 ? 1 : (n - 1) * gamma(n - 1));
+    const B = alphaArray.reduce((acc, a) => acc * gamma(a), 1) / gamma(alphaArray.reduce((a,b)=>a+b,0));
+    const prod = xArray.reduce((acc, xi, i) => acc * Math.pow(xi, alphaArray[i]-1),1);
+    return prod / B;
+};

package/src/stats/index.js

@@ -2,4 +2,5 @@ export * from './percentile/index.js';
 export * from './average/index.js';
 export * from './variability/index.js'
 export * from './rolling/index.js'
-export * from './accum/index.js'
+export * from './accum/index.js'
+export * from './distributions/index.js'

package/src/ufunc/index.js

@@ -0,0 +1 @@
+export * from 'ziko/math/functions'