@compstats/core 0.2.0 → 0.4.0

package/dist/linalg.js

@@ -0,0 +1,1860 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/frame.ts
+function isNumericColumn(column) {
+  return column.length > 0 && column.every((value) => typeof value === "number");
+}
+function numericColumns(data) {
+  return Object.keys(data).filter((name) => isNumericColumn(data[name]));
+}
+function requireThreeNumericColumns(numeric, caller) {
+  if (numeric.length < 3) {
+    throw new RangeError(`${caller}() needs at least 3 numeric columns; got ${numeric.length}. ` + "Supply x/y/z explicitly or add numeric columns.");
+  }
+}
+function frameRows(data) {
+  const names = Object.keys(data);
+  const first = names[0];
+  if (first === undefined) {
+    return 0;
+  }
+  const rows = data[first].length;
+  const ragged = names.find((name) => data[name].length !== rows);
+  if (ragged !== undefined) {
+    throw new RangeError(`every column needs the same number of rows: "${first}" has ${rows} ` + `but "${ragged}" has ${data[ragged].length}`);
+  }
+  return rows;
+}
+function requireNumericColumn(data, name, role) {
+  const column = data[name];
+  if (column === undefined) {
+    throw new RangeError(`Column "${name}" (passed as \`${role}\`) is not in the data.`);
+  }
+  if (!isNumericColumn(column)) {
+    throw new RangeError(`Column "${name}" (passed as \`${role}\`) is not numeric; ` + "only numeric columns can carry the statistics.");
+  }
+  return column;
+}
+
+// src/core/linalg/matrix.ts
+function matrix(values, options) {
+  const { byrow = false, dimnames } = options;
+  const [nrow, ncol] = extents(values.length, options);
+  const dense = Float64Array.from(values);
+  const data = new Float64Array(nrow * ncol);
+  if (dense.length === 1 && data.length > 1) {
+    data.fill(dense[0]);
+  } else if (byrow) {
+    dense.forEach((value, index) => {
+      const i = Math.floor(index / ncol);
+      const j = index % ncol;
+      data[j * nrow + i] = value;
+    });
+  } else {
+    data.set(dense);
+  }
+  return make(nrow, ncol, data, dimnames ?? null);
+}
+function extents(length, { nrow, ncol }) {
+  if (nrow === undefined && ncol === undefined) {
+    throw new RangeError("matrix() needs nrow or ncol");
+  }
+  if (nrow !== undefined) {
+    requireExtent(nrow, "nrow");
+  }
+  if (ncol !== undefined) {
+    requireExtent(ncol, "ncol");
+  }
+  const scalar = length === 1;
+  if (nrow !== undefined && ncol !== undefined) {
+    if (!scalar && nrow * ncol !== length) {
+      throw new RangeError(length > nrow * ncol ? "data is too long" : `data length [${length}] is not nrow * ncol [${nrow} * ${ncol}]`);
+    }
+    return [nrow, ncol];
+  }
+  const given = nrow ?? ncol;
+  const name = nrow !== undefined ? "rows" : "columns";
+  if (given === 0) {
+    if (length !== 0) {
+      throw new RangeError("data is too long");
+    }
+    return [0, 0];
+  }
+  const other = scalar ? 1 : length / given;
+  if (!scalar && length % given !== 0) {
+    throw new RangeError(`data length [${length}] is not a multiple of the number of ${name} [${given}]`);
+  }
+  return nrow !== undefined ? [nrow, other] : [other, given];
+}
+function requireExtent(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer, got ${value}`);
+  }
+}
+function make(nrow, ncol, data, dimnames) {
+  if (data.length !== nrow * ncol) {
+    throw new RangeError(`data length [${data.length}] is not nrow * ncol [${nrow} * ${ncol}]`);
+  }
+  if (dimnames !== null) {
+    const [rows, columns] = dimnames;
+    if (rows !== null && rows.length !== nrow) {
+      throw new RangeError(`length of dimnames [1] (${rows.length}) not equal to array extent (${nrow})`);
+    }
+    if (columns !== null && columns.length !== ncol) {
+      throw new RangeError(`length of dimnames [2] (${columns.length}) not equal to array extent (${ncol})`);
+    }
+    dimnames = rows === null && columns === null ? null : [rows === null ? null : [...rows], columns === null ? null : [...columns]];
+  }
+  return { nrow, ncol, data, dimnames };
+}
+function fromRows(rows) {
+  const nrow = rows.length;
+  const first = rows[0];
+  if (first === undefined || first.length === 0) {
+    throw new RangeError("fromRows() needs at least one row with one value");
+  }
+  const ncol = first.length;
+  const ragged = rows.findIndex((row) => row.length !== ncol);
+  if (ragged !== -1) {
+    throw new RangeError(`every row needs ${ncol} values; row ${ragged} has ${rows[ragged].length}`);
+  }
+  const data = new Float64Array(nrow * ncol);
+  rows.forEach((row, i) => {
+    Float64Array.from(row).forEach((value, j) => {
+      data[j * nrow + i] = value;
+    });
+  });
+  return make(nrow, ncol, data, null);
+}
+function fromColumns(columns) {
+  const ncol = columns.length;
+  const first = columns[0];
+  if (first === undefined || first.length === 0) {
+    throw new RangeError("fromColumns() needs at least one column with one value");
+  }
+  const nrow = first.length;
+  const ragged = columns.findIndex((column) => column.length !== nrow);
+  if (ragged !== -1) {
+    throw new RangeError(`every column needs ${nrow} values; column ${ragged} has ${columns[ragged].length}`);
+  }
+  const data = new Float64Array(nrow * ncol);
+  columns.forEach((column, j) => {
+    data.set(column, j * nrow);
+  });
+  return make(nrow, ncol, data, null);
+}
+function at(m, i, j) {
+  if (!Number.isInteger(i) || i < 0 || i >= m.nrow) {
+    throw new RangeError(`row index ${i} is outside 0..${m.nrow - 1}`);
+  }
+  if (!Number.isInteger(j) || j < 0 || j >= m.ncol) {
+    throw new RangeError(`column index ${j} is outside 0..${m.ncol - 1}`);
+  }
+  return m.data[j * m.nrow + i];
+}
+function row(m, i) {
+  if (!Number.isInteger(i) || i < 0 || i >= m.nrow) {
+    throw new RangeError(`row index ${i} is outside 0..${m.nrow - 1}`);
+  }
+  return Array.from({ length: m.ncol }, (_, j) => m.data[j * m.nrow + i]);
+}
+function column(m, j) {
+  if (!Number.isInteger(j) || j < 0 || j >= m.ncol) {
+    throw new RangeError(`column index ${j} is outside 0..${m.ncol - 1}`);
+  }
+  return Array.from(m.data.subarray(j * m.nrow, (j + 1) * m.nrow));
+}
+function toRows(m) {
+  return Array.from({ length: m.nrow }, (_, i) => row(m, i));
+}
+function toColumns(m) {
+  return Array.from({ length: m.ncol }, (_, j) => column(m, j));
+}
+function fromFrame(data, columns) {
+  const nrow = frameRows(data);
+  const names = columns ?? numericColumns(data);
+  const buffer = new Float64Array(nrow * names.length);
+  names.forEach((name, j) => {
+    buffer.set(requireNumericColumn(data, name, "columns"), j * nrow);
+  });
+  return make(nrow, names.length, buffer, names.length === 0 ? null : [null, [...names]]);
+}
+// src/core/arith.ts
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function mean(values) {
+  return sum(values) / values.length;
+}
+function extent(values) {
+  return values.reduce(([low, high], value) => [
+    value < low ? value : low,
+    value > high ? value : high
+  ], [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]);
+}
+function withoutNegativeZero(value) {
+  return value === 0 ? 0 : value;
+}
+function requireCount(value, name) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer, got ${value}`);
+  }
+}
+function zipWith(as, bs, combine) {
+  const length = Math.min(as.length, bs.length);
+  return as.slice(0, length).map((a, index) => combine(a, bs[index]));
+}
+function sd(values) {
+  if (values.length < 2) {
+    return Number.NaN;
+  }
+  const center = mean(values);
+  const squares = values.map((value) => (value - center) * (value - center));
+  return Math.sqrt(sum(squares) / (values.length - 1));
+}
+function meanAbsoluteDeviation(values) {
+  const center = mean(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);
+  return Number.isFinite(rounded) ? rounded : a * b + c;
+}
+function split(value) {
+  const scaled = 134217729 * value;
+  const high = scaled - (scaled - value);
+  return [high, value - high];
+}
+function twoProduct(a, b) {
+  const product = a * b;
+  const [aHigh, aLow] = split(a);
+  const [bHigh, bLow] = split(b);
+  const error = aLow * bLow - (product - aHigh * bHigh - aLow * bHigh - aHigh * bLow);
+  return [product, error];
+}
+function twoSum(a, b) {
+  const sum2 = a + b;
+  const carried = sum2 - a;
+  return [sum2, a - (sum2 - carried) + (b - carried)];
+}
+function quantile(values, p) {
+  return quantiles(values, [p])[0];
+}
+function quantiles(values, probs) {
+  if (probs.some((p) => !(p >= 0 && p <= 1))) {
+    throw new RangeError(`every probability must be in [0, 1], got ${probs}`);
+  }
+  if (values.length === 0) {
+    return probs.map(() => Number.NaN);
+  }
+  const sorted = Float64Array.from(values).sort();
+  return probs.map((p) => type7(sorted, p));
+}
+function median(values) {
+  return quantile(values, 0.5);
+}
+function type7(sorted, p) {
+  const position = 1 + (sorted.length - 1) * p;
+  const below = Math.floor(position);
+  const above = Math.ceil(position);
+  const low = sorted[below - 1];
+  const high = sorted[above - 1];
+  if (position > below && high !== low) {
+    const h = position - below;
+    return (1 - h) * low + h * high;
+  }
+  return low;
+}
+
+// src/core/linalg/ops.ts
+function t(m) {
+  const { nrow, ncol } = m;
+  const data = new Float64Array(nrow * ncol);
+  for (let j = 0;j < ncol; j++) {
+    for (let i = 0;i < nrow; i++) {
+      data[i * ncol + j] = m.data[j * nrow + i];
+    }
+  }
+  const dimnames = m.dimnames === null ? null : [m.dimnames[1], m.dimnames[0]];
+  return make(ncol, nrow, data, dimnames);
+}
+var transpose = t;
+function matmul(x, y) {
+  const [left, right] = conformProduct(x, y);
+  if (left.ncol !== right.nrow) {
+    throw new RangeError(`non-conformable arguments: ${left.nrow} x ${left.ncol} %*% ${right.nrow} x ${right.ncol}`);
+  }
+  const data = product(left, right);
+  return make(left.nrow, right.ncol, data, productDimnames(left, right));
+}
+function conformProduct(x, y) {
+  if (isMatrix(x)) {
+    if (isMatrix(y)) {
+      return [x, y];
+    }
+    return [x, y.length === x.ncol ? asColumn(y) : asRow(y)];
+  }
+  if (isMatrix(y)) {
+    return [x.length === y.nrow ? asRow(x) : asColumn(x), y];
+  }
+  return [asRow(x), x.length === 1 ? asRow(y) : asColumn(y)];
+}
+function crossprod(x, y = x) {
+  const left = asColumn(x);
+  const right = isMatrix(y) ? y : y.length === left.nrow ? asColumn(y) : asRow(y);
+  if (left.nrow !== right.nrow) {
+    throw new RangeError(`non-conformable arguments: crossprod of ${left.nrow} x ${left.ncol} and ${right.nrow} x ${right.ncol}`);
+  }
+  return matmul(t(left), right);
+}
+function tcrossprod(x, y = x) {
+  const bothVectors = !isMatrix(x) && !isMatrix(y);
+  const left = isMatrix(x) ? x : isMatrix(y) && y.ncol === x.length ? asRow(x) : asColumn(x);
+  const right = isMatrix(y) ? y : !bothVectors && left.nrow === 1 ? asRow(y) : asColumn(y);
+  if (left.ncol !== right.ncol) {
+    throw new RangeError(`non-conformable arguments: tcrossprod of ${left.nrow} x ${left.ncol} and ${right.nrow} x ${right.ncol}`);
+  }
+  return matmul(left, t(right));
+}
+function product(x, y) {
+  const { nrow, ncol: inner } = x;
+  const { ncol } = y;
+  const data = new Float64Array(nrow * ncol);
+  for (let j = 0;j < ncol; j++) {
+    for (let k = 0;k < inner; k++) {
+      const factor = y.data[j * y.nrow + k];
+      for (let i = 0;i < nrow; i++) {
+        data[j * nrow + i] = fusedMultiplyAdd(x.data[k * nrow + i], factor, data[j * nrow + i]);
+      }
+    }
+  }
+  return data;
+}
+function productDimnames(x, y) {
+  const rows = x.dimnames?.[0] ?? null;
+  const columns = y.dimnames?.[1] ?? null;
+  return rows === null && columns === null ? null : [rows, columns];
+}
+function asColumn(value) {
+  if (isMatrix(value)) {
+    return value;
+  }
+  return make(value.length, 1, Float64Array.from(value), null);
+}
+function asRow(value) {
+  return make(1, value.length, Float64Array.from(value), null);
+}
+function isMatrix(value) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (typeof value === "object" && value !== null && "nrow" in value && "ncol" in value && "data" in value) {
+    return true;
+  }
+  throw new TypeError("expected a Matrix or an array of numbers");
+}
+function cbind(...parts) {
+  const matrices = parts.map(asColumn);
+  const first = matrices[0];
+  if (first === undefined) {
+    throw new RangeError("cbind() needs at least one argument");
+  }
+  const nrow = first.nrow;
+  matrices.forEach((m, index) => {
+    if (m.nrow !== nrow) {
+      throw new RangeError(isMatrix(parts[index]) ? `number of rows of matrices must match (see arg ${index + 1})` : `number of rows of result is not a multiple of vector length (arg ${index + 1})`);
+    }
+  });
+  const ncol = matrices.reduce((total, m) => total + m.ncol, 0);
+  const data = new Float64Array(nrow * ncol);
+  let offset = 0;
+  matrices.forEach((m) => {
+    data.set(m.data, offset);
+    offset += m.data.length;
+  });
+  const rows = matrices.find((m) => m.dimnames?.[0])?.dimnames?.[0] ?? null;
+  const columns = boundNames(matrices.map((m) => ({ names: m.dimnames?.[1] ?? null, count: m.ncol })));
+  return make(nrow, ncol, data, rows === null && columns === null ? null : [rows, columns]);
+}
+function rbind(...parts) {
+  if (parts.length === 0) {
+    throw new RangeError("rbind() needs at least one argument");
+  }
+  const transposed = parts.map((part) => isMatrix(part) ? t(part) : part);
+  try {
+    return t(cbind(...transposed));
+  } catch (error) {
+    if (error instanceof RangeError) {
+      throw new RangeError(error.message.replace("number of rows", "number of columns"));
+    }
+    throw error;
+  }
+}
+function boundNames(parts) {
+  if (parts.every((part) => part.names === null)) {
+    return null;
+  }
+  return parts.flatMap((part) => part.names ?? new Array(part.count).fill(""));
+}
+function diag(arg) {
+  if (typeof arg === "number") {
+    return identity(arg);
+  }
+  if (Array.isArray(arg)) {
+    const values = arg;
+    const n2 = values.length;
+    const data = new Float64Array(n2 * n2);
+    values.forEach((value, i) => {
+      data[i * n2 + i] = value;
+    });
+    return make(n2, n2, data, null);
+  }
+  const m = arg;
+  const n = Math.min(m.nrow, m.ncol);
+  return Array.from({ length: n }, (_, i) => m.data[i * m.nrow + i]);
+}
+function identity(order) {
+  if (!Number.isInteger(order) || order < 0) {
+    throw new RangeError(`order must be a non-negative integer, got ${order}`);
+  }
+  const data = new Float64Array(order * order);
+  for (let i = 0;i < order; i++) {
+    data[i * order + i] = 1;
+  }
+  return make(order, order, data, null);
+}
+// src/core/linalg/qr.ts
+var DEFAULT_QR_TOLERANCE = 0.0000001;
+function qr(x, options = {}) {
+  const { tolerance = DEFAULT_QR_TOLERANCE } = options;
+  if (!(tolerance >= 0)) {
+    throw new RangeError(`tolerance must be a non-negative number, got ${tolerance}`);
+  }
+  if (!isMatrix(x)) {
+    throw new TypeError("expected a Matrix");
+  }
+  if (!x.data.every(Number.isFinite)) {
+    throw new RangeError("NA/NaN/Inf in foreign function call (arg 1)");
+  }
+  const { nrow, ncol } = x;
+  const columns = Array.from({ length: ncol }, (_, j) => Array.from(x.data.subarray(j * nrow, (j + 1) * nrow)));
+  const { householders, pivot, rank } = decompose(columns, tolerance, nrow);
+  const data = new Float64Array(nrow * ncol);
+  columns.forEach((column2, j) => {
+    data.set(column2, j * nrow);
+  });
+  const rows = x.dimnames?.[0] ?? null;
+  const names = x.dimnames?.[1] ?? null;
+  const dimnames = rows === null && names === null ? null : [rows, names === null ? null : pivot.map((from) => names[from])];
+  return { qr: make(nrow, ncol, data, dimnames), qraux: householders, pivot, rank };
+}
+function qrCoef(q, y) {
+  if (isMatrix(y)) {
+    requireRows(q, y.nrow);
+    const width = q.qr.ncol;
+    const data = new Float64Array(width * y.ncol);
+    for (let j = 0;j < y.ncol; j++) {
+      const solved = coefficientsOf(q, Array.from(y.data.subarray(j * y.nrow, (j + 1) * y.nrow)));
+      solved.forEach((value, i) => {
+        data[j * width + i] = value ?? Number.NaN;
+      });
+    }
+    return make(width, y.ncol, data, readerDimnames(originalColumnNames(q), y));
+  }
+  requireRows(q, y.length);
+  return coefficientsOf(q, y);
+}
+function coefficientsOf(q, y) {
+  const qty = transformed(q, y, true);
+  const solved = backSubstitute(q.qr, qty, q.rank);
+  const coefficients = new Array(q.qr.ncol).fill(null);
+  q.pivot.slice(0, q.rank).forEach((column2, position) => {
+    coefficients[column2] = solved[position];
+  });
+  return coefficients;
+}
+function originalColumnNames(q) {
+  const pivoted = q.qr.dimnames?.[1] ?? null;
+  if (pivoted === null) {
+    return null;
+  }
+  const names = new Array(pivoted.length);
+  q.pivot.forEach((original, position) => {
+    names[original] = pivoted[position];
+  });
+  return names;
+}
+function qrFitted(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, transformed(q, column2, true).map((value, index) => index < q.rank ? value : 0), false));
+}
+function qrResid(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, transformed(q, column2, true).map((value, index) => index < q.rank ? 0 : value), false));
+}
+function qrQty(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, column2, true));
+}
+function qrQy(q, y) {
+  return perColumn(q, y, (column2) => transformed(q, column2, false));
+}
+function perColumn(q, y, read) {
+  if (isMatrix(y)) {
+    requireRows(q, y.nrow);
+    const data = new Float64Array(y.nrow * y.ncol);
+    for (let j = 0;j < y.ncol; j++) {
+      data.set(read(Array.from(y.data.subarray(j * y.nrow, (j + 1) * y.nrow))), j * y.nrow);
+    }
+    return make(y.nrow, y.ncol, data, readerDimnames(null, y));
+  }
+  requireRows(q, y.length);
+  return read(y);
+}
+function readerDimnames(rows, y) {
+  const columns = y.dimnames?.[1] ?? null;
+  return rows === null && columns === null ? null : [rows, columns];
+}
+function transformed(q, y, transpose2) {
+  const result = [...y];
+  const count = reflectorCount(q);
+  if (transpose2) {
+    for (let step = 0;step < count; step++) {
+      applyReflector(q, step, result);
+    }
+  } else {
+    for (let step = count - 1;step >= 0; step--) {
+      applyReflector(q, step, result);
+    }
+  }
+  return result;
+}
+function qrQ(q) {
+  const { nrow, ncol } = q.qr;
+  const width = Math.min(nrow, ncol);
+  const data = new Float64Array(nrow * width);
+  for (let j = 0;j < width; j++) {
+    const unit = new Array(nrow).fill(0);
+    unit[j] = 1;
+    data.set(transformed(q, unit, false), j * nrow);
+  }
+  return make(nrow, width, data, null);
+}
+function qrR(q) {
+  const { nrow, ncol } = q.qr;
+  const height = Math.min(nrow, ncol);
+  const data = new Float64Array(height * ncol);
+  for (let j = 0;j < ncol; j++) {
+    for (let i = 0;i <= Math.min(j, height - 1); i++) {
+      data[j * height + i] = q.qr.data[j * nrow + i];
+    }
+  }
+  const rows = q.qr.dimnames?.[0]?.slice(0, height) ?? null;
+  const columns = q.qr.dimnames?.[1] ?? null;
+  return make(height, ncol, data, rows === null && columns === null ? null : [rows, columns]);
+}
+function requireRows(q, rows) {
+  if (rows !== q.qr.nrow) {
+    throw new RangeError("'qr' and 'y' must have the same number of rows");
+  }
+}
+function reflectorCount(q) {
+  return Math.min(q.rank, q.qr.nrow - 1);
+}
+function applyReflector(q, step, vector) {
+  const leading = q.qraux[step];
+  if (leading === 0) {
+    return;
+  }
+  const { nrow } = q.qr;
+  const column2 = q.qr.data.subarray(step * nrow, (step + 1) * nrow);
+  let inner = leading * vector[step];
+  for (let row2 = step + 1;row2 < nrow; row2++) {
+    inner = fusedMultiplyAdd(column2[row2], vector[row2], inner);
+  }
+  const factor = -inner / leading;
+  vector[step] = fusedMultiplyAdd(factor, leading, vector[step]);
+  for (let row2 = step + 1;row2 < nrow; row2++) {
+    vector[row2] = fusedMultiplyAdd(factor, column2[row2], vector[row2]);
+  }
+}
+function decompose(columns, tolerance, rows) {
+  const width = columns.length;
+  const pivot = columns.map((_, 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 { householders: qraux, pivot, rank: Math.min(k - 1, rows) };
+}
+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);
+    }
+    const factor = -inner / leading;
+    for (let row2 = step;row2 < rows; row2++) {
+      other[row2] = fusedMultiplyAdd(factor, column2[row2], other[row2]);
+    }
+    const running = qraux[index];
+    if (running !== 0) {
+      const ratio = Math.abs(other[step]) / running;
+      const remaining = Math.max(1 - ratio * ratio, 0);
+      if (Math.abs(remaining) < 0.000001) {
+        qraux[index] = norm(other, step + 1);
+        lastNorms[index] = qraux[index];
+      } else {
+        qraux[index] = running * Math.sqrt(remaining);
+      }
+    }
+  }
+  qraux[step] = leading;
+  column2[step] = -pivotNorm;
+}
+function backSubstitute(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 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);
+  }
+  return Math.sqrt(squares);
+}
+// src/core/linalg/lu.ts
+var SMALLEST_NORMAL = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014;
+function lu(a) {
+  requireSquare(a, "a");
+  const n = a.nrow;
+  const data = Float64Array.from(a.data);
+  const pivots = new Array(n).fill(0);
+  let zeroPivot = null;
+  const entry = (i, j) => data[j * n + i];
+  for (let j = 0;j < n; j++) {
+    let p = j;
+    for (let i = j + 1;i < n; i++) {
+      if (Math.abs(entry(i, j)) > Math.abs(entry(p, j))) {
+        p = i;
+      }
+    }
+    pivots[j] = p;
+    if (entry(p, j) !== 0) {
+      if (p !== j) {
+        swapRows(data, n, j, p);
+      }
+      const pivot = entry(j, j);
+      if (Math.abs(pivot) >= SMALLEST_NORMAL) {
+        const reciprocal = 1 / pivot;
+        for (let i = j + 1;i < n; i++) {
+          data[j * n + i] = entry(i, j) * reciprocal;
+        }
+      } else {
+        for (let i = j + 1;i < n; i++) {
+          data[j * n + i] = entry(i, j) / pivot;
+        }
+      }
+    } else if (zeroPivot === null) {
+      zeroPivot = j;
+    }
+    for (let jj = j + 1;jj < n; jj++) {
+      const factor = -entry(j, jj);
+      for (let i = j + 1;i < n; i++) {
+        data[jj * n + i] = fusedMultiplyAdd(entry(i, j), factor, entry(i, jj));
+      }
+    }
+  }
+  return { lu: make(n, n, data, null), pivots, zeroPivot };
+}
+function swapRows(data, n, i, p) {
+  for (let j = 0;j < n; j++) {
+    const held = data[j * n + i];
+    data[j * n + i] = data[j * n + p];
+    data[j * n + p] = held;
+  }
+}
+var DEFAULT_SOLVE_TOLERANCE = Number.EPSILON;
+function solve(a, second, third = {}) {
+  const [b, options] = splitArguments(second, third);
+  const { tolerance = DEFAULT_SOLVE_TOLERANCE } = options;
+  if (!(tolerance >= 0)) {
+    throw new RangeError(`tolerance must be a non-negative number, got ${tolerance}`);
+  }
+  requireSquare(a, "a");
+  const n = a.nrow;
+  if (n === 0) {
+    throw new RangeError("'a' is 0-diml");
+  }
+  const rhs = b === undefined ? identityData(n) : isMatrix(b) ? b : make(b.length, 1, Float64Array.from(b), null);
+  if (rhs.ncol === 0) {
+    throw new RangeError("no right-hand side in 'b'");
+  }
+  if (rhs.nrow !== n) {
+    throw new RangeError(`'b' (${rhs.nrow} x ${rhs.ncol}) must be compatible with 'a' (${n} x ${n})`);
+  }
+  const factored = lu(a);
+  if (factored.zeroPivot !== null) {
+    const i = factored.zeroPivot + 1;
+    throw new RangeError(`Lapack routine dgesv: system is exactly singular: U[${i},${i}] = 0`);
+  }
+  const solution = substitute(factored, rhs);
+  const anorm = oneNorm(a.data, n, n);
+  if (tolerance > 0 && Number.isFinite(anorm)) {
+    const inverse = b === undefined ? solution : substitute(factored, identityData(n));
+    const reciprocal = 1 / (anorm * oneNorm(inverse, n, n));
+    if (reciprocal < tolerance) {
+      throw new RangeError(`system is computationally singular: reciprocal condition number = ${formatG(reciprocal)}`);
+    }
+  }
+  if (b !== undefined && !isMatrix(b)) {
+    return Array.from(solution);
+  }
+  const aColumns = a.dimnames?.[1] ?? null;
+  const dimnames = b === undefined ? a.dimnames === null ? null : [aColumns, a.dimnames[0]] : aColumns === null && (rhs.dimnames?.[1] ?? null) === null ? null : [aColumns, rhs.dimnames?.[1] ?? null];
+  return make(n, rhs.ncol, solution, dimnames);
+}
+function splitArguments(second, third) {
+  if (second === undefined) {
+    return [undefined, third];
+  }
+  if (Array.isArray(second) || typeof second === "object" && "data" in second && "nrow" in second) {
+    return [second, third];
+  }
+  if (typeof second === "object" && second !== null && !ArrayBuffer.isView(second)) {
+    return [undefined, second];
+  }
+  throw new TypeError("expected a Matrix, an array of numbers, or the options");
+}
+function identityData(n) {
+  const data = new Float64Array(n * n);
+  for (let i = 0;i < n; i++) {
+    data[i * n + i] = 1;
+  }
+  return make(n, n, data, null);
+}
+function substitute(factored, rhs) {
+  const { lu: compact, pivots } = factored;
+  const n = compact.nrow;
+  const entry = (i, j) => compact.data[j * n + i];
+  const data = Float64Array.from(rhs.data);
+  const width = rhs.ncol;
+  pivots.forEach((p, i) => {
+    if (p !== i) {
+      for (let j = 0;j < width; j++) {
+        const held = data[j * n + i];
+        data[j * n + i] = data[j * n + p];
+        data[j * n + p] = held;
+      }
+    }
+  });
+  for (let j = 0;j < width; j++) {
+    const at2 = (i) => data[j * n + i];
+    for (let k = 0;k < n; k++) {
+      if (at2(k) !== 0) {
+        for (let i = k + 1;i < n; i++) {
+          data[j * n + i] = fusedMultiplyAdd(-at2(k), entry(i, k), at2(i));
+        }
+      }
+    }
+    for (let k = n - 1;k >= 0; k--) {
+      if (at2(k) !== 0) {
+        data[j * n + k] = at2(k) / entry(k, k);
+        for (let i = 0;i < k; i++) {
+          data[j * n + i] = fusedMultiplyAdd(-at2(k), entry(i, k), at2(i));
+        }
+      }
+    }
+  }
+  return data;
+}
+function det(a) {
+  const { modulus, sign } = determinant(a);
+  return sign * Math.exp(modulus);
+}
+function determinant(a) {
+  requireSquare(a, "x");
+  const factored = lu(a);
+  if (factored.zeroPivot !== null) {
+    return { modulus: Number.NEGATIVE_INFINITY, sign: 1 };
+  }
+  const n = a.nrow;
+  let modulus = 0;
+  let sign = 1;
+  for (let i = 0;i < n; i++) {
+    const pivot = factored.lu.data[i * n + i];
+    if (factored.pivots[i] !== i) {
+      sign = -sign;
+    }
+    if (pivot < 0) {
+      sign = -sign;
+    }
+    modulus += Math.log(Math.abs(pivot));
+  }
+  return { modulus, sign };
+}
+function rcond(a) {
+  if (!isMatrix(a)) {
+    throw new TypeError("expected a Matrix");
+  }
+  if (a.nrow !== a.ncol) {
+    return rcond(qrR(qr(a.nrow < a.ncol ? t(a) : a)));
+  }
+  const n = a.nrow;
+  if (n === 0) {
+    return Number.POSITIVE_INFINITY;
+  }
+  const anorm = oneNorm(a.data, n, n);
+  if (!Number.isFinite(anorm)) {
+    throw new RangeError("error code -5 from Lapack routine 'dgecon()'");
+  }
+  const factored = lu(a);
+  if (factored.zeroPivot !== null) {
+    return 0;
+  }
+  return 1 / (anorm * oneNorm(substitute(factored, identityData(n)), n, n));
+}
+function matrixNorm(a, type = "O") {
+  if (!isMatrix(a)) {
+    throw new TypeError("expected a Matrix");
+  }
+  const { nrow, ncol, data } = a;
+  switch (type.toUpperCase()) {
+    case "O":
+    case "1":
+      return oneNorm(data, nrow, ncol);
+    case "I": {
+      let largest = 0;
+      for (let i = 0;i < nrow; i++) {
+        let total = 0;
+        for (let j = 0;j < ncol; j++) {
+          total += Math.abs(data[j * nrow + i]);
+        }
+        largest = Math.max(largest, total);
+      }
+      return largest;
+    }
+    case "F":
+    case "E": {
+      let squares = 0;
+      data.forEach((value) => {
+        squares += value * value;
+      });
+      return Math.sqrt(squares);
+    }
+    case "M":
+      return data.reduce((largest, value) => Math.max(largest, Math.abs(value)), 0);
+    default:
+      throw new RangeError(`argument type[1]='${type}' must be one of 'M','1','O','I','F' or 'E'`);
+  }
+}
+function oneNorm(data, nrow, ncol) {
+  let largest = 0;
+  for (let j = 0;j < ncol; j++) {
+    let total = 0;
+    for (let i = 0;i < nrow; i++) {
+      total += Math.abs(data[j * nrow + i]);
+    }
+    largest = Math.max(largest, total);
+  }
+  return largest;
+}
+function requireSquare(a, name) {
+  if (!isMatrix(a)) {
+    throw new TypeError("expected a Matrix");
+  }
+  if (a.nrow !== a.ncol) {
+    throw new RangeError(name === "a" ? `'a' (${a.nrow} x ${a.ncol}) must be square` : "'x' must be a square matrix");
+  }
+}
+function formatG(value) {
+  if (value === 0 || !Number.isFinite(value)) {
+    return String(value);
+  }
+  const [mantissa, power] = value.toExponential(5).split("e");
+  const exponent = Number(power);
+  const trim = (digits) => digits.includes(".") ? digits.replace(/0+$/, "").replace(/\.$/, "") : digits;
+  if (exponent < -4 || exponent >= 6) {
+    const sign = exponent < 0 ? "-" : "+";
+    return `${trim(mantissa)}e${sign}${String(Math.abs(exponent)).padStart(2, "0")}`;
+  }
+  return trim(value.toFixed(Math.max(0, 5 - exponent)));
+}
+// src/core/linalg/namedVector.ts
+function namedVector(names, values) {
+  if (names.length !== values.length) {
+    throw new RangeError(`a named vector needs one name per value: ${names.length} names, ${values.length} values`);
+  }
+  return { names: [...names], values: [...values] };
+}
+function lookup(v, name) {
+  const index = v.names.indexOf(name);
+  return index === -1 ? undefined : v.values[index];
+}
+// src/core/linalg/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((product2, name) => product2 * columns.get(name)[row2], 1)));
+  const design = intercept ? [rows.map(() => 1), ...termColumns] : termColumns;
+  const names = [
+    ...intercept ? ["(Intercept)"] : [],
+    ...terms.map((factors) => factors.join(":"))
+  ];
+  const assign = [
+    ...intercept ? [0] : [],
+    ...terms.map((_, index) => index + 1)
+  ];
+  const n = rows.length;
+  const p = design.length;
+  const buffer = new Float64Array(n * p);
+  design.forEach((column2, j) => {
+    buffer.set(column2, j * n);
+  });
+  return {
+    matrix: make(n, p, buffer, p === 0 ? null : [null, names]),
+    rows,
+    assign,
+    termLabels: names.slice(intercept ? 1 : 0)
+  };
+}
+function orderTerms(terms) {
+  const seen = new Set;
+  const unique = [];
+  terms.forEach((term) => {
+    const factors = typeof term === "string" ? [term] : term;
+    if (factors.length === 0) {
+      throw new RangeError("an interaction term needs at least one column name");
+    }
+    const key = [...factors].sort().join("\x00");
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(factors);
+    }
+  });
+  return unique.map((factors, index) => ({ factors, index })).sort((a, b) => a.factors.length - b.factors.length || a.index - b.index).map(({ factors }) => factors);
+}
+// src/core/special.ts
+var LANCZOS_G = 607 / 128;
+var LANCZOS_LEAD = 0.9999999999999971;
+var LANCZOS_TAIL = [
+  57.15623566586292,
+  -59.59796035547549,
+  14.136097974741746,
+  -0.4919138160976202,
+  0.00003399464998481189,
+  0.00004652362892704858,
+  -0.00009837447530487956,
+  0.0001580887032249125,
+  -0.00021026444172410488,
+  0.00021743961811521265,
+  -0.0001643181065367639,
+  0.00008441822398385275,
+  -0.000026190838401581408,
+  0.0000036899182659531625
+];
+var LOG_SQRT_TWO_PI = 0.5 * Math.log(2 * Math.PI);
+function lanczosSeries(x) {
+  return LANCZOS_LEAD + sum(LANCZOS_TAIL.map((coefficient, index) => coefficient / (x + index)));
+}
+function logGamma(x) {
+  if (!(x > 0)) {
+    return Number.NaN;
+  }
+  const shifted = x + LANCZOS_G - 0.5;
+  return LOG_SQRT_TWO_PI + (x - 0.5) * Math.log(shifted) - shifted + Math.log(lanczosSeries(x));
+}
+function logBeta(a, b) {
+  if (!(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  const shiftedSum = a + b + LANCZOS_G - 0.5;
+  return LOG_SQRT_TWO_PI - (LANCZOS_G - 0.5) + Math.log(lanczosSeries(a)) + Math.log(lanczosSeries(b)) - Math.log(lanczosSeries(a + b)) + (a - 0.5) * Math.log1p(-b / shiftedSum) + (b - 0.5) * Math.log1p(-a / shiftedSum) - 0.5 * Math.log(shiftedSum);
+}
+var FRACTION_MAX_STEPS = 400;
+var FRACTION_EPSILON = 0.0000000000000003;
+var FRACTION_FLOOR = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001;
+function betaContinuedFraction(x, a, b) {
+  const total = a + b;
+  const aPlus = a + 1;
+  const aMinus = a - 1;
+  let c = 1;
+  let d = 1 - total * x / aPlus;
+  if (Math.abs(d) < FRACTION_FLOOR) {
+    d = FRACTION_FLOOR;
+  }
+  d = 1 / d;
+  let value = d;
+  for (let step = 1;step <= FRACTION_MAX_STEPS; step += 1) {
+    const twice = 2 * step;
+    const even = step * (b - step) * x / ((aMinus + twice) * (a + twice));
+    d = 1 + even * d;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = 1 + even / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    value *= d * c;
+    const odd = -(a + step) * (total + step) * x / ((a + twice) * (aPlus + twice));
+    d = 1 + odd * d;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = 1 + odd / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    const delta = d * c;
+    value *= delta;
+    if (Math.abs(delta - 1) < FRACTION_EPSILON) {
+      break;
+    }
+  }
+  return value;
+}
+function incompleteBeta(x, a, b) {
+  if (Number.isNaN(x)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
+    return 0;
+  }
+  if (x >= 1) {
+    return 1;
+  }
+  return incompleteBetaSplit(x, 1 - x, a, b);
+}
+function incompleteBetaSplit(x, complement, a, b) {
+  if (Number.isNaN(x) || Number.isNaN(complement) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  if (x <= 0) {
+    return 0;
+  }
+  if (complement <= 0) {
+    return 1;
+  }
+  const logX = complement < 0.5 ? Math.log1p(-complement) : Math.log(x);
+  const logComplement = x < 0.5 ? Math.log1p(-x) : Math.log(complement);
+  const front = Math.exp(a * logX + b * logComplement - logBeta(a, b));
+  if (x < (a + 1) / (a + b + 2)) {
+    return front * betaContinuedFraction(x, a, b) / a;
+  }
+  return 1 - front * betaContinuedFraction(complement, b, a) / b;
+}
+var GAMMA_MAX_STEPS = 1000;
+var GAMMA_EPSILON = 0.0000000000000003;
+function lowerGammaSeries(a, x) {
+  let term = 1 / a;
+  let total = term;
+  for (let step = 1;step <= GAMMA_MAX_STEPS; step += 1) {
+    term *= x / (a + step);
+    total += term;
+    if (Math.abs(term) < Math.abs(total) * GAMMA_EPSILON) {
+      break;
+    }
+  }
+  return total * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGammaFraction(a, x) {
+  let b = x + 1 - a;
+  let c = 1 / FRACTION_FLOOR;
+  let d = 1 / b;
+  let value = d;
+  for (let step = 1;step <= GAMMA_MAX_STEPS; step += 1) {
+    const numerator = -step * (step - a);
+    b += 2;
+    d = numerator * d + b;
+    if (Math.abs(d) < FRACTION_FLOOR) {
+      d = FRACTION_FLOOR;
+    }
+    c = b + numerator / c;
+    if (Math.abs(c) < FRACTION_FLOOR) {
+      c = FRACTION_FLOOR;
+    }
+    d = 1 / d;
+    const delta = d * c;
+    value *= delta;
+    if (Math.abs(delta - 1) < GAMMA_EPSILON) {
+      break;
+    }
+  }
+  return value * Math.exp(-x + a * Math.log(x) - logGamma(a));
+}
+function upperGamma(a, x) {
+  if (x <= 0) {
+    return 1;
+  }
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  return x < a + 1 ? 1 - lowerGammaSeries(a, x) : upperGammaFraction(a, x);
+}
+function normalCdf(z) {
+  if (Number.isNaN(z)) {
+    return Number.NaN;
+  }
+  const lower = 0.5 * upperGamma(0.5, 0.5 * z * z);
+  return z > 0 ? 1 - lower : lower;
+}
+var BELOW_ONE = 1 - Number.EPSILON / 2;
+var INVERSE_MAX_STEPS = 200;
+function inverseGuess(p, a, b) {
+  if (a >= 1 && b >= 1) {
+    const tail = p < 0.5 ? p : 1 - p;
+    const t2 = Math.sqrt(-2 * Math.log(tail));
+    const normal = (p < 0.5 ? -1 : 1) * ((2.30753 + t2 * 0.27061) / (1 + t2 * (0.99229 + t2 * 0.04481)) - t2);
+    const scale = (normal * normal - 3) / 6;
+    const harmonic = 2 / (1 / (2 * a - 1) + 1 / (2 * b - 1));
+    const w = normal * Math.sqrt(scale + harmonic) / harmonic - (1 / (2 * b - 1) - 1 / (2 * a - 1)) * (scale + 5 / 6 - 2 / (3 * harmonic));
+    return a / (a + b * Math.exp(2 * w));
+  }
+  const lower = Math.exp(a * Math.log(a / (a + b))) / a;
+  const upper = Math.exp(b * Math.log(b / (a + b))) / b;
+  const total = lower + upper;
+  if (p < lower / total) {
+    return Math.pow(a * total * p, 1 / a);
+  }
+  return 1 - Math.pow(b * total * (1 - p), 1 / b);
+}
+function inverseIncompleteBeta(p, a, b) {
+  if (Number.isNaN(p) || !(a > 0) || !(b > 0)) {
+    return Number.NaN;
+  }
+  if (p <= 0) {
+    return 0;
+  }
+  if (p >= 1) {
+    return 1;
+  }
+  const logBetaValue = logBeta(a, b);
+  let lower = 0;
+  let upper = 1;
+  let x = inverseGuess(p, a, b);
+  if (!(x > 0) || !(x < 1)) {
+    x = 0.5;
+  }
+  for (let step = 0;step < INVERSE_MAX_STEPS; step += 1) {
+    const residual = incompleteBeta(x, a, b) - p;
+    if (residual < 0) {
+      lower = x;
+    } else {
+      upper = x;
+    }
+    const density = Math.exp((a - 1) * Math.log(x) + (b - 1) * Math.log1p(-x) - logBetaValue);
+    let next = density > 0 && Number.isFinite(density) ? x - residual / density : Number.NaN;
+    if (!(next > lower) || !(next < upper)) {
+      next = 0.5 * (lower + upper);
+    }
+    if (next === x) {
+      break;
+    }
+    const moved = Math.abs(next - x);
+    x = next;
+    if (moved <= Number.EPSILON * x) {
+      break;
+    }
+  }
+  return Math.min(x, BELOW_ONE);
+}
+
+// src/core/tdist.ts
+function isNonCentral(ncp) {
+  return ncp !== undefined && ncp !== 0;
+}
+function isBadArgument(value, df, ncp) {
+  return Number.isNaN(value) || !(df > 0) || ncp !== undefined && Number.isNaN(ncp);
+}
+function dt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralDensity(x, df, ncp) : centralDensity(x, df);
+}
+function pt(x, df, ncp) {
+  if (isBadArgument(x, df, ncp)) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralProbability(x, df, ncp) : centralProbability(x, df);
+}
+function qt(p, df, ncp) {
+  if (isBadArgument(p, df, ncp) || p < 0 || p > 1) {
+    return Number.NaN;
+  }
+  return isNonCentral(ncp) ? nonCentralQuantile(p, df, ncp) : centralQuantile(p, df);
+}
+function centralDensity(x, df) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  const logDensity = -0.5 * Math.log(df) - logBeta(0.5, df / 2) - (df + 1) / 2 * Math.log1p(x * x / df);
+  return Math.exp(logDensity);
+}
+function centralProbability(x, df) {
+  if (x === 0) {
+    return 0.5;
+  }
+  if (x === Number.POSITIVE_INFINITY) {
+    return 1;
+  }
+  if (x === Number.NEGATIVE_INFINITY) {
+    return 0;
+  }
+  const tail = upperTail(Math.abs(x), df);
+  return x < 0 ? tail : 1 - tail;
+}
+function upperTail(t2, df) {
+  const squared = t2 * t2;
+  if (!Number.isFinite(squared)) {
+    return 0;
+  }
+  const total = df + squared;
+  return 0.5 * incompleteBetaSplit(df / total, squared / total, df / 2, 0.5);
+}
+var POLISH_MAX_STEPS = 4;
+function centralQuantile(p, df) {
+  if (p === 0.5) {
+    return 0;
+  }
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  const tail = p < 0.5 ? p : 1 - p;
+  const sign = p < 0.5 ? -1 : 1;
+  const twoSided = 2 * tail;
+  let squared;
+  if (twoSided > 0.5) {
+    const near = inverseIncompleteBeta(1 - twoSided, 0.5, df / 2);
+    squared = df * near / (1 - near);
+  } else {
+    const far = inverseIncompleteBeta(twoSided, df / 2, 0.5);
+    squared = df * (1 - far) / far;
+  }
+  return sign * polish(Math.sqrt(squared), tail, df);
+}
+function polish(start, tail, df) {
+  let t2 = start;
+  for (let step = 0;step < POLISH_MAX_STEPS; step += 1) {
+    const density = centralDensity(t2, df);
+    if (!(density > 0) || !Number.isFinite(t2)) {
+      break;
+    }
+    const move = (upperTail(t2, df) - tail) / density;
+    const next = t2 + move;
+    if (!(next > 0) || !Number.isFinite(next) || Math.abs(move) > 0.25 * t2) {
+      break;
+    }
+    if (next === t2) {
+      break;
+    }
+    t2 = next;
+    if (Math.abs(move) <= Number.EPSILON * t2) {
+      break;
+    }
+  }
+  return t2;
+}
+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 t2 = reflected ? -x : x;
+  const delta = reflected ? -ncp : ncp;
+  const lower = df > SERIES_DF_LIMIT || delta * delta > SERIES_NCP_LIMIT_SQUARED ? normalApproximation(t2, df, delta) : lenthSeries(t2, df, delta);
+  return reflected ? 1 - lower : lower;
+}
+function normalApproximation(t2, df, delta) {
+  const shrink = 1 / (4 * df);
+  const spread = Math.sqrt(1 + t2 * t2 * 2 * shrink);
+  return normalCdf((t2 * (1 - shrink) - delta) / spread);
+}
+function lenthSeries(t2, df, delta) {
+  const squared = t2 * t2;
+  const total = df + squared;
+  const x = squared / total;
+  const complement = df / total;
+  let sum2 = 0;
+  if (x > 0) {
+    const lambda = delta * delta;
+    let oddWeight = 0.5 * Math.exp(-0.5 * lambda);
+    let evenWeight = SQRT_TWO_OVER_PI * oddWeight * delta;
+    let remaining = 0.5 - oddWeight;
+    if (remaining < 0.0000001) {
+      remaining = -0.5 * Math.expm1(-0.5 * lambda);
+    }
+    let a = 0.5;
+    const b = 0.5 * df;
+    const powered = Math.pow(complement, b);
+    const logBetaValue = logBeta(0.5, b);
+    let oddTerm = incompleteBetaSplit(x, complement, a, b);
+    let oddStep = 2 * powered * Math.exp(a * Math.log(x) - logBetaValue);
+    let evenTerm = 1 - powered;
+    let evenStep = b * x * powered;
+    sum2 = oddWeight * oddTerm + evenWeight * evenTerm;
+    for (let step = 1;step <= SERIES_MAX_STEPS; step += 1) {
+      a += 1;
+      oddTerm -= oddStep;
+      evenTerm -= evenStep;
+      oddStep *= x * (a + b - 1) / a;
+      evenStep *= x * (a + b - 0.5) / (a + 0.5);
+      oddWeight *= lambda / (2 * step);
+      evenWeight *= lambda / (2 * step + 1);
+      remaining -= oddWeight;
+      if (remaining <= 0) {
+        break;
+      }
+      sum2 += oddWeight * oddTerm + evenWeight * evenTerm;
+      if (Math.abs(2 * remaining * (oddTerm - oddStep)) < SERIES_ERROR_MAX) {
+        break;
+      }
+    }
+  }
+  return Math.min(Math.max(sum2 + normalCdf(-delta), 0), 1);
+}
+function nonCentralDensity(x, df, ncp) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  if (Math.abs(x) > Math.sqrt(df * Number.EPSILON)) {
+    const stepped = x * Math.sqrt((df + 2) / df);
+    const difference = nonCentralProbability(stepped, df + 2, ncp) - nonCentralProbability(x, df, ncp);
+    return df / Math.abs(x) * Math.abs(difference);
+  }
+  return Math.exp(-0.5 * Math.log(df) - logBeta(0.5, df / 2) - 0.5 * ncp * ncp);
+}
+var QUANTILE_MAX_STEPS = 200;
+function nonCentralQuantile(p, df, ncp) {
+  if (p <= 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (p >= 1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let upper = Math.max(1, ncp);
+  while (Number.isFinite(upper) && nonCentralProbability(upper, df, ncp) < p) {
+    upper *= 2;
+  }
+  let lower = Math.min(-1, -ncp);
+  while (Number.isFinite(lower) && nonCentralProbability(lower, df, ncp) > p) {
+    lower *= 2;
+  }
+  let t2 = 0.5 * (lower + upper);
+  for (let step = 0;step < QUANTILE_MAX_STEPS; step += 1) {
+    const residual = nonCentralProbability(t2, df, ncp) - p;
+    if (residual < 0) {
+      lower = t2;
+    } else {
+      upper = t2;
+    }
+    const density = nonCentralDensity(t2, df, ncp);
+    let next = density > 0 && Number.isFinite(density) ? t2 - residual / density : Number.NaN;
+    if (!(next > lower) || !(next < upper)) {
+      next = 0.5 * (lower + upper);
+    }
+    if (next === t2) {
+      break;
+    }
+    const moved = Math.abs(next - t2);
+    t2 = next;
+    if (moved <= Number.EPSILON * Math.abs(t2)) {
+      break;
+    }
+  }
+  return t2;
+}
+
+// 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/linalg/cov.ts
+function refinedMean(values) {
+  const n = values.length;
+  const first = sum(values) / n;
+  if (!Number.isFinite(first)) {
+    return first;
+  }
+  return first + sum(values.map((value) => value - first)) / n;
+}
+function covariance(a, meanA, b, meanB) {
+  const n = a.length;
+  if (n < 2) {
+    return Number.NaN;
+  }
+  let total = 0;
+  for (let i = 0;i < n; i++) {
+    total += (a[i] - meanA) * (b[i] - meanB);
+  }
+  return total / (n - 1);
+}
+function requireSameLength(a, b) {
+  if (a.length !== b.length) {
+    throw new RangeError("incompatible dimensions");
+  }
+}
+function variance(a) {
+  const center = refinedMean(a);
+  return covariance(a, center, a, center);
+}
+function cov(x, y) {
+  if (isMatrix(x)) {
+    return pairwise(x, false);
+  }
+  if (y === undefined) {
+    throw new RangeError("cov() of a vector needs a second vector");
+  }
+  requireSameLength(x, y);
+  return covariance(x, refinedMean(x), y, refinedMean(y));
+}
+function cor(x, y) {
+  if (isMatrix(x)) {
+    return pairwise(x, true);
+  }
+  if (y === undefined) {
+    throw new RangeError("cor() of a vector needs a second vector");
+  }
+  requireSameLength(x, y);
+  const meanX = refinedMean(x);
+  const meanY = refinedMean(y);
+  const spread = Math.sqrt(covariance(x, meanX, x, meanX) * covariance(y, meanY, y, meanY));
+  return spread === 0 ? Number.NaN : clamp(covariance(x, meanX, y, meanY) / spread);
+}
+function pairwise(m, correlation) {
+  const { nrow, ncol } = m;
+  const columns = Array.from({ length: ncol }, (_, j) => Array.from(m.data.subarray(j * nrow, (j + 1) * nrow)));
+  const means = columns.map(refinedMean);
+  const data = new Float64Array(ncol * ncol);
+  for (let i = 0;i < ncol; i++) {
+    for (let j = 0;j <= i; j++) {
+      const value = covariance(columns[i], means[i], columns[j], means[j]);
+      data[j * ncol + i] = value;
+      data[i * ncol + j] = value;
+    }
+  }
+  if (correlation) {
+    const spreads = Array.from({ length: ncol }, (_, i) => Math.sqrt(data[i * ncol + i]));
+    for (let i = 0;i < ncol; i++) {
+      for (let j = 0;j <= i; j++) {
+        const divisor = spreads[i] * spreads[j];
+        const value = i === j ? 1 : divisor === 0 ? Number.NaN : clamp(data[j * ncol + i] / divisor);
+        data[j * ncol + i] = value;
+        data[i * ncol + j] = value;
+      }
+    }
+  }
+  const names = m.dimnames?.[1] ?? null;
+  const dimnames = names === null ? null : [names, names];
+  return make(ncol, ncol, data, dimnames);
+}
+function clamp(value) {
+  return value > 1 ? 1 : value < -1 ? -1 : value;
+}
+// src/core/linalg/eigen.ts
+function isSymmetric(m, tolerance = 100 * Number.EPSILON) {
+  const { nrow, ncol, data } = m;
+  if (nrow !== ncol) {
+    return false;
+  }
+  for (let j = 0;j < ncol; j++) {
+    for (let i = 0;i < j; i++) {
+      const a = data[j * nrow + i];
+      const b = data[i * nrow + j];
+      if (Math.abs(a - b) > tolerance * Math.max(Math.abs(a), Math.abs(b))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function eigenSymmetric(m) {
+  if (m.nrow !== m.ncol) {
+    throw new RangeError("non-square matrix in 'eigen'");
+  }
+  if (m.nrow === 0) {
+    throw new RangeError("0 x 0 matrix");
+  }
+  if (!m.data.every(Number.isFinite)) {
+    throw new RangeError("infinite or missing values in 'x'");
+  }
+  if (!isSymmetric(m)) {
+    throw new RangeError("'x' must be symmetric");
+  }
+  const n = m.nrow;
+  const a = Float64Array.from(m.data);
+  const v = new Float64Array(n * n);
+  for (let i = 0;i < n; i++) {
+    v[i * n + i] = 1;
+  }
+  jacobi(a, v, n);
+  const order = Array.from({ length: n }, (_, i) => i).sort((i, j) => a[j * n + j] - a[i * n + i] || i - j);
+  const values = order.map((i) => a[i * n + i]);
+  const vectors = new Float64Array(n * n);
+  order.forEach((from, k) => {
+    const columnVector = v.subarray(from * n, (from + 1) * n);
+    let largest = 0;
+    columnVector.forEach((entry) => {
+      if (Math.abs(entry) > Math.abs(largest)) {
+        largest = entry;
+      }
+    });
+    const sign = largest < 0 ? -1 : 1;
+    columnVector.forEach((entry, i) => {
+      vectors[k * n + i] = sign * entry + 0;
+    });
+  });
+  const rows = m.dimnames?.[0] ?? null;
+  return { values, vectors: make(n, n, vectors, rows === null ? null : [rows, null]) };
+}
+function jacobi(a, v, n) {
+  const at2 = (i, j) => a[j * n + i];
+  const set = (i, j, value) => {
+    a[j * n + i] = value;
+  };
+  for (let sweep = 0;sweep < 100; sweep++) {
+    let off = 0;
+    for (let p = 0;p < n; p++) {
+      for (let q = p + 1;q < n; q++) {
+        off += at2(p, q) * at2(p, q);
+      }
+    }
+    if (off === 0) {
+      return;
+    }
+    let diagonal = 0;
+    for (let p = 0;p < n; p++) {
+      diagonal += at2(p, p) * at2(p, p);
+    }
+    if (off <= Number.EPSILON * Number.EPSILON * diagonal) {
+      return;
+    }
+    for (let p = 0;p < n; p++) {
+      for (let q = p + 1;q < n; q++) {
+        const apq = at2(p, q);
+        if (apq === 0) {
+          continue;
+        }
+        const theta = (at2(q, q) - at2(p, p)) / (2 * apq);
+        const t2 = (theta >= 0 ? 1 : -1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+        const c = 1 / Math.sqrt(t2 * t2 + 1);
+        const s = t2 * c;
+        for (let k = 0;k < n; k++) {
+          const akp = at2(k, p);
+          const akq = at2(k, q);
+          set(k, p, c * akp - s * akq);
+          set(k, q, s * akp + c * akq);
+        }
+        for (let k = 0;k < n; k++) {
+          const apk = at2(p, k);
+          const aqk = at2(q, k);
+          set(p, k, c * apk - s * aqk);
+          set(q, k, s * apk + c * aqk);
+        }
+        for (let k = 0;k < n; k++) {
+          const vkp = v[p * n + k];
+          const vkq = v[q * n + k];
+          v[p * n + k] = c * vkp - s * vkq;
+          v[q * n + k] = s * vkp + c * vkq;
+        }
+      }
+    }
+  }
+}
+// src/core/linalg/prcomp.ts
+function prcomp(input, options = {}) {
+  const { center = true, scale = false } = options;
+  const m = isMatrixLike(input) ? input : fromFrame(input);
+  const { nrow: n, ncol: p } = m;
+  if (!m.data.every(Number.isFinite)) {
+    throw new RangeError("infinite or missing values in 'x'");
+  }
+  const columns = Array.from({ length: p }, (_, j) => Array.from(m.data.subarray(j * n, (j + 1) * n)));
+  const centers = columns.map((column2) => center ? sum(column2) / n : 0);
+  const centered = columns.map((column2, j) => column2.map((value) => value - centers[j]));
+  const scales = scale ? centered.map((column2) => Math.sqrt(sum(column2.map((value) => value * value)) / Math.max(1, n - 1))) : null;
+  if (scales !== null && scales.some((value) => value === 0)) {
+    throw new RangeError("cannot rescale a constant/zero column to unit variance");
+  }
+  const prepared = centered.map((column2, j) => scales === null ? column2 : column2.map((value) => value / scales[j]));
+  const divisor = Math.max(1, n - 1);
+  const covariance2 = new Float64Array(p * p);
+  for (let i = 0;i < p; i++) {
+    for (let j = 0;j <= i; j++) {
+      let total = 0;
+      for (let k = 0;k < n; k++) {
+        total += prepared[i][k] * prepared[j][k];
+      }
+      covariance2[j * p + i] = total / divisor;
+      covariance2[i * p + j] = total / divisor;
+    }
+  }
+  const variables = m.dimnames?.[1] ?? null;
+  const eigen = eigenSymmetric(make(p, p, covariance2, variables === null ? null : [variables, variables]));
+  const components = Array.from({ length: p }, (_, k) => `PC${k + 1}`);
+  const rotation = make(p, p, Float64Array.from(eigen.vectors.data), [variables, components]);
+  const data = new Float64Array(n * p);
+  prepared.forEach((column2, j) => {
+    data.set(column2, j * n);
+  });
+  const scores = matmul(make(n, p, data, null), rotation);
+  return {
+    sdev: eigen.values.map((value) => Math.sqrt(Math.max(value, 0))),
+    rotation,
+    center: centers,
+    scale: scales,
+    x: make(n, p, scores.data, [m.dimnames?.[0] ?? null, components])
+  };
+}
+function isMatrixLike(input) {
+  return "data" in input && input.data instanceof Float64Array && typeof input.nrow === "number";
+}
+// src/core/linalg/vector.ts
+function elementwise(a, b, combine) {
+  if (typeof b === "number") {
+    return a.map((x) => combine(x, b));
+  }
+  requireSameLength2(a, b);
+  return zipWith(a, b, combine);
+}
+function requireSameLength2(a, b) {
+  if (a.length !== b.length) {
+    throw new RangeError(`vector lengths differ: ${a.length} and ${b.length}`);
+  }
+}
+function add(a, b) {
+  return elementwise(a, b, (x, y) => x + y);
+}
+function sub(a, b) {
+  return elementwise(a, b, (x, y) => x - y);
+}
+function mul(a, b) {
+  return elementwise(a, b, (x, y) => x * y);
+}
+function div(a, b) {
+  return elementwise(a, b, (x, y) => x / y);
+}
+function square(a) {
+  return a.map((x) => x * x);
+}
+function dot(a, b) {
+  requireSameLength2(a, b);
+  return sum(mul(a, b));
+}
+function norm2(a) {
+  return Math.sqrt(sum(square(a)));
+}
+function cosine(a, b) {
+  return dot(a, b) / (norm2(a) * norm2(b));
+}
+export {
+  variance,
+  transpose,
+  toRows,
+  toColumns,
+  tcrossprod,
+  t,
+  sub,
+  square,
+  solve,
+  row,
+  rcond,
+  rbind,
+  qrResid,
+  qrR,
+  qrQy,
+  qrQty,
+  qrQ,
+  qrFitted,
+  qrCoef,
+  qr,
+  prcomp,
+  norm2 as norm,
+  namedVector,
+  mul,
+  modelMatrix,
+  matrixNorm,
+  matrix,
+  matmul,
+  lu,
+  lookup,
+  lm,
+  isSymmetric,
+  identity,
+  fromRows,
+  fromFrame,
+  fromColumns,
+  eigenSymmetric,
+  dot,
+  div,
+  diag,
+  determinant,
+  det,
+  crossprod,
+  cov,
+  cosine,
+  cor,
+  column,
+  cbind,
+  at,
+  add,
+  DEFAULT_SOLVE_TOLERANCE,
+  DEFAULT_QR_TOLERANCE
+};
+
+//# debugId=3595AB073D7D3A5A64756E2164756E21
+//# sourceMappingURL=linalg.js.map