numz 0.0.3 → 0.2.0

package/src/signal/conv/conv.js

@@ -0,0 +1,43 @@
+import { Complex } from 'ziko/math/complex';
+import { add, mul} from 'ziko/math/functions'
+
+// const nextPow2 = n => 1 << Math.ceil(Math.log2(n));
+
+
+export function conv(signal, kernel, mode = 'full') {
+    const N = signal.length;
+    const M = kernel.length;
+    if(signal.some(n => n?.isComplex?.()) || kernel.some(n => n?.isComplex?.())){
+        signal = new Complex(signal, 0);
+        kernel = new Complex(kernel, 0);
+    }
+    let outLength;
+    let startIdx;
+    switch(mode){
+        case 'full' : {
+            outLength = N + M - 1;
+            startIdx = 0;
+        }; break;
+        case 'same' : {
+            outLength = N;
+            startIdx = Math.floor((M - 1) / 2);            
+        }; break;
+        case 'valid' : {
+            outLength = Math.max(N - M + 1, 0);
+            startIdx = M - 1;           
+        }; break;
+        default : throw new Error(`Invalid mode: ${mode}. Must be 'full', 'same', or 'valid'`);
+    }
+    const out = new Array(outLength);
+    for (let n = 0; n < outLength; n++) {
+        let sum = new Complex(0, 0);
+        const actualN = n + startIdx;
+        for (let k = 0; k < M; k++) {
+            const idx = actualN - k;
+            if (idx >= 0 && idx < N)
+                sum = add(mul(signal[idx], kernel[k]))
+        }
+        out[n] = sum;
+    }
+    return out;
+}

package/src/signal/conv/conv2.js

@@ -0,0 +1,71 @@
+import { Complex } from 'ziko/math/complex';
+import { add, mul} from 'ziko/math/functions'
+export function conv2(signal, kernel, mode = 'full', boundary = 'fill', fillValue = 0) {
+    const isMatix = signal?.isMatix?.() || kernel?.isMatix?.();
+    const signalRows = signal.length;
+    const signalCols = signal[0].length;
+    const kernelRows = kernel.length;
+    const kernelCols = kernel[0].length;
+
+    const flippedKernel = kernel.map(row => [...row].reverse()).reverse();
+    
+    // Determine output size
+    let outRows, outCols;
+    switch(mode){
+        case 'full':{
+            outRows = signalRows + kernelRows - 1;
+            outCols = signalCols + kernelCols - 1;
+        }; break;
+        case 'same':{
+            outRows = signalRows;
+            outCols = signalCols;
+        }; break;
+        case 'valid':{
+            outRows = signalRows - kernelRows + 1;
+            outCols = signalCols - kernelCols + 1;
+        }; break;
+        default: throw new Error("mode must be 'full', 'same', or 'valid'");
+
+    }
+    // Initialize output
+    const output = Array.from({ length: outRows }, () => Array(outCols).fill(0));
+
+    // Helper to get signal value considering boundary
+    function getSignalValue(i, j) {
+        if (i < 0 || i >= signalRows || j < 0 || j >= signalCols) {
+            if (boundary === 'fill') return fillValue;
+            if (boundary === 'wrap') return signal[(i + signalRows) % signalRows][(j + signalCols) % signalCols];
+            if (boundary === 'symm') {
+                const ii = i < 0 ? -i - 1 : i >= signalRows ? 2*signalRows - i - 1 : i;
+                const jj = j < 0 ? -j - 1 : j >= signalCols ? 2*signalCols - j - 1 : j;
+                return signal[ii][jj];
+            }
+            return 0;
+        }
+        return signal[i][j];
+    }
+
+    // Convolution
+    for (let i = 0; i < outRows; i++) {
+        for (let j = 0; j < outCols; j++) {
+            let sum = 0;
+            for (let m = 0; m < kernelRows; m++) {
+                for (let n = 0; n < kernelCols; n++) {
+                    const ii = i + m - Math.floor(kernelRows / 2);
+                    const jj = j + n - Math.floor(kernelCols / 2);
+                    sum += flippedKernel[m][n] * getSignalValue(ii, jj);
+                    sum = add(
+                        mul(
+                            flippedKernel[m][n],
+                            getSignalValue(ii, jj)
+                        )
+                    )
+                }
+            }
+            output[i][j] = sum;
+        }
+    }
+
+    return output;
+}
+

