@cloudglides/nox 2.0.0 → 3.0.0

package/src/utils/diagnostics.js

@@ -0,0 +1,309 @@
+export function residualDiagnostics(model) {
+  if (!model.residuals || !model.predictions) {
+    throw new TypeError('model must have residuals and predictions');
+  }
+
+  const residuals = model.residuals;
+  const predictions = model.predictions;
+  const n = residuals.length;
+
+  const mean = residuals.reduce((a, b) => a + b, 0) / n;
+  let variance = 0;
+  for (let i = 0; i < n; i++) {
+    variance += (residuals[i] - mean) ** 2;
+  }
+  variance /= (n - 1);
+  const stddev = Math.sqrt(variance);
+
+  const standardized = residuals.map(r => r / stddev);
+
+  const studentized = residuals.map((r, i) => {
+    const leverage = 1 / n;
+    const se = stddev * Math.sqrt(1 - leverage);
+    return r / se;
+  });
+
+  const qqData = [...standardized].sort((a, b) => a - b);
+  const qqTheoretical = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const p = (i + 0.5) / n;
+    qqTheoretical[i] = invNormal(p);
+  }
+
+  let correlation = 0;
+  let sumX2 = 0, sumY2 = 0;
+  for (let i = 0; i < n; i++) {
+    correlation += qqData[i] * qqTheoretical[i];
+    sumX2 += qqData[i] * qqData[i];
+    sumY2 += qqTheoretical[i] * qqTheoretical[i];
+  }
+  const qqCorr = correlation / Math.sqrt(sumX2 * sumY2);
+
+  return {
+    residuals,
+    standardized,
+    studentized,
+    mean,
+    variance,
+    stddev,
+    qqCorrelation: qqCorr,
+    qqData,
+    qqTheoretical
+  };
+}
+
+export function leverageValues(X) {
+  if (!Array.isArray(X) || X.length === 0) {
+    throw new TypeError('X must be non-empty array');
+  }
+
+  const n = X.length;
+  const p = Array.isArray(X[0]) ? X[0].length : 1;
+
+  const Xmat = X.map(row => Array.isArray(row) ? [1, ...row] : [1, row]);
+  const XtX = matmul(transpose(Xmat), Xmat);
+  
+  let invXtX;
+  try {
+    invXtX = matrixInverse(XtX);
+  } catch {
+    throw new RangeError('X matrix is singular');
+  }
+
+  const leverages = new Array(n);
+  for (let i = 0; i < n; i++) {
+    let leverage = 0;
+    for (let j = 0; j <= p; j++) {
+      for (let k = 0; k <= p; k++) {
+        leverage += Xmat[i][j] * invXtX[j][k] * Xmat[i][k];
+      }
+    }
+    leverages[i] = leverage;
+  }
+
+  return leverages;
+}
+
+export function cookDistance(residuals, predictions, leverage, n, p) {
+  if (!Array.isArray(residuals) || !Array.isArray(predictions)) {
+    throw new TypeError('residuals and predictions must be arrays');
+  }
+
+  const sigma2 = residuals.reduce((s, r) => s + r * r, 0) / (n - p - 1);
+  const cooks = new Array(n);
+
+  for (let i = 0; i < n; i++) {
+    const lev = leverage[i];
+    cooks[i] = (residuals[i] ** 2 / (sigma2 * (p + 1))) * (lev / (1 - lev));
+  }
+
+  return cooks;
+}
+
+export function durwinWatson(residuals) {
+  if (!Array.isArray(residuals) || residuals.length < 2) {
+    throw new TypeError('residuals must be array of length >= 2');
+  }
+
+  let numerator = 0;
+  let denominator = 0;
+
+  for (let i = 1; i < residuals.length; i++) {
+    const diff = residuals[i] - residuals[i - 1];
+    numerator += diff * diff;
+  }
+
+  for (let i = 0; i < residuals.length; i++) {
+    denominator += residuals[i] * residuals[i];
+  }
+
+  return numerator / denominator;
+}
+
+export function vif(X) {
+  if (!Array.isArray(X) || X.length === 0) {
+    throw new TypeError('X must be non-empty array of features');
+  }
+
+  const n = X.length;
+  const p = Array.isArray(X[0]) ? X[0].length : 1;
+  const vifs = new Array(p);
+
+  for (let j = 0; j < p; j++) {
+    const y = X.map(row => Array.isArray(row) ? row[j] : row);
+    const Xj = X.map((row, i) => {
+      const features = Array.isArray(row) ? row : [row];
+      return features.filter((_, k) => k !== j);
+    });
+
+    if (Xj[0].length === 0) {
+      vifs[j] = 1;
+      continue;
+    }
+
+    const r2 = computeR2(Xj, y);
+    vifs[j] = 1 / (1 - r2);
+  }
+
+  return vifs;
+}
+
+function computeR2(X, y) {
+  const n = X.length;
+  const yMean = y.reduce((a, b) => a + b, 0) / n;
+  
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    ssTot += (y[i] - yMean) ** 2;
+  }
+
+  const Xmat = X.map(row => Array.isArray(row) ? [1, ...row] : [1, row]);
+  const XtX = matmul(transpose(Xmat), Xmat);
+  const Xty = matmul(transpose(Xmat), y.map(yi => [yi]));
+  
+  let beta;
+  try {
+    beta = solve(XtX, Xty).flat();
+  } catch {
+    return 0;
+  }
+
+  let ssRes = 0;
+  for (let i = 0; i < n; i++) {
+    let pred = beta[0];
+    for (let j = 1; j < beta.length; j++) {
+      pred += beta[j] * (Array.isArray(X[i]) ? X[i][j - 1] : X[i]);
+    }
+    ssRes += (y[i] - pred) ** 2;
+  }
+
+  return 1 - (ssRes / ssTot);
+}
+
+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]];
+
+    if (Math.abs(aug[i][i]) < 1e-10) {
+      throw new RangeError('matrix is singular');
+    }
+
+    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]);
+}
+
+function matrixInverse(A) {
+  const n = A.length;
+  const aug = A.map((row, i) => {
+    const augRow = [...row];
+    for (let j = 0; j < n; j++) {
+      augRow.push(i === j ? 1 : 0);
+    }
+    return augRow;
+  });
+
+  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]];
+
+    const pivot = aug[i][i];
+    for (let j = 0; j < 2 * n; j++) {
+      aug[i][j] /= pivot;
+    }
+
+    for (let k = 0; k < n; k++) {
+      if (k !== i) {
+        const factor = aug[k][i];
+        for (let j = 0; j < 2 * n; j++) {
+          aug[k][j] -= factor * aug[i][j];
+        }
+      }
+    }
+  }
+
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = aug[i].slice(n);
+  }
+  return result;
+}
+
+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);
+  }
+}

