@cloudglides/nox 1.1.5 → 2.0.0

package/src/utils/precomputed.js

@@ -0,0 +1,166 @@
+export class WeightedDistribution {
+  constructor(items, weights) {
+    if (!Array.isArray(items) || items.length === 0) {
+      throw new TypeError('items must be non-empty array');
+    }
+    if (!Array.isArray(weights) || weights.length !== items.length) {
+      throw new TypeError('weights length must match items');
+    }
+
+    this.items = items;
+    this.cumsum = new Array(items.length);
+    let total = 0;
+
+    for (let i = 0; i < weights.length; i++) {
+      if (typeof weights[i] !== 'number' || weights[i] < 0) {
+        throw new RangeError('all weights must be non-negative numbers');
+      }
+      total += weights[i];
+      this.cumsum[i] = total;
+    }
+
+    if (total <= 0) {
+      throw new RangeError('weights must sum to positive value');
+    }
+
+    this.total = total;
+  }
+
+  pick(rng) {
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('rng must be an RNG instance');
+    }
+
+    const rand = rng.nextFloat() * this.total;
+    let left = 0, right = this.cumsum.length;
+
+    while (left < right) {
+      const mid = (left + right) >> 1;
+      if (rand < this.cumsum[mid]) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+
+    return this.items[left];
+  }
+
+  sample(rng, n) {
+    if (typeof n !== 'number' || n < 1) {
+      throw new RangeError('n must be positive integer');
+    }
+
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      result[i] = this.pick(rng);
+    }
+    return result;
+  }
+}
+
+export class CategoricalDistribution {
+  constructor(probabilities) {
+    if (!Array.isArray(probabilities) || probabilities.length === 0) {
+      throw new TypeError('probabilities must be non-empty array');
+    }
+
+    this.cumsum = new Array(probabilities.length);
+    let total = 0;
+
+    for (let i = 0; i < probabilities.length; i++) {
+      if (typeof probabilities[i] !== 'number' || probabilities[i] < 0) {
+        throw new RangeError('all probabilities must be non-negative');
+      }
+      total += probabilities[i];
+      this.cumsum[i] = total;
+    }
+
+    if (Math.abs(total - 1) > 1e-10) {
+      for (let i = 0; i < this.cumsum.length; i++) {
+        this.cumsum[i] /= total;
+      }
+    }
+
+    this.n = probabilities.length;
+  }
+
+  sample(rng) {
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('rng must be an RNG instance');
+    }
+
+    const u = rng.nextFloat();
+    let left = 0, right = this.cumsum.length;
+
+    while (left < right) {
+      const mid = (left + right) >> 1;
+      if (u < this.cumsum[mid]) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+
+    return left;
+  }
+
+  samples(rng, n) {
+    if (typeof n !== 'number' || n < 1) {
+      throw new RangeError('n must be positive integer');
+    }
+
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      result[i] = this.sample(rng);
+    }
+    return result;
+  }
+}
+
+export class NormalDistribution {
+  constructor(mean = 0, stddev = 1) {
+    if (typeof mean !== 'number') {
+      throw new TypeError('mean must be number');
+    }
+    if (typeof stddev !== 'number' || stddev <= 0) {
+      throw new RangeError('stddev must be positive');
+    }
+
+    this.mean = mean;
+    this.stddev = stddev;
+    this.hasSpare = false;
+    this.spare = 0;
+  }
+
+  sample(rng) {
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('rng must be an RNG instance');
+    }
+
+    if (this.hasSpare) {
+      this.hasSpare = false;
+      return this.spare * this.stddev + this.mean;
+    }
+
+    this.hasSpare = true;
+    const u1 = rng.nextFloat();
+    const u2 = rng.nextFloat();
+    const mag = Math.sqrt(-2 * Math.log(u1 > 1e-10 ? u1 : 1e-10));
+    
+    this.spare = Math.sin(2 * Math.PI * u2) * mag;
+    return Math.cos(2 * Math.PI * u2) * mag * this.stddev + this.mean;
+  }
+
+  samples(rng, n) {
+    if (typeof n !== 'number' || n < 1) {
+      throw new RangeError('n must be positive integer');
+    }
+
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      result[i] = this.sample(rng);
+    }
+    return result;
+  }
+}

package/src/utils/probability.js