package/src/signal/conv/index.js

@@ -0,0 +1,2 @@
+export * from './conv.js'
+export * from './conv2.js'

package/src/signal/fft/fft.js

@@ -0,0 +1,47 @@
+import { Complex } from 'ziko/math/complex' 
+import { isPow2 } from './utils/index.js';
+
+export function dft(arr) {
+    const N = arr.length;
+    const out = new Array(N);
+
+    for (let k = 0; k < N; k++) {
+        let sum = new Complex(0, 0);
+        for (let n = 0; n < N; n++) {
+            const W = Complex.twiddle(k * n, N);
+            sum = sum.add(W.mul(arr[n]));
+        }
+        out[k] = sum;
+    }
+    return out;
+}
+
+export function fft(arr) {
+    const N = arr.length;
+
+    // fallback for non power-of-two
+    if (!isPow2(N)) {
+        return dft(arr);
+    }
+
+    if (N === 1) return [arr[0]];
+
+    const even = new Array(N / 2);
+    const odd  = new Array(N / 2);
+
+    for (let i = 0; i < N / 2; i++) {
+        even[i] = arr[2*i];
+        odd[i]  = arr[2*i+1];
+    }
+
+    const Fe = fft(even);
+    const Fo = fft(odd);
+
+    const out = new Array(N);
+    for (let k = 0; k < N / 2; k++) {
+        const t = Complex.twiddle(k, N).mul(Fo[k]);
+        out[k]       = Fe[k].add(t);
+        out[k+N/2]   = Fe[k].sub(t);
+    }
+    return out;
+}

package/src/signal/fft/ifft.js

@@ -0,0 +1,16 @@
+import { Complex } from 'ziko/math/complex';
+import { fft, dft } from './fft.js'; 
+import { isPow2 } from './utils/index.js';
+
+export function ifft(arr) {
+    const N = arr.length;
+
+    // Step 1: conjugate input
+    const conjugated = arr.map(n => new Complex(n, 0).conj)
+
+    // Step 2: compute FFT (or DFT if not power-of-2)
+    const y = isPow2(N) ? fft(conjugated) : dft(conjugated);
+
+    // Step 3: conjugate output and normalize
+    return y.map(c => new Complex(c.a / N, -c.b / N));
+}

package/src/signal/fft/index.js

@@ -1,52 +1,2 @@
-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.Twidlle(N, k).mul(odd[k]);
-        out[k]        = add(even[k], t)
-        out[k + N/2]  = sub(even[k], t)
-    }
-    return out;
-}
-
-export function fftnd(data) {
-    if (data instanceof Matrix) data = data.toComplex();
-
-    if (Array.isArray(data) && !Array.isArray(data[0])) {
-        return fft1d(data);
-    }
-
-    if (data instanceof Matrix) {
-        const rows = data.rows;
-        const cols = data.cols;
-
-        // FFT along rows
-        let rowFFT = new Matrix(rows, cols, []);
-        for (let i = 0; i < rows; i++) {
-            rowFFT.arr[i] = fft1d(data.arr[i]);
-        }
-
-        let colFFT = new Matrix(cols, rows, []);
-        const rowFFT_T = rowFFT.T;
-        for (let i = 0; i < cols; i++) {
-            colFFT.arr[i] = fft1d(rowFFT_T.arr[i]);
-        }
-
-        return colFFT.T; 
-    }
-
-    if (Array.isArray(data)) {
-        return data.map(fftnd);
-    }
-
-    throw new Error("Invalid data type for FFT");
-}
+export * from './fft.js';
+export * from './ifft.js'

package/src/signal/fft/utils/index.js

@@ -1,19 +1 @@
-// export const C = (x) => x?.isComplex?.() ? x : new Complex(x, 0);
-// export function twiddle(N, k) {
-//     const angle = -2 * Math.PI * k / N;
-//     return new Complex(Math.cos(angle), Math.sin(angle));
-// }
-
-// function normalizeComplexND(data) {
-//     if (data instanceof Matrix) {
-//         return new Matrix(
-//             data.rows,
-//             data.cols,
-//             data.arr.flat(1).map(C)
-//         );
-//     } else if (Array.isArray(data)) {
-//         return data.map(normalizeComplexND);
-//     } else {
-//         return C(data);
-//     }
-// }
+export const isPow2 = n => (n & (n - 1)) === 0;

