numz 0.0.3 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",

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/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'