@@ -0,0 +1,199 @@
+export function cdf(x, distribution = 'uniform', ...params) {
+  if (typeof x !== 'number') {
+    throw new TypeError('x must be a number');
+  }
+
+  switch (distribution.toLowerCase()) {
+    case 'uniform': {
+      const [min = 0, max = 1] = params;
+      if (x < min) return 0;
+      if (x > max) return 1;
+      return (x - min) / (max - min);
+    }
+    
+    case 'normal': {
+      const [mu = 0, sigma = 1] = params;
+      const z = (x - mu) / sigma;
+      return 0.5 * (1 + erf(z / Math.sqrt(2)));
+    }
+    
+    case 'exponential': {
+      const [lambda = 1] = params;
+      if (x < 0) return 0;
+      return 1 - Math.exp(-lambda * x);
+    }
+    
+    case 'poisson': {
+      const [lambda = 1] = params;
+      if (x < 0) return 0;
+      const k = Math.floor(x);
+      let sum = 0;
+      const expNeg = Math.exp(-lambda);
+      let term = expNeg;
+      
+      for (let i = 0; i <= k; i++) {
+        sum += term;
+        if (i < k) term *= lambda / (i + 1);
+      }
+      return sum;
+    }
+    
+    case 'beta': {
+      const [a = 1, b = 1] = params;
+      if (x <= 0) return 0;
+      if (x >= 1) return 1;
+      return incompleteBeta(x, a, b);
+    }
+    
+    default:
+      throw new RangeError(`unknown distribution: ${distribution}`);
+  }
+}
+
+export function ppf(p, distribution = 'uniform', ...params) {
+  if (typeof p !== 'number' || p < 0 || p > 1) {
+    throw new RangeError('p must be in [0, 1]');
+  }
+
+  switch (distribution.toLowerCase()) {
+    case 'uniform': {
+      const [min = 0, max = 1] = params;
+      return min + p * (max - min);
+    }
+    
+    case 'normal': {
+      const [mu = 0, sigma = 1] = params;
+      return mu + sigma * invNormal(p);
+    }
+    
+    case 'exponential': {
+      const [lambda = 1] = params;
+      if (p === 0) return 0;
+      if (p === 1) return Infinity;
+      return -Math.log(1 - p) / lambda;
+    }
+    
+    case 'beta': {
+      const [a = 1, b = 1] = params;
+      if (p === 0) return 0;
+      if (p === 1) return 1;
+      return invIncompleteBeta(p, a, b);
+    }
+    
+    default:
+      throw new RangeError(`unknown distribution: ${distribution}`);
+  }
+}
+
+export function sf(x, distribution = 'uniform', ...params) {
+  if (typeof x !== 'number') {
+    throw new TypeError('x must be a number');
+  }
+  
+  return 1 - cdf(x, distribution, ...params);
+}
+
+function erf(x) {
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const t4 = t3 * t;
+  const t5 = t4 * t;
+
+  return sign * (1 - (a1 * t + a2 * t2 + a3 * t3 + a4 * t4 + a5 * t5) * Math.exp(-absX * absX));
+}
+
+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 incompleteBeta(x, a, b) {
+  const maxIterations = 100;
+  const epsilon = 1e-10;
+  
+  let sum = 1;
+  let term = 1;
+  
+  for (let i = 1; i <= maxIterations; i++) {
+    term *= (a + b - 1) * x / ((a + i - 1) * (1 - x / (a + i)));
+    const nextSum = sum + term;
+    
+    if (Math.abs(nextSum - sum) < epsilon) {
+      break;
+    }
+    sum = nextSum;
+  }
+  
+  return sum * Math.exp(a * Math.log(x) + b * Math.log(1 - x) - logBeta(a, b)) / a;
+}
+
+function invIncompleteBeta(p, a, b) {
+  let x = 0.5;
+  
+  for (let i = 0; i < 20; i++) {
+    const fx = incompleteBeta(x, a, b) - p;
+    const absX = Math.log(x / (1 - x));
+    const denom = (Math.exp(a * absX - logBeta(a, b)) * Math.exp(b * Math.log(1 - x))) / (a + b);
+    const dx = fx / denom;
+    
+    x = Math.max(0.001, Math.min(0.999, x - dx));
+    
+    if (Math.abs(dx) < 1e-10) break;
+  }
+  
+  return x;
+}
+
+function logBeta(a, b) {
+  return logGamma(a) + logGamma(b) - logGamma(a + b);
+}
+
+function logGamma(x) {
+  const coefficients = [
+    676.5203681218851,
+    -1259.1392167224028,
+    771.32342877765313,
+    -176.61502916214059,
+    12.507343278686905,
+    -0.13857109526572012,
+    9.9843695780195716e-6,
+    1.5056327351493116e-7
+  ];
+  
+  const g = 7;
+  const z = x - 1;
+  let sum = 0.99999999999980993;
+  
+  for (let i = 0; i < coefficients.length; i++) {
+    sum += coefficients[i] / (z + i + 1);
+  }
+  
+  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(z + g + 0.5) - (z + g + 0.5) + Math.log(sum);
+}

