@cloudglides/nox 1.1.6 → 3.0.0

package/src/utils/pvalues.js

@@ -0,0 +1,142 @@
+export function tTestPValue(t, df, twoTailed = true) {
+  if (typeof t !== 'number' || typeof df !== 'number') {
+    throw new TypeError('t and df must be numbers');
+  }
+
+  const tAbs = Math.abs(t);
+  let p = 2 * (1 - tCDF(tAbs, df));
+  
+  return twoTailed ? p : p / 2;
+}
+
+export function zTestPValue(z, twoTailed = true) {
+  if (typeof z !== 'number') {
+    throw new TypeError('z must be number');
+  }
+
+  const zAbs = Math.abs(z);
+  const p = 2 * (1 - normalCDF(zAbs));
+  
+  return twoTailed ? p : p / 2;
+}
+
+export function fTestPValue(f, df1, df2) {
+  if (typeof f !== 'number' || typeof df1 !== 'number' || typeof df2 !== 'number') {
+    throw new TypeError('f, df1, df2 must be numbers');
+  }
+
+  if (f < 0) return 1;
+  
+  const alpha = df2 / (df1 * f + df2);
+  return 1 - incompleteBeta(alpha, df2 / 2, df1 / 2);
+}
+
+export function chi2PValue(chi2, df) {
+  if (typeof chi2 !== 'number' || typeof df !== 'number') {
+    throw new TypeError('chi2 and df must be numbers');
+  }
+
+  if (chi2 < 0) return 1;
+  
+  return 1 - incompleteBeta(chi2 / (chi2 + 1), 1, df / 2);
+}
+
+export function uTestPValue(u, n1, n2) {
+  if (typeof u !== 'number' || typeof n1 !== 'number' || typeof n2 !== 'number') {
+    throw new TypeError('u, n1, n2 must be numbers');
+  }
+
+  const mean = (n1 * n2) / 2;
+  const std = Math.sqrt((n1 * n2 * (n1 + n2 + 1)) / 12);
+  const z = Math.abs((u - mean) / std);
+  
+  return 2 * (1 - normalCDF(z));
+}
+
+export function pearsonPValue(r, n) {
+  if (typeof r !== 'number' || typeof n !== 'number') {
+    throw new TypeError('r and n must be numbers');
+  }
+
+  if (Math.abs(r) >= 1) return 0;
+  
+  const t = r * Math.sqrt((n - 2) / (1 - r * r));
+  const df = n - 2;
+  
+  return tTestPValue(t, df, true);
+}
+
+function normalCDF(z) {
+  return 0.5 * (1 + erf(z / Math.sqrt(2)));
+}
+
+function tCDF(t, df) {
+  const x = df / (df + t * t);
+  return 1 - incompleteBeta(x, df / 2, 0.5);
+}
+
+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 incompleteBeta(x, a, b, maxIter = 100) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+
+  let sum = 1;
+  let term = 1;
+  
+  for (let i = 1; i <= maxIter; i++) {
+    term *= (a + b - 1) * x / ((a + i - 1) * (1 - x / (a + i)));
+    const nextSum = sum + term;
+    
+    if (Math.abs(nextSum - sum) < 1e-14) {
+      break;
+    }
+    sum = nextSum;
+  }
+  
+  return sum * Math.exp(a * Math.log(x) + b * Math.log(1 - x) - logBeta(a, b)) / a;
+}
+
+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;
+}

package/src/utils/rootfinding.js

@@ -0,0 +1,158 @@
+export function bisection(f, a, b, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+  if (a >= b) {
+    throw new RangeError('a must be less than b');
+  }
+
+  const fa = f(a);
+  const fb = f(b);
+
+  if (fa * fb > 0) {
+    throw new RangeError('f(a) and f(b) must have opposite signs');
+  }
+
+  let c, fc;
+  for (let i = 0; i < maxIter; i++) {
+    c = (a + b) / 2;
+    fc = f(c);
+
+    if (Math.abs(fc) < tol || Math.abs(b - a) / 2 < tol) {
+      return { root: c, iterations: i + 1, residual: Math.abs(fc) };
+    }
+
+    if (fa * fc < 0) {
+      b = c;
+      fb = fc;
+    } else {
+      a = c;
+      fa = fc;
+    }
+  }
+
+  return { root: c, iterations: maxIter, residual: Math.abs(fc) };
+}
+
+export function newtonRaphson(f, df, x0, tol = 1e-6, maxIter = 100) {
+  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;
+  for (let i = 0; i < maxIter; i++) {
+    const fx = f(x);
+    const dfx = df(x);
+
+    if (Math.abs(dfx) < 1e-14) {
+      throw new RangeError('derivative too close to zero');
+    }
+
+    const xNew = x - fx / dfx;
+
+    if (Math.abs(xNew - x) < tol) {
+      return { root: xNew, iterations: i + 1, residual: Math.abs(f(xNew)) };
+    }
+
+    x = xNew;
+  }
+
+  return { root: x, iterations: maxIter, residual: Math.abs(f(x)) };
+}
+
+export function secant(f, x0, x1, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof x0 !== 'number' || typeof x1 !== 'number') {
+    throw new TypeError('x0 and x1 must be numbers');
+  }
+
+  let xPrev = x0;
+  let xCurr = x1;
+  let fPrev = f(xPrev);
+  let fCurr = f(xCurr);
+
+  for (let i = 0; i < maxIter; i++) {
+    if (Math.abs(fCurr - fPrev) < 1e-14) {
+      throw new RangeError('denominator too close to zero');
+    }
+
+    const xNext = xCurr - fCurr * (xCurr - xPrev) / (fCurr - fPrev);
+
+    if (Math.abs(xNext - xCurr) < tol) {
+      return { root: xNext, iterations: i + 1, residual: Math.abs(f(xNext)) };
+    }
+
+    xPrev = xCurr;
+    xCurr = xNext;
+    fPrev = fCurr;
+    fCurr = f(xCurr);
+  }
+
+  return { root: xCurr, iterations: maxIter, residual: Math.abs(fCurr) };
+}
+
+export function falsePosition(f, a, b, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+
+  let fa = f(a);
+  let fb = f(b);
+
+  if (fa * fb > 0) {
+    throw new RangeError('f(a) and f(b) must have opposite signs');
+  }
+
+  for (let i = 0; i < maxIter; i++) {
+    const c = a - (fa * (b - a)) / (fb - fa);
+    const fc = f(c);
+
+    if (Math.abs(fc) < tol) {
+      return { root: c, iterations: i + 1, residual: Math.abs(fc) };
+    }
+
+    if (fa * fc < 0) {
+      b = c;
+      fb = fc;
+    } else {
+      a = c;
+      fa = fc;
+    }
+  }
+
+  const c = a - (fa * (b - a)) / (fb - fa);
+  return { root: c, iterations: maxIter, residual: Math.abs(f(c)) };
+}
+
+export function fixedPoint(g, x0, tol = 1e-6, maxIter = 100) {
+  if (typeof g !== 'function') {
+    throw new TypeError('g must be function');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  for (let i = 0; i < maxIter; i++) {
+    const xNew = g(x);
+
+    if (Math.abs(xNew - x) < tol) {
+      return { root: xNew, iterations: i + 1, residual: Math.abs(xNew - x) };
+    }
+
+    x = xNew;
+  }
+
+  return { root: x, iterations: maxIter, residual: Math.abs(g(x) - x) };
+}