@cloudglides/nox 1.1.6 → 3.0.0

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