@compstats/core 0.3.0 → 0.4.0

package/dist/index.js

@@ -48,6 +48,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);
@@ -630,960 +633,1549 @@ function requireNumericColumn(data, name, role) {
   }
   return column;
 }
-// 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");
+// 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 width = design[0].length;
-  if (design.some((row) => row.length !== width)) {
-    throw new RangeError("every design row needs the same number of columns");
+  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;
   }
-  if (y.length !== rows) {
-    throw new RangeError(`the response has ${y.length} values but the design has ${rows} rows`);
+  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;
   }
-  if (weights !== undefined) {
-    if (weights.length !== rows) {
-      throw new RangeError(`there are ${weights.length} weights but ${rows} rows`);
+  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;
     }
-    if (weights.some((weight) => !(weight >= 0))) {
-      throw new RangeError("weights cannot be negative or missing");
+    c = 1 + even / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
     }
-  }
-  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];
-  });
-  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 };
-}
-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;
-  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;
+    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;
     }
-    if (step === rows - 1) {
-      continue;
+    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;
     }
-    householders[step] = reflect(columns, step, rows);
   }
-  return { householders, pivot, rank: Math.min(live, rows) };
+  return value;
 }
-function reflect(columns, step, rows) {
-  const column = columns[step];
-  const length = norm(column, step);
-  if (length === 0) {
+function incompleteBeta(x, a, b) {
+  if (Number.isNaN(x)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
     return 0;
   }
-  const pivotNorm = column[step] < 0 ? -length : length;
-  for (let row = step;row < rows; row++) {
-    column[row] = column[row] / pivotNorm;
+  if (x >= 1) {
+    return 1;
   }
-  const leading = 1 + column[step];
-  column[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];
-    }
-    const factor = -inner / leading;
-    for (let row = step;row < rows; row++) {
-      other[row] = other[row] + factor * column[row];
+  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;
     }
   }
-  column[step] = -pivotNorm;
-  return leading;
+  return total * Math.exp(-x + a * Math.log(x) - logGamma(a));
 }
-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;
+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;
     }
-    const column = columns[step];
-    let inner = leading * response[step];
-    for (let row = step + 1;row < rows; row++) {
-      inner += column[row] * response[row];
+    c = b + numerator / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
     }
-    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];
+    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 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];
-    }
-    solved[row] = value / columns[row][row];
+function upperGamma(a, x) {
+  if (x <= 0) {
+    return 1;
   }
-  return solved;
-}
-function cycleToEnd(columns, pivot, originalNorms, step) {
-  moveToEnd(columns, step);
-  moveToEnd(pivot, step);
-  moveToEnd(originalNorms, step);
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  return x < a + 1 ? 1 - lowerGammaSeries(a, x) : upperGammaFraction(a, x);
 }
-function moveToEnd(track, from) {
-  const [moved] = track.splice(from, 1);
-  track.push(moved);
+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;
 }
-function norm(column, from) {
-  return Math.hypot(...column.slice(from));
+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);
 }