package/src/utils/regression.js

@@ -0,0 +1,170 @@
+export class LinearRegression {
+  constructor(x, y) {
+    if (!Array.isArray(x) || !Array.isArray(y)) {
+      throw new TypeError('x and y must be arrays');
+    }
+    if (x.length !== y.length || x.length < 2) {
+      throw new RangeError('x and y must have same length >= 2');
+    }
+
+    const n = x.length;
+    const sumX = x.reduce((a, b) => a + b, 0);
+    const sumY = y.reduce((a, b) => a + b, 0);
+    const sumXY = x.reduce((sum, xi, i) => sum + xi * y[i], 0);
+    const sumX2 = x.reduce((sum, xi) => sum + xi * xi, 0);
+
+    const meanX = sumX / n;
+    const meanY = sumY / n;
+
+    this.slope = (sumXY - n * meanX * meanY) / (sumX2 - n * meanX * meanX);
+    this.intercept = meanY - this.slope * meanX;
+
+    const yPred = x.map(xi => this.slope * xi + this.intercept);
+    
+    let ssRes = 0, ssTot = 0;
+    for (let i = 0; i < n; i++) {
+      ssRes += (y[i] - yPred[i]) ** 2;
+      ssTot += (y[i] - meanY) ** 2;
+    }
+
+    this.rSquared = 1 - ssRes / ssTot;
+    this.rmse = Math.sqrt(ssRes / n);
+    this.residuals = y.map((yi, i) => yi - yPred[i]);
+    this.predictions = yPred;
+  }
+
+  predict(x) {
+    if (typeof x === 'number') {
+      return this.slope * x + this.intercept;
+    }
+    if (Array.isArray(x)) {
+      return x.map(xi => this.slope * xi + this.intercept);
+    }
+    throw new TypeError('x must be number or array');
+  }
+}
+
+export class MultipleRegression {
+  constructor(X, y) {
+    if (!Array.isArray(X) || !Array.isArray(y)) {
+      throw new TypeError('X and y must be arrays');
+    }
+    if (X.length !== y.length || X.length < 2) {
+      throw new RangeError('X and y must have same length >= 2');
+    }
+    if (!Array.isArray(X[0])) {
+      throw new TypeError('X must be array of arrays (features)');
+    }
+
+    const n = X.length;
+    const p = X[0].length;
+
+    const matX = X.map(row => [1, ...row]);
+    
+    const XtX = matmul(transpose(matX), matX);
+    const Xty = matmul(transpose(matX), y.map(yi => [yi]));
+
+    this.coefficients = solve(XtX, Xty).flat();
+    this.intercept = this.coefficients[0];
+
+    const yPred = X.map((row, i) => {
+      let pred = this.intercept;
+      for (let j = 0; j < p; j++) {
+        pred += this.coefficients[j + 1] * row[j];
+      }
+      return pred;
+    });
+
+    const meanY = y.reduce((a, b) => a + b, 0) / n;
+    let ssRes = 0, ssTot = 0;
+
+    for (let i = 0; i < n; i++) {
+      ssRes += (y[i] - yPred[i]) ** 2;
+      ssTot += (y[i] - meanY) ** 2;
+    }
+
+    this.rSquared = 1 - ssRes / ssTot;
+    this.adjRSquared = 1 - (1 - this.rSquared) * (n - 1) / (n - p - 1);
+    this.rmse = Math.sqrt(ssRes / n);
+    this.predictions = yPred;
+    this.residuals = y.map((yi, i) => yi - yPred[i]);
+  }
+
+  predict(X) {
+    if (typeof X[0] === 'number') {
+      let pred = this.intercept;
+      for (let i = 0; i < X.length; i++) {
+        pred += this.coefficients[i + 1] * X[i];
+      }
+      return pred;
+    }
+
+    return X.map(row => {
+      let pred = this.intercept;
+      for (let i = 0; i < row.length; i++) {
+        pred += this.coefficients[i + 1] * row[i];
+      }
+      return pred;
+    });
+  }
+}
+
+function transpose(matrix) {
+  const result = [];
+  for (let j = 0; j < matrix[0].length; j++) {
+    result[j] = [];
+    for (let i = 0; i < matrix.length; i++) {
+      result[j].push(matrix[i][j]);
+    }
+  }
+  return result;
+}
+
+function matmul(A, B) {
+  const result = [];
+  for (let i = 0; i < A.length; i++) {
+    result[i] = [];
+    for (let j = 0; j < B[0].length; j++) {
+      let sum = 0;
+      for (let k = 0; k < A[0].length; k++) {
+        sum += A[i][k] * B[k][j];
+      }
+      result[i][j] = sum;
+    }
+  }
+  return result;
+}
+
+function solve(A, b) {
+  const n = A.length;
+  const aug = A.map((row, i) => [...row, b[i][0]]);
+
+  for (let i = 0; i < n; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k < n; k++) {
+      if (Math.abs(aug[k][i]) > Math.abs(aug[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+
+    [aug[i], aug[maxRow]] = [aug[maxRow], aug[i]];
+
+    for (let k = i + 1; k < n; k++) {
+      const factor = aug[k][i] / aug[i][i];
+      for (let j = i; j < n + 1; j++) {
+        aug[k][j] -= factor * aug[i][j];
+      }
+    }
+  }
+
+  const x = new Array(n);
+  for (let i = n - 1; i >= 0; i--) {
+    x[i] = aug[i][n];
+    for (let j = i + 1; j < n; j++) {
+      x[i] -= aug[i][j] * x[j];
+    }
+    x[i] /= aug[i][i];
+  }
+
+  return x.map(xi => [xi]);
+}

package/src/utils/resampling.js

@@ -0,0 +1,112 @@
+export function bootstrap(r, data, n, statistic) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new TypeError('data must be a non-empty array');
+  }
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+  if (typeof statistic !== 'function') {
+    throw new TypeError('statistic must be a function');
+  }
+
+  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);
+  }
+
+  return samples;
+}
+
+export function jackknife(data, statistic) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new TypeError('data must be a non-empty array');
+  }
+  if (typeof statistic !== 'function') {
+    throw new TypeError('statistic must be a function');
+  }
+
+  const n = data.length;
+  const samples = new Array(n);
+
+  for (let i = 0; i < n; i++) {
+    const subset = data.slice(0, i).concat(data.slice(i + 1));
+    samples[i] = statistic(subset);
+  }
+
+  return samples;
+}
+
+export function crossValidation(r, data, k, trainFn, testFn) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new TypeError('data must be a non-empty array');
+  }
+  if (typeof k !== 'number' || k < 2 || k !== Math.floor(k)) {
+    throw new RangeError('k must be an integer >= 2');
+  }
+  if (typeof trainFn !== 'function' || typeof testFn !== 'function') {
+    throw new TypeError('trainFn and testFn must be functions');
+  }
+
+  const n = data.length;
+  const foldSize = Math.floor(n / k);
+  const shuffled = [...data];
+  
+  for (let i = n - 1; i > 0; i--) {
+    const j = r.nextInt(i + 1);
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+
+  const scores = new Array(k);
+
+  for (let fold = 0; fold < k; fold++) {
+    const start = fold * foldSize;
+    const end = fold === k - 1 ? n : (fold + 1) * foldSize;
+    
+    const testSet = shuffled.slice(start, end);
+    const trainSet = shuffled.slice(0, start).concat(shuffled.slice(end));
+    
+    const model = trainFn(trainSet);
+    scores[fold] = testFn(model, testSet);
+  }
+
+  return scores;
+}
+
+export function permutationTest(r, data1, data2, testStatistic, n) {
+  if (!Array.isArray(data1) || !Array.isArray(data2)) {
+    throw new TypeError('data1 and data2 must be arrays');
+  }
+  if (typeof testStatistic !== 'function') {
+    throw new TypeError('testStatistic must be a function');
+  }
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const observed = testStatistic(data1, data2);
+  const combined = [...data1, ...data2];
+  const n1 = data1.length;
+  let count = 0;
+
+  for (let i = 0; i < n; i++) {
+    for (let j = combined.length - 1; j > 0; j--) {
+      const k = r.nextInt(j + 1);
+      [combined[j], combined[k]] = [combined[k], combined[j]];
+    }
+
+    const perm1 = combined.slice(0, n1);
+    const perm2 = combined.slice(n1);
+    
+    if (Math.abs(testStatistic(perm1, perm2)) >= Math.abs(observed)) {
+      count++;
+    }
+  }
+
+  return count / n;
+}