regressio 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2505 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core/distributions.ts
+var exports_distributions = {};
+__export(exports_distributions, {
+  tTestPValue: () => tTestPValue,
+  tPDF: () => tPDF,
+  tInverseCDF: () => tInverseCDF,
+  tCDF: () => tCDF,
+  regularizedIncompleteBeta: () => regularizedIncompleteBeta,
+  normalPDF: () => normalPDF,
+  normalInverseCDF: () => normalInverseCDF,
+  normalCDF: () => normalCDF,
+  logGamma: () => logGamma,
+  logBeta: () => logBeta,
+  inverseErf: () => inverseErf,
+  fTestPValue: () => fTestPValue,
+  fPDF: () => fPDF,
+  fInverseCDF: () => fInverseCDF,
+  fCDF: () => fCDF,
+  erf: () => erf,
+  chi2TestPValue: () => chi2TestPValue,
+  chi2PDF: () => chi2PDF,
+  chi2InverseCDF: () => chi2InverseCDF,
+  chi2CDFExact: () => chi2CDFExact,
+  chi2CDF: () => chi2CDF
+});
+function logGamma(x) {
+  if (x <= 0)
+    throw new Error("logGamma: x must be positive");
+  if (x < 0.5) {
+    return Math.log(Math.PI / Math.sin(Math.PI * x)) - logGamma(1 - x);
+  }
+  x -= 1;
+  let a = LANCZOS_COEFFS[0];
+  for (let i = 1;i < LANCZOS_G + 2; i++) {
+    a += LANCZOS_COEFFS[i] / (x + i);
+  }
+  const t = x + LANCZOS_G + 0.5;
+  return 0.5 * Math.log(2 * Math.PI) + (x + 0.5) * Math.log(t) - t + Math.log(a);
+}
+function logBeta(a, b) {
+  return logGamma(a) + logGamma(b) - logGamma(a + b);
+}
+function regularizedIncompleteBeta(x, a, b) {
+  if (x <= 0)
+    return 0;
+  if (x >= 1)
+    return 1;
+  if (x > (a + 1) / (a + b + 2)) {
+    return 1 - regularizedIncompleteBeta(1 - x, b, a);
+  }
+  const lnPrefix = a * Math.log(x) + b * Math.log(1 - x) - logBeta(a, b) - Math.log(a);
+  const maxIter = 200;
+  const eps = 0.00000000000001;
+  const tiny = 0.000000000000000000000000000001;
+  let c = 1;
+  let d = 1 - (a + b) * x / (a + 1);
+  if (Math.abs(d) < tiny)
+    d = tiny;
+  d = 1 / d;
+  let h = d;
+  for (let m = 1;m <= maxIter; m++) {
+    const m2 = 2 * m;
+    let num = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
+    d = 1 + num * d;
+    if (Math.abs(d) < tiny)
+      d = tiny;
+    c = 1 + num / c;
+    if (Math.abs(c) < tiny)
+      c = tiny;
+    d = 1 / d;
+    h *= d * c;
+    num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
+    d = 1 + num * d;
+    if (Math.abs(d) < tiny)
+      d = tiny;
+    c = 1 + num / c;
+    if (Math.abs(c) < tiny)
+      c = tiny;
+    d = 1 / d;
+    const delta = d * c;
+    h *= delta;
+    if (Math.abs(delta - 1) < eps)
+      break;
+  }
+  return Math.exp(lnPrefix) * h;
+}
+function erf(x) {
+  if (x === 0)
+    return 0;
+  const sign = x >= 0 ? 1 : -1;
+  const ax = Math.abs(x);
+  if (ax < 0.5) {
+    const x2 = ax * ax;
+    let term = ax;
+    let sum = ax;
+    for (let n = 1;n < 30; n++) {
+      term *= -x2 / n;
+      sum += term / (2 * n + 1);
+    }
+    return sign * (2 / Math.sqrt(Math.PI)) * sum;
+  }
+  const t = 1 / (1 + 0.3275911 * ax);
+  const poly = t * (0.254829592 + t * (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429))));
+  return sign * (1 - poly * Math.exp(-ax * ax));
+}
+function inverseErf(x) {
+  if (x <= -1)
+    return -Infinity;
+  if (x >= 1)
+    return Infinity;
+  const a = 0.147;
+  const ln1mx2 = Math.log(1 - x * x);
+  const term = 2 / (Math.PI * a) + ln1mx2 / 2;
+  const sign = x >= 0 ? 1 : -1;
+  return sign * Math.sqrt(Math.sqrt(term * term - ln1mx2 / a) - term);
+}
+function normalPDF(x, mu = 0, sigma = 1) {
+  const z = (x - mu) / sigma;
+  return Math.exp(-0.5 * z * z) / (sigma * Math.sqrt(2 * Math.PI));
+}
+function normalCDF(x, mu = 0, sigma = 1) {
+  return 0.5 * (1 + erf((x - mu) / (sigma * Math.SQRT2)));
+}
+function normalInverseCDF(p, mu = 0, sigma = 1) {
+  return mu + sigma * Math.SQRT2 * inverseErf(2 * p - 1);
+}
+function tPDF(t, df) {
+  const coeff = Math.exp(logGamma((df + 1) / 2) - logGamma(df / 2));
+  return coeff / Math.sqrt(df * Math.PI) * (1 + t * t / df) ** (-(df + 1) / 2);
+}
+function tCDF(t, df) {
+  if (df <= 0)
+    throw new Error("tCDF: df must be positive");
+  const x = df / (t * t + df);
+  const ib = regularizedIncompleteBeta(x, df / 2, 0.5);
+  return t >= 0 ? 1 - 0.5 * ib : 0.5 * ib;
+}
+function tInverseCDF(p, df) {
+  if (p <= 0)
+    return -Infinity;
+  if (p >= 1)
+    return Infinity;
+  if (Math.abs(p - 0.5) < 0.000000000000001)
+    return 0;
+  let lo = -1000;
+  let hi = 1000;
+  for (let i = 0;i < 100; i++) {
+    const mid = (lo + hi) / 2;
+    if (tCDF(mid, df) < p) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return (lo + hi) / 2;
+}
+function tTestPValue(tStat, df) {
+  return 2 * (1 - tCDF(Math.abs(tStat), df));
+}
+function fPDF(x, df1, df2) {
+  if (x <= 0)
+    return 0;
+  const half1 = df1 / 2;
+  const half2 = df2 / 2;
+  const lnCoeff = half1 * Math.log(df1) + half2 * Math.log(df2) - logBeta(half1, half2);
+  return Math.exp(lnCoeff + (half1 - 1) * Math.log(x) - (half1 + half2) * Math.log(df1 * x + df2));
+}
+function fCDF(x, df1, df2) {
+  if (x <= 0)
+    return 0;
+  const z = df1 * x / (df1 * x + df2);
+  return regularizedIncompleteBeta(z, df1 / 2, df2 / 2);
+}
+function fInverseCDF(p, df1, df2) {
+  if (p <= 0)
+    return 0;
+  if (p >= 1)
+    return Infinity;
+  let lo = 0;
+  let hi = 1000;
+  while (fCDF(hi, df1, df2) < p)
+    hi *= 2;
+  for (let i = 0;i < 100; i++) {
+    const mid = (lo + hi) / 2;
+    if (fCDF(mid, df1, df2) < p) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return (lo + hi) / 2;
+}
+function fTestPValue(fStat, df1, df2) {
+  return 1 - fCDF(fStat, df1, df2);
+}
+function chi2PDF(x, df) {
+  if (x <= 0)
+    return 0;
+  const k2 = df / 2;
+  return Math.exp((k2 - 1) * Math.log(x) - x / 2 - k2 * Math.LN2 - logGamma(k2));
+}
+function chi2CDF(x, df) {
+  return chi2CDFExact(x, df);
+}
+function chi2CDFExact(x, df) {
+  if (x <= 0)
+    return 0;
+  return regularizedLowerGamma(df / 2, x / 2);
+}
+function regularizedLowerGamma(a, x) {
+  if (x <= 0)
+    return 0;
+  if (x < a + 1) {
+    return lowerGammaSeries(a, x);
+  }
+  return 1 - upperGammaCF(a, x);
+}
+function lowerGammaSeries(a, x) {
+  let term = 1 / a;
+  let sum = term;
+  for (let n = 1;n < 300; n++) {
+    term *= x / (a + n);
+    sum += term;
+    if (Math.abs(term) < 0.000000000000001 * Math.abs(sum))
+      break;
+  }
+  return sum * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGammaCF(a, x) {
+  const tiny = 0.000000000000000000000000000001;
+  let b = x + 1 - a;
+  let c = 1 / tiny;
+  let d = 1 / b;
+  let h = d;
+  for (let n = 1;n < 300; n++) {
+    const an = -n * (n - a);
+    b += 2;
+    d = an * d + b;
+    if (Math.abs(d) < tiny)
+      d = tiny;
+    c = b + an / c;
+    if (Math.abs(c) < tiny)
+      c = tiny;
+    d = 1 / d;
+    const delta = d * c;
+    h *= delta;
+    if (Math.abs(delta - 1) < 0.000000000000001)
+      break;
+  }
+  return h * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function chi2InverseCDF(p, df) {
+  if (p <= 0)
+    return 0;
+  if (p >= 1)
+    return Infinity;
+  let lo = 0;
+  let hi = Math.max(df * 4, 100);
+  while (chi2CDFExact(hi, df) < p)
+    hi *= 2;
+  for (let i = 0;i < 100; i++) {
+    const mid = (lo + hi) / 2;
+    if (chi2CDFExact(mid, df) < p) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return (lo + hi) / 2;
+}
+function chi2TestPValue(stat, df) {
+  return 1 - chi2CDFExact(stat, df);
+}
+var LANCZOS_G = 7, LANCZOS_COEFFS;
+var init_distributions = __esm(() => {
+  LANCZOS_COEFFS = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    0.000009984369578019572,
+    0.00000015056327351493116
+  ];
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  vif: () => vif,
+  useWasmModule: () => useWasmModule,
+  useWasmEngine: () => useWasmEngine,
+  useTypescriptEngine: () => useTypescriptEngine,
+  unstandardize: () => unstandardize,
+  unnormalize: () => unnormalize,
+  studentizedResiduals: () => studentizedResiduals,
+  standardize: () => standardize,
+  shapiroWilk: () => shapiroWilk,
+  residualDiagnostics: () => residualDiagnostics,
+  predictionInterval: () => predictionInterval,
+  polynomialFeatures: () => polynomialFeatures,
+  oneHotEncode: () => oneHotEncode,
+  normalize: () => normalize,
+  leverage: () => leverage,
+  isWasmActive: () => isWasmActive,
+  interactionFeatures: () => interactionFeatures,
+  imputeMedian: () => imputeMedian,
+  imputeMean: () => imputeMean,
+  getEngine: () => getEngine,
+  durbinWatson: () => durbinWatson,
+  dropMissing: () => dropMissing,
+  correlationMatrix: () => correlationMatrix,
+  cooksDistance: () => cooksDistance,
+  confidenceInterval: () => confidenceInterval,
+  conditionNumber: () => conditionNumber,
+  breuschPagan: () => breuschPagan,
+  bootstrapCoefficients: () => bootstrapCoefficients,
+  WeightedRegression: () => WeightedRegression,
+  RobustRegression: () => RobustRegression,
+  RidgeRegression: () => RidgeRegression,
+  PolynomialRegression: () => PolynomialRegression,
+  NeuralNetwork: () => NeuralNetwork,
+  MulticlassLogisticRegression: () => MulticlassLogisticRegression,
+  Matrix: () => Matrix,
+  LogisticRegression: () => LogisticRegression,
+  LinearRegression: () => LinearRegression,
+  LassoRegression: () => LassoRegression,
+  KNearestNeighbors: () => KNearestNeighbors,
+  ElasticNet: () => ElasticNet
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/core/engine.ts
+var currentEngine = { name: "typescript" };
+function getEngine() {
+  return currentEngine;
+}
+function isWasmActive() {
+  return currentEngine.name === "wasm" && currentEngine.wasm != null;
+}
+async function useWasmEngine() {
+  try {
+    const wasm = await import("../../pkg");
+    currentEngine = { name: "wasm", wasm };
+  } catch {
+    throw new Error("WASM engine not available. Build it with: cd rust && wasm-pack build --target bundler --out-dir ../pkg");
+  }
+}
+function useWasmModule(wasmModule) {
+  currentEngine = { name: "wasm", wasm: wasmModule };
+}
+function useTypescriptEngine() {
+  currentEngine = { name: "typescript" };
+}
+function engineMatrixMultiply(a, aRows, aCols, b, bRows, bCols) {
+  if (currentEngine.wasm) {
+    return currentEngine.wasm.matrix_multiply(a, aRows, aCols, b, bRows, bCols);
+  }
+  const result = new Float64Array(aRows * bCols);
+  for (let i = 0;i < aRows; i++) {
+    for (let k = 0;k < aCols; k++) {
+      const aik = a[i * aCols + k];
+      for (let j = 0;j < bCols; j++) {
+        result[i * bCols + j] += aik * b[k * bCols + j];
+      }
+    }
+  }
+  return result;
+}
+function engineQR(data, rows, cols) {
+  if (currentEngine.wasm) {
+    const result = currentEngine.wasm.qr_decompose(data, rows, cols);
+    const qSize = rows * rows;
+    const Q = result.slice(0, qSize);
+    const R = result.slice(qSize);
+    return { Q, R };
+  }
+  return null;
+}
+function engineCholesky(data, n) {
+  if (currentEngine.wasm) {
+    return currentEngine.wasm.cholesky(data, n);
+  }
+  return null;
+}
+function engineSolveTriangular(r, b, n) {
+  if (currentEngine.wasm) {
+    return currentEngine.wasm.solve_triangular(r, b, n);
+  }
+  return null;
+}
+// src/core/matrix.ts
+class Matrix {
+  rows;
+  cols;
+  data;
+  constructor(rows, cols, data) {
+    this.rows = rows;
+    this.cols = cols;
+    if (data) {
+      this.data = data instanceof Float64Array ? data : new Float64Array(data);
+    } else {
+      this.data = new Float64Array(rows * cols);
+    }
+  }
+  static fromArray(arr) {
+    const rows = arr.length;
+    if (rows === 0)
+      return new Matrix(0, 0);
+    const cols = arr[0].length;
+    const data = new Float64Array(rows * cols);
+    for (let i = 0;i < rows; i++) {
+      const row = arr[i];
+      if (row.length !== cols) {
+        throw new Error(`Row ${i} has ${row.length} columns, expected ${cols}`);
+      }
+      for (let j = 0;j < cols; j++) {
+        data[i * cols + j] = row[j];
+      }
+    }
+    return new Matrix(rows, cols, data);
+  }
+  static zeros(rows, cols) {
+    return new Matrix(rows, cols);
+  }
+  static ones(rows, cols) {
+    const data = new Float64Array(rows * cols).fill(1);
+    return new Matrix(rows, cols, data);
+  }
+  static identity(n) {
+    const m = new Matrix(n, n);
+    for (let i = 0;i < n; i++) {
+      m.data[i * n + i] = 1;
+    }
+    return m;
+  }
+  static columnVector(arr) {
+    return new Matrix(arr.length, 1, new Float64Array(arr));
+  }
+  static rowVector(arr) {
+    return new Matrix(1, arr.length, new Float64Array(arr));
+  }
+  static diagonal(values) {
+    const n = values.length;
+    const m = new Matrix(n, n);
+    for (let i = 0;i < n; i++) {
+      m.data[i * n + i] = values[i];
+    }
+    return m;
+  }
+  get(i, j) {
+    return this.data[i * this.cols + j];
+  }
+  set(i, j, value) {
+    this.data[i * this.cols + j] = value;
+  }
+  getColumn(j) {
+    const col = new Float64Array(this.rows);
+    for (let i = 0;i < this.rows; i++) {
+      col[i] = this.data[i * this.cols + j];
+    }
+    return new Matrix(this.rows, 1, col);
+  }
+  getRow(i) {
+    const start = i * this.cols;
+    return new Matrix(1, this.cols, this.data.slice(start, start + this.cols));
+  }
+  setColumn(j, col) {
+    for (let i = 0;i < this.rows; i++) {
+      this.data[i * this.cols + j] = col.data[i];
+    }
+  }
+  transpose() {
+    const result = new Matrix(this.cols, this.rows);
+    for (let i = 0;i < this.rows; i++) {
+      for (let j = 0;j < this.cols; j++) {
+        result.data[j * this.rows + i] = this.data[i * this.cols + j];
+      }
+    }
+    return result;
+  }
+  multiply(other) {
+    if (this.cols !== other.rows) {
+      throw new Error(`Matrix multiply: incompatible dimensions (${this.rows}x${this.cols}) * (${other.rows}x${other.cols})`);
+    }
+    const resultData = engineMatrixMultiply(this.data, this.rows, this.cols, other.data, other.rows, other.cols);
+    return new Matrix(this.rows, other.cols, resultData);
+  }
+  add(other) {
+    this.assertSameDimensions(other, "add");
+    const result = new Matrix(this.rows, this.cols);
+    for (let i = 0;i < this.data.length; i++) {
+      result.data[i] = this.data[i] + other.data[i];
+    }
+    return result;
+  }
+  subtract(other) {
+    this.assertSameDimensions(other, "subtract");
+    const result = new Matrix(this.rows, this.cols);
+    for (let i = 0;i < this.data.length; i++) {
+      result.data[i] = this.data[i] - other.data[i];
+    }
+    return result;
+  }
+  scale(scalar) {
+    const result = new Matrix(this.rows, this.cols);
+    for (let i = 0;i < this.data.length; i++) {
+      result.data[i] = this.data[i] * scalar;
+    }
+    return result;
+  }
+  addInPlace(other) {
+    this.assertSameDimensions(other, "addInPlace");
+    for (let i = 0;i < this.data.length; i++) {
+      this.data[i] += other.data[i];
+    }
+  }
+  subtractInPlace(other) {
+    this.assertSameDimensions(other, "subtractInPlace");
+    for (let i = 0;i < this.data.length; i++) {
+      this.data[i] -= other.data[i];
+    }
+  }
+  scaleInPlace(scalar) {
+    for (let i = 0;i < this.data.length; i++) {
+      this.data[i] *= scalar;
+    }
+  }
+  norm() {
+    let sum = 0;
+    for (let i = 0;i < this.data.length; i++) {
+      sum += this.data[i] * this.data[i];
+    }
+    return Math.sqrt(sum);
+  }
+  trace() {
+    if (this.rows !== this.cols) {
+      throw new Error("Trace is only defined for square matrices");
+    }
+    let sum = 0;
+    for (let i = 0;i < this.rows; i++) {
+      sum += this.data[i * this.cols + i];
+    }
+    return sum;
+  }
+  determinant() {
+    if (this.rows !== this.cols) {
+      throw new Error("Determinant is only defined for square matrices");
+    }
+    const n = this.rows;
+    if (n === 0)
+      return 1;
+    if (n === 1)
+      return this.data[0];
+    if (n === 2)
+      return this.data[0] * this.data[3] - this.data[1] * this.data[2];
+    const a = new Float64Array(this.data);
+    let det = 1;
+    for (let col = 0;col < n; col++) {
+      let maxVal = Math.abs(a[col * n + col]);
+      let maxRow = col;
+      for (let row = col + 1;row < n; row++) {
+        const val = Math.abs(a[row * n + col]);
+        if (val > maxVal) {
+          maxVal = val;
+          maxRow = row;
+        }
+      }
+      if (maxVal < 0.000000000000001)
+        return 0;
+      if (maxRow !== col) {
+        det = -det;
+        for (let j = 0;j < n; j++) {
+          const tmp = a[col * n + j];
+          a[col * n + j] = a[maxRow * n + j];
+          a[maxRow * n + j] = tmp;
+        }
+      }
+      det *= a[col * n + col];
+      const pivot = a[col * n + col];
+      for (let row = col + 1;row < n; row++) {
+        const factor = a[row * n + col] / pivot;
+        for (let j = col + 1;j < n; j++) {
+          a[row * n + j] -= factor * a[col * n + j];
+        }
+      }
+    }
+    return det;
+  }
+  submatrix(rowStart, rowEnd, colStart, colEnd) {
+    const rows = rowEnd - rowStart;
+    const cols = colEnd - colStart;
+    const result = new Matrix(rows, cols);
+    for (let i = 0;i < rows; i++) {
+      for (let j = 0;j < cols; j++) {
+        result.data[i * cols + j] = this.data[(rowStart + i) * this.cols + (colStart + j)];
+      }
+    }
+    return result;
+  }
+  clone() {
+    return new Matrix(this.rows, this.cols, new Float64Array(this.data));
+  }
+  toArray() {
+    const result = [];
+    for (let i = 0;i < this.rows; i++) {
+      const row = [];
+      for (let j = 0;j < this.cols; j++) {
+        row.push(this.data[i * this.cols + j]);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  toFlatArray() {
+    return Array.from(this.data);
+  }
+  dot(other) {
+    let sum = 0;
+    for (let i = 0;i < this.data.length; i++) {
+      sum += this.data[i] * other.data[i];
+    }
+    return sum;
+  }
+  assertSameDimensions(other, op) {
+    if (this.rows !== other.rows || this.cols !== other.cols) {
+      throw new Error(`Matrix ${op}: incompatible dimensions (${this.rows}x${this.cols}) vs (${other.rows}x${other.cols})`);
+    }
+  }
+}
+// src/core/decompositions.ts
+function qrDecomposition(A) {
+  const m = A.rows;
+  const n = A.cols;
+  if (isWasmActive()) {
+    const wasmResult = engineQR(A.data, m, n);
+    if (wasmResult) {
+      return {
+        Q: new Matrix(m, m, wasmResult.Q),
+        R: new Matrix(m, n, wasmResult.R)
+      };
+    }
+  }
+  const R = A.clone();
+  const Q = Matrix.identity(m);
+  const minMN = Math.min(m, n);
+  for (let k = 0;k < minMN; k++) {
+    const x = new Float64Array(m - k);
+    for (let i = 0;i < m - k; i++) {
+      x[i] = R.get(k + i, k);
+    }
+    let xNorm = 0;
+    for (let i = 0;i < x.length; i++) {
+      xNorm += x[i] * x[i];
+    }
+    xNorm = Math.sqrt(xNorm);
+    if (xNorm < 0.000000000000001)
+      continue;
+    const alpha = x[0] >= 0 ? -xNorm : xNorm;
+    const v = new Float64Array(x);
+    v[0] -= alpha;
+    let vNorm = 0;
+    for (let i = 0;i < v.length; i++) {
+      vNorm += v[i] * v[i];
+    }
+    vNorm = Math.sqrt(vNorm);
+    if (vNorm < 0.000000000000001)
+      continue;
+    for (let i = 0;i < v.length; i++) {
+      v[i] /= vNorm;
+    }
+    for (let j = k;j < n; j++) {
+      let dot = 0;
+      for (let i = 0;i < v.length; i++) {
+        dot += v[i] * R.get(k + i, j);
+      }
+      for (let i = 0;i < v.length; i++) {
+        R.set(k + i, j, R.get(k + i, j) - 2 * v[i] * dot);
+      }
+    }
+    for (let i = 0;i < m; i++) {
+      let dot = 0;
+      for (let j = 0;j < v.length; j++) {
+        dot += Q.get(i, k + j) * v[j];
+      }
+      for (let j = 0;j < v.length; j++) {
+        Q.set(i, k + j, Q.get(i, k + j) - 2 * dot * v[j]);
+      }
+    }
+  }
+  return { Q, R };
+}
+function backSubstitution(R, b) {
+  const n = R.cols;
+  if (isWasmActive()) {
+    const bFlat = new Float64Array(n);
+    for (let i = 0;i < n; i++)
+      bFlat[i] = b.get(i, 0);
+    const wasmResult = engineSolveTriangular(R.data, bFlat, n);
+    if (wasmResult) {
+      return Matrix.columnVector(Array.from(wasmResult));
+    }
+  }
+  const x = new Float64Array(n);
+  for (let i = n - 1;i >= 0; i--) {
+    let sum = b.get(i, 0);
+    for (let j = i + 1;j < n; j++) {
+      sum -= R.get(i, j) * x[j];
+    }
+    const diag = R.get(i, i);
+    if (Math.abs(diag) < 0.000000000000001) {
+      throw new Error("Matrix is singular or near-singular (zero diagonal in R)");
+    }
+    x[i] = sum / diag;
+  }
+  return Matrix.columnVector(Array.from(x));
+}
+function solveQR(Q, R, b) {
+  const Qtb = Q.transpose().multiply(b);
+  const n = R.cols;
+  const Rsq = R.submatrix(0, n, 0, n);
+  const bTop = Qtb.submatrix(0, n, 0, 1);
+  return backSubstitution(Rsq, bTop);
+}
+function choleskyDecomposition(A) {
+  if (A.rows !== A.cols) {
+    throw new Error("Cholesky: matrix must be square");
+  }
+  const n = A.rows;
+  if (isWasmActive()) {
+    const wasmResult = engineCholesky(A.data, n);
+    if (wasmResult) {
+      return { L: new Matrix(n, n, wasmResult) };
+    }
+  }
+  const L = Matrix.zeros(n, n);
+  for (let j = 0;j < n; j++) {
+    let sum = 0;
+    for (let k = 0;k < j; k++) {
+      sum += L.get(j, k) * L.get(j, k);
+    }
+    const diag = A.get(j, j) - sum;
+    if (diag <= 0) {
+      throw new Error("Cholesky: matrix is not positive-definite");
+    }
+    L.set(j, j, Math.sqrt(diag));
+    for (let i = j + 1;i < n; i++) {
+      let s = 0;
+      for (let k = 0;k < j; k++) {
+        s += L.get(i, k) * L.get(j, k);
+      }
+      L.set(i, j, (A.get(i, j) - s) / L.get(j, j));
+    }
+  }
+  return { L };
+}
+function forwardSubstitution(L, b) {
+  const n = L.rows;
+  const y = new Float64Array(n);
+  for (let i = 0;i < n; i++) {
+    let sum = b.get(i, 0);
+    for (let j = 0;j < i; j++) {
+      sum -= L.get(i, j) * y[j];
+    }
+    y[i] = sum / L.get(i, i);
+  }
+  return Matrix.columnVector(Array.from(y));
+}
+function solveCholesky(L, b) {
+  const y = forwardSubstitution(L, b);
+  return backSubstitution(L.transpose(), y);
+}
+function svd(A) {
+  const m = A.rows;
+  const n = A.cols;
+  const k = Math.min(m, n);
+  const W = A.clone();
+  const V = Matrix.identity(n);
+  const maxIter = 100;
+  const tol = 0.000000000001;
+  for (let iter = 0;iter < maxIter; iter++) {
+    let converged = true;
+    for (let p = 0;p < n - 1; p++) {
+      for (let q = p + 1;q < n; q++) {
+        let app = 0;
+        let aqq = 0;
+        let apq = 0;
+        for (let i = 0;i < m; i++) {
+          const wp = W.get(i, p);
+          const wq = W.get(i, q);
+          app += wp * wp;
+          aqq += wq * wq;
+          apq += wp * wq;
+        }
+        if (Math.abs(apq) < tol * Math.sqrt(app * aqq))
+          continue;
+        converged = false;
+        const tau = (aqq - app) / (2 * apq);
+        const t = Math.sign(tau) / (Math.abs(tau) + Math.sqrt(1 + tau * tau));
+        const c = 1 / Math.sqrt(1 + t * t);
+        const s = t * c;
+        for (let i = 0;i < m; i++) {
+          const wp = W.get(i, p);
+          const wq = W.get(i, q);
+          W.set(i, p, c * wp - s * wq);
+          W.set(i, q, s * wp + c * wq);
+        }
+        for (let i = 0;i < n; i++) {
+          const vp = V.get(i, p);
+          const vq = V.get(i, q);
+          V.set(i, p, c * vp - s * vq);
+          V.set(i, q, s * vp + c * vq);
+        }
+      }
+    }
+    if (converged)
+      break;
+  }
+  const S = [];
+  const U = Matrix.zeros(m, k);
+  for (let j = 0;j < k; j++) {
+    let norm = 0;
+    for (let i = 0;i < m; i++) {
+      norm += W.get(i, j) * W.get(i, j);
+    }
+    norm = Math.sqrt(norm);
+    S.push(norm);
+    if (norm > 0.000000000000001) {
+      for (let i = 0;i < m; i++) {
+        U.set(i, j, W.get(i, j) / norm);
+      }
+    }
+  }
+  const indices = S.map((_, i) => i).sort((a, b) => S[b] - S[a]);
+  const sortedS = indices.map((i) => S[i]);
+  const sortedU = Matrix.zeros(m, k);
+  const sortedV = Matrix.zeros(n, k);
+  for (let j = 0;j < k; j++) {
+    const srcIdx = indices[j];
+    for (let i = 0;i < m; i++) {
+      sortedU.set(i, j, U.get(i, srcIdx));
+    }
+    for (let i = 0;i < n; i++) {
+      sortedV.set(i, j, V.get(i, srcIdx));
+    }
+  }
+  return { U: sortedU, S: sortedS, V: sortedV };
+}
+
+// src/models/base.ts
+init_distributions();
+class BaseRegression {
+  _coefficients = [];
+  _intercept = 0;
+  _fitted = false;
+  _fitIntercept;
+  _X = [];
+  _y = [];
+  _yHat = [];
+  constructor(options = {}) {
+    this._fitIntercept = options.fitIntercept ?? true;
+  }
+  get coefficients() {
+    this.assertFitted();
+    return this._coefficients;
+  }
+  get intercept() {
+    this.assertFitted();
+    return this._intercept;
+  }
+  residuals() {
+    this.assertFitted();
+    return this._y.map((yi, i) => yi - this._yHat[i]);
+  }
+  statistics() {
+    this.assertFitted();
+    const n = this._y.length;
+    const p = this._coefficients.length;
+    const k = p + (this._fitIntercept ? 1 : 0);
+    const dfResidual = n - k;
+    if (dfResidual <= 0) {
+      throw new Error("Not enough observations for statistical inference");
+    }
+    let yMean = 0;
+    for (let i = 0;i < n; i++)
+      yMean += this._y[i];
+    yMean /= n;
+    let rss = 0;
+    let tss = 0;
+    for (let i = 0;i < n; i++) {
+      const residual = this._y[i] - this._yHat[i];
+      rss += residual * residual;
+      const diff = this._y[i] - yMean;
+      tss += diff * diff;
+    }
+    const rSquared = 1 - rss / tss;
+    const adjustedRSquared = 1 - (1 - rSquared) * (n - 1) / dfResidual;
+    const mse = rss / dfResidual;
+    const residualStandardError = Math.sqrt(mse);
+    const Xdesign = this._fitIntercept ? this.addInterceptColumn(this._X) : this._X;
+    const A = Matrix.fromArray(Xdesign);
+    const { R } = qrDecomposition(A);
+    const Rsq = R.submatrix(0, k, 0, k);
+    const Rinv = Matrix.zeros(k, k);
+    for (let j = 0;j < k; j++) {
+      const ej = Matrix.zeros(k, 1);
+      ej.set(j, 0, 1);
+      const col = backSubstitution(Rsq, ej);
+      for (let i = 0;i < k; i++) {
+        Rinv.set(i, j, col.get(i, 0));
+      }
+    }
+    const XtXinv = Rinv.multiply(Rinv.transpose());
+    const standardErrors = [];
+    const tStatistics = [];
+    const pValues = [];
+    const confidenceIntervals = [];
+    const tCrit = tInverseCDF(0.975, dfResidual);
+    const allCoeffs = this._fitIntercept ? [this._intercept, ...this._coefficients] : [...this._coefficients];
+    for (let i = 0;i < k; i++) {
+      const se = Math.sqrt(mse * XtXinv.get(i, i));
+      const coeff = allCoeffs[i];
+      const tStat = coeff / se;
+      const pVal = tTestPValue(tStat, dfResidual);
+      standardErrors.push(se);
+      tStatistics.push(tStat);
+      pValues.push(pVal);
+      confidenceIntervals.push([coeff - tCrit * se, coeff + tCrit * se]);
+    }
+    const ess = tss - rss;
+    const fStatistic = p > 0 ? ess / p / (rss / dfResidual) : 0;
+    const fPValue = p > 0 ? fTestPValue(fStatistic, p, dfResidual) : 1;
+    const aic = n * Math.log(rss / n) + 2 * k;
+    const bic = n * Math.log(rss / n) + Math.log(n) * k;
+    return {
+      rSquared,
+      adjustedRSquared,
+      standardErrors,
+      tStatistics,
+      pValues,
+      confidenceIntervals,
+      fStatistic,
+      fPValue,
+      residualStandardError,
+      aic,
+      bic,
+      degreesOfFreedom: dfResidual,
+      nObservations: n
+    };
+  }
+  summary() {
+    const stats = this.statistics();
+    const allCoeffs = this._fitIntercept ? [this._intercept, ...this._coefficients] : [...this._coefficients];
+    const names = this._fitIntercept ? ["(Intercept)", ...this._coefficients.map((_, i) => `x${i + 1}`)] : this._coefficients.map((_, i) => `x${i + 1}`);
+    const lines = ["Coefficients:"];
+    lines.push(padRight("", 15) + padRight("Estimate", 12) + padRight("Std. Error", 12) + padRight("t value", 10) + padRight("Pr(>|t|)", 12) + "");
+    for (let i = 0;i < allCoeffs.length; i++) {
+      const stars = significanceStars(stats.pValues[i]);
+      lines.push(padRight(names[i], 15) + padRight(allCoeffs[i].toFixed(4), 12) + padRight(stats.standardErrors[i].toFixed(4), 12) + padRight(stats.tStatistics[i].toFixed(2), 10) + padRight(stats.pValues[i].toFixed(4), 12) + stars);
+    }
+    lines.push("---");
+    lines.push(`Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1`);
+    lines.push("");
+    lines.push(`Residual standard error: ${stats.residualStandardError.toFixed(4)} on ${stats.degreesOfFreedom} degrees of freedom`);
+    lines.push(`Multiple R-squared: ${stats.rSquared.toFixed(4)}, Adjusted R-squared: ${stats.adjustedRSquared.toFixed(4)}`);
+    lines.push(`F-statistic: ${stats.fStatistic.toFixed(2)} on ${this._coefficients.length} and ${stats.degreesOfFreedom} DF, p-value: ${stats.fPValue.toFixed(6)}`);
+    return lines.join(`
+`);
+  }
+  normalizeInput(X) {
+    if (X.length === 0)
+      throw new Error("Input data cannot be empty");
+    if (typeof X[0] === "number") {
+      return X.map((v) => [v]);
+    }
+    return X;
+  }
+  addInterceptColumn(X) {
+    return X.map((row) => [1, ...row]);
+  }
+  validateFitInput(X, y) {
+    if (X.length !== y.length) {
+      throw new Error(`X has ${X.length} rows but y has ${y.length} elements`);
+    }
+    if (X.length === 0)
+      throw new Error("Input data cannot be empty");
+  }
+  assertFitted() {
+    if (!this._fitted) {
+      throw new Error("Model has not been fitted. Call fit() first.");
+    }
+  }
+}
+function padRight(s, len) {
+  return s.length >= len ? s : s + " ".repeat(len - s.length);
+}
+function significanceStars(p) {
+  if (p < 0.001)
+    return " ***";
+  if (p < 0.01)
+    return " **";
+  if (p < 0.05)
+    return " *";
+  if (p < 0.1)
+    return " .";
+  return "";
+}
+
+// src/models/linear-regression.ts
+class LinearRegression extends BaseRegression {
+  constructor(options = {}) {
+    super(options);
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    this.validateFitInput(Xmat, y);
+    this._X = Xmat;
+    this._y = y;
+    const Xdesign = this._fitIntercept ? this.addInterceptColumn(Xmat) : Xmat;
+    const A = Matrix.fromArray(Xdesign);
+    const b = Matrix.columnVector(y);
+    const { Q, R } = qrDecomposition(A);
+    const beta = solveQR(Q, R, b);
+    const betaArray = beta.toFlatArray();
+    if (this._fitIntercept) {
+      this._intercept = betaArray[0];
+      this._coefficients = betaArray.slice(1);
+    } else {
+      this._intercept = 0;
+      this._coefficients = betaArray;
+    }
+    this._yHat = this.predict(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return sum;
+    });
+  }
+}
+
+// src/diagnostics/multicollinearity.ts
+function vif(X) {
+  const p = X[0].length;
+  if (p < 2)
+    return [1];
+  const result = [];
+  for (let j = 0;j < p; j++) {
+    const yCol = X.map((row) => row[j]);
+    const XOther = X.map((row) => row.filter((_, idx) => idx !== j));
+    const model = new LinearRegression;
+    model.fit(XOther, yCol);
+    const stats = model.statistics();
+    const r2 = stats.rSquared;
+    result.push(1 / Math.max(1 - r2, 0.000000000000001));
+  }
+  return result;
+}
+function correlationMatrix(X) {
+  const n = X.length;
+  const p = X[0].length;
+  const means = [];
+  for (let j = 0;j < p; j++) {
+    let sum = 0;
+    for (let i = 0;i < n; i++)
+      sum += X[i][j];
+    means.push(sum / n);
+  }
+  const stds = [];
+  for (let j = 0;j < p; j++) {
+    let sum = 0;
+    for (let i = 0;i < n; i++) {
+      const diff = X[i][j] - means[j];
+      sum += diff * diff;
+    }
+    stds.push(Math.sqrt(sum / n));
+  }
+  const corr = [];
+  for (let j1 = 0;j1 < p; j1++) {
+    const row = [];
+    for (let j2 = 0;j2 < p; j2++) {
+      if (j1 === j2) {
+        row.push(1);
+      } else {
+        let sum = 0;
+        for (let i = 0;i < n; i++) {
+          sum += (X[i][j1] - means[j1]) / Math.max(stds[j1], 0.000000000000001) * ((X[i][j2] - means[j2]) / Math.max(stds[j2], 0.000000000000001));
+        }
+        row.push(sum / n);
+      }
+    }
+    corr.push(row);
+  }
+  return corr;
+}
+function conditionNumber(X) {
+  const A = Matrix.fromArray(X);
+  const { S } = svd(A);
+  const sMax = S[0] ?? 1;
+  const sMin = S[S.length - 1] ?? 0;
+  return sMin > 0.000000000000001 ? sMax / sMin : Infinity;
+}
+// src/diagnostics/residuals.ts
+function residualDiagnostics(X, y, yHat, fitIntercept = true) {
+  const n = y.length;
+  const raw = y.map((yi, i) => yi - yHat[i]);
+  const Xdesign = fitIntercept ? X.map((row) => [1, ...row]) : X;
+  const A = Matrix.fromArray(Xdesign);
+  const k = A.cols;
+  const { Q } = qrDecomposition(A);
+  const leverageValues = [];
+  for (let i = 0;i < n; i++) {
+    let h = 0;
+    for (let j = 0;j < k; j++) {
+      h += Q.get(i, j) * Q.get(i, j);
+    }
+    leverageValues.push(h);
+  }
+  let rss = 0;
+  for (const r of raw)
+    rss += r * r;
+  const s = Math.sqrt(rss / (n - k));
+  const studentized = raw.map((r, i) => {
+    const h = leverageValues[i];
+    const denom = s * Math.sqrt(Math.max(1 - h, 0.000000000000001));
+    return r / denom;
+  });
+  const cooksDistance = studentized.map((eStar, i) => {
+    const h = leverageValues[i];
+    return eStar * eStar * h / (k * Math.max(1 - h, 0.000000000000001));
+  });
+  return {
+    raw,
+    studentized,
+    cooksDistance,
+    leverage: leverageValues
+  };
+}
+function leverage(X, fitIntercept = true) {
+  const Xdesign = fitIntercept ? X.map((row) => [1, ...row]) : X;
+  const A = Matrix.fromArray(Xdesign);
+  const k = A.cols;
+  const { Q } = qrDecomposition(A);
+  const result = [];
+  for (let i = 0;i < A.rows; i++) {
+    let h = 0;
+    for (let j = 0;j < k; j++) {
+      h += Q.get(i, j) * Q.get(i, j);
+    }
+    result.push(h);
+  }
+  return result;
+}
+function cooksDistance(X, y, yHat, fitIntercept = true) {
+  return residualDiagnostics(X, y, yHat, fitIntercept).cooksDistance;
+}
+function studentizedResiduals(X, y, yHat, fitIntercept = true) {
+  return residualDiagnostics(X, y, yHat, fitIntercept).studentized;
+}
+// src/diagnostics/tests.ts
+init_distributions();
+function durbinWatson(residuals) {
+  const n = residuals.length;
+  let num = 0;
+  let den = 0;
+  for (let i = 0;i < n; i++) {
+    den += residuals[i] * residuals[i];
+    if (i > 0) {
+      const diff = residuals[i] - residuals[i - 1];
+      num += diff * diff;
+    }
+  }
+  const statistic = den > 0 ? num / den : 2;
+  const pValue = Math.exp(-Math.abs(statistic - 2) * Math.sqrt(n) * 0.5);
+  return { statistic, pValue };
+}
+function breuschPagan(X, residuals) {
+  const n = residuals.length;
+  const squaredResiduals = residuals.map((r) => r * r);
+  const auxModel = new LinearRegression;
+  auxModel.fit(X, squaredResiduals);
+  const stats = auxModel.statistics();
+  const statistic = n * stats.rSquared;
+  const df = X[0].length;
+  const pValue = chi2TestPValue(statistic, df);
+  return { statistic, pValue };
+}
+function shapiroWilk(data) {
+  const n = data.length;
+  if (n < 3)
+    throw new Error("Shapiro-Wilk requires at least 3 observations");
+  const sorted = [...data].sort((a2, b) => a2 - b);
+  let mean = 0;
+  for (const x of sorted)
+    mean += x;
+  mean /= n;
+  let ss = 0;
+  for (const x of sorted)
+    ss += (x - mean) ** 2;
+  if (ss < 0.000000000000001) {
+    return { statistic: 1, pValue: 1 };
+  }
+  const { normalInverseCDF: normalInverseCDF2 } = (init_distributions(), __toCommonJS(exports_distributions));
+  const m = [];
+  for (let i = 0;i < n; i++) {
+    const p = (i + 1 - 0.375) / (n + 0.25);
+    m.push(normalInverseCDF2(p));
+  }
+  let mSqSum = 0;
+  for (const mi of m)
+    mSqSum += mi * mi;
+  const mNorm = Math.sqrt(mSqSum);
+  const a = m.map((mi) => mi / mNorm);
+  let aTimesX = 0;
+  for (let i = 0;i < n; i++) {
+    aTimesX += a[i] * sorted[i];
+  }
+  const statistic = aTimesX * aTimesX / ss;
+  const lnW = Math.log(1 - statistic);
+  const mu = -1.2725 + 1.0521 * Math.log(n);
+  const sigma = 1.0308 - 0.26758 * Math.log(n);
+  const z = (lnW - mu) / sigma;
+  const { normalCDF: normCDF } = (init_distributions(), __toCommonJS(exports_distributions));
+  const pValue = 1 - normCDF(z);
+  return { statistic, pValue: Math.max(0, Math.min(1, pValue)) };
+}
+// src/models/lasso-regression.ts
+class LassoRegression extends BaseRegression {
+  _alpha;
+  _maxIterations;
+  _tolerance;
+  constructor(options = {}) {
+    super(options);
+    this._alpha = options.alpha ?? 1;
+    this._maxIterations = options.maxIterations ?? 1000;
+    this._tolerance = options.tolerance ?? 0.0001;
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    this.validateFitInput(Xmat, y);
+    this._X = Xmat;
+    this._y = y;
+    const n = Xmat.length;
+    const p = Xmat[0].length;
+    const { Xstd, xMeans, xStds, yMean } = this.standardize(Xmat, y);
+    const yCentered = y.map((yi) => yi - yMean);
+    const beta = new Float64Array(p);
+    const residual = new Float64Array(yCentered);
+    const colNormsSq = new Float64Array(p);
+    for (let j = 0;j < p; j++) {
+      let sum = 0;
+      for (let i = 0;i < n; i++) {
+        sum += Xstd[i][j] * Xstd[i][j];
+      }
+      colNormsSq[j] = sum;
+    }
+    for (let iter = 0;iter < this._maxIterations; iter++) {
+      let maxChange = 0;
+      for (let j = 0;j < p; j++) {
+        const oldBeta = beta[j];
+        let rho = 0;
+        for (let i = 0;i < n; i++) {
+          rho += Xstd[i][j] * (residual[i] + oldBeta * Xstd[i][j]);
+        }
+        beta[j] = this.coordinateUpdate(rho, colNormsSq[j], n, j);
+        const change = beta[j] - oldBeta;
+        if (change !== 0) {
+          for (let i = 0;i < n; i++) {
+            residual[i] -= change * Xstd[i][j];
+          }
+        }
+        maxChange = Math.max(maxChange, Math.abs(change));
+      }
+      if (maxChange < this._tolerance)
+        break;
+    }
+    this._coefficients = Array.from(beta).map((bj, j) => {
+      const std = xStds[j];
+      return std > 0.000000000000001 ? bj / std : 0;
+    });
+    this._intercept = this._fitIntercept ? yMean - this._coefficients.reduce((sum, bj, j) => sum + bj * xMeans[j], 0) : 0;
+    this._yHat = this.predict(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return sum;
+    });
+  }
+  coordinateUpdate(rho, colNormSq, n, _j) {
+    return this.softThreshold(rho, n * this._alpha) / colNormSq;
+  }
+  softThreshold(rho, lambda) {
+    if (rho < -lambda)
+      return rho + lambda;
+    if (rho > lambda)
+      return rho - lambda;
+    return 0;
+  }
+  standardize(X, y) {
+    const n = X.length;
+    const p = X[0].length;
+    const xMeans = [];
+    const xStds = [];
+    for (let j = 0;j < p; j++) {
+      let sum = 0;
+      for (let i = 0;i < n; i++)
+        sum += X[i][j];
+      xMeans.push(sum / n);
+    }
+    for (let j = 0;j < p; j++) {
+      let sum = 0;
+      for (let i = 0;i < n; i++) {
+        const diff = X[i][j] - xMeans[j];
+        sum += diff * diff;
+      }
+      xStds.push(Math.sqrt(sum / n));
+    }
+    const Xstd = X.map((row) => row.map((val, j) => {
+      const std = xStds[j];
+      return std > 0.000000000000001 ? (val - xMeans[j]) / std : 0;
+    }));
+    let yMean = 0;
+    for (let i = 0;i < n; i++)
+      yMean += y[i];
+    yMean /= n;
+    return { Xstd, xMeans, xStds, yMean };
+  }
+}
+
+// src/models/elastic-net.ts
+class ElasticNet extends LassoRegression {
+  _l1Ratio;
+  constructor(options = {}) {
+    super({
+      fitIntercept: options.fitIntercept,
+      alpha: options.alpha,
+      maxIterations: options.maxIterations,
+      tolerance: options.tolerance
+    });
+    this._l1Ratio = options.l1Ratio ?? 0.5;
+  }
+  coordinateUpdate(rho, colNormSq, n, _j) {
+    const l1Penalty = n * this._alpha * this._l1Ratio;
+    const l2Penalty = n * this._alpha * (1 - this._l1Ratio);
+    return this.softThreshold(rho, l1Penalty) / (colNormSq + l2Penalty);
+  }
+}
+// src/models/knn.ts
+class KNearestNeighbors {
+  _k;
+  _distance;
+  _mode;
+  _fitted = false;
+  _X = [];
+  _y = [];
+  constructor(options = {}) {
+    this._k = options.k ?? 5;
+    this._distance = options.distance ?? "euclidean";
+    this._mode = options.mode ?? "classification";
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    if (Xmat.length !== y.length) {
+      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
+    }
+    if (Xmat.length < this._k) {
+      throw new Error(`Need at least k=${this._k} samples, got ${Xmat.length}`);
+    }
+    this._X = Xmat;
+    this._y = y;
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => this.predictOne(row));
+  }
+  neighbors(point) {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    return this.findNeighbors(point).map((n) => n.index);
+  }
+  predictOne(point) {
+    const nearest = this.findNeighbors(point);
+    if (this._mode === "regression") {
+      let sum = 0;
+      for (const n of nearest)
+        sum += this._y[n.index];
+      return sum / nearest.length;
+    }
+    const votes = new Map;
+    for (const n of nearest) {
+      const label = this._y[n.index];
+      votes.set(label, (votes.get(label) ?? 0) + 1);
+    }
+    let bestLabel = 0;
+    let bestCount = 0;
+    for (const [label, count] of votes) {
+      if (count > bestCount) {
+        bestCount = count;
+        bestLabel = label;
+      }
+    }
+    return bestLabel;
+  }
+  findNeighbors(point) {
+    const distances = [];
+    for (let i = 0;i < this._X.length; i++) {
+      const d = this.computeDistance(point, this._X[i]);
+      distances.push({ index: i, distance: d });
+    }
+    distances.sort((a, b) => a.distance - b.distance);
+    return distances.slice(0, this._k);
+  }
+  computeDistance(a, b) {
+    let sum = 0;
+    for (let i = 0;i < a.length; i++) {
+      const diff = a[i] - b[i];
+      if (this._distance === "manhattan") {
+        sum += Math.abs(diff);
+      } else {
+        sum += diff * diff;
+      }
+    }
+    return this._distance === "manhattan" ? sum : Math.sqrt(sum);
+  }
+  normalizeInput(X) {
+    if (X.length === 0)
+      throw new Error("Input data cannot be empty");
+    if (typeof X[0] === "number") {
+      return X.map((v) => [v]);
+    }
+    return X;
+  }
+}
+// src/models/logistic-regression.ts
+class LogisticRegression {
+  _coefficients = [];
+  _intercept = 0;
+  _fitted = false;
+  _fitIntercept;
+  _maxIterations;
+  _tolerance;
+  _y = [];
+  _probabilities = [];
+  constructor(options = {}) {
+    this._fitIntercept = options.fitIntercept ?? true;
+    this._maxIterations = options.maxIterations ?? 100;
+    this._tolerance = options.tolerance ?? 0.000001;
+  }
+  get coefficients() {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    return this._coefficients;
+  }
+  get intercept() {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    return this._intercept;
+  }
+  sigmoid(z) {
+    if (z >= 0)
+      return 1 / (1 + Math.exp(-z));
+    const expZ = Math.exp(z);
+    return expZ / (1 + expZ);
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    if (Xmat.length !== y.length) {
+      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
+    }
+    for (const yi of y) {
+      if (yi !== 0 && yi !== 1) {
+        throw new Error("Logistic regression requires binary y (0 or 1)");
+      }
+    }
+    this._X = Xmat;
+    this._y = y;
+    const n = Xmat.length;
+    const Xdesign = this._fitIntercept ? this.addInterceptColumn(Xmat) : Xmat;
+    const k = Xdesign[0].length;
+    const beta = new Float64Array(k);
+    for (let iter = 0;iter < this._maxIterations; iter++) {
+      const eta = new Float64Array(n);
+      const p = new Float64Array(n);
+      for (let i = 0;i < n; i++) {
+        let sum = 0;
+        for (let j = 0;j < k; j++) {
+          sum += Xdesign[i][j] * beta[j];
+        }
+        eta[i] = sum;
+        p[i] = this.sigmoid(sum);
+      }
+      const sqrtW = new Float64Array(n);
+      const z = new Float64Array(n);
+      for (let i = 0;i < n; i++) {
+        const pi = Math.max(0.000000000000001, Math.min(1 - 0.000000000000001, p[i]));
+        const wi = pi * (1 - pi);
+        sqrtW[i] = Math.sqrt(Math.max(wi, 0.0000000001));
+        z[i] = eta[i] + (y[i] - pi) / wi;
+      }
+      const XW = Matrix.zeros(n, k);
+      const zW = Matrix.zeros(n, 1);
+      for (let i = 0;i < n; i++) {
+        for (let j = 0;j < k; j++) {
+          XW.set(i, j, Xdesign[i][j] * sqrtW[i]);
+        }
+        zW.set(i, 0, z[i] * sqrtW[i]);
+      }
+      const { Q, R } = qrDecomposition(XW);
+      const betaNew = solveQR(Q, R, zW);
+      let maxChange = 0;
+      for (let j = 0;j < k; j++) {
+        maxChange = Math.max(maxChange, Math.abs(betaNew.get(j, 0) - beta[j]));
+        beta[j] = betaNew.get(j, 0);
+      }
+      if (maxChange < this._tolerance)
+        break;
+    }
+    const betaArray = Array.from(beta);
+    if (this._fitIntercept) {
+      this._intercept = betaArray[0];
+      this._coefficients = betaArray.slice(1);
+    } else {
+      this._intercept = 0;
+      this._coefficients = betaArray;
+    }
+    this._probabilities = this.predictProbability(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    return this.predictProbability(X).map((p) => p >= 0.5 ? 1 : 0);
+  }
+  predictProbability(X) {
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return this.sigmoid(sum);
+    });
+  }
+  statistics() {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const n = this._y.length;
+    const predicted = this._probabilities.map((p) => p >= 0.5 ? 1 : 0);
+    let tp = 0;
+    let tn = 0;
+    let fp = 0;
+    let fn = 0;
+    for (let i = 0;i < n; i++) {
+      if (this._y[i] === 1 && predicted[i] === 1)
+        tp++;
+      else if (this._y[i] === 0 && predicted[i] === 0)
+        tn++;
+      else if (this._y[i] === 0 && predicted[i] === 1)
+        fp++;
+      else
+        fn++;
+    }
+    const accuracy = (tp + tn) / n;
+    const precision = tp + fp > 0 ? tp / (tp + fp) : 0;
+    const recall = tp + fn > 0 ? tp / (tp + fn) : 0;
+    const f1Score = precision + recall > 0 ? 2 * precision * recall / (precision + recall) : 0;
+    let logLik = 0;
+    for (let i = 0;i < n; i++) {
+      const pi = Math.max(0.000000000000001, Math.min(1 - 0.000000000000001, this._probabilities[i]));
+      logLik += this._y[i] * Math.log(pi) + (1 - this._y[i]) * Math.log(1 - pi);
+    }
+    let yMean = 0;
+    for (const yi of this._y)
+      yMean += yi;
+    yMean /= n;
+    const pBar = Math.max(0.000000000000001, Math.min(1 - 0.000000000000001, yMean));
+    const nullLogLik = n * (pBar * Math.log(pBar) + (1 - pBar) * Math.log(1 - pBar));
+    const pseudoRSquared = 1 - logLik / nullLogLik;
+    const k = this._coefficients.length + (this._fitIntercept ? 1 : 0);
+    const aic = -2 * logLik + 2 * k;
+    const bic = -2 * logLik + Math.log(n) * k;
+    return {
+      accuracy,
+      precision,
+      recall,
+      f1Score,
+      confusionMatrix: {
+        truePositives: tp,
+        trueNegatives: tn,
+        falsePositives: fp,
+        falseNegatives: fn
+      },
+      pseudoRSquared,
+      logLikelihood: logLik,
+      aic,
+      bic
+    };
+  }
+  normalizeInput(X) {
+    if (X.length === 0)
+      throw new Error("Input data cannot be empty");
+    if (typeof X[0] === "number") {
+      return X.map((v) => [v]);
+    }
+    return X;
+  }
+  addInterceptColumn(X) {
+    return X.map((row) => [1, ...row]);
+  }
+}
+// src/models/multiclass-logistic-regression.ts
+class MulticlassLogisticRegression {
+  _weights = Matrix.zeros(0, 0);
+  _fitted = false;
+  _fitIntercept;
+  _maxIterations;
+  _tolerance;
+  _learningRate;
+  _nClasses = 0;
+  _classes = [];
+  _X = [];
+  _y = [];
+  constructor(options = {}) {
+    this._fitIntercept = options.fitIntercept ?? true;
+    this._maxIterations = options.maxIterations ?? 200;
+    this._tolerance = options.tolerance ?? 0.000001;
+    this._learningRate = options.learningRate ?? 0.1;
+  }
+  get weights() {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    return this._weights;
+  }
+  get classes() {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    return this._classes;
+  }
+  softmax(logits) {
+    const max = Math.max(...logits);
+    const exps = logits.map((l) => Math.exp(l - max));
+    const sum = exps.reduce((a, b) => a + b, 0);
+    return exps.map((e) => e / sum);
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    if (Xmat.length !== y.length) {
+      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
+    }
+    this._X = Xmat;
+    this._y = y;
+    this._classes = [...new Set(y)].sort((a, b) => a - b);
+    this._nClasses = this._classes.length;
+    for (const yi of y) {
+      if (!this._classes.includes(yi)) {
+        throw new Error(`Unexpected label ${yi}`);
+      }
+    }
+    const n = Xmat.length;
+    const Xdesign = this._fitIntercept ? Xmat.map((row) => [1, ...row]) : Xmat;
+    const k = Xdesign[0].length;
+    const K = this._nClasses;
+    const Y = Matrix.zeros(n, K);
+    for (let i = 0;i < n; i++) {
+      const classIdx = this._classes.indexOf(y[i]);
+      Y.set(i, classIdx, 1);
+    }
+    this._weights = Matrix.zeros(k, K);
+    const XMat = Matrix.fromArray(Xdesign);
+    for (let iter = 0;iter < this._maxIterations; iter++) {
+      const scores = XMat.multiply(this._weights);
+      const P = Matrix.zeros(n, K);
+      for (let i = 0;i < n; i++) {
+        const logits = [];
+        for (let c = 0;c < K; c++)
+          logits.push(scores.get(i, c));
+        const probs = this.softmax(logits);
+        for (let c = 0;c < K; c++)
+          P.set(i, c, probs[c]);
+      }
+      const diff = P.subtract(Y);
+      const grad = XMat.transpose().multiply(diff).scale(1 / n);
+      let maxChange = 0;
+      for (let i = 0;i < grad.data.length; i++) {
+        const delta = this._learningRate * grad.data[i];
+        this._weights.data[i] -= delta;
+        maxChange = Math.max(maxChange, Math.abs(delta));
+      }
+      if (maxChange < this._tolerance)
+        break;
+    }
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const probs = this.predictProbability(X);
+    return probs.map((row) => {
+      let maxIdx = 0;
+      let maxVal = row[0];
+      for (let c = 1;c < row.length; c++) {
+        if (row[c] > maxVal) {
+          maxVal = row[c];
+          maxIdx = c;
+        }
+      }
+      return this._classes[maxIdx];
+    });
+  }
+  predictProbability(X) {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const Xmat = this.normalizeInput(X);
+    const Xdesign = this._fitIntercept ? Xmat.map((row) => [1, ...row]) : Xmat;
+    const XMat = Matrix.fromArray(Xdesign);
+    const scores = XMat.multiply(this._weights);
+    const K = this._nClasses;
+    const result = [];
+    for (let i = 0;i < Xmat.length; i++) {
+      const logits = [];
+      for (let c = 0;c < K; c++)
+        logits.push(scores.get(i, c));
+      result.push(this.softmax(logits));
+    }
+    return result;
+  }
+  statistics() {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const predicted = this.predict(this._X);
+    const n = this._y.length;
+    const K = this._nClasses;
+    let correct = 0;
+    for (let i = 0;i < n; i++) {
+      if (predicted[i] === this._y[i])
+        correct++;
+    }
+    const precision = [];
+    const recall = [];
+    for (let c = 0;c < K; c++) {
+      const cls = this._classes[c];
+      let tp = 0;
+      let fp = 0;
+      let fn = 0;
+      for (let i = 0;i < n; i++) {
+        if (predicted[i] === cls && this._y[i] === cls)
+          tp++;
+        else if (predicted[i] === cls && this._y[i] !== cls)
+          fp++;
+        else if (predicted[i] !== cls && this._y[i] === cls)
+          fn++;
+      }
+      precision.push(tp + fp > 0 ? tp / (tp + fp) : 0);
+      recall.push(tp + fn > 0 ? tp / (tp + fn) : 0);
+    }
+    const probs = this.predictProbability(this._X);
+    let logLik = 0;
+    for (let i = 0;i < n; i++) {
+      const classIdx = this._classes.indexOf(this._y[i]);
+      logLik += Math.log(Math.max(probs[i][classIdx], 0.000000000000001));
+    }
+    return {
+      accuracy: correct / n,
+      precision,
+      recall,
+      nClasses: K,
+      logLikelihood: logLik
+    };
+  }
+  normalizeInput(X) {
+    if (X.length === 0)
+      throw new Error("Input data cannot be empty");
+    if (typeof X[0] === "number") {
+      return X.map((v) => [v]);
+    }
+    return X;
+  }
+}
+// src/models/neural-network.ts
+class NeuralNetwork {
+  _layers = [];
+  _learningRate;
+  _epochs;
+  _task;
+  _fitted = false;
+  _outputSize = 0;
+  _classes = [];
+  constructor(options) {
+    this._learningRate = options.learningRate ?? 0.01;
+    this._epochs = options.epochs ?? 100;
+    this._task = options.task ?? "regression";
+    this._layerConfigs = options.layers;
+  }
+  _layerConfigs;
+  initializeLayers(inputSize, outputSize) {
+    this._layers = [];
+    let prevSize = inputSize;
+    for (const config of this._layerConfigs) {
+      this._layers.push(this.createLayer(prevSize, config.units, config.activation ?? "relu"));
+      prevSize = config.units;
+    }
+    const outputActivation = this._task === "classification" && outputSize > 1 ? "softmax" : "linear";
+    this._layers.push(this.createLayer(prevSize, outputSize, outputActivation));
+  }
+  createLayer(inputSize, units, activation) {
+    const scale = Math.sqrt(6 / (inputSize + units));
+    const weights = new Float64Array(inputSize * units);
+    for (let i = 0;i < weights.length; i++) {
+      weights[i] = (Math.random() * 2 - 1) * scale;
+    }
+    return {
+      weights,
+      biases: new Float64Array(units),
+      inputSize,
+      units,
+      activation
+    };
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    if (Xmat.length !== y.length) {
+      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
+    }
+    const inputSize = Xmat[0].length;
+    const n = Xmat.length;
+    if (this._task === "classification") {
+      this._classes = [...new Set(y)].sort((a, b) => a - b);
+      this._outputSize = this._classes.length;
+    } else {
+      this._outputSize = 1;
+    }
+    this.initializeLayers(inputSize, this._outputSize);
+    for (let epoch = 0;epoch < this._epochs; epoch++) {
+      for (let i = 0;i < n; i++) {
+        const input = Xmat[i];
+        const activations = this.forward(input);
+        const outputLayer = activations[activations.length - 1];
+        const target = this.encodeTarget(y[i]);
+        const outputError = new Float64Array(this._outputSize);
+        for (let j = 0;j < this._outputSize; j++) {
+          outputError[j] = outputLayer[j] - target[j];
+        }
+        this.backward(activations, outputError);
+      }
+    }
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      const activations = this.forward(row);
+      const output = activations[activations.length - 1];
+      if (this._task === "classification") {
+        let maxIdx = 0;
+        let maxVal = output[0];
+        for (let c = 1;c < output.length; c++) {
+          if (output[c] > maxVal) {
+            maxVal = output[c];
+            maxIdx = c;
+          }
+        }
+        return this._classes[maxIdx];
+      }
+      return output[0];
+    });
+  }
+  predictRaw(X) {
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      const activations = this.forward(row);
+      return Array.from(activations[activations.length - 1]);
+    });
+  }
+  forward(input) {
+    const activations = [new Float64Array(input)];
+    let current = new Float64Array(input);
+    for (const layer of this._layers) {
+      const z = new Float64Array(layer.units);
+      for (let j = 0;j < layer.units; j++) {
+        let sum = layer.biases[j];
+        for (let i = 0;i < layer.inputSize; i++) {
+          sum += current[i] * layer.weights[i * layer.units + j];
+        }
+        z[j] = sum;
+      }
+      current = this.activate(z, layer.activation);
+      activations.push(current);
+    }
+    return activations;
+  }
+  backward(activations, outputError) {
+    const deltas = new Array(this._layers.length);
+    deltas[this._layers.length - 1] = outputError;
+    for (let l = this._layers.length - 2;l >= 0; l--) {
+      const layer = this._layers[l];
+      const output = activations[l + 1];
+      const nextLayer = this._layers[l + 1];
+      const nextDelta = deltas[l + 1];
+      const delta = new Float64Array(layer.units);
+      for (let j = 0;j < layer.units; j++) {
+        let sum = 0;
+        for (let k = 0;k < nextLayer.units; k++) {
+          sum += nextDelta[k] * nextLayer.weights[j * nextLayer.units + k];
+        }
+        delta[j] = sum * this.activationDerivative(output[j], layer.activation);
+      }
+      deltas[l] = delta;
+    }
+    const lr = this._learningRate;
+    for (let l = 0;l < this._layers.length; l++) {
+      const layer = this._layers[l];
+      const input = activations[l];
+      const delta = deltas[l];
+      for (let j = 0;j < layer.units; j++) {
+        for (let i = 0;i < layer.inputSize; i++) {
+          layer.weights[i * layer.units + j] -= lr * delta[j] * input[i];
+        }
+        layer.biases[j] -= lr * delta[j];
+      }
+    }
+  }
+  activate(z, fn) {
+    const result = new Float64Array(z.length);
+    switch (fn) {
+      case "relu":
+        for (let i = 0;i < z.length; i++)
+          result[i] = Math.max(0, z[i]);
+        break;
+      case "sigmoid":
+        for (let i = 0;i < z.length; i++)
+          result[i] = this.sigmoid(z[i]);
+        break;
+      case "tanh":
+        for (let i = 0;i < z.length; i++)
+          result[i] = Math.tanh(z[i]);
+        break;
+      case "linear":
+        result.set(z);
+        break;
+      case "softmax": {
+        const max = Math.max(...z);
+        let sum = 0;
+        for (let i = 0;i < z.length; i++) {
+          result[i] = Math.exp(z[i] - max);
+          sum += result[i];
+        }
+        for (let i = 0;i < z.length; i++)
+          result[i] /= sum;
+        break;
+      }
+    }
+    return result;
+  }
+  activationDerivative(output, fn) {
+    switch (fn) {
+      case "relu":
+        return output > 0 ? 1 : 0;
+      case "sigmoid":
+        return output * (1 - output);
+      case "tanh":
+        return 1 - output * output;
+      case "linear":
+        return 1;
+      case "softmax":
+        return output * (1 - output);
+    }
+  }
+  sigmoid(z) {
+    if (z >= 0)
+      return 1 / (1 + Math.exp(-z));
+    const expZ = Math.exp(z);
+    return expZ / (1 + expZ);
+  }
+  encodeTarget(y) {
+    if (this._task === "regression") {
+      return new Float64Array([y]);
+    }
+    const encoded = new Float64Array(this._outputSize);
+    const idx = this._classes.indexOf(y);
+    if (idx >= 0)
+      encoded[idx] = 1;
+    return encoded;
+  }
+  normalizeInput(X) {
+    if (X.length === 0)
+      throw new Error("Input data cannot be empty");
+    if (typeof X[0] === "number") {
+      return X.map((v) => [v]);
+    }
+    return X;
+  }
+}
+// src/models/polynomial-regression.ts
+class PolynomialRegression extends BaseRegression {
+  _degree;
+  _inner;
+  constructor(options = {}) {
+    super(options);
+    this._degree = options.degree ?? 2;
+    this._inner = new LinearRegression({ fitIntercept: this._fitIntercept });
+  }
+  expandFeatures(X) {
+    return X.map((row) => {
+      const x = row[0];
+      const expanded = [];
+      for (let d = 1;d <= this._degree; d++) {
+        expanded.push(x ** d);
+      }
+      return expanded;
+    });
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    this.validateFitInput(Xmat, y);
+    if (Xmat[0].length !== 1) {
+      throw new Error("PolynomialRegression expects a single feature. Use LinearRegression with manual feature engineering for multiple features.");
+    }
+    this._X = Xmat;
+    this._y = y;
+    const Xexpanded = this.expandFeatures(Xmat);
+    this._inner.fit(Xexpanded, y);
+    this._coefficients = this._inner.coefficients;
+    this._intercept = this._inner.intercept;
+    this._yHat = this.predict(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const Xmat = this.normalizeInput(X);
+    const Xexpanded = this.expandFeatures(Xmat);
+    return this._inner.predict(Xexpanded);
+  }
+}
+// src/models/ridge-regression.ts
+class RidgeRegression extends BaseRegression {
+  _alpha;
+  constructor(options = {}) {
+    super(options);
+    this._alpha = options.alpha ?? 1;
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    this.validateFitInput(Xmat, y);
+    this._X = Xmat;
+    this._y = y;
+    const Xdesign = this._fitIntercept ? this.addInterceptColumn(Xmat) : Xmat;
+    const A = Matrix.fromArray(Xdesign);
+    const b = Matrix.columnVector(y);
+    const XtX = A.transpose().multiply(A);
+    const p = XtX.cols;
+    const startIdx = this._fitIntercept ? 1 : 0;
+    for (let i = startIdx;i < p; i++) {
+      XtX.set(i, i, XtX.get(i, i) + this._alpha);
+    }
+    const Xty = A.transpose().multiply(b);
+    const { L } = choleskyDecomposition(XtX);
+    const beta = solveCholesky(L, Xty);
+    const betaArray = beta.toFlatArray();
+    if (this._fitIntercept) {
+      this._intercept = betaArray[0];
+      this._coefficients = betaArray.slice(1);
+    } else {
+      this._intercept = 0;
+      this._coefficients = betaArray;
+    }
+    this._yHat = this.predict(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return sum;
+    });
+  }
+}
+// src/models/weighted-regression.ts
+class WeightedRegression extends BaseRegression {
+  _weights;
+  constructor(options = {}) {
+    super(options);
+    this._weights = options.weights;
+  }
+  fit(X, y, weights) {
+    const Xmat = this.normalizeInput(X);
+    this.validateFitInput(Xmat, y);
+    const w = weights ?? this._weights;
+    if (!w)
+      throw new Error("Weights must be provided either in constructor or fit()");
+    if (w.length !== y.length) {
+      throw new Error(`Weights length (${w.length}) must match y length (${y.length})`);
+    }
+    this._X = Xmat;
+    this._y = y;
+    const Xdesign = this._fitIntercept ? this.addInterceptColumn(Xmat) : Xmat;
+    const sqrtW = w.map((wi) => Math.sqrt(wi));
+    const Xweighted = Xdesign.map((row, i) => row.map((val) => val * sqrtW[i]));
+    const yWeighted = y.map((yi, i) => yi * sqrtW[i]);
+    const A = Matrix.fromArray(Xweighted);
+    const b = Matrix.columnVector(yWeighted);
+    const { Q, R } = qrDecomposition(A);
+    const beta = solveQR(Q, R, b);
+    const betaArray = beta.toFlatArray();
+    if (this._fitIntercept) {
+      this._intercept = betaArray[0];
+      this._coefficients = betaArray.slice(1);
+    } else {
+      this._intercept = 0;
+      this._coefficients = betaArray;
+    }
+    this._yHat = this.predict(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return sum;
+    });
+  }
+}
+
+// src/models/robust-regression.ts
+class RobustRegression extends BaseRegression {
+  _method;
+  _tuningConstant;
+  _maxIterations;
+  _tolerance;
+  constructor(options = {}) {
+    super(options);
+    this._method = options.method ?? "huber";
+    this._tuningConstant = options.tuningConstant ?? (this._method === "huber" ? 1.345 : 4.685);
+    this._maxIterations = options.maxIterations ?? 50;
+    this._tolerance = options.tolerance ?? 0.0001;
+  }
+  fit(X, y) {
+    const Xmat = this.normalizeInput(X);
+    this.validateFitInput(Xmat, y);
+    this._X = Xmat;
+    this._y = y;
+    const ols = new LinearRegression({ fitIntercept: this._fitIntercept });
+    ols.fit(Xmat, y);
+    this._coefficients = ols.coefficients;
+    this._intercept = ols.intercept;
+    for (let iter = 0;iter < this._maxIterations; iter++) {
+      const prevCoeffs = [...this._coefficients];
+      const prevIntercept = this._intercept;
+      const yHat = this.predict(Xmat);
+      const residuals = y.map((yi, i) => yi - yHat[i]);
+      const absResiduals = residuals.map(Math.abs).sort((a, b) => a - b);
+      const mad = median(absResiduals);
+      const scale = Math.max(mad / 0.6745, 0.0000000001);
+      const weights = residuals.map((r) => {
+        const u = r / scale;
+        return this._method === "huber" ? huberWeight(u, this._tuningConstant) : tukeyWeight(u, this._tuningConstant);
+      });
+      const wls = new WeightedRegression({ fitIntercept: this._fitIntercept });
+      wls.fit(Xmat, y, weights);
+      this._coefficients = wls.coefficients;
+      this._intercept = wls.intercept;
+      let maxChange = Math.abs(this._intercept - prevIntercept);
+      for (let j = 0;j < this._coefficients.length; j++) {
+        maxChange = Math.max(maxChange, Math.abs(this._coefficients[j] - prevCoeffs[j]));
+      }
+      if (maxChange < this._tolerance)
+        break;
+    }
+    this._yHat = this.predict(Xmat);
+    this._fitted = true;
+    return this;
+  }
+  predict(X) {
+    const Xmat = this.normalizeInput(X);
+    return Xmat.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return sum;
+    });
+  }
+}
+function huberWeight(u, k) {
+  return Math.abs(u) <= k ? 1 : k / Math.abs(u);
+}
+function tukeyWeight(u, k) {
+  if (Math.abs(u) > k)
+    return 0;
+  const t = 1 - (u / k) ** 2;
+  return t * t;
+}
+function median(sorted) {
+  const n = sorted.length;
+  if (n === 0)
+    return 0;
+  const mid = Math.floor(n / 2);
+  return n % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+// src/predictions/bootstrap.ts
+function bootstrapCoefficients(X, y, nBootstrap = 1000, alpha = 0.05, fitIntercept = true) {
+  const n = X.length;
+  const p = X[0].length;
+  const nParams = p + (fitIntercept ? 1 : 0);
+  const allCoeffs = Array.from({ length: nParams }, () => []);
+  for (let b = 0;b < nBootstrap; b++) {
+    const indices = Array.from({ length: n }, () => Math.floor(Math.random() * n));
+    const Xb = indices.map((i) => X[i]);
+    const yb = indices.map((i) => y[i]);
+    try {
+      const model = new LinearRegression({ fitIntercept });
+      model.fit(Xb, yb);
+      const coeffs = fitIntercept ? [model.intercept, ...model.coefficients] : [...model.coefficients];
+      for (let j = 0;j < nParams; j++) {
+        allCoeffs[j].push(coeffs[j]);
+      }
+    } catch {}
+  }
+  const coefficients = [];
+  const confidenceIntervals = [];
+  const standardErrors = [];
+  for (let j = 0;j < nParams; j++) {
+    const samples = allCoeffs[j];
+    if (samples.length === 0) {
+      coefficients.push(0);
+      confidenceIntervals.push([0, 0]);
+      standardErrors.push(0);
+      continue;
+    }
+    const mean = samples.reduce((a, b) => a + b, 0) / samples.length;
+    coefficients.push(mean);
+    const variance = samples.reduce((sum, x) => sum + (x - mean) ** 2, 0) / (samples.length - 1);
+    standardErrors.push(Math.sqrt(variance));
+    const sorted = [...samples].sort((a, b) => a - b);
+    const loIdx = Math.floor(alpha / 2 * sorted.length);
+    const hiIdx = Math.floor((1 - alpha / 2) * sorted.length);
+    confidenceIntervals.push([sorted[loIdx], sorted[Math.min(hiIdx, sorted.length - 1)]]);
+  }
+  return { coefficients, confidenceIntervals, standardErrors };
+}
+// src/predictions/intervals.ts
+init_distributions();
+function confidenceInterval(X, y, yHat, newX, newYHat, fitIntercept = true, alpha = 0.05) {
+  const { s, XtXinv, df } = computeBase(X, y, yHat, fitIntercept);
+  const tCrit = tInverseCDF(1 - alpha / 2, df);
+  return newX.map((row, idx) => {
+    const x0 = fitIntercept ? [1, ...row] : row;
+    const x0vec = Matrix.columnVector(x0);
+    const se = s * Math.sqrt(quadForm(XtXinv, x0vec));
+    const predicted = newYHat[idx];
+    return {
+      predicted,
+      lower: predicted - tCrit * se,
+      upper: predicted + tCrit * se
+    };
+  });
+}
+function predictionInterval(X, y, yHat, newX, newYHat, fitIntercept = true, alpha = 0.05) {
+  const { s, XtXinv, df } = computeBase(X, y, yHat, fitIntercept);
+  const tCrit = tInverseCDF(1 - alpha / 2, df);
+  return newX.map((row, idx) => {
+    const x0 = fitIntercept ? [1, ...row] : row;
+    const x0vec = Matrix.columnVector(x0);
+    const se = s * Math.sqrt(1 + quadForm(XtXinv, x0vec));
+    const predicted = newYHat[idx];
+    return {
+      predicted,
+      lower: predicted - tCrit * se,
+      upper: predicted + tCrit * se
+    };
+  });
+}
+function computeBase(X, y, yHat, fitIntercept) {
+  const n = y.length;
+  const Xdesign = fitIntercept ? X.map((row) => [1, ...row]) : X;
+  const A = Matrix.fromArray(Xdesign);
+  const k = A.cols;
+  const df = n - k;
+  let rss = 0;
+  for (let i = 0;i < n; i++) {
+    const r = y[i] - yHat[i];
+    rss += r * r;
+  }
+  const s = Math.sqrt(rss / df);
+  const { R } = qrDecomposition(A);
+  const Rsq = R.submatrix(0, k, 0, k);
+  const Rinv = Matrix.zeros(k, k);
+  for (let j = 0;j < k; j++) {
+    const ej = Matrix.zeros(k, 1);
+    ej.set(j, 0, 1);
+    const col = backSubstitution(Rsq, ej);
+    for (let i = 0;i < k; i++) {
+      Rinv.set(i, j, col.get(i, 0));
+    }
+  }
+  const XtXinv = Rinv.multiply(Rinv.transpose());
+  return { s, XtXinv, k, df };
+}
+function quadForm(M, v) {
+  const Mv = M.multiply(v);
+  return v.dot(Mv);
+}
+// src/preprocessing/encoding.ts
+function oneHotEncode(column, categories, dropFirst = false) {
+  const cats = categories ?? [...new Set(column)].sort();
+  const startIdx = dropFirst ? 1 : 0;
+  const resultCats = cats.slice(startIdx);
+  return column.map((val) => resultCats.map((cat) => val === cat ? 1 : 0));
+}
+// src/preprocessing/features.ts
+function polynomialFeatures(X, degree) {
+  return X.map((row) => {
+    const expanded = [];
+    for (const x of row) {
+      for (let d = 1;d <= degree; d++) {
+        expanded.push(x ** d);
+      }
+    }
+    return expanded;
+  });
+}
+function interactionFeatures(X, pairs) {
+  const p = X[0].length;
+  const allPairs = pairs ?? (() => {
+    const result = [];
+    for (let i = 0;i < p; i++) {
+      for (let j = i + 1;j < p; j++) {
+        result.push([i, j]);
+      }
+    }
+    return result;
+  })();
+  return X.map((row) => allPairs.map(([i, j]) => row[i] * row[j]));
+}
+// src/preprocessing/missing.ts
+function dropMissing(X, y) {
+  const validIndices = [];
+  for (let i = 0;i < X.length; i++) {
+    const rowValid = X[i].every((v) => v != null && !Number.isNaN(v));
+    const yValid = y ? y[i] != null && !Number.isNaN(y[i]) : true;
+    if (rowValid && yValid)
+      validIndices.push(i);
+  }
+  return {
+    X: validIndices.map((i) => X[i]),
+    y: y ? validIndices.map((i) => y[i]) : undefined
+  };
+}
+function imputeMean(X) {
+  const n = X.length;
+  const p = X[0].length;
+  const means = [];
+  for (let j = 0;j < p; j++) {
+    let sum = 0;
+    let count = 0;
+    for (let i = 0;i < n; i++) {
+      const val = X[i][j];
+      if (!Number.isNaN(val)) {
+        sum += val;
+        count++;
+      }
+    }
+    means.push(count > 0 ? sum / count : 0);
+  }
+  return X.map((row) => row.map((val, j) => Number.isNaN(val) ? means[j] : val));
+}
+function imputeMedian(X) {
+  const n = X.length;
+  const p = X[0].length;
+  const medians = [];
+  for (let j = 0;j < p; j++) {
+    const values = [];
+    for (let i = 0;i < n; i++) {
+      const val = X[i][j];
+      if (!Number.isNaN(val))
+        values.push(val);
+    }
+    values.sort((a, b) => a - b);
+    const mid = Math.floor(values.length / 2);
+    medians.push(values.length === 0 ? 0 : values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid]);
+  }
+  return X.map((row) => row.map((val, j) => Number.isNaN(val) ? medians[j] : val));
+}
+// src/preprocessing/scaling.ts
+function standardize(X) {
+  const n = X.length;
+  const p = X[0].length;
+  const means = [];
+  const stds = [];
+  for (let j = 0;j < p; j++) {
+    let sum = 0;
+    for (let i = 0;i < n; i++)
+      sum += X[i][j];
+    const mean = sum / n;
+    means.push(mean);
+    let sqSum = 0;
+    for (let i = 0;i < n; i++)
+      sqSum += (X[i][j] - mean) ** 2;
+    stds.push(Math.sqrt(sqSum / n));
+  }
+  const transformed = X.map((row) => row.map((val, j) => {
+    const std = stds[j];
+    return std > 0.000000000000001 ? (val - means[j]) / std : 0;
+  }));
+  return { transformed, means, stds };
+}
+function unstandardize(X, params) {
+  return X.map((row) => row.map((val, j) => val * params.stds[j] + params.means[j]));
+}
+function normalize(X) {
+  const n = X.length;
+  const p = X[0].length;
+  const mins = [];
+  const maxs = [];
+  for (let j = 0;j < p; j++) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0;i < n; i++) {
+      const val = X[i][j];
+      if (val < min)
+        min = val;
+      if (val > max)
+        max = val;
+    }
+    mins.push(min);
+    maxs.push(max);
+  }
+  const transformed = X.map((row) => row.map((val, j) => {
+    const range = maxs[j] - mins[j];
+    return range > 0.000000000000001 ? (val - mins[j]) / range : 0;
+  }));
+  return { transformed, mins, maxs };
+}
+function unnormalize(X, params) {
+  return X.map((row) => row.map((val, j) => val * (params.maxs[j] - params.mins[j]) + params.mins[j]));
+}