@compstats/core 0.2.0 → 0.4.0

package/dist/3d.js

@@ -660,6 +660,9 @@ function meanAbsoluteDeviation(values) {
   return mean(values.map((value) => Math.abs(value - center)));
 }
 function fusedMultiplyAdd(a, b, c) {
+  if (a * b === 0) {
+    return c + a * b;
+  }
   const [product, productError] = twoProduct(a, b);
   const [sum2, sumError] = twoSum(c, product);
   const rounded = sum2 + (sumError + productError);
@@ -711,129 +714,1142 @@ function type7(sorted, p) {
   return low;
 }
 
-// src/core/ols.ts
-var DEFAULT_LEAST_SQUARES_TOLERANCE = 0.0000001;
-function leastSquares(design, y, options = {}) {
-  const { weights, tolerance = DEFAULT_LEAST_SQUARES_TOLERANCE } = options;
-  const rows = design.length;
-  if (rows === 0) {
-    throw new RangeError("least squares needs at least one row");
-  }
-  const width = design[0].length;
-  if (design.some((row) => row.length !== width)) {
-    throw new RangeError("every design row needs the same number of columns");
-  }
-  if (y.length !== rows) {
-    throw new RangeError(`the response has ${y.length} values but the design has ${rows} rows`);
-  }
-  if (weights !== undefined) {
-    if (weights.length !== rows) {
-      throw new RangeError(`there are ${weights.length} weights but ${rows} rows`);
-    }
-    if (weights.some((weight) => !(weight >= 0))) {
-      throw new RangeError("weights cannot be negative or missing");
-    }
-  }
-  const scale = weights?.map((weight) => Math.sqrt(weight));
-  const scaled = (value, row) => scale === undefined ? value : value * scale[row];
-  const columns = Array.from({ length: width }, (_, column) => design.map((row, index) => scaled(row[column], index)));
-  const projected = y.map(scaled);
-  const { householders, pivot, rank } = decompose(columns, tolerance, rows);
-  applyHouseholders(columns, householders, projected, Math.min(rank, rows - 1));
-  const solved = backSubstitute(columns, projected, rank);
-  const coefficients = new Array(width).fill(null);
-  pivot.slice(0, rank).forEach((column, position) => {
-    coefficients[column] = solved[position];
+// src/core/special.ts
+var LANCZOS_G = 607 / 128;
+var LANCZOS_LEAD = 0.9999999999999971;
+var LANCZOS_TAIL = [
+  57.15623566586292,
+  -59.59796035547549,
+  14.136097974741746,
+  -0.4919138160976202,
+  0.00003399464998481189,
+  0.00004652362892704858,
+  -0.00009837447530487956,
+  0.0001580887032249125,
+  -0.00021026444172410488,
+  0.00021743961811521265,
+  -0.0001643181065367639,
+  0.00008441822398385275,
+  -0.000026190838401581408,
+  0.0000036899182659531625
+];
+var LOG_SQRT_TWO_PI = 0.5 * Math.log(2 * Math.PI);
+function lanczosSeries(x) {
+  return LANCZOS_LEAD + sum(LANCZOS_TAIL.map((coefficient, index) => coefficient / (x + index)));
+}
+function logGamma(x) {
+  if (!(x > 0)) {
+    return Number.NaN;
+  }
+  const shifted = x + LANCZOS_G - 0.5;
+  return LOG_SQRT_TWO_PI + (x - 0.5) * Math.log(shifted) - shifted + Math.log(lanczosSeries(x));
+}
+function logBeta(a, b) {
+  if (!(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  const shiftedSum = a + b + LANCZOS_G - 0.5;
+  return LOG_SQRT_TWO_PI - (LANCZOS_G - 0.5) + Math.log(lanczosSeries(a)) + Math.log(lanczosSeries(b)) - Math.log(lanczosSeries(a + b)) + (a - 0.5) * Math.log1p(-b / shiftedSum) + (b - 0.5) * Math.log1p(-a / shiftedSum) - 0.5 * Math.log(shiftedSum);
+}
+var FRACTION_MAX_STEPS = 400;
+var FRACTION_EPSILON = 0.0000000000000003;
+var FRACTION_FLOOR = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001;
+function betaContinuedFraction(x, a, b) {
+  const total = a + b;
+  const aPlus = a + 1;
+  const aMinus = a - 1;
+  let c = 1;
+  let d = 1 - total * x / aPlus;
+  if (Math.abs(d) < FRACTION_FLOOR) {
+    d = FRACTION_FLOOR;
+  }
+  d = 1 / d;
+  let value = d;
+  for (let step = 1;step <= FRACTION_MAX_STEPS; step += 1) {
+    const twice = 2 * step;
+    const even = step * (b - step) * x / ((aMinus + twice) * (a + twice));
+    d = 1 + even * d;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = 1 + even / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    value *= d * c;
+    const odd = -(a + step) * (total + step) * x / ((a + twice) * (aPlus + twice));
+    d = 1 + odd * d;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = 1 + odd / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    const delta = d * c;
+    value *= delta;
+    if (Math.abs(delta - 1) < FRACTION_EPSILON) {
+      break;
+    }
+  }
+  return value;
+}
+function incompleteBeta(x, a, b) {
+  if (Number.isNaN(x)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
+    return 0;
+  }
+  if (x >= 1) {
+    return 1;
+  }
+  return incompleteBetaSplit(x, 1 - x, a, b);
+}
+function incompleteBetaSplit(x, complement, a, b) {
+  if (Number.isNaN(x) || Number.isNaN(complement) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
+    return 0;
+  }
+  if (complement <= 0) {
+    return 1;
+  }
+  const logX = complement < 0.5 ? Math.log1p(-complement) : Math.log(x);
+  const logComplement = x < 0.5 ? Math.log1p(-x) : Math.log(complement);
+  const front = Math.exp(a * logX + b * logComplement - logBeta(a, b));
+  if (x < (a + 1) / (a + b + 2)) {
+    return front * betaContinuedFraction(x, a, b) / a;
+  }
+  return 1 - front * betaContinuedFraction(complement, b, a) / b;
+}
+var GAMMA_MAX_STEPS = 1000;
+var GAMMA_EPSILON = 0.0000000000000003;
+function lowerGammaSeries(a, x) {
+  let term = 1 / a;
+  let total = term;
+  for (let step = 1;step <= GAMMA_MAX_STEPS; step += 1) {
+    term *= x / (a + step);
+    total += term;
+    if (Math.abs(term) < Math.abs(total) * GAMMA_EPSILON) {
+      break;
+    }
+  }
+  return total * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGammaFraction(a, x) {
+  let b = x + 1 - a;
+  let c = 1 / FRACTION_FLOOR;
+  let d = 1 / b;
+  let value = d;
+  for (let step = 1;step <= GAMMA_MAX_STEPS; step += 1) {
+    const numerator = -step * (step - a);
+    b += 2;
+    d = numerator * d + b;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = b + numerator / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    const delta = d * c;
+    value *= delta;
+    if (Math.abs(delta - 1) < GAMMA_EPSILON) {
+      break;
+    }
+  }
+  return value * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGamma(a, x) {
+  if (x <= 0) {
+    return 1;
+  }
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  return x < a + 1 ? 1 - lowerGammaSeries(a, x) : upperGammaFraction(a, x);
+}
+function normalCdf(z) {
+  if (Number.isNaN(z)) {
+    return Number.NaN;
+  }
+  const lower = 0.5 * upperGamma(0.5, 0.5 * z * z);
+  return z > 0 ? 1 - lower : lower;
+}
+var BELOW_ONE = 1 - Number.EPSILON / 2;
+var INVERSE_MAX_STEPS = 200;
+function inverseGuess(p, a, b) {
+  if (a >= 1 && b >= 1) {
+    const tail = p < 0.5 ? p : 1 - p;
+    const t = Math.sqrt(-2 * Math.log(tail));
+    const normal = (p < 0.5 ? -1 : 1) * ((2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t);
+    const scale = (normal * normal - 3) / 6;
+    const harmonic = 2 / (1 / (2 * a - 1) + 1 / (2 * b - 1));
+    const w = normal * Math.sqrt(scale + harmonic) / harmonic - (1 / (2 * b - 1) - 1 / (2 * a - 1)) * (scale + 5 / 6 - 2 / (3 * harmonic));
+    return a / (a + b * Math.exp(2 * w));
+  }
+  const lower = Math.exp(a * Math.log(a / (a + b))) / a;
+  const upper = Math.exp(b * Math.log(b / (a + b))) / b;
+  const total = lower + upper;
+  if (p < lower / total) {
+    return Math.pow(a * total * p, 1 / a);
+  }
+  return 1 - Math.pow(b * total * (1 - p), 1 / b);
+}
+function inverseIncompleteBeta(p, a, b) {
+  if (Number.isNaN(p) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  if (p <= 0) {
+    return 0;
+  }
+  if (p >= 1) {
+    return 1;
+  }
+  const logBetaValue = logBeta(a, b);
+  let lower = 0;
+  let upper = 1;
+  let x = inverseGuess(p, a, b);
+  if (!(x > 0) || !(x < 1)) {
+    x = 0.5;
+  }
+  for (let step = 0;step < INVERSE_MAX_STEPS; step += 1) {
+    const residual = incompleteBeta(x, a, b) - p;
+    if (residual < 0) {
+      lower = x;
+    } else {
+      upper = x;
+    }
+    const density = Math.exp((a - 1) * Math.log(x) + (b - 1) * Math.log1p(-x) - logBetaValue);
+    let next = density > 0 && Number.isFinite(density) ? x - residual / density : Number.NaN;
+    if (!(next > lower) || !(next < upper)) {
+      next = 0.5 * (lower + upper);
+    }
+    if (next === x) {
+      break;
+    }
+    const moved = Math.abs(next - x);
+    x = next;
+    if (moved <= Number.EPSILON * x) {
+      break;
+    }
+  }
+  return Math.min(x, BELOW_ONE);
+}
+
+// src/core/tdist.ts
+function isNonCentral(ncp) {
+  return ncp !== undefined && ncp !== 0;
+}
+function isBadArgument(value, df, ncp) {
+  return Number.isNaN(value) || !(df > 0) || ncp !== undefined && Number.isNaN(ncp);
+}
+function dt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralDensity(x, df, ncp) : centralDensity(x, df);
+}
+function pt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralProbability(x, df, ncp) : centralProbability(x, df);
+}
+function qt(p, df, ncp) {
+  if (isBadArgument(p, df, ncp) || p < 0 || p > 1) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralQuantile(p, df, ncp) : centralQuantile(p, df);
+}
+function centralDensity(x, df) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  const logDensity = -0.5 * Math.log(df) - logBeta(0.5, df / 2) - (df + 1) / 2 * Math.log1p(x * x / df);
+  return Math.exp(logDensity);
+}
+function centralProbability(x, df) {
+  if (x === 0) {
+    return 0.5;
+  }
+  if (x === Number.POSITIVE_INFINITY) {
+    return 1;
+  }
+  if (x === Number.NEGATIVE_INFINITY) {
+    return 0;
+  }
+  const tail = upperTail(Math.abs(x), df);
+  return x < 0 ? tail : 1 - tail;
+}
+function upperTail(t, df) {
+  const squared = t * t;
+  if (!Number.isFinite(squared)) {
+    return 0;
+  }
+  const total = df + squared;
+  return 0.5 * incompleteBetaSplit(df / total, squared / total, df / 2, 0.5);
+}
+var POLISH_MAX_STEPS = 4;
+function centralQuantile(p, df) {
+  if (p === 0.5) {
+    return 0;
+  }
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  const tail = p < 0.5 ? p : 1 - p;
+  const sign = p < 0.5 ? -1 : 1;
+  const twoSided = 2 * tail;
+  let squared;
+  if (twoSided > 0.5) {
+    const near = inverseIncompleteBeta(1 - twoSided, 0.5, df / 2);
+    squared = df * near / (1 - near);
+  } else {
+    const far = inverseIncompleteBeta(twoSided, df / 2, 0.5);
+    squared = df * (1 - far) / far;
+  }
+  return sign * polish(Math.sqrt(squared), tail, df);
+}
+function polish(start, tail, df) {
+  let t = start;
+  for (let step = 0;step < POLISH_MAX_STEPS; step += 1) {
+    const density = centralDensity(t, df);
+    if (!(density > 0) || !Number.isFinite(t)) {
+      break;
+    }
+    const move = (upperTail(t, df) - tail) / density;
+    const next = t + move;
+    if (!(next > 0) || !Number.isFinite(next) || Math.abs(move) > 0.25 * t) {
+      break;
+    }
+    if (next === t) {
+      break;
+    }
+    t = next;
+    if (Math.abs(move) <= Number.EPSILON * t) {
+      break;
+    }
+  }
+  return t;
+}
+var SERIES_MAX_STEPS = 1000;
+var SERIES_ERROR_MAX = 0.000000000001;
+var SERIES_NCP_LIMIT_SQUARED = 2 * Math.LN2 * 1022;
+var SERIES_DF_LIMIT = 400000;
+var SQRT_TWO_OVER_PI = Math.sqrt(2 / Math.PI);
+function nonCentralProbability(x, df, ncp) {
+  if (x === Number.POSITIVE_INFINITY) {
+    return 1;
+  }
+  if (x === Number.NEGATIVE_INFINITY) {
+    return 0;
+  }
+  const reflected = x < 0;
+  const t = reflected ? -x : x;
+  const delta = reflected ? -ncp : ncp;
+  const lower = df > SERIES_DF_LIMIT || delta * delta > SERIES_NCP_LIMIT_SQUARED ? normalApproximation(t, df, delta) : lenthSeries(t, df, delta);
+  return reflected ? 1 - lower : lower;
+}
+function normalApproximation(t, df, delta) {
+  const shrink = 1 / (4 * df);
+  const spread = Math.sqrt(1 + t * t * 2 * shrink);
+  return normalCdf((t * (1 - shrink) - delta) / spread);
+}
+function lenthSeries(t, df, delta) {
+  const squared = t * t;
+  const total = df + squared;
+  const x = squared / total;
+  const complement = df / total;
+  let sum2 = 0;
+  if (x > 0) {
+    const lambda = delta * delta;
+    let oddWeight = 0.5 * Math.exp(-0.5 * lambda);
+    let evenWeight = SQRT_TWO_OVER_PI * oddWeight * delta;
+    let remaining = 0.5 - oddWeight;
+    if (remaining < 0.0000001) {
+      remaining = -0.5 * Math.expm1(-0.5 * lambda);
+    }
+    let a = 0.5;
+    const b = 0.5 * df;
+    const powered = Math.pow(complement, b);
+    const logBetaValue = logBeta(0.5, b);
+    let oddTerm = incompleteBetaSplit(x, complement, a, b);
+    let oddStep = 2 * powered * Math.exp(a * Math.log(x) - logBetaValue);
+    let evenTerm = 1 - powered;
+    let evenStep = b * x * powered;
+    sum2 = oddWeight * oddTerm + evenWeight * evenTerm;
+    for (let step = 1;step <= SERIES_MAX_STEPS; step += 1) {
+      a += 1;
+      oddTerm -= oddStep;
+      evenTerm -= evenStep;
+      oddStep *= x * (a + b - 1) / a;
+      evenStep *= x * (a + b - 0.5) / (a + 0.5);
+      oddWeight *= lambda / (2 * step);
+      evenWeight *= lambda / (2 * step + 1);
+      remaining -= oddWeight;
+      if (remaining <= 0) {
+        break;
+      }
+      sum2 += oddWeight * oddTerm + evenWeight * evenTerm;
+      if (Math.abs(2 * remaining * (oddTerm - oddStep)) < SERIES_ERROR_MAX) {
+        break;
+      }
+    }
+  }
+  return Math.min(Math.max(sum2 + normalCdf(-delta), 0), 1);
+}
+function nonCentralDensity(x, df, ncp) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  if (Math.abs(x) > Math.sqrt(df * Number.EPSILON)) {
+    const stepped = x * Math.sqrt((df + 2) / df);
+    const difference = nonCentralProbability(stepped, df + 2, ncp) - nonCentralProbability(x, df, ncp);
+    return df / Math.abs(x) * Math.abs(difference);
+  }
+  return Math.exp(-0.5 * Math.log(df) - logBeta(0.5, df / 2) - 0.5 * ncp * ncp);
+}
+var QUANTILE_MAX_STEPS = 200;
+function nonCentralQuantile(p, df, ncp) {
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let upper = Math.max(1, ncp);
+  while (Number.isFinite(upper) && nonCentralProbability(upper, df, ncp) < p) {
+    upper *= 2;
+  }
+  let lower = Math.min(-1, -ncp);
+  while (Number.isFinite(lower) && nonCentralProbability(lower, df, ncp) > p) {
+    lower *= 2;
+  }
+  let t = 0.5 * (lower + upper);
+  for (let step = 0;step < QUANTILE_MAX_STEPS; step += 1) {
+    const residual = nonCentralProbability(t, df, ncp) - p;
+    if (residual < 0) {
+      lower = t;
+    } else {
+      upper = t;
+    }
+    const density = nonCentralDensity(t, df, ncp);
+    let next = density > 0 && Number.isFinite(density) ? t - residual / density : Number.NaN;
+    if (!(next > lower) || !(next < upper)) {
+      next = 0.5 * (lower + upper);
+    }
+    if (next === t) {
+      break;
+    }
+    const moved = Math.abs(next - t);
+    t = next;
+    if (moved <= Number.EPSILON * Math.abs(t)) {
+      break;
+    }
+  }
+  return t;
+}
+
+// src/core/linalg/matrix.ts
+function matrix(values, options) {
+  const { byrow = false, dimnames } = options;
+  const [nrow, ncol] = extents(values.length, options);
+  const dense = Float64Array.from(values);
+  const data = new Float64Array(nrow * ncol);
+  if (dense.length === 1 && data.length > 1) {
+    data.fill(dense[0]);
+  } else if (byrow) {
+    dense.forEach((value, index) => {
+      const i = Math.floor(index / ncol);
+      const j = index % ncol;
+      data[j * nrow + i] = value;
+    });
+  } else {
+    data.set(dense);
+  }
+  return make(nrow, ncol, data, dimnames ?? null);
+}
+function extents(length, { nrow, ncol }) {
+  if (nrow === undefined && ncol === undefined) {
+    throw new RangeError("matrix() needs nrow or ncol");
+  }
+  if (nrow !== undefined) {
+    requireExtent(nrow, "nrow");
+  }
+  if (ncol !== undefined) {
+    requireExtent(ncol, "ncol");
+  }
+  const scalar = length === 1;
+  if (nrow !== undefined && ncol !== undefined) {
+    if (!scalar && nrow * ncol !== length) {
+      throw new RangeError(length > nrow * ncol ? "data is too long" : `data length [${length}] is not nrow * ncol [${nrow} * ${ncol}]`);
+    }
+    return [nrow, ncol];
+  }
+  const given = nrow ?? ncol;
+  const name = nrow !== undefined ? "rows" : "columns";
+  if (given === 0) {
+    if (length !== 0) {
+      throw new RangeError("data is too long");
+    }
+    return [0, 0];
+  }
+  const other = scalar ? 1 : length / given;
+  if (!scalar && length % given !== 0) {
+    throw new RangeError(`data length [${length}] is not a multiple of the number of ${name} [${given}]`);
+  }
+  return nrow !== undefined ? [nrow, other] : [other, given];
+}
+function requireExtent(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer, got ${value}`);
+  }
+}
+function make(nrow, ncol, data, dimnames) {
+  if (data.length !== nrow * ncol) {
+    throw new RangeError(`data length [${data.length}] is not nrow * ncol [${nrow} * ${ncol}]`);
+  }
+  if (dimnames !== null) {
+    const [rows, columns] = dimnames;
+    if (rows !== null && rows.length !== nrow) {
+      throw new RangeError(`length of dimnames [1] (${rows.length}) not equal to array extent (${nrow})`);
+    }
+    if (columns !== null && columns.length !== ncol) {
+      throw new RangeError(`length of dimnames [2] (${columns.length}) not equal to array extent (${ncol})`);
+    }
+    dimnames = rows === null && columns === null ? null : [rows === null ? null : [...rows], columns === null ? null : [...columns]];
+  }
+  return { nrow, ncol, data, dimnames };
+}
+function fromRows(rows) {
+  const nrow = rows.length;
+  const first = rows[0];
+  if (first === undefined || first.length === 0) {
+    throw new RangeError("fromRows() needs at least one row with one value");
+  }
+  const ncol = first.length;
+  const ragged = rows.findIndex((row) => row.length !== ncol);
+  if (ragged !== -1) {
+    throw new RangeError(`every row needs ${ncol} values; row ${ragged} has ${rows[ragged].length}`);
+  }
+  const data = new Float64Array(nrow * ncol);
+  rows.forEach((row, i) => {
+    Float64Array.from(row).forEach((value, j) => {
+      data[j * nrow + i] = value;
+    });
   });
-  const fitted = design.map((row) => sum(zipWith(row, coefficients, (value, coefficient) => coefficient === null ? 0 : value * coefficient)));
-  const residuals = zipWith(y, fitted, (value, fit) => value - fit);
-  return { coefficients, fitted, residuals, rank };
+  return make(nrow, ncol, data, null);
+}
+function fromColumns(columns) {
+  const ncol = columns.length;
+  const first = columns[0];
+  if (first === undefined || first.length === 0) {
+    throw new RangeError("fromColumns() needs at least one column with one value");
+  }
+  const nrow = first.length;
+  const ragged = columns.findIndex((column) => column.length !== nrow);
+  if (ragged !== -1) {
+    throw new RangeError(`every column needs ${nrow} values; column ${ragged} has ${columns[ragged].length}`);
+  }
+  const data = new Float64Array(nrow * ncol);
+  columns.forEach((column, j) => {
+    data.set(column, j * nrow);
+  });
+  return make(nrow, ncol, data, null);
+}
+function at(m, i, j) {
+  if (!Number.isInteger(i) || i < 0 || i >= m.nrow) {
+    throw new RangeError(`row index ${i} is outside 0..${m.nrow - 1}`);
+  }
+  if (!Number.isInteger(j) || j < 0 || j >= m.ncol) {
+    throw new RangeError(`column index ${j} is outside 0..${m.ncol - 1}`);
+  }
+  return m.data[j * m.nrow + i];
+}
+function row(m, i) {
+  if (!Number.isInteger(i) || i < 0 || i >= m.nrow) {
+    throw new RangeError(`row index ${i} is outside 0..${m.nrow - 1}`);
+  }
+  return Array.from({ length: m.ncol }, (_, j) => m.data[j * m.nrow + i]);
+}
+function column(m, j) {
+  if (!Number.isInteger(j) || j < 0 || j >= m.ncol) {
+    throw new RangeError(`column index ${j} is outside 0..${m.ncol - 1}`);
+  }
+  return Array.from(m.data.subarray(j * m.nrow, (j + 1) * m.nrow));
+}
+function toRows(m) {
+  return Array.from({ length: m.nrow }, (_, i) => row(m, i));
+}
+function toColumns(m) {
+  return Array.from({ length: m.ncol }, (_, j) => column(m, j));
+}
+function fromFrame(data, columns) {
+  const nrow = frameRows(data);
+  const names = columns ?? numericColumns(data);
+  const buffer = new Float64Array(nrow * names.length);
+  names.forEach((name, j) => {
+    buffer.set(requireNumericColumn(data, name, "columns"), j * nrow);
+  });
+  return make(nrow, names.length, buffer, names.length === 0 ? null : [null, [...names]]);
+}
+
+// src/core/linalg/modelMatrix.ts
+function modelMatrix(data, spec) {
+  const { outcome, intercept = true } = spec;
+  const rowCount = frameRows(data);
+  const terms = orderTerms(spec.terms);
+  const columns = new Map;
+  const read = (name, role) => {
+    const held = columns.get(name);
+    if (held !== undefined) {
+      return held;
+    }
+    const column2 = requireNumericColumn(data, name, role);
+    columns.set(name, column2);
+    return column2;
+  };
+  if (outcome !== undefined) {
+    read(outcome, "outcome");
+  }
+  terms.forEach((factors) => {
+    factors.forEach((name) => read(name, "terms"));
+  });
+  const involved = [...columns.values()];
+  const rows = Array.from({ length: rowCount }, (_, row2) => row2).filter((row2) => involved.every((column2) => Number.isFinite(column2[row2])));
+  const termColumns = terms.map((factors) => rows.map((row2) => factors.reduce((product, name) => product * columns.get(name)[row2], 1)));
+  const design = intercept ? [rows.map(() => 1), ...termColumns] : termColumns;
+  const names = [
+    ...intercept ? ["(Intercept)"] : [],
+    ...terms.map((factors) => factors.join(":"))
+  ];
+  const assign = [
+    ...intercept ? [0] : [],
+    ...terms.map((_, index) => index + 1)
+  ];
+  const n = rows.length;
+  const p = design.length;
+  const buffer = new Float64Array(n * p);
+  design.forEach((column2, j) => {
+    buffer.set(column2, j * n);
+  });
+  return {
+    matrix: make(n, p, buffer, p === 0 ? null : [null, names]),
+    rows,
+    assign,
+    termLabels: names.slice(intercept ? 1 : 0)
+  };
+}
+function orderTerms(terms) {
+  const seen = new Set;
+  const unique = [];
+  terms.forEach((term) => {
+    const factors = typeof term === "string" ? [term] : term;
+    if (factors.length === 0) {
+      throw new RangeError("an interaction term needs at least one column name");
+    }
+    const key = [...factors].sort().join("\x00");
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(factors);
+    }
+  });
+  return unique.map((factors, index) => ({ factors, index })).sort((a, b) => a.factors.length - b.factors.length || a.index - b.index).map(({ factors }) => factors);
+}
+
+// src/core/linalg/namedVector.ts
+function namedVector(names, values) {
+  if (names.length !== values.length) {
+    throw new RangeError(`a named vector needs one name per value: ${names.length} names, ${values.length} values`);
+  }
+  return { names: [...names], values: [...values] };
+}
+function lookup(v, name) {
+  const index = v.names.indexOf(name);
+  return index === -1 ? undefined : v.values[index];
+}
+
+// src/core/linalg/ops.ts
+function t(m) {
+  const { nrow, ncol } = m;
+  const data = new Float64Array(nrow * ncol);
+  for (let j = 0;j < ncol; j++) {
+    for (let i = 0;i < nrow; i++) {
+      data[i * ncol + j] = m.data[j * nrow + i];
+    }
+  }
+  const dimnames = m.dimnames === null ? null : [m.dimnames[1], m.dimnames[0]];
+  return make(ncol, nrow, data, dimnames);
+}
+var transpose = t;
+function matmul(x, y) {
+  const [left, right] = conformProduct(x, y);
+  if (left.ncol !== right.nrow) {
+    throw new RangeError(`non-conformable arguments: ${left.nrow} x ${left.ncol} %*% ${right.nrow} x ${right.ncol}`);
+  }
+  const data = product(left, right);
+  return make(left.nrow, right.ncol, data, productDimnames(left, right));
+}
+function conformProduct(x, y) {
+  if (isMatrix(x)) {
+    if (isMatrix(y)) {
+      return [x, y];
+    }
+    return [x, y.length === x.ncol ? asColumn(y) : asRow(y)];
+  }
+  if (isMatrix(y)) {
+    return [x.length === y.nrow ? asRow(x) : asColumn(x), y];
+  }
+  return [asRow(x), x.length === 1 ? asRow(y) : asColumn(y)];
+}
+function crossprod(x, y = x) {
+  const left = asColumn(x);
+  const right = isMatrix(y) ? y : y.length === left.nrow ? asColumn(y) : asRow(y);
+  if (left.nrow !== right.nrow) {
+    throw new RangeError(`non-conformable arguments: crossprod of ${left.nrow} x ${left.ncol} and ${right.nrow} x ${right.ncol}`);
+  }
+  return matmul(t(left), right);
+}
+function tcrossprod(x, y = x) {
+  const bothVectors = !isMatrix(x) && !isMatrix(y);
+  const left = isMatrix(x) ? x : isMatrix(y) && y.ncol === x.length ? asRow(x) : asColumn(x);
+  const right = isMatrix(y) ? y : !bothVectors && left.nrow === 1 ? asRow(y) : asColumn(y);
+  if (left.ncol !== right.ncol) {
+    throw new RangeError(`non-conformable arguments: tcrossprod of ${left.nrow} x ${left.ncol} and ${right.nrow} x ${right.ncol}`);
+  }
+  return matmul(left, t(right));
+}
+function product(x, y) {
+  const { nrow, ncol: inner } = x;
+  const { ncol } = y;
+  const data = new Float64Array(nrow * ncol);
+  for (let j = 0;j < ncol; j++) {
+    for (let k = 0;k < inner; k++) {
+      const factor = y.data[j * y.nrow + k];
+      for (let i = 0;i < nrow; i++) {
+        data[j * nrow + i] = fusedMultiplyAdd(x.data[k * nrow + i], factor, data[j * nrow + i]);
+      }
+    }
+  }
+  return data;
+}
+function productDimnames(x, y) {
+  const rows = x.dimnames?.[0] ?? null;
+  const columns = y.dimnames?.[1] ?? null;
+  return rows === null && columns === null ? null : [rows, columns];
+}
+function asColumn(value) {
+  if (isMatrix(value)) {
+    return value;
+  }
+  return make(value.length, 1, Float64Array.from(value), null);
+}
+function asRow(value) {
+  return make(1, value.length, Float64Array.from(value), null);
+}
+function isMatrix(value) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (typeof value === "object" && value !== null && "nrow" in value && "ncol" in value && "data" in value) {
+    return true;
+  }
+  throw new TypeError("expected a Matrix or an array of numbers");
+}
+function cbind(...parts) {
+  const matrices = parts.map(asColumn);
+  const first = matrices[0];
+  if (first === undefined) {
+    throw new RangeError("cbind() needs at least one argument");
+  }
+  const nrow = first.nrow;
+  matrices.forEach((m, index) => {
+    if (m.nrow !== nrow) {
+      throw new RangeError(isMatrix(parts[index]) ? `number of rows of matrices must match (see arg ${index + 1})` : `number of rows of result is not a multiple of vector length (arg ${index + 1})`);
+    }
+  });
+  const ncol = matrices.reduce((total, m) => total + m.ncol, 0);
+  const data = new Float64Array(nrow * ncol);
+  let offset = 0;
+  matrices.forEach((m) => {
+    data.set(m.data, offset);
+    offset += m.data.length;
+  });
+  const rows = matrices.find((m) => m.dimnames?.[0])?.dimnames?.[0] ?? null;
+  const columns = boundNames(matrices.map((m) => ({ names: m.dimnames?.[1] ?? null, count: m.ncol })));
+  return make(nrow, ncol, data, rows === null && columns === null ? null : [rows, columns]);
+}
+function rbind(...parts) {
+  if (parts.length === 0) {
+    throw new RangeError("rbind() needs at least one argument");
+  }
+  const transposed = parts.map((part) => isMatrix(part) ? t(part) : part);
+  try {
+    return t(cbind(...transposed));
+  } catch (error) {
+    if (error instanceof RangeError) {
+      throw new RangeError(error.message.replace("number of rows", "number of columns"));
+    }
+    throw error;
+  }
+}
+function boundNames(parts) {
+  if (parts.every((part) => part.names === null)) {
+    return null;
+  }
+  return parts.flatMap((part) => part.names ?? new Array(part.count).fill(""));
+}
+function diag(arg) {
+  if (typeof arg === "number") {
+    return identity(arg);
+  }
+  if (Array.isArray(arg)) {
+    const values = arg;
+    const n2 = values.length;
+    const data = new Float64Array(n2 * n2);
+    values.forEach((value, i) => {
+      data[i * n2 + i] = value;
+    });
+    return make(n2, n2, data, null);
+  }
+  const m = arg;
+  const n = Math.min(m.nrow, m.ncol);
+  return Array.from({ length: n }, (_, i) => m.data[i * m.nrow + i]);
+}
+function identity(order) {
+  if (!Number.isInteger(order) || order < 0) {
+    throw new RangeError(`order must be a non-negative integer, got ${order}`);
+  }
+  const data = new Float64Array(order * order);
+  for (let i = 0;i < order; i++) {
+    data[i * order + i] = 1;
+  }
+  return make(order, order, data, null);
+}
+
+// src/core/linalg/qr.ts
+var DEFAULT_QR_TOLERANCE = 0.0000001;
+function qr(x, options = {}) {
+  const { tolerance = DEFAULT_QR_TOLERANCE } = options;
+  if (!(tolerance >= 0)) {
+    throw new RangeError(`tolerance must be a non-negative number, got ${tolerance}`);
+  }
+  if (!isMatrix(x)) {
+    throw new TypeError("expected a Matrix");
+  }
+  if (!x.data.every(Number.isFinite)) {
+    throw new RangeError("NA/NaN/Inf in foreign function call (arg 1)");
+  }
+  const { nrow, ncol } = x;
+  const columns = Array.from({ length: ncol }, (_, j) => Array.from(x.data.subarray(j * nrow, (j + 1) * nrow)));
+  const { householders, pivot, rank } = decompose(columns, tolerance, nrow);
+  const data = new Float64Array(nrow * ncol);
+  columns.forEach((column2, j) => {
+    data.set(column2, j * nrow);
+  });
+  const rows = x.dimnames?.[0] ?? null;
+  const names = x.dimnames?.[1] ?? null;
+  const dimnames = rows === null && names === null ? null : [rows, names === null ? null : pivot.map((from) => names[from])];
+  return { qr: make(nrow, ncol, data, dimnames), qraux: householders, pivot, rank };
+}
+function qrCoef(q, y) {
+  if (isMatrix(y)) {
+    requireRows(q, y.nrow);
+    const width = q.qr.ncol;
+    const data = new Float64Array(width * y.ncol);
+    for (let j = 0;j < y.ncol; j++) {
+      const solved = coefficientsOf(q, Array.from(y.data.subarray(j * y.nrow, (j + 1) * y.nrow)));
+      solved.forEach((value, i) => {
+        data[j * width + i] = value ?? Number.NaN;
+      });
+    }
+    return make(width, y.ncol, data, readerDimnames(originalColumnNames(q), y));
+  }
+  requireRows(q, y.length);
+  return coefficientsOf(q, y);
+}
+function coefficientsOf(q, y) {
+  const qty = transformed(q, y, true);
+  const solved = backSubstitute(q.qr, qty, q.rank);
+  const coefficients = new Array(q.qr.ncol).fill(null);
+  q.pivot.slice(0, q.rank).forEach((column2, position) => {
+    coefficients[column2] = solved[position];
+  });
+  return coefficients;
+}
+function originalColumnNames(q) {
+  const pivoted = q.qr.dimnames?.[1] ?? null;
+  if (pivoted === null) {
+    return null;
+  }
+  const names = new Array(pivoted.length);
+  q.pivot.forEach((original, position) => {
+    names[original] = pivoted[position];
+  });
+  return names;
+}
+function qrFitted(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, transformed(q, column2, true).map((value, index) => index < q.rank ? value : 0), false));
+}
+function qrResid(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, transformed(q, column2, true).map((value, index) => index < q.rank ? 0 : value), false));
+}
+function qrQty(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, column2, true));
+}
+function qrQy(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, column2, false));
+}
+function perColumn(q, y, read) {
+  if (isMatrix(y)) {
+    requireRows(q, y.nrow);
+    const data = new Float64Array(y.nrow * y.ncol);
+    for (let j = 0;j < y.ncol; j++) {
+      data.set(read(Array.from(y.data.subarray(j * y.nrow, (j + 1) * y.nrow))), j * y.nrow);
+    }
+    return make(y.nrow, y.ncol, data, readerDimnames(null, y));
+  }
+  requireRows(q, y.length);
+  return read(y);
+}
+function readerDimnames(rows, y) {
+  const columns = y.dimnames?.[1] ?? null;
+  return rows === null && columns === null ? null : [rows, columns];
+}
+function transformed(q, y, transpose2) {
+  const result = [...y];
+  const count = reflectorCount(q);
+  if (transpose2) {
+    for (let step = 0;step < count; step++) {
+      applyReflector(q, step, result);
+    }
+  } else {
+    for (let step = count - 1;step >= 0; step--) {
+      applyReflector(q, step, result);
+    }
+  }
+  return result;
+}
+function qrQ(q) {
+  const { nrow, ncol } = q.qr;
+  const width = Math.min(nrow, ncol);
+  const data = new Float64Array(nrow * width);
+  for (let j = 0;j < width; j++) {
+    const unit = new Array(nrow).fill(0);
+    unit[j] = 1;
+    data.set(transformed(q, unit, false), j * nrow);
+  }
+  return make(nrow, width, data, null);
+}
+function qrR(q) {
+  const { nrow, ncol } = q.qr;
+  const height = Math.min(nrow, ncol);
+  const data = new Float64Array(height * ncol);
+  for (let j = 0;j < ncol; j++) {
+    for (let i = 0;i <= Math.min(j, height - 1); i++) {
+      data[j * height + i] = q.qr.data[j * nrow + i];
+    }
+  }
+  const rows = q.qr.dimnames?.[0]?.slice(0, height) ?? null;
+  const columns = q.qr.dimnames?.[1] ?? null;
+  return make(height, ncol, data, rows === null && columns === null ? null : [rows, columns]);
+}
+function requireRows(q, rows) {
+  if (rows !== q.qr.nrow) {
+    throw new RangeError("'qr' and 'y' must have the same number of rows");
+  }
+}
+function reflectorCount(q) {
+  return Math.min(q.rank, q.qr.nrow - 1);
+}
+function applyReflector(q, step, vector) {
+  const leading = q.qraux[step];
+  if (leading === 0) {
+    return;
+  }
+  const { nrow } = q.qr;
+  const column2 = q.qr.data.subarray(step * nrow, (step + 1) * nrow);
+  let inner = leading * vector[step];
+  for (let row2 = step + 1;row2 < nrow; row2++) {
+    inner = fusedMultiplyAdd(column2[row2], vector[row2], inner);
+  }
+  const factor = -inner / leading;
+  vector[step] = fusedMultiplyAdd(factor, leading, vector[step]);
+  for (let row2 = step + 1;row2 < nrow; row2++) {
+    vector[row2] = fusedMultiplyAdd(factor, column2[row2], vector[row2]);
+  }
 }
 function decompose(columns, tolerance, rows) {
   const width = columns.length;
-  const pivot = columns.map((_, column) => column);
-  const originalNorms = columns.map((column) => norm(column, 0) || 1);
-  const householders = new Array(width).fill(0);
-  let live = width;
+  const pivot = columns.map((_, column2) => column2);
+  const qraux = columns.map((column2) => norm(column2, 0));
+  const lastNorms = [...qraux];
+  const originalNorms = qraux.map((value) => value || 1);
+  let k = width + 1;
   for (let step = 0;step < Math.min(rows, width); step++) {
-    while (step < live && norm(columns[step], step) < originalNorms[step] * tolerance) {
-      cycleToEnd(columns, pivot, originalNorms, step);
-      live -= 1;
+    while (step + 1 < k && qraux[step] < originalNorms[step] * tolerance) {
+      moveToEnd(columns, step);
+      moveToEnd(pivot, step);
+      moveToEnd(qraux, step);
+      moveToEnd(lastNorms, step);
+      moveToEnd(originalNorms, step);
+      k -= 1;
     }
     if (step === rows - 1) {
       continue;
     }
-    householders[step] = reflect(columns, step, rows);
+    reflect(columns, qraux, lastNorms, step, rows);
   }
-  return { householders, pivot, rank: Math.min(live, rows) };
+  return { householders: qraux, pivot, rank: Math.min(k - 1, rows) };
 }
-function reflect(columns, step, rows) {
-  const column = columns[step];
-  const length = norm(column, step);
+function reflect(columns, qraux, lastNorms, step, rows) {
+  const column2 = columns[step];
+  const length = norm(column2, step);
   if (length === 0) {
-    return 0;
+    return;
   }
-  const pivotNorm = column[step] < 0 ? -length : length;
-  for (let row = step;row < rows; row++) {
-    column[row] = column[row] / pivotNorm;
+  const pivotNorm = column2[step] < 0 ? -length : length;
+  const reciprocal = 1 / pivotNorm;
+  for (let row2 = step;row2 < rows; row2++) {
+    column2[row2] = column2[row2] * reciprocal;
   }
-  const leading = 1 + column[step];
-  column[step] = leading;
+  const leading = 1 + column2[step];
+  column2[step] = leading;
   for (let index = step + 1;index < columns.length; index++) {
     const other = columns[index];
     let inner = 0;
-    for (let row = step;row < rows; row++) {
-      inner += column[row] * other[row];
+    for (let row2 = step;row2 < rows; row2++) {
+      inner = fusedMultiplyAdd(column2[row2], other[row2], inner);
     }
     const factor = -inner / leading;
-    for (let row = step;row < rows; row++) {
-      other[row] = other[row] + factor * column[row];
+    for (let row2 = step;row2 < rows; row2++) {
+      other[row2] = fusedMultiplyAdd(factor, column2[row2], other[row2]);
     }
-  }
-  column[step] = -pivotNorm;
-  return leading;
-}
-function applyHouseholders(columns, householders, response, count) {
-  const rows = response.length;
-  for (let step = 0;step < count; step++) {
-    const leading = householders[step];
-    if (leading === 0) {
-      continue;
-    }
-    const column = columns[step];
-    let inner = leading * response[step];
-    for (let row = step + 1;row < rows; row++) {
-      inner += column[row] * response[row];
-    }
-    const factor = -inner / leading;
-    response[step] = response[step] + factor * leading;
-    for (let row = step + 1;row < rows; row++) {
-      response[row] = response[row] + factor * column[row];
+    const running = qraux[index];
+    if (running !== 0) {
+      const ratio = Math.abs(other[step]) / running;
+      const remaining = Math.max(1 - ratio * ratio, 0);
+      if (Math.abs(remaining) < 0.000001) {
+        qraux[index] = norm(other, step + 1);
+        lastNorms[index] = qraux[index];
+      } else {
+        qraux[index] = running * Math.sqrt(remaining);
+      }
     }
   }
+  qraux[step] = leading;
+  column2[step] = -pivotNorm;
 }
-function backSubstitute(columns, response, rank) {
-  const solved = new Array(rank).fill(0);
-  for (let row = rank - 1;row >= 0; row--) {
-    let value = response[row];
-    for (let column = row + 1;column < rank; column++) {
-      value -= columns[column][row] * solved[column];
+function backSubstitute(compact, response, rank) {
+  const { nrow } = compact;
+  const entry = (i, j) => compact.data[j * nrow + i];
+  const solved = response.slice(0, rank);
+  for (let column2 = rank - 1;column2 >= 0; column2--) {
+    const value = solved[column2] / entry(column2, column2);
+    solved[column2] = value;
+    for (let row2 = 0;row2 < column2; row2++) {
+      solved[row2] = fusedMultiplyAdd(-value, entry(row2, column2), solved[row2]);
     }
-    solved[row] = value / columns[row][row];
   }
   return solved;
 }
-function cycleToEnd(columns, pivot, originalNorms, step) {
-  moveToEnd(columns, step);
-  moveToEnd(pivot, step);
-  moveToEnd(originalNorms, step);
-}
 function moveToEnd(track, from) {
   const [moved] = track.splice(from, 1);
   track.push(moved);
 }
-function norm(column, from) {
-  return Math.hypot(...column.slice(from));
+function norm(column2, from) {
+  let squares = 0;
+  for (let row2 = from;row2 < column2.length; row2++) {
+    const value = column2[row2];
+    squares = fusedMultiplyAdd(value, value, squares);
+  }
+  return Math.sqrt(squares);
+}
+
+// src/core/linalg/lm.ts
+function lm(data, options) {
+  const { outcome, intercept = true, tolerance = DEFAULT_QR_TOLERANCE } = options;
+  const design = modelMatrix(data, options);
+  const { rows } = design;
+  const n = rows.length;
+  if (n === 0) {
+    throw new RangeError("0 (non-NA) cases");
+  }
+  const outcomeColumn = data[outcome];
+  const y = rows.map((row2) => outcomeColumn[row2]);
+  const factored = qr(design.matrix, { tolerance });
+  const coefficients = qrCoef(factored, y);
+  const residuals = qrResid(factored, y);
+  const fitted = zipWith(y, residuals, (value, residual) => value - residual);
+  const names = design.matrix.dimnames?.[1] ?? [];
+  const { rank } = factored;
+  const dfResidual = n - rank;
+  const interceptCount = intercept ? 1 : 0;
+  const rss = sum(residuals.map((r) => r * r));
+  const centered = intercept ? mean(fitted) : 0;
+  const mss = sum(fitted.map((f) => (f - centered) * (f - centered)));
+  const resvar = rss / dfResidual;
+  const numdf = rank - interceptCount;
+  const rSquared = numdf > 0 ? mss / (mss + rss) : 0;
+  const adjRSquared = numdf > 0 ? 1 - (1 - rSquared) * ((n - interceptCount) / dfResidual) : 0;
+  const standardErrors = standardErrorsOf(factored, resvar, names.length);
+  const tValues = zipWith(coefficients, standardErrors, (b, se) => b === null || se === null ? null : b / se);
+  const pValues = tValues.map((tv) => tv === null ? null : 2 * pt(-Math.abs(tv), dfResidual));
+  return {
+    coefficients: namedVector(names, coefficients),
+    standardErrors: namedVector(names, standardErrors),
+    tValues: namedVector(names, tValues),
+    pValues: namedVector(names, pValues),
+    fitted: padded(fitted, rows, outcomeColumn.length),
+    residuals: padded(residuals, rows, outcomeColumn.length),
+    rank,
+    dfResidual,
+    rSquared,
+    adjRSquared,
+    sigma: Math.sqrt(resvar),
+    fStatistic: numdf > 0 ? { value: mss / numdf / resvar, numdf, dendf: dfResidual } : null,
+    rows,
+    termLabels: design.termLabels
+  };
+}
+function standardErrorsOf(factored, resvar, width) {
+  const { rank, pivot } = factored;
+  const { nrow } = factored.qr;
+  const r = (i, j) => factored.qr.data[j * nrow + i];
+  const inverse = Array.from({ length: rank }, (_, k) => {
+    const x = new Array(rank).fill(0);
+    x[k] = 1 / r(k, k);
+    for (let i = k - 1;i >= 0; i--) {
+      let total = 0;
+      for (let j = i + 1;j <= k; j++) {
+        total += r(i, j) * x[j];
+      }
+      x[i] = -total / r(i, i);
+    }
+    return x;
+  });
+  const diagonal = Array.from({ length: rank }, (_, i) => sum(inverse.map((columnOfInverse) => columnOfInverse[i] ** 2)));
+  const errors = new Array(width).fill(null);
+  pivot.slice(0, rank).forEach((original, position) => {
+    errors[original] = Math.sqrt(diagonal[position] * resvar);
+  });
+  return errors;
+}
+function padded(values, rows, length) {
+  const out = new Array(length).fill(Number.NaN);
+  rows.forEach((row2, index) => {
+    out[row2] = values[index];
+  });
+  return out;
 }
 
 // src/core/moderation.ts
@@ -850,43 +1866,25 @@ function moderationSurface(data, options) {
     }
     named.add(control);
   });
-  const rows = frameRows(data);
+  frameRows(data);
   const y = requireNumericColumn(data, outcome, "outcome");
   const ivColumn = requireNumericColumn(data, iv, "iv");
   const modColumn = requireNumericColumn(data, mod, "mod");
   const controlColumns = controls.map((control) => requireNumericColumn(data, control, "controls"));
   const modelColumns = [y, ivColumn, modColumn, ...controlColumns];
-  const completeRows = y.map((_, row) => row).filter((row) => modelColumns.every((column) => Number.isFinite(column[row])));
-  if (completeRows.length === 0) {
+  const anyComplete = y.some((_, row2) => modelColumns.every((column2) => Number.isFinite(column2[row2])));
+  if (!anyComplete) {
     throw new RangeError("the model has no complete rows: every row is missing a value in " + "the outcome, the IV, the moderator, or a control");
   }
-  const designColumns = [
-    { name: "(Intercept)", values: new Array(rows).fill(1) },
-    { name: iv, values: ivColumn },
-    { name: mod, values: modColumn },
-    ...controls.map((control, index) => ({
-      name: control,
-      values: controlColumns[index]
-    })),
-    ...interaction ? [
-      {
-        name: `${iv}:${mod}`,
-        values: zipWith(ivColumn, modColumn, (a, b) => a * b)
-      }
-    ] : []
-  ];
-  const design = completeRows.map((row) => designColumns.map((column) => column.values[row]));
-  const fit = leastSquares(design, completeRows.map((row) => y[row]));
-  const coefficients = designColumns.map((column, index) => ({
-    name: column.name,
-    value: fit.coefficients[index] ?? null
-  }));
-  const fitted = new Array(rows).fill(Number.NaN);
-  const residuals = new Array(rows).fill(Number.NaN);
-  completeRows.forEach((row, survivor) => {
-    fitted[row] = fit.fitted[survivor];
-    residuals[row] = fit.residuals[survivor];
+  const fit = lm(data, {
+    outcome,
+    terms: [iv, mod, ...controls, ...interaction ? [[iv, mod]] : []]
   });
+  const { fitted, residuals } = fit;
+  const coefficients = fit.coefficients.names.map((name, index) => ({
+    name,
+    value: fit.coefficients.values[index] ?? null
+  }));
   const ivValues = rSeq(...extent(ivColumn), GRID_STEPS);
   const modValues = rSeq(...extent(modColumn), GRID_STEPS);
   const holds = Object.fromEntries(controls.map((control, index) => [
@@ -1980,5 +2978,5 @@ export {
   DEFAULT_SCATTER3D_STYLE
 };
 
-//# debugId=167ACAEEE5BCC45664756E2164756E21
+//# debugId=F613BD0490CF40B764756E2164756E21
 //# sourceMappingURL=3d.js.map