@cloudglides/nox 1.1.5 → 2.0.0

package/src/utils/combinatorics.js

@@ -1,85 +1,129 @@
 export const combinations = (arr, k) => {
-  if (k > arr.length) return [];
-  if (k === 1) return arr.map(x => [x]);
-  if (k === arr.length) return [arr];
+   if (!Array.isArray(arr)) {
+     throw new TypeError('arr must be an array');
+   }
+   if (typeof k !== 'number' || !Number.isInteger(k)) {
+     throw new TypeError('k must be an integer');
+   }
+   if (k <= 0) {
+     throw new RangeError('k must be positive');
+   }
+   if (k > arr.length) {
+     throw new RangeError('k cannot exceed array length');
+   }
 
-  const result = [];
-  const combine = (start, current) => {
-    if (current.length === k) {
-      result.push([...current]);
-      return;
-    }
-    for (let i = start; i < arr.length; i++) {
-      current.push(arr[i]);
-      combine(i + 1, current);
-      current.pop();
-    }
-  };
+   if (k === 1) return arr.map(x => [x]);
+   if (k === arr.length) return [arr];
+
+   const result = [];
+   const combine = (start, current) => {
+     if (current.length === k) {
+       result.push([...current]);
+       return;
+     }
+     for (let i = start; i < arr.length; i++) {
+       current.push(arr[i]);
+       combine(i + 1, current);
+       current.pop();
+     }
+   };
 
-  combine(0, []);
-  return result;
-};
+   combine(0, []);
+   return result;
+ };
 
 export const permutations = (arr) => {
-  if (arr.length <= 1) return [arr];
+   if (!Array.isArray(arr)) {
+     throw new TypeError('arr must be an array');
+   }
+   if (arr.length <= 1) return [arr];
 
-  const result = [];
-  const permute = (arr, start) => {
-    if (start === arr.length - 1) {
-      result.push([...arr]);
-      return;
-    }
-    for (let i = start; i < arr.length; i++) {
-      [arr[start], arr[i]] = [arr[i], arr[start]];
-      permute(arr, start + 1);
-      [arr[start], arr[i]] = [arr[i], arr[start]];
-    }
-  };
+   const result = [];
+   const permute = (arr, start) => {
+     if (start === arr.length - 1) {
+       result.push([...arr]);
+       return;
+     }
+     for (let i = start; i < arr.length; i++) {
+       [arr[start], arr[i]] = [arr[i], arr[start]];
+       permute(arr, start + 1);
+       [arr[start], arr[i]] = [arr[i], arr[start]];
+     }
+   };
 
-  permute([...arr], 0);
-  return result;
-};
+   permute([...arr], 0);
+   return result;
+ };
 
 export const kPermutations = (arr, k) => {
-  if (k > arr.length) return [];
-  if (k === 1) return arr.map(x => [x]);
+   if (!Array.isArray(arr)) {
+     throw new TypeError('arr must be an array');
+   }
+   if (typeof k !== 'number' || !Number.isInteger(k)) {
+     throw new TypeError('k must be an integer');
+   }
+   if (k <= 0) {
+     throw new RangeError('k must be positive');
+   }
+   if (k > arr.length) {
+     throw new RangeError('k cannot exceed array length');
+   }
+   if (k === 1) return arr.map(x => [x]);
 
-  const result = [];
-  const perm = (available, current) => {
-    if (current.length === k) {
-      result.push([...current]);
-      return;
-    }
-    for (let i = 0; i < available.length; i++) {
-      const item = available[i];
-      const remaining = available.slice(0, i).concat(available.slice(i + 1));
-      perm(remaining, [...current, item]);
-    }
-  };
+   const result = [];
+   const perm = (available, current) => {
+     if (current.length === k) {
+       result.push([...current]);
+       return;
+     }
+     for (let i = 0; i < available.length; i++) {
+       const item = available[i];
+       const remaining = available.slice(0, i).concat(available.slice(i + 1));
+       perm(remaining, [...current, item]);
+     }
+   };
 
-  perm(arr, []);
-  return result;
-};
+   perm(arr, []);
+   return result;
+ };
 
 export const randomCombination = (arr, k, rng) => {
-  const indices = [];
-  const n = arr.length;
-  
-  while (indices.length < k) {
-    const idx = rng.nextInt(n);
-    if (!indices.includes(idx)) {
-      indices.push(idx);
+    if (!Array.isArray(arr)) {
+      throw new TypeError('arr must be an array');
+    }
+    if (typeof k !== 'number' || !Number.isInteger(k)) {
+      throw new TypeError('k must be an integer');
+    }
+    if (k <= 0) {
+      throw new RangeError('k must be positive');
+    }
+    if (k > arr.length) {
+      throw new RangeError('k cannot exceed array length');
+    }
+    if (!rng || typeof rng.nextInt !== 'function') {
+      throw new TypeError('rng must be an RNG instance');
     }
-  }
-  
-  return indices.sort((a, b) => a - b).map(i => arr[i]);
-};
+   const indices = new Set();
+   const n = arr.length;
+   
+   while (indices.size < k) {
+     indices.add(rng.nextInt(n));
+   }
+   
+   return Array.from(indices).sort((a, b) => a - b).map(i => arr[i]);
+ };
 
 export const randomPermutation = (arr, rng) => {
-  const copy = [...arr];
-  for (let i = copy.length - 1; i > 0; i--) {
-    const j = rng.nextInt(i + 1);
-    [copy[i], copy[j]] = [copy[j], copy[i]];
-  }
-  return copy;
-};
+   if (!Array.isArray(arr)) {
+     throw new TypeError('arr must be array');
+   }
+   if (!rng || typeof rng.nextInt !== 'function') {
+     throw new TypeError('rng must be an RNG instance');
+   }
+   const copy = [...arr];
+   for (let i = copy.length - 1; i > 0; i--) {
+     const j = rng.nextInt(i + 1);
+     [copy[i], copy[j]] = [copy[j], copy[i]];
+   }
+   return copy;
+ };

