numz 0.0.0

package/demo/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "preview",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "vite": "^5.4.8"
+  }
+}

package/demo/public/vite.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

package/demo/src/pages/[blog]/[lang]/index.js

@@ -0,0 +1,3 @@
+export default ({blog,lang})=>{
+    console.log({blog,lang})
+}

package/demo/src/pages/[blog]/index.js

@@ -0,0 +1,3 @@
+export default (params)=>{
+    console.log(params)
+}

package/demo/src/pages/about.js

@@ -0,0 +1,6 @@
+import { p } from "ziko"
+export default ()=>{
+    return p("About  ").style({
+        color:"red",
+    })
+}

package/demo/src/pages/articles/[data]/[color]/index.js

@@ -0,0 +1,6 @@
+import { text } from "ziko";
+export default ({data,color})=>{
+    return text(data).style({
+        color : color
+    })
+}

package/demo/src/pages/articles/a1.js

@@ -0,0 +1,6 @@
+import { p } from "ziko"
+export default ()=>{
+    return p("Bla bla bla  ").style({
+        color:"red",
+    })
+}

package/demo/src/pages/index.js

@@ -0,0 +1,20 @@
+import { p,App,Flex } from "ziko"
+
+const {QueryParams} = __Ziko__
+export default ()=>{
+    return App({
+        head : {
+            title : "ziko",
+        },
+        wrapper : ()=>Flex(p("Hello world").style({
+            color : QueryParams.color ?? "black"
+        })).size("100vw","100vh").vertical(0,0)
+    })
+}
+document.body.style.overflow = "hidden"
+// export default ()=>{
+//     return p("Hello from zikojs File based routing ").style({
+//         color:"red",
+//         fontFamily : "Gloria Hallelujah"
+//     })
+// }

package/demo/src/pages/me.js

@@ -0,0 +1,3 @@
+export default ()=>{
+    console.log("me")
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "numz",
+  "version": "0.0.0",
+  "description": "scientific computing with zikojs",
+  "main": "index.js",
+  "type": "module",
+  "exports":{
+    "./*" : {
+      "import" : "./src/*/index.js"
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "cross-env NODE_ENV=development rollup --config rollup.config.js",
+    "watch": "cross-env NODE_ENV=development rollup --config rollup.config.js -w",
+    "build": "cross-env NODE_ENV=production rollup --config rollup.config.js"
+  },
+  "author": "zakaria elalaoui",
+  "keywords": [
+    "zikojs",
+    "zikojs-addons"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-terser": "^0.4.4",
+    "cross-env": "^7.0.3",
+    "rollup": "^4.24.0"
+  },
+  "dependencies": {
+    "ziko": "^0.54.1"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,66 @@
+import resolve from "@rollup/plugin-node-resolve";
+import commonjs from '@rollup/plugin-commonjs';
+import terser from "@rollup/plugin-terser";
+
+const Addon_name = "ziko-math-signal";
+const NamedExport = "ZMS"
+const Author = "";
+
+const banner = `
+/*
+  Project: ${Addon_name}
+  Author: ${Author}
+  Date : ${new Date()}
+*/
+`;
+const isProduction = process.env.NODE_ENV === "production";
+
+const output = [
+  {
+    file: `dist/${Addon_name}.mjs`,
+    format: "es",
+    banner,
+    exports: "named",
+  },
+  {
+    file: `dist/${Addon_name}.js`,
+    format: "umd",
+    name: NamedExport,
+    banner,
+    exports: "named",
+  },
+];
+isProduction &&
+  output.push(
+    {
+      file: `dist/${Addon_name}.min.mjs`,
+      format: "es",
+      banner,
+      exports: "named",
+    },
+    {
+      file: `dist/${Addon_name}.min.js`,
+      format: "umd",
+      name: NamedExport,
+      banner,
+      exports: "named",
+      plugins: [
+        terser({
+          output: {
+            comments: (node, { type, value }) =>
+              type === "comment2" && value.includes("Author"),
+          },
+        }),
+      ],
+    },
+  );
+
+export default {
+  input: "src/index.js",
+  output,
+  external: ["ziko"],
+  plugins: [
+    resolve(),
+    commonjs(),
+  ],
+};

package/src/index.js

@@ -0,0 +1 @@
+export * from './stats/index.js'

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,27 @@
+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;
+}

package/src/signal/fft/index.js

@@ -0,0 +1,48 @@
+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);
+    }
+    return out;
+}
+
+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");
+}

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

@@ -0,0 +1,19 @@
+// 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);
+//     }
+// }

package/src/stats/accum/index.js

@@ -0,0 +1,39 @@
+export const accum_sum = (arr) => {
+  let result = [];
+  let total = 0;
+  for (let x of arr) {
+    total += x;
+    result.push(total);
+  }
+  return result;
+};
+
+export const accum_product = (arr) => {
+  let result = [];
+  let prod = 1;
+  for (let x of arr) {
+    prod *= x;
+    result.push(prod);
+  }
+  return result;
+};
+
+export const accum_max = (arr) => {
+  let result = [];
+  let m = -Infinity;
+  for (let x of arr) {
+    m = Math.max(m, x);
+    result.push(m);
+  }
+  return result;
+};
+
+export const accum_min = (arr) => {
+  let result = [];
+  let m = Infinity;
+  for (let x of arr) {
+    m = Math.min(m, x);
+    result.push(m);
+  }
+  return result;
+};

package/src/stats/average/index.js