-
-// src/core/moderation.ts
-var GRID_STEPS = 15;
-function moderationSurface(data, options) {
-  const { outcome, iv, mod, interaction = true, controls = [] } = options;
-  if (iv === mod) {
-    throw new RangeError(`\`iv\` and \`mod\` must name different columns, both name "${iv}"`);
+function inverseIncompleteBeta(p, a, b) {
+  if (Number.isNaN(p) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
   }
-  const named = new Set([outcome, iv, mod]);
-  controls.forEach((control) => {
-    if (named.has(control)) {
-      throw new RangeError(`control "${control}" already names the outcome, the iv, the mod, ` + "or another control");
-    }
-    named.add(control);
-  });
-  const rows = 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) {
-    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");
+  if (p <= 0) {
+    return 0;
   }
-  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 ivValues = rSeq(...extent(ivColumn), GRID_STEPS);
-  const modValues = rSeq(...extent(modColumn), GRID_STEPS);
-  const holds = Object.fromEntries(controls.map((control, index) => [
-    control,
-    mean(controlColumns[index].filter(Number.isFinite))
-  ]));
-  const weights = coefficients.map((term) => term.value ?? 0);
-  const predictions = modValues.flatMap((modValue) => ivValues.map((ivValue) => {
-    const gridRow = [
-      1,
-      ivValue,
-      modValue,
-      ...controls.map((control) => holds[control]),
-      ...interaction ? [ivValue * modValue] : []
-    ];
-    return sum(zipWith(gridRow, weights, (value, weight) => value * weight));
-  }));
-  const [dataLow, dataHigh] = extent(y);
-  const [surfaceLow, surfaceHigh] = extent(predictions);
-  return {
-    coefficients,
-    fitted,
-    residuals,
-    ivValues,
-    modValues,
-    predictions,
-    zlim: [Math.min(dataLow, surfaceLow), Math.max(dataHigh, surfaceHigh)],
-    holds
-  };
+  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);
 }
-function rSeq(from, to, length) {
-  if (from === to) {
-    return new Array(length).fill(from);
+
+// 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;
   }
-  const by = (to - from) / (length - 1);
-  return Array.from({ length }, (_, index) => index === 0 ? from : index === length - 1 ? to : from + index * by);
+  return isNonCentral(ncp) ? nonCentralDensity(x, df, ncp) : centralDensity(x, df);
 }
-// src/core/regression.ts
-function completePointRows(points) {
-  return points.flatMap((point, row) => Number.isFinite(point.x) && Number.isFinite(point.y) ? [row] : []);
+function pt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralProbability(x, df, ncp) : centralProbability(x, df);
 }
-function linearRegression(points) {
-  const rows = completePointRows(points);
-  if (rows.length === 0) {
-    return null;
+function qt(p, df, ncp) {
+  if (isBadArgument(p, df, ncp) || p < 0 || p > 1) {
+    return Number.NaN;
   }
-  const xs = rows.map((row) => points[row].x);
-  const ys = rows.map((row) => points[row].y);
-  const meanX = mean(xs);
-  const meanY = mean(ys);
-  const devX = xs.map((x) => x - meanX);
-  const devY = ys.map((y) => y - meanY);
-  const sumSquaresX = sum(devX.map((d) => d * d));
-  const sumSquaresY = sum(devY.map((d) => d * d));
-  const sumProducts = sum(zipWith(devX, devY, (dx, dy) => dx * dy));
-  const slope = sumSquaresX === 0 ? null : sumProducts / sumSquaresX;
-  const intercept = slope === null ? meanY : meanY - slope * meanX;
-  const correlation = sumSquaresX === 0 || sumSquaresY === 0 ? null : sumProducts / Math.sqrt(sumSquaresX * sumSquaresY);
-  const fittedComplete = xs.map((x) => slope === null ? intercept : intercept + slope * x);
-  const ssr = sum(fittedComplete.map((f) => (f - meanY) * (f - meanY)));
-  const sse = sum(zipWith(ys, fittedComplete, (y, f) => (y - f) * (y - f)));
-  const sst = sumSquaresY;
-  const rSquared = sst === 0 ? null : ssr / sst;
-  const fitted = new Array(points.length).fill(Number.NaN);
-  rows.forEach((row, survivor) => {
-    fitted[row] = fittedComplete[survivor];
-  });
-  return {
-    intercept,
-    slope,
-    correlation,
-    ssr,
-    sse,
-    sst,
-    rSquared,
-    fitted
-  };
+  return isNonCentral(ncp) ? nonCentralQuantile(p, df, ncp) : centralQuantile(p, df);
 }
-// src/core/matrix.ts
-var SMALLEST_NORMAL = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014;
-function determinant(matrix) {
-  return determinantOf(factorize(matrix));
+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 invertMatrix(matrix) {
-  const factorization = factorize(matrix);
-  const determinant2 = determinantOf(factorization);
-  const zeroPivot = zeroPivotOf(factorization);
-  if (zeroPivot !== null) {
-    return {
-      determinant: determinant2,
-      inverse: null,
-      singularity: "exact",
-      rcond: 0,
-      zeroPivot
-    };
+function centralProbability(x, df) {
+  if (x === 0) {
+    return 0.5;
   }
-  const inverse = solveForIdentity(factorization);
-  const rcond = 1 / (oneNorm(matrix) * oneNorm(inverse));
-  if (rcond < Number.EPSILON) {
-    return {
-      determinant: determinant2,
-      inverse: null,
-      singularity: "computational",
-      rcond,
-      zeroPivot: null
-    };
+  if (x === Number.POSITIVE_INFINITY) {
+    return 1;
   }
-  return {
-    determinant: determinant2,
-    inverse,
-    singularity: null,
-    rcond,
-    zeroPivot: null
-  };
+  if (x === Number.NEGATIVE_INFINITY) {
+    return 0;
+  }
+  const tail = upperTail(Math.abs(x), df);
+  return x < 0 ? tail : 1 - tail;
 }
-function factorize(matrix) {
-  const interchanged = Math.abs(matrix.y1) > Math.abs(matrix.x1);
-  const leading = interchanged ? matrix.y1 : matrix.x1;
-  const upperRight = interchanged ? matrix.y2 : matrix.x2;
-  const below = interchanged ? matrix.x1 : matrix.y1;
-  const belowRight = interchanged ? matrix.x2 : matrix.y2;
-  const multiplier = Math.abs(leading) >= SMALLEST_NORMAL ? below * (1 / leading) : below / leading;
-  const trailing = fusedMultiplyAdd(-multiplier, upperRight, belowRight);
-  return {
-    interchanged,
-    multiplier,
-    pivots: [leading, trailing],
-    upperRight
-  };
+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);
 }
-function determinantOf(factorization) {
-  const { interchanged, pivots } = factorization;
-  if (zeroPivotOf(factorization) !== null) {
+var POLISH_MAX_STEPS = 4;
+function centralQuantile(p, df) {
+  if (p === 0.5) {
     return 0;
   }
-  const modulus = sum(pivots.map((pivot) => Math.log(Math.abs(pivot))));
-  const sign = pivots.reduce((carried, pivot) => pivot < 0 ? -carried : carried, interchanged ? -1 : 1);
-  return sign * Math.exp(modulus);
+  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);
 }
-function zeroPivotOf(factorization) {
-  const [leading, trailing] = factorization.pivots;
-  if (leading === 0) {
-    return 1;
+var QUANTILE_MAX_STEPS = 200;
+function nonCentralQuantile(p, df, ncp) {
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
   }
-  return trailing === 0 ? 2 : null;
-}
-function solveForIdentity(factorization) {
-  const { interchanged } = factorization;
-  const [firstTop, firstBottom] = interchanged ? [0, 1] : [1, 0];
-  const [secondTop, secondBottom] = interchanged ? [1, 0] : [0, 1];
-  const [x1, y1] = solveColumn(factorization, firstTop, firstBottom);
-  const [x2, y2] = solveColumn(factorization, secondTop, secondBottom);
-  return {
-    x1: withoutNegativeZero(x1),
-    y1: withoutNegativeZero(y1),
-    x2: withoutNegativeZero(x2),
-    y2: withoutNegativeZero(y2)
-  };
-}
-function solveColumn(factorization, top, bottom) {
-  const { multiplier, pivots, upperRight } = factorization;
-  const lower = fusedMultiplyAdd(-multiplier, top, bottom) / pivots[1];
-  const upper = fusedMultiplyAdd(-upperRight, lower, top) / pivots[0];
-  return [upper, lower];
-}
-function oneNorm(matrix) {
-  return Math.max(Math.abs(matrix.x1) + Math.abs(matrix.y1), Math.abs(matrix.x2) + Math.abs(matrix.y2));
-}
-// src/core/pca.ts
-function principalComponents(points) {
-  const rows = completePointRows(points);
-  if (rows.length === 0) {
-    return null;
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
   }
-  const complete = rows.map((row) => points[row]);
-  const centerX = mean(complete.map((point) => point.x));
-  const centerY = mean(complete.map((point) => point.y));
-  const devX = complete.map((point) => point.x - centerX);
-  const devY = complete.map((point) => point.y - centerY);
-  const divisor = Math.max(1, complete.length - 1);
-  const varX = sum(devX.map((d) => d * d)) / divisor;
-  const varY = sum(devY.map((d) => d * d)) / divisor;
-  const covariance = sum(zipWith(devX, devY, (dx, dy) => dx * dy)) / divisor;
-  const [first, second] = componentsOf(varX, varY, covariance);
-  const scores = points.map(() => ({ x: Number.NaN, y: Number.NaN }));
-  rows.forEach((row, survivor) => {
-    const dx = devX[survivor];
-    const dy = devY[survivor];
-    scores[row] = {
-      x: dx * first.loadings[0] + dy * first.loadings[1],
-      y: dx * second.loadings[0] + dy * second.loadings[1]
-    };
-  });
-  return {
-    sdev: [sdevOf(first.variance), sdevOf(second.variance)],
-    rotation: [first.loadings, second.loadings],
-    center: { x: centerX, y: centerY },
-    scores
-  };
-}
-function componentsOf(varX, varY, covariance) {
-  if (covariance === 0) {
-    const alongX = { variance: varX, loadings: [1, 0] };
-    const alongY = { variance: varY, loadings: [0, 1] };
-    return varX >= varY ? [alongX, alongY] : [alongY, alongX];
+  let upper = Math.max(1, ncp);
+  while (Number.isFinite(upper) && nonCentralProbability(upper, df, ncp) < p) {
+    upper *= 2;
   }
-  const middle = (varX + varY) / 2;
-  const spread = Math.hypot((varX - varY) / 2, covariance);
-  const larger = middle + spread;
-  const smaller = middle - spread;
-  const fromRowX = larger - varX;
-  const fromRowY = larger - varY;
-  const direction = fromRowX >= fromRowY ? [covariance, fromRowX] : [fromRowY, covariance];
-  const leading = signed(unit(direction));
-  const trailing = signed([negated(leading[1]), leading[0]]);
-  return [
-    { variance: larger, loadings: leading },
-    { variance: smaller, loadings: trailing }
-  ];
-}
-function unit(vector) {
-  const length = Math.hypot(vector[0], vector[1]);
-  return [vector[0] / length, vector[1] / length];
-}
-function signed(vector) {
-  const dominant = Math.abs(vector[0]) >= Math.abs(vector[1]) ? vector[0] : vector[1];
-  return dominant >= 0 ? vector : [negated(vector[0]), negated(vector[1])];
+  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;
 }
-function negated(value) {
-  return withoutNegativeZero(-value);
+
+// 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 sdevOf(variance) {
-  return Math.sqrt(Math.max(0, variance));
+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];
 }
-// src/core/logit.ts
-var DEFAULT_LOGIT_EPSILON = 0.00000001;
-var DEFAULT_LOGIT_MAX_ITERATIONS = 25;
-var LINK_THRESHOLD = 30;
-var BOUND = 10 * Number.EPSILON;
-function logisticRegression(points, options = {}) {
-  const {
-    epsilon = DEFAULT_LOGIT_EPSILON,
-    maxIterations = DEFAULT_LOGIT_MAX_ITERATIONS
-  } = options;
-  const rows = completePointRows(points);
-  if (rows.length === 0) {
-    return null;
+function requireExtent(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer, got ${value}`);
   }
-  const complete = rows.map((row) => points[row]);
-  if (complete.some((point) => point.y !== 0 && point.y !== 1)) {
-    throw new RangeError("every outcome must be 0 or 1");
+}
+function make(nrow, ncol, data, dimnames) {
+  if (data.length !== nrow * ncol) {
+    throw new RangeError(`data length [${data.length}] is not nrow * ncol [${nrow} * ${ncol}]`);
   }
-  const outcomes = complete.map((point) => point.y);
-  const design = complete.map((point) => [1, point.x]);
-  let fitted = outcomes.map((outcome) => (outcome + 0.5) / 2);
-  let predictors = fitted.map(logit);
-  let previousDeviance = totalDeviance(outcomes, fitted);
-  let deviance = previousDeviance;
-  let coefficients = [Number.NaN, null];
-  let rank = 0;
-  let iterations = 0;
-  let converged = false;
-  for (let iteration = 1;iteration <= maxIterations; iteration++) {
-    iterations = iteration;
-    const working = predictors.map((predictor, row) => {
-      const probability = fitted[row];
-      const slope = linkSlope(predictor);
-      return {
-        weight: slope * slope / (probability * (1 - probability)),
-        response: predictor + (outcomes[row] - probability) / slope
-      };
-    });
-    const step = leastSquares(design, working.map((row) => row.response), {
-      weights: working.map((row) => row.weight),
-      tolerance: Math.min(0.0000001, epsilon / 1000)
-    });
-    if (step.coefficients.some((coefficient) => coefficient !== null && !Number.isFinite(coefficient))) {
-      break;
+  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})`);
     }
-    coefficients = step.coefficients;
-    rank = step.rank;
-    predictors = design.map((row) => sum(zipWith(row, coefficients, (value, coefficient) => coefficient === null ? 0 : value * coefficient)));
-    fitted = predictors.map(linkInverse);
-    deviance = totalDeviance(outcomes, fitted);
-    if (Math.abs(deviance - previousDeviance) / (0.1 + Math.abs(deviance)) < epsilon) {
-      converged = true;
-      break;
+    if (columns !== null && columns.length !== ncol) {
+      throw new RangeError(`length of dimnames [2] (${columns.length}) not equal to array extent (${ncol})`);
     }
-    previousDeviance = deviance;
+    dimnames = rows === null && columns === null ? null : [rows === null ? null : [...rows], columns === null ? null : [...columns]];
   }
-  const wholeMean = mean(outcomes);
-  const nullDeviance = totalDeviance(outcomes, outcomes.map(() => wholeMean));
-  const paddedFitted = new Array(points.length).fill(Number.NaN);
-  const paddedPredictors = new Array(points.length).fill(Number.NaN);
-  rows.forEach((row, survivor) => {
-    paddedFitted[row] = fitted[survivor];
-    paddedPredictors[row] = predictors[survivor];
-  });
-  return {
-    intercept: coefficients[0] ?? Number.NaN,
-    slope: coefficients[1] ?? null,
-    fitted: paddedFitted,
-    linearPredictors: paddedPredictors,
-    deviance,
-    nullDeviance,
-    aic: deviance + 2 * rank,
-    rank,
-    iterations,
-    converged,
-    saturated: fitted.some((probability) => probability > 1 - BOUND || probability < BOUND)
-  };
+  return { nrow, ncol, data, dimnames };
 }
-function predictLogit(fit, x) {
-  return linkInverse(fit.intercept + (fit.slope ?? 0) * x);
+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;
+    });
+  });
+  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 logit(probability) {
-  return Math.log(probability / (1 - probability));
+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 linkInverse(predictor) {
-  const odds = predictor < -LINK_THRESHOLD ? Number.EPSILON : predictor > LINK_THRESHOLD ? 1 / Number.EPSILON : Math.exp(predictor);
-  return odds / (1 + odds);
+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 linkSlope(predictor) {
-  if (predictor > LINK_THRESHOLD || predictor < -LINK_THRESHOLD) {
-    return Number.EPSILON;
+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}`);
   }
-  const odds = Math.exp(predictor);
-  return odds / ((1 + odds) * (1 + odds));
+  return Array.from(m.data.subarray(j * m.nrow, (j + 1) * m.nrow));
 }
-function totalDeviance(outcomes, probabilities) {
-  return sum(zipWith(outcomes, probabilities, (outcome, probability) => 2 * (surprise(outcome, probability) + surprise(1 - outcome, 1 - probability))));
+function toRows(m) {
+  return Array.from({ length: m.nrow }, (_, i) => row(m, i));
 }
-function surprise(outcome, probability) {
-  return outcome !== 0 ? outcome * Math.log(outcome / probability) : 0;
+function toColumns(m) {
+  return Array.from({ length: m.ncol }, (_, j) => column(m, j));
 }
-// 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 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 logGamma(x) {
-  if (!(x > 0)) {
-    return Number.NaN;
+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`);
   }
-  const shifted = x + LANCZOS_G - 0.5;
-  return LOG_SQRT_TWO_PI + (x - 0.5) * Math.log(shifted) - shifted + Math.log(lanczosSeries(x));
+  return { names: [...names], values: [...values] };
 }
-function logBeta(a, b) {
-  if (!(a > 0) || !(b > 0)) {
-    return Number.NaN;
+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 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);
+  const dimnames = m.dimnames === null ? null : [m.dimnames[1], m.dimnames[0]];
+  return make(ncol, nrow, data, dimnames);
 }
-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;
+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}`);
   }
-  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;
+  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];
     }
-    c = 1 + even / c;
-    if (Math.abs(c) < FRACTION_FLOOR) {
-      c = FRACTION_FLOOR;
+    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]);
+      }
     }
-    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;
+  }
+  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})`);
     }
-    c = 1 + odd / c;
-    if (Math.abs(c) < FRACTION_FLOOR) {
-      c = FRACTION_FLOOR;
+  });
+  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"));
     }
