numz 0.1.0 → 0.3.0

package/docs/src/content/docs/reference/signal/functions/sequences/nums.md

@@ -0,0 +1,17 @@
+---
+title: nums
+description: nums
+sidebar : 
+    order: 2
+---
+## Definition 
+
+## Signature 
+```ts
+nums(num : number, n : number) : number[]
+```
+## Usage
+
+```ts
+const z = nums(1.5, 10) // [1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5]
+```

package/docs/src/content/docs/reference/signal/functions/sequences/ones.md

@@ -0,0 +1,19 @@
+---
+title: ones
+description: ones
+sidebar : 
+    order: 1
+---
+## Definition 
+
+## Signature
+
+```ts
+ones(n : number) : number[]
+```
+
+## Usage
+
+```ts
+const z = ones(10) // [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+```

package/docs/src/content/docs/reference/signal/functions/sequences/zeros.md

@@ -0,0 +1,20 @@
+---
+title: zeros
+description: zeros
+sidebar: 
+    order : 0
+---
+
+## Defintion
+
+## Signature
+
+```ts
+zeros(n : number) : []number
+```
+
+## Usage
+
+```ts
+const z = zeros(10) // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+```

package/docs/src/content/docs/reference/stats/accum/accum-max.md

@@ -0,0 +1,4 @@
+---
+title: accum_max
+description: accum_max
+---

package/docs/src/content/docs/reference/stats/accum/accum-min.md

@@ -0,0 +1,4 @@
+---
+title: accum_min
+description: accum_min
+---

package/docs/src/content/docs/reference/stats/accum/accum-prod.md

@@ -0,0 +1,4 @@
+---
+title: accum_prod
+description: accum_prod
+---

package/docs/src/content/docs/reference/stats/accum/accum-sum.md

@@ -0,0 +1,4 @@
+---
+title: accum_sum
+description: accum_sum
+---

package/docs/src/content/docs/reference/stats/averages/contraharmonic-mean.md

@@ -0,0 +1,4 @@
+---
+title: ch_mean
+description: contraharmonic mean
+---

package/docs/src/content/docs/reference/stats/averages/geo_mean.md

@@ -0,0 +1,6 @@
+---
+title: geo_mean
+description: geo_mean
+sidebar : 
+    order: 1
+---

package/docs/src/content/docs/reference/stats/averages/harmonic_mean.md

@@ -0,0 +1,4 @@
+---
+title: har_mean
+description: har_mean
+---

package/docs/src/content/docs/reference/stats/averages/iq-mean.md

@@ -0,0 +1,4 @@
+---
+title: iq_mean
+description: iq_mean
+---

package/docs/src/content/docs/reference/stats/averages/mean.md

@@ -0,0 +1,6 @@
+---
+title: mean
+description: mean
+sidebar : 
+    order: 0
+---

package/docs/src/content/docs/reference/stats/averages/midhinge.md

@@ -0,0 +1,4 @@
+---
+title: midhinge
+description: midhinge
+---

package/docs/src/content/docs/reference/stats/averages/midrange.md

@@ -0,0 +1,4 @@
+---
+title: midrange
+description: midrange
+---

package/docs/src/content/docs/reference/stats/averages/power_mean.md

@@ -0,0 +1,4 @@
+---
+title: pow_mean
+description: accum_prod
+---

package/docs/src/content/docs/reference/stats/averages/rms.md

@@ -0,0 +1,12 @@
+---
+title: rms
+description: rms
+sidebar : 
+    order: 2
+---
+
+
+# 11
+
+
+## 22

package/docs/src/content/docs/reference/stats/averages/trimmed_mean.md

@@ -0,0 +1,4 @@
+---
+title: trim_mean
+description: trim_mean
+---

package/docs/src/content/docs/reference/stats/averages/weighted_mean.md

@@ -0,0 +1,4 @@
+---
+title: w_mean
+description: weighted mean
+---

package/docs/src/content/docs/reference/stats/averages/winsorized_mean.md

@@ -0,0 +1,4 @@
+---
+title: win_mean
+description: win_mean
+---

package/docs/src/content.config.ts

@@ -0,0 +1,7 @@
+import { defineCollection } from 'astro:content';
+import { docsLoader } from '@astrojs/starlight/loaders';
+import { docsSchema } from '@astrojs/starlight/schema';
+
+export const collections = {
+	docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
+};

package/docs/src/styles/custom.css

@@ -0,0 +1,21 @@
+:root {
+  --sl-content-width: 50rem;
+  --sl-text-5xl: 3.5rem;
+}
+
+h1{
+    color : darkblue;
+    /* text-decoration: 2px underline blueviolet;
+    text-decoration-skip-ink: auto; */
+    /* border-bottom: 1px red solid; */
+}
+p a{
+    color: blueviolet;
+    text-decoration: none;
+    &:hover{
+        text-decoration: underline;
+    }
+}
+/* strong{
+    color: blueviolet;
+} */