@@ -0,0 +1,75 @@
+// Mean
+export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+export const geo_mean = (...x) => (x.reduce((a, b) => a * b)) ** (1/x.length);
+// Quadratic Mean
+export const rms = (...x) => {
+    const n = x.length;
+    return (Math.hypot(...x)/n)**(1/n)
+}
+
+export const weighted_mean=(values, weights)=>{
+  let sum = 0, sw = 0;
+  for (let i = 0; i < values.length; i++) {
+    sum += values[i] * weights[i];
+    sw += weights[i];
+  }
+  return sum / sw;
+}
+
+export const harmonic_mean = (...x) => {
+  let s = 0, i = 0;
+  for(i=0; i<x.length; i++) 
+    s += 1/x[i]
+  return x.length / s;
+}
+
+export const power_mean = (X, p) =>{
+  let s = 0, i = 0, l = X.length;
+  for(i=0; i < l; i++) 
+    s+= X[i]**p
+  return (s / l) ** (1 / p);
+}
+
+export const trimmed_mean = (X, k) =>{
+  let a = [...X].sort((a,b)=>a-b).slice(k, X.length - k);
+  return mean(...a);
+}
+
+export const winsorized_mean = (X, k) =>{
+  let a = [...X].sort((a,b)=>a-b);
+  let low = a[k], high = a[a.length - k - 1];
+  a = a.map(x => Math.max(low, Math.min(high, x)));
+  return mean(a);
+}
+
+export const midrange = (x) =>{
+  let min = Math.min(...x);
+  let max = Math.max(...x);
+  return (min + max) / 2;
+}
+
+export const midhinge = (...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)];
+  return (q1 + q3) / 2;
+}
+
+
+export const interquartile_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)];
+  let m = a.filter(x => x >= q1 && x <= q3);
+  return mean(m);
+}
+
+
+export const contraharmonic_mean = (...x) =>{
+  let num = 0, den = 0, i, l = x.length;
+  for(i = 0; i < l; i++){
+    num += x[i]**2;
+    den += x[i]
+  }
+  return num / den;
+}

package/src/stats/index.js

@@ -0,0 +1,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'

package/src/stats/percentile/index.js

@@ -0,0 +1,18 @@
+export const percentile = (X, p) => {
+  if (X.length === 0) 
+    return NaN;
+  let a = X.sort((x, y) => x - y);
+  let index = (p / 100) * (a.length - 1);
+  let i = Math.floor(index);
+  let f = index - i;
+  if (i === a.length - 1) 
+    return a[i]; 
+  return a[i] * (1 - f) + a[i + 1] * f;
+}
+
+export const q1 = X => percentile(X, 25); 
+export const median = X => percentile(X, 50); 
+export const q3 = X => percentile(X, 75); 
+
+// Interquartile Range
+export const iqr = X => q3(X) - q1(X)

package/src/stats/rolling/index.js

@@ -0,0 +1,34 @@
+// Simple Moving Average
+export const sma = (X, w) =>{
+  let r = [];
+  for (let i = 0; i <= X.length - w; i++) {
+    let s = 0;
+    for (let j = 0; j < w; j++) s += X[i + j];
+    r.push(s / w);
+  }
+  return r;
+}
+
+// exponential Moving Average
+export const ema = (X, alpha) =>{
+  let r = [], prev = X[0];
+  r.push(prev);
+  for (let i = 1; i < X.length; i++) {
+    prev = alpha * X[i] + (1 - alpha) * prev;
+    r.push(prev);
+  }
+  return r;
+}
+
+// weightedMovingAverage
+export const wma = (X, weights) =>{
+  let k = weights.length;
+  let sw = weights.reduce((a,b)=>a+b, 0);
+  let r = [];
+  for (let i = 0; i <= X.length - k; i++) {
+    let s = 0;
+    for (let j = 0; j < k; j++) s += X[i+j] * weights[j];
+    r.push(s / sw);
+  }
+  return r;
+}

package/src/stats/variability/index.js

@@ -0,0 +1,37 @@
+// Population Variance
+import { mean } from "../average/index.js";
+export const variance = (...x) => {
+  const n = x.length;
+  if (n === 0) return NaN;
+  const x_mean = mean(...x);
+  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
+};
+export const std = (...x) => Math.sqrt(variance(...x));
+
+export const sample_variance = (...x) => {
+  const n = x.length;
+  if (n < 2) return NaN;
+  const x_mean = mean(...x);
+  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / (n - 1);
+};
+export const sample_std = (...x) => Math.sqrt(sample_variance(...x));
+
+export const weighted_variance = (X, weights) => {
+  const n = X.length;
+  if (n === 0 || weights.length !== n) return NaN;
+  const sw = weights.reduce((sum, w) => sum + w, 0);
+  const mean = X.reduce((sum, x, i) => sum + x * weights[i], 0) / sw;
+  return X.reduce((sum, x, i) => sum + weights[i] * (x - mean) ** 2, 0) / sw;
+};
+export const weighted_std = (X, weights) => Math.sqrt(weighted_variance(X, weights));
+
+export const rolling_variance = (X, windowSize) => {
+  if (windowSize < 1 || X.length < windowSize) return [];
+  let result = [];
+  for (let i = 0; i <= X.length - windowSize; i++) {
+    const w = X.slice(i, i + windowSize);
+    result.push(sample_variance(w)); // usually sample variance for rolling
+  }
+  return result;
+};
+export const rolling_std = (X, windowSize) => Math.sqrt(rolling_variance(X, windowSize));