-    d = 1 / d;
-    const delta = d * c;
-    value *= delta;
-    if (Math.abs(delta - 1) < FRACTION_EPSILON) {
-      break;
+    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));
   }
-  return value;
+  requireRows(q, y.length);
+  return coefficientsOf(q, y);
 }
-function incompleteBeta(x, a, b) {
-  if (Number.isNaN(x)) {
-    return Number.NaN;
+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;
   }
-  if (x <= 0) {
-    return 0;
+  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));
   }
-  if (x >= 1) {
-    return 1;
+  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 incompleteBetaSplit(x, 1 - x, a, b);
+  return result;
 }
-function incompleteBetaSplit(x, complement, a, b) {
-  if (Number.isNaN(x) || Number.isNaN(complement) || !(a > 0) || !(b > 0)) {
-    return Number.NaN;
+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];
+    }
   }
-  if (x <= 0) {
-    return 0;
+  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");
   }
-  if (complement <= 0) {
-    return 1;
+}
+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 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;
+  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]);
   }
-  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;
+function decompose(columns, tolerance, rows) {
+  const width = columns.length;
+  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 + 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;
     }
+    reflect(columns, qraux, lastNorms, step, rows);
   }
-  return total * Math.exp(-x + a * Math.log(x) - logGamma(a));
+  return { householders: qraux, pivot, rank: Math.min(k - 1, rows) };
 }