package/src/utils/logistic.js

@@ -0,0 +1,91 @@
+export class LogisticRegression {
+  constructor(X, y, learningRate = 0.01, iterations = 1000) {
+    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)');
+    }
+    if (y.some(val => val !== 0 && val !== 1)) {
+      throw new RangeError('y must contain only 0 and 1 (binary classification)');
+    }
+
+    const n = X.length;
+    const p = X[0].length;
+
+    this.coefficients = new Array(p + 1).fill(0);
+    this.learningRate = learningRate;
+    this.iterations = iterations;
+
+    for (let iter = 0; iter < iterations; iter++) {
+      const gradients = new Array(p + 1).fill(0);
+
+      for (let i = 0; i < n; i++) {
+        let z = this.coefficients[0];
+        for (let j = 0; j < p; j++) {
+          z += this.coefficients[j + 1] * X[i][j];
+        }
+
+        const sigmoid = 1 / (1 + Math.exp(-z));
+        const error = sigmoid - y[i];
+
+        gradients[0] += error;
+        for (let j = 0; j < p; j++) {
+          gradients[j + 1] += error * X[i][j];
+        }
+      }
+
+      for (let j = 0; j < p + 1; j++) {
+        this.coefficients[j] -= (learningRate / n) * gradients[j];
+      }
+    }
+
+    this.intercept = this.coefficients[0];
+  }
+
+  predict(X) {
+    if (typeof X[0] === 'number') {
+      let z = this.intercept;
+      for (let i = 0; i < X.length; i++) {
+        z += this.coefficients[i + 1] * X[i];
+      }
+      return 1 / (1 + Math.exp(-z));
+    }
+
+    return X.map(row => {
+      let z = this.intercept;
+      for (let i = 0; i < row.length; i++) {
+        z += this.coefficients[i + 1] * row[i];
+      }
+      return 1 / (1 + Math.exp(-z));
+    });
+  }
+
+  predictClass(X, threshold = 0.5) {
+    const probs = this.predict(X);
+    if (Array.isArray(probs)) {
+      return probs.map(p => p >= threshold ? 1 : 0);
+    }
+    return probs >= threshold ? 1 : 0;
+  }
+
+  evaluate(X, y) {
+    if (X.length !== y.length) {
+      throw new RangeError('X and y must have same length');
+    }
+
+    const predictions = this.predictClass(X);
+    let correct = 0;
+
+    for (let i = 0; i < y.length; i++) {
+      if (predictions[i] === y[i]) {
+        correct++;
+      }
+    }
+
+    return correct / y.length;
+  }
+}

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/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);
+}