@cloudglides/nox 1.1.6 → 3.0.0

package/src/utils/optimization.js

@@ -0,0 +1,215 @@
+export function gradientDescent(f, df, x0, learningRate = 0.01, iterations = 100, tol = 1e-6) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  const history = [x];
+
+  for (let i = 0; i < iterations; i++) {
+    const grad = df(x);
+    const xNew = x - learningRate * grad;
+
+    if (Math.abs(xNew - x) < tol) {
+      history.push(xNew);
+      return { x: xNew, iterations: i + 1, value: f(xNew), history };
+    }
+
+    x = xNew;
+    history.push(x);
+  }
+
+  return { x, iterations, value: f(x), history };
+}
+
+export function momentumDescent(f, df, x0, learningRate = 0.01, momentum = 0.9, iterations = 100, tol = 1e-6) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  let velocity = 0;
+  const history = [x];
+
+  for (let i = 0; i < iterations; i++) {
+    const grad = df(x);
+    velocity = momentum * velocity + learningRate * grad;
+    const xNew = x - velocity;
+
+    if (Math.abs(xNew - x) < tol) {
+      history.push(xNew);
+      return { x: xNew, iterations: i + 1, value: f(xNew), history };
+    }
+
+    x = xNew;
+    history.push(x);
+  }
+
+  return { x, iterations, value: f(x), history };
+}
+
+export function adam(f, df, x0, learningRate = 0.001, iterations = 100, beta1 = 0.9, beta2 = 0.999, eps = 1e-8, tol = 1e-6) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  let m = 0;
+  let v = 0;
+  const history = [x];
+
+  for (let t = 1; t <= iterations; t++) {
+    const grad = df(x);
+    
+    m = beta1 * m + (1 - beta1) * grad;
+    v = beta2 * v + (1 - beta2) * grad * grad;
+
+    const mHat = m / (1 - Math.pow(beta1, t));
+    const vHat = v / (1 - Math.pow(beta2, t));
+
+    const xNew = x - learningRate * mHat / (Math.sqrt(vHat) + eps);
+
+    if (Math.abs(xNew - x) < tol) {
+      history.push(xNew);
+      return { x: xNew, iterations: t, value: f(xNew), history };
+    }
+
+    x = xNew;
+    history.push(x);
+  }
+
+  return { x, iterations, value: f(x), history };
+}
+
+export function simplex(f, vertices, maxIter = 1000, tol = 1e-6) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (!Array.isArray(vertices) || vertices.length < 2) {
+    throw new TypeError('vertices must be array of points');
+  }
+
+  const n = vertices[0].length;
+  let currentVertices = vertices.map(v => [...v]);
+
+  for (let iter = 0; iter < maxIter; iter++) {
+    const values = currentVertices.map(f);
+    
+    const sorted = currentVertices.map((v, i) => [v, values[i]])
+      .sort((a, b) => a[1] - b[1]);
+
+    if (sorted[sorted.length - 1][1] - sorted[0][1] < tol) {
+      return { min: sorted[0][0], value: sorted[0][1], iterations: iter };
+    }
+
+    const best = sorted.slice(0, n).map(x => x[0]);
+    const worst = sorted[sorted.length - 1][0];
+
+    const centroid = new Array(n);
+    for (let i = 0; i < n; i++) {
+      centroid[i] = best.reduce((sum, v) => sum + v[i], 0) / n;
+    }
+
+    const reflected = centroid.map((x, i) => x + (x - worst[i]));
+    const reflectedValue = f(reflected);
+
+    if (reflectedValue < sorted[0][1]) {
+      currentVertices = [...best, reflected];
+    } else if (reflectedValue < sorted[n - 1][1]) {
+      currentVertices = [...best, reflected];
+    } else {
+      const contracted = centroid.map((x, i) => x + 0.5 * (worst[i] - x));
+      currentVertices = [...best, contracted];
+    }
+  }
+
+  const values = currentVertices.map(f);
+  const minIdx = values.indexOf(Math.min(...values));
+  return { min: currentVertices[minIdx], value: values[minIdx], iterations: maxIter };
+}
+
+export function brent(f, a, b, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  
+  let fa = f(a);
+  let fb = f(b);
+  
+  if (fa * fb > 0) {
+    throw new RangeError('f(a) and f(b) must have opposite signs');
+  }
+
+  if (Math.abs(fa) < Math.abs(fb)) {
+    [a, b] = [b, a];
+    [fa, fb] = [fb, fa];
+  }
+
+  let c = a;
+  let fc = fa;
+  let d = b - a;
+  let e = d;
+
+  for (let i = 0; i < maxIter; i++) {
+    if (Math.abs(fc) < Math.abs(fb)) {
+      a = b;
+      b = c;
+      c = a;
+      fa = fb;
+      fb = fc;
+      fc = fa;
+    }
+
+    const tol1 = tol * Math.abs(b) + 1e-12;
+    const xm = 0.5 * (c - b);
+
+    if (Math.abs(xm) <= tol1 || Math.abs(fb) < 1e-14) {
+      return { root: b, iterations: i + 1, residual: Math.abs(fb) };
+    }
+
+    if (Math.abs(e) >= tol1 && Math.abs(fa) > Math.abs(fb)) {
+      let s = fb / fa;
+      let p, q;
+
+      if (Math.abs(a - c) < 1e-14) {
+        p = 2 * xm * s;
+        q = 1 - s;
+      } else {
+        q = fa / fc;
+        const r = fb / fc;
+        p = s * (2 * xm * q * (q - r) - (b - a) * (r - 1));
+        q = (q - 1) * (r - 1) * (s - 1);
+      }
+
+      if (p > 0) q = -q;
+      else p = -p;
+
+      if (2 * p < 3 * xm * q - Math.abs(tol1 * q) && p < Math.abs(0.5 * e * q)) {
+        e = d;
+        d = p / q;
+      } else {
+        d = xm;
+        e = d;
+      }
+    } else {
+      d = xm;
+      e = d;
+    }
+
+    a = b;
+    fa = fb;
+    b += Math.abs(d) > tol1 ? d : (xm > 0 ? tol1 : -tol1);
+    fb = f(b);
+  }
+
+  return { root: b, iterations: maxIter, residual: Math.abs(fb) };
+}