-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;
+function reflect(columns, qraux, lastNorms, step, rows) {
+  const column2 = columns[step];
+  const length = norm(column2, step);
+  if (length === 0) {
+    return;
+  }
+  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 + column2[step];
+  column2[step] = leading;
+  for (let index = step + 1;index < columns.length; index++) {
+    const other = columns[index];
+    let inner = 0;
+    for (let row2 = step;row2 < rows; row2++) {
+      inner = fusedMultiplyAdd(column2[row2], other[row2], inner);
     }
-    c = b + numerator / c;
-    if (Math.abs(c) < FRACTION_FLOOR) {
-      c = FRACTION_FLOOR;
+    const factor = -inner / leading;
+    for (let row2 = step;row2 < rows; row2++) {
+      other[row2] = fusedMultiplyAdd(factor, column2[row2], other[row2]);
     }
-    d = 1 / d;
-    const delta = d * c;
-    value *= delta;
-    if (Math.abs(delta - 1) < GAMMA_EPSILON) {
-      break;
+    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);
+      }
     }
   }
-  return value * Math.exp(-x + a * Math.log(x) - logGamma(a));
+  qraux[step] = leading;
+  column2[step] = -pivotNorm;
+}
+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]);
+    }
+  }
+  return solved;
 }
-function upperGamma(a, x) {
-  if (x <= 0) {
-    return 1;
+function moveToEnd(track, from) {
+  const [moved] = track.splice(from, 1);
+  track.push(moved);
+}
+function norm(column2, from) {
+  let squares = 0;
+  for (let row2 = from;row2 < column2.length; row2++) {
+    const value = column2[row2];
+    squares = fusedMultiplyAdd(value, value, squares);
   }
-  if (!Number.isFinite(x)) {
-    return 0;
+  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
+var GRID_STEPS = 15;
+function moderationSurface(data, options) {
+  const { outcome, iv, mod, interaction = true, controls = [] } = options;
+  if (iv === mod) {
+    throw new RangeError(`\`iv\` and \`mod\` must name different columns, both name "${iv}"`);
+  }
+  const named = new Set([outcome, iv, mod]);
+  controls.forEach((control) => {
+    if (named.has(control)) {
+      throw new RangeError(`control "${control}" already names the outcome, the iv, the mod, ` + "or another control");
+    }
+    named.add(control);
+  });
+  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 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 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) => [
+    control,
+    mean(controlColumns[index].filter(Number.isFinite))
+  ]));
+  const weights = coefficients.map((term) => term.value ?? 0);
+  const predictions = modValues.flatMap((modValue) => ivValues.map((ivValue) => {
+    const gridRow = [
+      1,
+      ivValue,
+      modValue,
+      ...controls.map((control) => holds[control]),
+      ...interaction ? [ivValue * modValue] : []
+    ];
+    return sum(zipWith(gridRow, weights, (value, weight) => value * weight));
+  }));
+  const [dataLow, dataHigh] = extent(y);
+  const [surfaceLow, surfaceHigh] = extent(predictions);
+  return {
+    coefficients,
+    fitted,
+    residuals,
+    ivValues,
+    modValues,
+    predictions,
+    zlim: [Math.min(dataLow, surfaceLow), Math.max(dataHigh, surfaceHigh)],
+    holds
+  };
+}
+function rSeq(from, to, length) {
+  if (from === to) {
+    return new Array(length).fill(from);
   }
-  return x < a + 1 ? 1 - lowerGammaSeries(a, x) : upperGammaFraction(a, x);
+  const by = (to - from) / (length - 1);
+  return Array.from({ length }, (_, index) => index === 0 ? from : index === length - 1 ? to : from + index * by);
 }
-function normalCdf(z) {
-  if (Number.isNaN(z)) {
-    return Number.NaN;
+// src/core/regression.ts
+function completePointRows(points) {
+  return points.flatMap((point, row2) => Number.isFinite(point.x) && Number.isFinite(point.y) ? [row2] : []);
+}
+function linearRegression(points) {
+  const rows = completePointRows(points);
+  if (rows.length === 0) {
+    return null;
   }
-  const lower = 0.5 * upperGamma(0.5, 0.5 * z * z);
-  return z > 0 ? 1 - lower : lower;
+  const xs = rows.map((row2) => points[row2].x);
+  const ys = rows.map((row2) => points[row2].y);
+  const meanX = mean(xs);
+  const meanY = mean(ys);
+  const devX = xs.map((x) => x - meanX);
+  const devY = ys.map((y) => y - meanY);
+  const sumSquaresX = sum(devX.map((d) => d * d));
+  const sumSquaresY = sum(devY.map((d) => d * d));
+  const sumProducts = sum(zipWith(devX, devY, (dx, dy) => dx * dy));
+  const slope = sumSquaresX === 0 ? null : sumProducts / sumSquaresX;
+  const intercept = slope === null ? meanY : meanY - slope * meanX;
+  const correlation = sumSquaresX === 0 || sumSquaresY === 0 ? null : sumProducts / Math.sqrt(sumSquaresX * sumSquaresY);
+  const fittedComplete = xs.map((x) => slope === null ? intercept : intercept + slope * x);
+  const ssr = sum(fittedComplete.map((f) => (f - meanY) * (f - meanY)));
+  const sse = sum(zipWith(ys, fittedComplete, (y, f) => (y - f) * (y - f)));
+  const sst = sumSquaresY;
+  const rSquared = sst === 0 ? null : ssr / sst;
+  const fitted = new Array(points.length).fill(Number.NaN);
+  rows.forEach((row2, survivor) => {
+    fitted[row2] = fittedComplete[survivor];
+  });
+  return {
+    intercept,
+    slope,
+    correlation,
+    ssr,
+    sse,
+    sst,
+    rSquared,
+    fitted
+  };
 }
-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));
+// src/core/matrix.ts
+var SMALLEST_NORMAL = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014;
+function determinant(matrix2) {
+  return determinantOf(factorize(matrix2));
+}
+function invertMatrix(matrix2) {
+  const factorization = factorize(matrix2);
+  const determinant2 = determinantOf(factorization);
+  const zeroPivot = zeroPivotOf(factorization);
+  if (zeroPivot !== null) {
+    return {
+      determinant: determinant2,
+      inverse: null,
+      singularity: "exact",
+      rcond: 0,
+      zeroPivot
+    };
   }
-  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);
+  const inverse = solveForIdentity(factorization);
+  const rcond = 1 / (oneNorm(matrix2) * oneNorm(inverse));
+  if (rcond < Number.EPSILON) {
+    return {
+      determinant: determinant2,
+      inverse: null,
+      singularity: "computational",
+      rcond,
+      zeroPivot: null
+    };
   }
-  return 1 - Math.pow(b * total * (1 - p), 1 / b);
+  return {
+    determinant: determinant2,
+    inverse,
+    singularity: null,
+    rcond,
+    zeroPivot: null
+  };
 }