package/docs/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "include": [".astro/types.d.ts", "**/*"],
+  "exclude": ["dist"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",
@@ -29,6 +29,6 @@
     "rollup": "^4.24.0"
   },
   "dependencies": {
-    "ziko": "^0.54.4"
+    "ziko": "^0.57.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,4 @@
 export * from './pulse/index.js'
 export * from './sequence/index.js'
-export * from './periodic'
+export * from './periodic/index.js'
+export * from './window/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/functions/window/index.js

@@ -0,0 +1,142 @@
+const {cos, sin, abs, sqrt, exp, PI} = Math
+export const hanning_window=(N, ArrayType = Float64Array)=>{
+  const w = new ArrayType(N);
+  const factor = 2 * PI / N;
+  for (let n = 0; n < N; n++) 
+    w[n] = 0.5 - 0.5 * cos(factor * n);
+  return w;
+}
+
+export const hamming_window=(N, ArrayType = Float64Array)=>{
+  const w = new ArrayType(N);
+  const factor = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = 0.54 - 0.46 * cos(factor * n);
+  return w;
+}
+
+const I0 = (x) => {
+  let sum = 1;
+  let u = 1;
+  let k = 1;
+  const x2 = (x * x) / 4;
+  while (true) {
+    // const prev = u;
+    u *= x2 / (k * k);
+    sum += u;
+    if (u < 1e-10 * sum) break;
+    k++;
+  }
+  return sum;
+};
+
+export const kaiser_window = (N, beta = 5, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const denom = I0(beta);
+  for (let n = 0; n < N; n++) {
+    const r = (2 * n) / (N - 1) - 1;
+    w[n] = I0(beta * sqrt(1 - r * r)) / denom;
+  }
+  return w;
+};
+
+export const blackman_window = (N, beta = 0.16, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const factor = 2 * PI / N;
+  const a0 = (1 - beta) / 2;
+  const a1 = 0.5;
+  const a2 = beta / 2;
+  for (let n = 0; n < N; n++) 
+    w[n] = a0,- a1 * cos(factor * n) + a2 * cos(2 * factor * n);
+  return w;
+};
+
+export const bartlett_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  for (let n = 0; n < N; n++)
+    w[n] = 1 - abs((2 * n) / (N - 1) - 1);
+  return w;
+};
+
+export const blackman_harris_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const a0 = 0.35875;
+  const a1 = 0.48829;
+  const a2 = 0.14128;
+  const a3 = 0.01168;
+  const f = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = a0 - a1 * cos(f * n) + a2 * cos(2 * f * n) - a3 * cos(3 * f * n);
+  return w;
+};
+
+export const nuttall_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const f = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = 0.355768 - 0.487396 * cos(f * n) + 0.144232 * cos(2 * f * n) - 0.012604 * cos(3 * f * n);
+  return w;
+};
+
+export const flat_top_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const f = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = 1 - 1.93 * cos(f * n) + 1.29 * cos(2 * f * n) - 0.388 * cos(3 * f * n) + 0.028 * cos(4 * f * n);
+  return w;
+};
+
+export const tukey_window = (N, alpha = 0.5, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const edge = alpha * (N - 1) / 2;
+  for (let n = 0; n < N; n++) {
+    if (n < edge)
+      w[n] = 0.5 * (1 + cos(PI * (2*n/(alpha*(N-1)) - 1)));
+    else if (n > (N - 1 - edge))
+      w[n] = 0.5 * (1 + cos(PI * (2*n/(alpha*(N-1)) - 2/alpha + 1)));
+    else 
+      w[n] = 1;
+  }
+  return w;
+};
+
+export const gaussian_window = (N, sigma = 0.4, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const m = (N - 1) / 2;
+  const s2 = sigma * m;
+  for (let n = 0; n < N; n++)
+    w[n] = exp(-0.5 * ((n - m) / s2) ** 2);
+  return w;
+};
+
+
+const sinc = (x) => x === 0 ? 1 : sin(PI * x) / (PI * x);
+export const lanczos_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  for (let n = 0; n < N; n++)
+    w[n] = sinc(2 * n / (N - 1) - 1);
+  return w;
+};
+
+export const poisson_window = (N, alpha = 3, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const m = (N - 1) / 2;
+  for (let n = 0; n < N; n++)
+    w[n] = exp(-alpha * abs(n - m) / m);
+  return w;
+};
+
+export const rect_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  w.fill(1);
+  return w;
+};
+
+export const tri_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const M = (N - 1) / 2;
+  for (let n = 0; n < N; n++) {
+    w[n] = 1 - abs((n - M) / M);
+  }
+  return w;
+};

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)];