package/src/signal/functions/index.js

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

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

@@ -1,8 +1,18 @@
 import { mapfun, nthr, pow } from "ziko/math/functions";
+import { Matrix } from 'ziko/math/matrix'
 
-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 zeros = (n, m, d) => {
+    if(m) return Matrix.zeros(n, m);
+    return new Array(n).fill(0)
+}
+export const ones = (n, m) => {
+     if(m) return Matrix.ones(n, m);
+    return new Array(n).fill(1)   
+};
+export const nums = (num, n, m, d) => {
+     if(m) return Matrix.nums(n, m);
+    return new Array(n).fill(num)   
+};
 
 
 export const arange = (a, b, step, include = false) => {  

package/src/signal/index.js

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

package/src/stats/average/index.js

@@ -55,8 +55,8 @@ export const midhinge = (...x) =>{
   return (q1 + q3) / 2;
 }
 
-
-export const interquartile_mean = (...x) =>{
+// interquartile_mean
+export const iq_mean = (...x) =>{
   let a = x.sort((a,b)=>a-b);
   let q1 = a[Math.floor((a.length - 1) * 0.25)];
   let q3 = a[Math.floor((a.length - 1) * 0.75)];

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'

package/test/index.js

@@ -0,0 +1,39 @@
+import { fft, ifft } from "../src/signal/fft/index.js";
+import { conv, conv2 } from '../src/signal/conv/index.js'
+import { Complex } from "ziko/math/complex";
+// import { cos } from 'ziko/math/functions'
+
+// const x = Array.from({ length: 100 }, (_, j)=> j/10)
+// const y = cos(x)
+
+// const ff = fft(x)
+// // const ff = fft([1,2,3])
+// // console.log(ff)
+
+// // console.log(ifft(ff))
+const signal = [1, 2, 3, 4, 5];
+let kernel = [1, 0.5];
+// kernel = [1, new Complex(0, 0.5)];
+const result = conv(signal, kernel);
+console.log(
+   result
+)
+
+// console.log(ff)
+// console.log(ifft(ff).map(n=>+ n.a.toFixed(7)))
+// console.log(x)
+
+
+// Example usage:
+const image = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9]
+];
+
+const filter = [
+    [1, 0],
+    [0, 1]
+];
+
+console.log(conv2(image, filter, 'full', 'fill'));

package/test/index.py

@@ -0,0 +1,14 @@
+from scipy import signal
+image = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9]
+]
+
+kernel = [
+    [1, 0],
+    [0, 1]
+]
+print(
+    signal.convolve2d(image, kernel, 'full')
+)

package/src/signal/fft/fft1d/index.js

@@ -1,18 +0,0 @@
-import { twiddle } from "../utils/index.js";
-export function fft1d(arr) {
-    const N = arr.length;
-    if (N === 1) return [arr[0]];
-
-    // Split even/odd
-    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 w = twiddle(N, k);
-        const t = w.mul(odd[k]);
-        out[k]        = even[k].add(t);
-        out[k + N/2]  = even[k].sub(t);
-    }
-    return out;
-}

package/src/signal/fft/fftnd/index.js

@@ -1,27 +0,0 @@
-import { normalizeComplexND } from '../utils/index.js'
-import { fft1d } from '../fft1d/index.js';
-function fftND(arr) {
-    arr = normalizeComplexND(arr);
-
-    // Base case: 1-D
-    if (!Array.isArray(arr[0])) 
-        return fft1d(arr);
-
-    const transformed = arr.map(sub => fftND(sub));
-
-    const rows = transformed.length;
-    const cols = transformed[0].length;
-
-    const colsData = Array.from({ length: cols }, (_, c) =>
-        Array.from({ length: rows }, (_, r) => transformed[r][c])
-    );
-
-    const colsTransformed = colsData.map(col => fft1d(col));
-
-    // Transpose back
-    const out = Array.from({ length: rows }, (_, r) =>
-        Array.from({ length: cols }, (_, c) => colsTransformed[c][r])
-    );
-
-    return out;
-}