-function inverseIncompleteBeta(p, a, b) {
-  if (Number.isNaN(p) || !(a > 0) || !(b > 0)) {
-    return Number.NaN;
-  }
-  if (p <= 0) {
+function factorize(matrix2) {
+  const interchanged = Math.abs(matrix2.y1) > Math.abs(matrix2.x1);
+  const leading = interchanged ? matrix2.y1 : matrix2.x1;
+  const upperRight = interchanged ? matrix2.y2 : matrix2.x2;
+  const below = interchanged ? matrix2.x1 : matrix2.y1;
+  const belowRight = interchanged ? matrix2.x2 : matrix2.y2;
+  const multiplier = Math.abs(leading) >= SMALLEST_NORMAL ? below * (1 / leading) : below / leading;
+  const trailing = fusedMultiplyAdd(-multiplier, upperRight, belowRight);
+  return {
+    interchanged,
+    multiplier,
+    pivots: [leading, trailing],
+    upperRight
+  };
+}
+function determinantOf(factorization) {
+  const { interchanged, pivots } = factorization;
+  if (zeroPivotOf(factorization) !== null) {
     return 0;
   }
-  if (p >= 1) {
+  const modulus = sum(pivots.map((pivot) => Math.log(Math.abs(pivot))));
+  const sign = pivots.reduce((carried, pivot) => pivot < 0 ? -carried : carried, interchanged ? -1 : 1);
+  return sign * Math.exp(modulus);
+}
+function zeroPivotOf(factorization) {
+  const [leading, trailing] = factorization.pivots;
+  if (leading === 0) {
     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);
+  return trailing === 0 ? 2 : null;
 }
-
-// src/core/tdist.ts
-function isNonCentral(ncp) {
-  return ncp !== undefined && ncp !== 0;
+function solveForIdentity(factorization) {
+  const { interchanged } = factorization;
+  const [firstTop, firstBottom] = interchanged ? [0, 1] : [1, 0];
+  const [secondTop, secondBottom] = interchanged ? [1, 0] : [0, 1];
+  const [x1, y1] = solveColumn(factorization, firstTop, firstBottom);
+  const [x2, y2] = solveColumn(factorization, secondTop, secondBottom);
+  return {
+    x1: withoutNegativeZero(x1),
+    y1: withoutNegativeZero(y1),
+    x2: withoutNegativeZero(x2),
+    y2: withoutNegativeZero(y2)
+  };
 }
-function isBadArgument(value, df, ncp) {
-  return Number.isNaN(value) || !(df > 0) || ncp !== undefined && Number.isNaN(ncp);
+function solveColumn(factorization, top, bottom) {
+  const { multiplier, pivots, upperRight } = factorization;
+  const lower = fusedMultiplyAdd(-multiplier, top, bottom) / pivots[1];
+  const upper = fusedMultiplyAdd(-upperRight, lower, top) / pivots[0];
+  return [upper, lower];
 }
-function dt(x, df, ncp) {
-  if (isBadArgument(x, df, ncp)) {
-    return Number.NaN;
-  }
-  return isNonCentral(ncp) ? nonCentralDensity(x, df, ncp) : centralDensity(x, df);
+function oneNorm(matrix2) {
+  return Math.max(Math.abs(matrix2.x1) + Math.abs(matrix2.y1), Math.abs(matrix2.x2) + Math.abs(matrix2.y2));
 }
-function pt(x, df, ncp) {
-  if (isBadArgument(x, df, ncp)) {
-    return Number.NaN;
+// src/core/pca.ts
+function principalComponents(points) {
+  const rows = completePointRows(points);
+  if (rows.length === 0) {
+    return null;
   }
-  return isNonCentral(ncp) ? nonCentralProbability(x, df, ncp) : centralProbability(x, df);
+  const complete = rows.map((row2) => points[row2]);
+  const centerX = mean(complete.map((point) => point.x));
+  const centerY = mean(complete.map((point) => point.y));
+  const devX = complete.map((point) => point.x - centerX);
+  const devY = complete.map((point) => point.y - centerY);
+  const divisor = Math.max(1, complete.length - 1);
+  const varX = sum(devX.map((d) => d * d)) / divisor;
+  const varY = sum(devY.map((d) => d * d)) / divisor;
+  const covariance = sum(zipWith(devX, devY, (dx, dy) => dx * dy)) / divisor;
+  const [first, second] = componentsOf(varX, varY, covariance);
+  const scores = points.map(() => ({ x: Number.NaN, y: Number.NaN }));
+  rows.forEach((row2, survivor) => {
+    const dx = devX[survivor];
+    const dy = devY[survivor];
+    scores[row2] = {
+      x: dx * first.loadings[0] + dy * first.loadings[1],
+      y: dx * second.loadings[0] + dy * second.loadings[1]
+    };
+  });
+  return {
+    sdev: [sdevOf(first.variance), sdevOf(second.variance)],
+    rotation: [first.loadings, second.loadings],
+    center: { x: centerX, y: centerY },
+    scores
+  };
 }
-function qt(p, df, ncp) {
-  if (isBadArgument(p, df, ncp) || p < 0 || p > 1) {
-    return Number.NaN;
+function componentsOf(varX, varY, covariance) {
+  if (covariance === 0) {
+    const alongX = { variance: varX, loadings: [1, 0] };
+    const alongY = { variance: varY, loadings: [0, 1] };
+    return varX >= varY ? [alongX, alongY] : [alongY, alongX];
   }
-  return isNonCentral(ncp) ? nonCentralQuantile(p, df, ncp) : centralQuantile(p, df);
+  const middle = (varX + varY) / 2;
+  const spread = Math.hypot((varX - varY) / 2, covariance);
+  const larger = middle + spread;
+  const smaller = middle - spread;
+  const fromRowX = larger - varX;
+  const fromRowY = larger - varY;
+  const direction = fromRowX >= fromRowY ? [covariance, fromRowX] : [fromRowY, covariance];
+  const leading = signed(unit(direction));
+  const trailing = signed([negated(leading[1]), leading[0]]);
+  return [
+    { variance: larger, loadings: leading },
+    { variance: smaller, loadings: trailing }
+  ];
 }
-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 unit(vector) {
+  const length = Math.hypot(vector[0], vector[1]);
+  return [vector[0] / length, vector[1] / length];
 }
-function centralProbability(x, df) {
-  if (x === 0) {
-    return 0.5;
+function signed(vector) {
+  const dominant = Math.abs(vector[0]) >= Math.abs(vector[1]) ? vector[0] : vector[1];
+  return dominant >= 0 ? vector : [negated(vector[0]), negated(vector[1])];
+}
+function negated(value) {
+  return withoutNegativeZero(-value);
+}
+function sdevOf(variance) {
+  return Math.sqrt(Math.max(0, variance));
+}
+// 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");
   }
-  if (x === Number.POSITIVE_INFINITY) {
-    return 1;
+  const width = design[0].length;
+  if (design.some((row2) => row2.length !== width)) {
+    throw new RangeError("every design row needs the same number of columns");
   }
-  if (x === Number.NEGATIVE_INFINITY) {
-    return 0;
+  if (y.length !== rows) {
+    throw new RangeError(`the response has ${y.length} values but the design has ${rows} rows`);
   }
-  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;
+  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 total = df + squared;
-  return 0.5 * incompleteBetaSplit(df / total, squared / total, df / 2, 0.5);
+  const scale = weights?.map((weight) => Math.sqrt(weight));
+  const scaled = (value, row2) => scale === undefined ? value : value * scale[row2];
+  const buffer = new Float64Array(rows * width);
+  design.forEach((row2, index) => {
+    for (let column2 = 0;column2 < width; column2++) {
+      buffer[column2 * rows + index] = scaled(row2[column2], index);
+    }
+  });
+  const factored = qr(make(rows, width, buffer, null), { tolerance });
+  const coefficients = qrCoef(factored, y.map(scaled));
+  const fitted = design.map((row2) => sum(zipWith(row2, coefficients, (value, coefficient) => coefficient === null ? 0 : value * coefficient)));
+  const residuals = zipWith(y, fitted, (value, fit) => value - fit);
+  return { coefficients, fitted, residuals, rank: factored.rank };
 }
-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;
+
+// src/core/logit.ts
+var DEFAULT_LOGIT_EPSILON = 0.00000001;
+var DEFAULT_LOGIT_MAX_ITERATIONS = 25;
+var LINK_THRESHOLD = 30;
+var BOUND = 10 * Number.EPSILON;
+function logisticRegression(points, options = {}) {
+  const {
+    epsilon = DEFAULT_LOGIT_EPSILON,
+    maxIterations = DEFAULT_LOGIT_MAX_ITERATIONS
+  } = options;
+  const rows = completePointRows(points);
+  if (rows.length === 0) {
+    return null;
   }
-  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;
+  const complete = rows.map((row2) => points[row2]);
+  if (complete.some((point) => point.y !== 0 && point.y !== 1)) {
+    throw new RangeError("every outcome must be 0 or 1");
   }
-  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) {
+  const outcomes = complete.map((point) => point.y);
+  const design = complete.map((point) => [1, point.x]);
+  let fitted = outcomes.map((outcome) => (outcome + 0.5) / 2);
+  let predictors = fitted.map(logit);
+  let previousDeviance = totalDeviance(outcomes, fitted);
+  let deviance = previousDeviance;
+  let coefficients = [Number.NaN, null];
+  let rank = 0;
+  let iterations = 0;
+  let converged = false;
+  for (let iteration = 1;iteration <= maxIterations; iteration++) {
+    iterations = iteration;
+    const working = predictors.map((predictor, row2) => {
+      const probability = fitted[row2];
+      const slope = linkSlope(predictor);
+      return {
+        weight: slope * slope / (probability * (1 - probability)),
+        response: predictor + (outcomes[row2] - probability) / slope
+      };
+    });
+    const step = leastSquares(design, working.map((row2) => row2.response), {
+      weights: working.map((row2) => row2.weight),
+      tolerance: Math.min(0.0000001, epsilon / 1000)
+    });
+    if (step.coefficients.some((coefficient) => coefficient !== null && !Number.isFinite(coefficient))) {
       break;
     }
-    t = next;
-    if (Math.abs(move) <= Number.EPSILON * t) {
+    coefficients = step.coefficients;
+    rank = step.rank;
+    predictors = design.map((row2) => sum(zipWith(row2, coefficients, (value, coefficient) => coefficient === null ? 0 : value * coefficient)));
+    fitted = predictors.map(linkInverse);
+    deviance = totalDeviance(outcomes, fitted);
+    if (Math.abs(deviance - previousDeviance) / (0.1 + Math.abs(deviance)) < epsilon) {
+      converged = true;
       break;
     }
+    previousDeviance = deviance;
   }
-  return t;
+  const wholeMean = mean(outcomes);
+  const nullDeviance = totalDeviance(outcomes, outcomes.map(() => wholeMean));
+  const paddedFitted = new Array(points.length).fill(Number.NaN);
+  const paddedPredictors = new Array(points.length).fill(Number.NaN);
+  rows.forEach((row2, survivor) => {
+    paddedFitted[row2] = fitted[survivor];
+    paddedPredictors[row2] = predictors[survivor];
+  });
+  return {
+    intercept: coefficients[0] ?? Number.NaN,
+    slope: coefficients[1] ?? null,
+    fitted: paddedFitted,
+    linearPredictors: paddedPredictors,
+    deviance,
+    nullDeviance,
+    aic: deviance + 2 * rank,
+    rank,
+    iterations,
+    converged,
+    saturated: fitted.some((probability) => probability > 1 - BOUND || probability < BOUND)
+  };
 }
-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 predictLogit(fit, x) {
+  return linkInverse(fit.intercept + (fit.slope ?? 0) * x);
 }
-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 logit(probability) {
+  return Math.log(probability / (1 - probability));
 }
-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 linkInverse(predictor) {
+  const odds = predictor < -LINK_THRESHOLD ? Number.EPSILON : predictor > LINK_THRESHOLD ? 1 / Number.EPSILON : Math.exp(predictor);
+  return odds / (1 + odds);
 }
-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);
+function linkSlope(predictor) {
+  if (predictor > LINK_THRESHOLD || predictor < -LINK_THRESHOLD) {
+    return Number.EPSILON;
   }
-  return Math.exp(-0.5 * Math.log(df) - logBeta(0.5, df / 2) - 0.5 * ncp * ncp);
+  const odds = Math.exp(predictor);
+  return odds / ((1 + odds) * (1 + odds));
 }
-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;
+function totalDeviance(outcomes, probabilities) {
+  return sum(zipWith(outcomes, probabilities, (outcome, probability) => 2 * (surprise(outcome, probability) + surprise(1 - outcome, 1 - probability))));
+}
+function surprise(outcome, probability) {
+  return outcome !== 0 ? outcome * Math.log(outcome / probability) : 0;
 }
 // src/core/ttest.ts
 var DEFAULT_T_TEST_OPTIONS = {
@@ -1596,27 +2188,27 @@ var FILL_UPPER_QUANTILE = 0.999;
 function tTestStats(options = {}) {
   const { diff, sd: sd2, n, alpha } = { ...DEFAULT_T_TEST_OPTIONS, ...options };
   const df = n - 1;
-  const t = diff / (sd2 / Math.sqrt(n));
+  const t2 = diff / (sd2 / Math.sqrt(n));
   const criticalValue = qt(1 - alpha, df);
-  const beta = pt(criticalValue, df, t);
+  const beta = pt(criticalValue, df, t2);
   const power = 1 - beta;
-  const altMedian = qt(0.5, df, t);
-  const altFillFrom = qt(beta, df, t);
+  const altMedian = qt(0.5, df, t2);
+  const altFillFrom = qt(beta, df, t2);
   return {
     diff,
     sd: sd2,
     n,
     alpha,
     df,
-    t,
+    t: t2,
     criticalValue,
     beta,
     power,
     altMedian,
-    altMedianDensity: dt(altMedian, df, t),
+    altMedianDensity: dt(altMedian, df, t2),
     altFill: {
       from: altFillFrom,
-      to: qt(FILL_UPPER_QUANTILE, df, t)
+      to: qt(FILL_UPPER_QUANTILE, df, t2)
     },
     nullFill: {
       from: criticalValue,
@@ -2701,8 +3293,8 @@ var HEAD_LENGTH = 24;
 function matrixInverseScale(width, height) {
   return createScale({ width, height, x: WORLD, y: WORLD });
 }
-function plotMatrixInverse(target, matrix) {
-  const inversion = invertMatrix(matrix);
+function plotMatrixInverse(target, matrix2) {
+  const inversion = invertMatrix(matrix2);
   const { ctx, width, height } = resolveTarget(target);
   if (inversion.inverse === null) {
     return inversion;
@@ -2713,22 +3305,22 @@ function plotMatrixInverse(target, matrix) {
   const { area } = scale;
   ctx.save();
   clipToArea(ctx, area);
-  drawMatrix(ctx, scale, matrix, MATRIX_FILL);
+  drawMatrix(ctx, scale, matrix2, MATRIX_FILL);
   drawMatrix(ctx, scale, inversion.inverse, INVERSE_FILL);
   ctx.restore();
   return inversion;
 }
-function drawMatrix(ctx, scale, matrix, fill) {
-  drawParallelogram(ctx, scale, matrix, fill);
-  drawColumnArrow(ctx, scale, matrix.x1, matrix.y1);
-  drawColumnArrow(ctx, scale, matrix.x2, matrix.y2);
+function drawMatrix(ctx, scale, matrix2, fill) {
+  drawParallelogram(ctx, scale, matrix2, fill);
+  drawColumnArrow(ctx, scale, matrix2.x1, matrix2.y1);
+  drawColumnArrow(ctx, scale, matrix2.x2, matrix2.y2);
 }
-function drawParallelogram(ctx, scale, matrix, fill) {
+function drawParallelogram(ctx, scale, matrix2, fill) {
   const corners = [
     [0, 0],
-    [matrix.x1, matrix.y1],
-    [matrix.x1 + matrix.x2, matrix.y1 + matrix.y2],
-    [matrix.x2, matrix.y2],
+    [matrix2.x1, matrix2.y1],
+    [matrix2.x1 + matrix2.x2, matrix2.y1 + matrix2.y2],
+    [matrix2.x2, matrix2.y2],
     [0, 0]
   ];
   ctx.save();
@@ -2932,29 +3524,29 @@ function drawRows(ctx, scale, rows, colors) {
   ctx.setLineDash([]);
   ctx.lineWidth = SPAN_WIDTH;
   ctx.strokeStyle = colors.span99;
-  for (const { interval, row } of rows) {
-    drawSpan(ctx, scale, interval.ci99.low, interval.ci99.high, row);
+  for (const { interval, row: row2 } of rows) {
+    drawSpan(ctx, scale, interval.ci99.low, interval.ci99.high, row2);
   }
   ctx.strokeStyle = colors.span95;
-  for (const { interval, row } of rows) {
-    drawSpan(ctx, scale, interval.ci95.low, interval.ci95.high, row);
+  for (const { interval, row: row2 } of rows) {
+    drawSpan(ctx, scale, interval.ci95.low, interval.ci95.high, row2);
   }
   ctx.fillStyle = colors.point;
-  for (const { interval, row } of rows) {
-    drawDiamond(ctx, scale, interval.mean, row);
+  for (const { interval, row: row2 } of rows) {
+    drawDiamond(ctx, scale, interval.mean, row2);
   }
   ctx.restore();
 }
-function drawSpan(ctx, scale, low, high, row) {
-  const y = scale.toPixelY(row);
+function drawSpan(ctx, scale, low, high, row2) {
+  const y = scale.toPixelY(row2);
   ctx.beginPath();
   ctx.moveTo(scale.toPixelX(low), y);
   ctx.lineTo(scale.toPixelX(high), y);
   ctx.stroke();
 }
-function drawDiamond(ctx, scale, at, row) {
-  const x = scale.toPixelX(at);
-  const y = scale.toPixelY(row);
+function drawDiamond(ctx, scale, at2, row2) {
+  const x = scale.toPixelX(at2);
+  const y = scale.toPixelY(row2);
   ctx.beginPath();
   ctx.moveTo(x, y - POINT_RADIUS2);
   ctx.lineTo(x + POINT_RADIUS2, y);
@@ -2962,12 +3554,12 @@ function drawDiamond(ctx, scale, at, row) {
   ctx.lineTo(x - POINT_RADIUS2, y);
   ctx.fill();
 }
-function drawPopulationMean(ctx, scale, at) {
-  if (!Number.isFinite(at)) {
+function drawPopulationMean(ctx, scale, at2) {
+  if (!Number.isFinite(at2)) {
     return;
   }
   const { area } = scale;
-  const x = scale.toPixelX(at);
+  const x = scale.toPixelX(at2);
   ctx.save();
   ctx.setLineDash([]);
   ctx.strokeStyle = MEAN_LINE_COLOR;
@@ -3244,17 +3836,17 @@ function drawCaret(ctx, scale, atRight, color) {
   ctx.fill();
   ctx.restore();
 }
-function drawMarkNote(ctx, scale, note, at) {
+function drawMarkNote(ctx, scale, note, at2) {
   ctx.save();
   ctx.setLineDash([]);
   ctx.fillStyle = MARK_COLOR;
   ctx.font = COUNT_FONT;
   ctx.textAlign = "left";
   ctx.textBaseline = "middle";
-  ctx.fillText(note, scale.area.left, scale.toPixelY(at) + LABEL_LINE_HEIGHT);
+  ctx.fillText(note, scale.area.left, scale.toPixelY(at2) + LABEL_LINE_HEIGHT);
   ctx.restore();
 }
-function drawLabel(ctx, scale, lines, at, font) {
+function drawLabel(ctx, scale, lines, at2, font) {
   ctx.save();
   ctx.setLineDash([]);
   ctx.fillStyle = TEXT_COLOR2;
@@ -3262,7 +3854,7 @@ function drawLabel(ctx, scale, lines, at, font) {
   ctx.textAlign = "left";
   ctx.textBaseline = "middle";
   lines.forEach((line, index) => {
-    ctx.fillText(line, scale.area.left, scale.toPixelY(at) + index * LABEL_LINE_HEIGHT);
+    ctx.fillText(line, scale.area.left, scale.toPixelY(at2) + index * LABEL_LINE_HEIGHT);
   });
   ctx.restore();
 }
@@ -4337,5 +4929,5 @@ export {
   DEFAULT_LEAST_SQUARES_TOLERANCE
 };
 
-//# debugId=CC683922C616AE5764756E2164756E21
+//# debugId=6C77280FC4EBBC8264756E2164756E21
 //# sourceMappingURL=index.js.map