package/src/utils/confidence.js

@@ -0,0 +1,145 @@
+export function bootstrapCI(r, data, statistic, level = 0.95, n = 1000) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new TypeError('data must be non-empty array');
+  }
+  if (typeof statistic !== 'function') {
+    throw new TypeError('statistic must be function');
+  }
+  if (typeof level !== 'number' || level <= 0 || level >= 1) {
+    throw new RangeError('level must be in (0, 1)');
+  }
+
+  const samples = new Array(n);
+  const size = data.length;
+
+  for (let i = 0; i < n; i++) {
+    const resample = new Array(size);
+    for (let j = 0; j < size; j++) {
+      resample[j] = data[r.nextInt(size)];
+    }
+    samples[i] = statistic(resample);
+  }
+
+  samples.sort((a, b) => a - b);
+
+  const alpha = 1 - level;
+  const lower = Math.floor(alpha / 2 * n);
+  const upper = Math.ceil((1 - alpha / 2) * n);
+
+  return {
+    lower: samples[lower],
+    upper: samples[upper],
+    estimate: statistic(data),
+    level
+  };
+}
+
+export function meanCI(data, stddev, level = 0.95, variance = null) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new TypeError('data must be non-empty array');
+  }
+  if (typeof level !== 'number' || level <= 0 || level >= 1) {
+    throw new RangeError('level must be in (0, 1)');
+  }
+
+  const n = data.length;
+  const mean = data.reduce((a, b) => a + b, 0) / n;
+
+  if (variance !== null) {
+    if (typeof variance !== 'number' || variance <= 0) {
+      throw new RangeError('variance must be positive');
+    }
+    const se = Math.sqrt(variance / n);
+    const z = invNormal((1 + level) / 2);
+    return {
+      mean,
+      lower: mean - z * se,
+      upper: mean + z * se,
+      level
+    };
+  }
+
+  if (typeof stddev !== 'number' || stddev <= 0) {
+    throw new RangeError('stddev must be positive');
+  }
+
+  const se = stddev / Math.sqrt(n);
+  const df = n - 1;
+  const t = invT((1 + level) / 2, df);
+
+  return {
+    mean,
+    lower: mean - t * se,
+    upper: mean + t * se,
+    level,
+    df
+  };
+}
+
+export function proportionCI(successes, n, level = 0.95, method = 'wilson') {
+  if (typeof successes !== 'number' || successes < 0 || successes > n) {
+    throw new RangeError('successes must be in [0, n]');
+  }
+  if (typeof n !== 'number' || n <= 0) {
+    throw new RangeError('n must be positive');
+  }
+  if (typeof level !== 'number' || level <= 0 || level >= 1) {
+    throw new RangeError('level must be in (0, 1)');
+  }
+
+  const p = successes / n;
+  const z = invNormal((1 + level) / 2);
+  const z2 = z * z;
+
+  if (method === 'wilson') {
+    const center = (successes + z2 / 2) / (n + z2);
+    const margin = z * Math.sqrt(p * (1 - p) / n + z2 / (4 * n * n)) / (1 + z2 / n);
+    return {
+      estimate: p,
+      lower: Math.max(0, center - margin),
+      upper: Math.min(1, center + margin),
+      level
+    };
+  }
+
+  if (method === 'normal') {
+    const se = Math.sqrt(p * (1 - p) / n);
+    return {
+      estimate: p,
+      lower: Math.max(0, p - z * se),
+      upper: Math.min(1, p + z * se),
+      level
+    };
+  }
+
+  throw new RangeError(`unknown method: ${method}`);
+}
+
+function invNormal(p) {
+  if (p <= 0.5) {
+    const t = Math.sqrt(-2 * Math.log(p));
+    const c0 = 2.515517;
+    const c1 = 0.802853;
+    const c2 = 0.010328;
+    const d1 = 1.432788;
+    const d2 = 0.189269;
+    const d3 = 0.001308;
+    return -(t - (c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
+  } else {
+    const t = Math.sqrt(-2 * Math.log(1 - p));
+    const c0 = 2.515517;
+    const c1 = 0.802853;
+    const c2 = 0.010328;
+    const d1 = 1.432788;
+    const d2 = 0.189269;
+    const d3 = 0.001308;
+    return t - (c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t);
+  }
+}
+
+function invT(p, df) {
+  const t = invNormal(p);
+  const t2 = t * t;
+  const g = (0.196 * t2 * t2 + 0.196 * t2 + 0.55) * (Math.exp(-0.0008 * t2 * t2 - 0.24 * t2 - 1.2)) + t * (1 + 0.0000092 * t2 * t2 + 0.00014 * t2);
+  return t + g / df;
+}

package/src/utils/decomposition.js

@@ -0,0 +1,204 @@
+export function svd(A, maxIter = 100) {
+  if (!Array.isArray(A) || A.length === 0) {
+    throw new TypeError('A must be non-empty matrix');
+  }
+
+  const m = A.length;
+  const n = A[0].length;
+  const k = Math.min(m, n);
+
+  const U = A.map(row => [...row]);
+  const VT = new Array(n);
+  for (let i = 0; i < n; i++) {
+    VT[i] = new Array(n);
+    for (let j = 0; j < n; j++) {
+      VT[i][j] = i === j ? 1 : 0;
+    }
+  }
+
+  const S = new Array(k);
+  for (let i = 0; i < k; i++) {
+    S[i] = 1;
+  }
+
+  for (let iter = 0; iter < maxIter; iter++) {
+    for (let i = 0; i < Math.min(m, n); i++) {
+      for (let j = i + 1; j < Math.min(m, n); j++) {
+        const x = new Array(m);
+        const y = new Array(m);
+
+        for (let p = 0; p < m; p++) {
+          x[p] = U[p][i];
+          y[p] = U[p][j];
+        }
+
+        const xNorm = Math.sqrt(x.reduce((a, b) => a + b * b, 0));
+        const yNorm = Math.sqrt(y.reduce((a, b) => a + b * b, 0));
+        const xy = x.reduce((a, b, p) => a + b * y[p], 0);
+
+        if (xNorm < 1e-10 || yNorm < 1e-10 || Math.abs(xy) < 1e-10) continue;
+
+        const cos = xy / (xNorm * yNorm);
+        const angle = Math.acos(Math.min(1, Math.max(-1, cos)));
+        const sin = Math.sin(angle);
+        const cosTheta = Math.cos(angle);
+        const sinTheta = Math.sin(angle);
+
+        for (let p = 0; p < m; p++) {
+          const up_i = U[p][i];
+          const up_j = U[p][j];
+          U[p][i] = cosTheta * up_i + sinTheta * up_j;
+          U[p][j] = -sinTheta * up_i + cosTheta * up_j;
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < k; i++) {
+    let colNorm = 0;
+    for (let j = 0; j < m; j++) {
+      colNorm += U[j][i] * U[j][i];
+    }
+    S[i] = Math.sqrt(colNorm);
+  }
+
+  return { U, S, VT };
+}
+
+export function qr(A) {
+  if (!Array.isArray(A) || A.length === 0) {
+    throw new TypeError('A must be non-empty matrix');
+  }
+
+  const m = A.length;
+  const n = A[0].length;
+
+  const Q = A.map(row => [...row]);
+  const R = new Array(n);
+  for (let i = 0; i < n; i++) {
+    R[i] = new Array(n);
+    for (let j = 0; j < n; j++) {
+      R[i][j] = 0;
+    }
+  }
+
+  for (let j = 0; j < n; j++) {
+    let normCol = 0;
+    for (let i = 0; i < m; i++) {
+      normCol += Q[i][j] * Q[i][j];
+    }
+    R[j][j] = Math.sqrt(normCol);
+
+    if (R[j][j] > 1e-10) {
+      for (let i = 0; i < m; i++) {
+        Q[i][j] /= R[j][j];
+      }
+    }
+
+    for (let k = j + 1; k < n; k++) {
+      R[j][k] = 0;
+      for (let i = 0; i < m; i++) {
+        R[j][k] += Q[i][j] * A[i][k];
+      }
+
+      for (let i = 0; i < m; i++) {
+        Q[i][k] -= R[j][k] * Q[i][j];
+      }
+    }
+  }
+
+  return { Q, R };
+}
+
+export function cholesky(A) {
+  if (!Array.isArray(A) || A.length !== A[0].length) {
+    throw new TypeError('A must be square matrix');
+  }
+
+  const n = A.length;
+  const L = new Array(n);
+  for (let i = 0; i < n; i++) {
+    L[i] = new Array(n);
+    for (let j = 0; j < n; j++) {
+      L[i][j] = 0;
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let sum = 0;
+      for (let k = 0; k < j; k++) {
+        sum += L[i][k] * L[j][k];
+      }
+
+      if (i === j) {
+        const val = A[i][i] - sum;
+        if (val <= 0) {
+          throw new RangeError('matrix must be positive definite');
+        }
+        L[i][j] = Math.sqrt(val);
+      } else {
+        L[i][j] = (A[i][j] - sum) / L[j][j];
+      }
+    }
+  }
+
+  return L;
+}
+
+export function lu(A) {
+  if (!Array.isArray(A) || A.length !== A[0].length) {
+    throw new TypeError('A must be square matrix');
+  }
+
+  const n = A.length;
+  const LU = A.map(row => [...row]);
+  const P = new Array(n);
+  for (let i = 0; i < n; i++) {
+    P[i] = i;
+  }
+
+  for (let i = 0; i < n; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k < n; k++) {
+      if (Math.abs(LU[k][i]) > Math.abs(LU[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+
+    [LU[i], LU[maxRow]] = [LU[maxRow], LU[i]];
+    [P[i], P[maxRow]] = [P[maxRow], P[i]];
+
+    if (Math.abs(LU[i][i]) < 1e-10) {
+      throw new RangeError('matrix is singular');
+    }
+
+    for (let k = i + 1; k < n; k++) {
+      LU[k][i] /= LU[i][i];
+      for (let j = i + 1; j < n; j++) {
+        LU[k][j] -= LU[k][i] * LU[i][j];
+      }
+    }
+  }
+
+  const L = new Array(n);
+  const U = new Array(n);
+  for (let i = 0; i < n; i++) {
+    L[i] = new Array(n);
+    U[i] = new Array(n);
+    for (let j = 0; j < n; j++) {
+      if (j < i) {
+        L[i][j] = LU[i][j];
+        U[i][j] = 0;
+      } else if (j === i) {
+        L[i][j] = 1;
+        U[i][j] = LU[i][j];
+      } else {
+        L[i][j] = 0;
+        U[i][j] = LU[i][j];
+      }
+    }
+  }
+
+  return { L, U, P };
+}

package/src/utils/distributions-advanced.js

@@ -0,0 +1,122 @@
+import { gamma } from './distributions-extra.js';
+
+export function dirichlet(r, alpha) {
+  if (!Array.isArray(alpha) || alpha.length === 0) {
+    throw new TypeError('alpha must be a non-empty array');
+  }
+  
+  const k = alpha.length;
+  const samples = new Array(k);
+  let sum = 0;
+
+  for (let i = 0; i < k; i++) {
+    if (typeof alpha[i] !== 'number' || alpha[i] <= 0) {
+      throw new RangeError('all alpha values must be positive');
+    }
+    samples[i] = gamma(r, alpha[i], 1);
+    sum += samples[i];
+  }
+
+  for (let i = 0; i < k; i++) {
+    samples[i] /= sum;
+  }
+
+  return samples;
+}
+
+export function dirichlets(r, alpha, n) {
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const samples = new Array(n);
+  for (let i = 0; i < n; i++) {
+    samples[i] = dirichlet(r, alpha);
+  }
+  return samples;
+}
+
+export function mixture(r, distributions, weights) {
+  if (!Array.isArray(distributions) || distributions.length === 0) {
+    throw new TypeError('distributions must be a non-empty array');
+  }
+  if (!Array.isArray(weights) || weights.length !== distributions.length) {
+    throw new TypeError('weights length must match distributions');
+  }
+
+  let sum = weights.reduce((a, b) => a + b, 0);
+  if (sum <= 0) {
+    throw new RangeError('weights must sum to positive value');
+  }
+
+  const normalized = weights.map(w => w / sum);
+  let u = r.nextFloat();
+  let cumsum = 0;
+
+  for (let i = 0; i < normalized.length; i++) {
+    cumsum += normalized[i];
+    if (u < cumsum) {
+      return distributions[i](r);
+    }
+  }
+
+  return distributions[distributions.length - 1](r);
+}
+
+export function mixtures(r, distributions, weights, n) {
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const samples = new Array(n);
+  for (let i = 0; i < n; i++) {
+    samples[i] = mixture(r, distributions, weights);
+  }
+  return samples;
+}
+
+export function studentT(r, df) {
+  if (typeof df !== 'number' || df <= 0) {
+    throw new RangeError('degrees of freedom must be positive');
+  }
+
+  const z = r.normal();
+  const u = r.nextFloat();
+  const chi2Val = -2 * Math.log(u) + (df - 1) * Math.log(1 - 2 * u / df);
+  const v = Math.sqrt((df * chi2Val) / (df + z * z));
+
+  return z / v;
+}
+
+export function studentTs(r, df, n) {
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const samples = new Array(n);
+  for (let i = 0; i < n; i++) {
+    samples[i] = studentT(r, df);
+  }
+  return samples;
+}
+
+export function betaBinomial(r, n, alpha, beta) {
+  if (typeof n !== 'number' || n < 0 || n !== Math.floor(n)) {
+    throw new RangeError('n must be a non-negative integer');
+  }
+  if (typeof alpha !== 'number' || alpha <= 0) {
+    throw new RangeError('alpha must be positive');
+  }
+  if (typeof beta !== 'number' || beta <= 0) {
+    throw new RangeError('beta must be positive');
+  }
+
+  const p = gamma(r, alpha, 1) / (gamma(r, alpha, 1) + gamma(r, beta, 1));
+  let count = 0;
+
+  for (let i = 0; i < n; i++) {
+    if (r.nextFloat() < p) count++;
+  }
+
+  return count;
+}