package/src/utils/polynomial.js

@@ -0,0 +1,136 @@
+export class PolynomialRegression {
+  constructor(x, y, degree = 2) {
+    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 (typeof degree !== 'number' || degree < 1) {
+      throw new RangeError('degree must be positive integer');
+    }
+    if (x.length <= degree) {
+      throw new RangeError('need at least degree+1 data points');
+    }
+
+    const n = x.length;
+    this.degree = degree;
+
+    const X = x.map(xi => {
+      const row = [1];
+      for (let d = 1; d <= degree; d++) {
+        row.push(Math.pow(xi, d));
+      }
+      return row;
+    });
+
+    const XtX = matmul(transpose(X), X);
+    const Xty = matmul(transpose(X), y.map(yi => [yi]));
+
+    this.coefficients = solve(XtX, Xty).flat();
+
+    const yPred = x.map(xi => {
+      let pred = this.coefficients[0];
+      for (let d = 1; d <= degree; d++) {
+        pred += this.coefficients[d] * Math.pow(xi, d);
+      }
+      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 - degree - 1);
+    this.rmse = Math.sqrt(ssRes / n);
+    this.predictions = yPred;
+    this.residuals = y.map((yi, i) => yi - yPred[i]);
+  }
+
+  predict(x) {
+    if (typeof x === 'number') {
+      let pred = this.coefficients[0];
+      for (let d = 1; d <= this.degree; d++) {
+        pred += this.coefficients[d] * Math.pow(x, d);
+      }
+      return pred;
+    }
+
+    if (Array.isArray(x)) {
+      return x.map(xi => {
+        let pred = this.coefficients[0];
+        for (let d = 1; d <= this.degree; d++) {
+          pred += this.coefficients[d] * Math.pow(xi, d);
+        }
+        return pred;
+      });
+    }
+
+    throw new TypeError('x must be number or array');
+  }
+}
+
+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/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);
+}