@danielsimonjr/mathts-functions 0.29.0 → 0.31.0

package/dist/index.js

@@ -2750,12 +2750,12 @@ var parallelStatVariance = mathTyped4("parallelStatVariance", {
   },
   // Variadic form
   "number, number": (a, b) => {
-    const mean6 = (a + b) / 2;
-    return ((a - mean6) ** 2 + (b - mean6) ** 2) / 1;
+    const mean7 = (a + b) / 2;
+    return ((a - mean7) ** 2 + (b - mean7) ** 2) / 1;
   },
   "number, number, number": (a, b, c) => {
-    const mean6 = (a + b + c) / 3;
-    return ((a - mean6) ** 2 + (b - mean6) ** 2 + (c - mean6) ** 2) / 2;
+    const mean7 = (a + b + c) / 3;
+    return ((a - mean7) ** 2 + (b - mean7) ** 2 + (c - mean7) ** 2) / 2;
   }
 });
 var parallelStatStd = mathTyped4("parallelStatStd", {
@@ -3012,10 +3012,10 @@ var parallelStatMAD = mathTyped4("parallelStatMAD", {
     const n = data.length;
     if (n === 0) return NaN;
     const result = await computePool3.mean(data);
-    const mean6 = result.result;
+    const mean7 = result.result;
     let mad2 = 0;
     for (let i = 0; i < n; i++) {
-      mad2 += Math.abs(data[i] - mean6);
+      mad2 += Math.abs(data[i] - mean7);
     }
     return mad2 / n;
   },
@@ -8381,18 +8381,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot3 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot5 = v1[0] * v2[0] + v1[1] * v2[1];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot3 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot5 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot3 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot5 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2);
   const mag2 = Math.sqrt(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2);
   if (mag1 === 0 || mag2 === 0) return NaN;
-  return Math.acos(Math.max(-1, Math.min(1, dot3 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot5 / (mag1 * mag2))));
 }
 function cross3D(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
@@ -8497,14 +8497,14 @@ function reflectVector(v, normal) {
   const mag = Math.sqrt(normal.reduce((s, c) => s + c * c, 0));
   if (mag === 0) return v.slice();
   const n = normal.map((c) => c / mag);
-  const dot3 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot3 * n[i]);
+  const dot5 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot5 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot3 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot5 = v.reduce((s, c, i) => s + c * onto[i], 0);
   const magSq = onto.reduce((s, c) => s + c * c, 0);
   if (magSq === 0) return onto.map(() => 0);
-  const scale = dot3 / magSq;
+  const scale = dot5 / magSq;
   return onto.map((c) => c * scale);
 }
 function distance2D(a, b) {
@@ -13108,7 +13108,7 @@ function quadprog(H, f, A, b) {
   }
   return x;
 }
-function linprog(c, A, b) {
+function linprogOnePhaseLegacy(c, A, b) {
   const m = A.length;
   const n = c.length;
   const tableau = [];
@@ -13179,6 +13179,285 @@ function linprog(c, A, b) {
   }
   return x;
 }
+var LINPROG_TOL = 1e-9;
+function linprogSolveTwoPhase(costWork, Aeq, beq, hasSlack, slackCol) {
+  const m = Aeq.length;
+  const nw = costWork.length;
+  if (m === 0) {
+    for (let j = 0; j < nw; j++) {
+      if (costWork[j] < -LINPROG_TOL) return { xWork: [], status: "unbounded" };
+    }
+    return { xWork: new Array(nw).fill(0), status: "optimal" };
+  }
+  const rows = [];
+  const rhs = [];
+  const flipped = [];
+  for (let i2 = 0; i2 < m; i2++) {
+    let row2 = [...Aeq[i2]];
+    let b = beq[i2];
+    let f = false;
+    if (b < 0) {
+      row2 = row2.map((v) => -v);
+      b = -b;
+      f = true;
+    }
+    rows.push(row2);
+    rhs.push(b);
+    flipped.push(f);
+  }
+  const basis = new Array(m).fill(-1);
+  const artificialCols = [];
+  let nextCol = nw;
+  for (let i2 = 0; i2 < m; i2++) {
+    if (hasSlack[i2] && !flipped[i2]) {
+      basis[i2] = slackCol[i2];
+    } else {
+      const col = nextCol++;
+      artificialCols.push(col);
+      basis[i2] = col;
+    }
+  }
+  const totalCols = nextCol;
+  const isArtificial = new Array(totalCols).fill(false);
+  for (const col of artificialCols) isArtificial[col] = true;
+  const width = totalCols + 1;
+  const tableau = [];
+  for (let i2 = 0; i2 < m; i2++) {
+    const row2 = new Array(width).fill(0);
+    for (let j = 0; j < nw; j++) row2[j] = rows[i2][j];
+    if (isArtificial[basis[i2]]) row2[basis[i2]] = 1;
+    row2[totalCols] = rhs[i2];
+    tableau.push(row2);
+  }
+  const pivot = (pr, pc, objRow) => {
+    const pivotVal = tableau[pr][pc];
+    for (let j = 0; j < width; j++) tableau[pr][j] /= pivotVal;
+    for (let i2 = 0; i2 < tableau.length; i2++) {
+      if (i2 === pr) continue;
+      const factor3 = tableau[i2][pc];
+      if (factor3 === 0) continue;
+      for (let j = 0; j < width; j++) tableau[i2][j] -= factor3 * tableau[pr][j];
+    }
+    const factor2 = objRow[pc];
+    if (factor2 !== 0) {
+      for (let j = 0; j < width; j++) objRow[j] -= factor2 * tableau[pr][j];
+    }
+  };
+  const buildObjRow = (costFull) => {
+    const row2 = new Array(width).fill(0);
+    for (let j = 0; j < totalCols; j++) row2[j] = costFull[j];
+    for (let i2 = 0; i2 < tableau.length; i2++) {
+      const cb = costFull[basis[i2]];
+      if (cb === 0) continue;
+      for (let j = 0; j < width; j++) row2[j] -= cb * tableau[i2][j];
+    }
+    return row2;
+  };
+  const runSimplex = (objRow, excluded, maxIter = 2e3) => {
+    for (let iter = 0; iter < maxIter; iter++) {
+      let pivotCol = -1;
+      let minVal = -LINPROG_TOL;
+      for (let j = 0; j < totalCols; j++) {
+        if (excluded[j]) continue;
+        if (objRow[j] < minVal) {
+          minVal = objRow[j];
+          pivotCol = j;
+        }
+      }
+      if (pivotCol === -1) return "optimal";
+      let pivotRow = -1;
+      let minRatio = Infinity;
+      for (let i2 = 0; i2 < tableau.length; i2++) {
+        if (tableau[i2][pivotCol] > LINPROG_TOL) {
+          const ratio = tableau[i2][totalCols] / tableau[i2][pivotCol];
+          if (ratio < minRatio - 1e-12) {
+            minRatio = ratio;
+            pivotRow = i2;
+          }
+        }
+      }
+      if (pivotRow === -1) return "unbounded";
+      basis[pivotRow] = pivotCol;
+      pivot(pivotRow, pivotCol, objRow);
+    }
+    return "optimal";
+  };
+  const noExclusions = new Array(totalCols).fill(false);
+  const cost1 = new Array(totalCols).fill(0);
+  for (const col of artificialCols) cost1[col] = 1;
+  const objRow1 = buildObjRow(cost1);
+  const phase1Status = runSimplex(objRow1, noExclusions);
+  if (phase1Status === "unbounded") return { xWork: [], status: "infeasible" };
+  let phase1Obj = 0;
+  for (let i2 = 0; i2 < tableau.length; i2++) phase1Obj += cost1[basis[i2]] * tableau[i2][totalCols];
+  if (phase1Obj > 1e-7) return { xWork: [], status: "infeasible" };
+  let i = 0;
+  while (i < tableau.length) {
+    if (!isArtificial[basis[i]]) {
+      i++;
+      continue;
+    }
+    let pc = -1;
+    for (let j = 0; j < nw; j++) {
+      if (Math.abs(tableau[i][j]) > 1e-8) {
+        pc = j;
+        break;
+      }
+    }
+    if (pc === -1) {
+      tableau.splice(i, 1);
+      basis.splice(i, 1);
+      continue;
+    }
+    basis[i] = pc;
+    pivot(i, pc, new Array(width).fill(0));
+    i++;
+  }
+  const costFull2 = new Array(totalCols).fill(0);
+  for (let j = 0; j < nw; j++) costFull2[j] = costWork[j];
+  const objRow2 = buildObjRow(costFull2);
+  const excludeArtificial = isArtificial.slice();
+  const phase2Status = runSimplex(objRow2, excludeArtificial);
+  if (phase2Status === "unbounded") return { xWork: [], status: "unbounded" };
+  const xWork = new Array(nw).fill(0);
+  for (let r = 0; r < tableau.length; r++) {
+    if (basis[r] < nw) xWork[basis[r]] = Math.max(0, tableau[r][totalCols]);
+  }
+  return { xWork, status: "optimal" };
+}
+function linprogTwoPhase(c, opts) {
+  const n = c.length;
+  const boundsResolved = [];
+  for (let j = 0; j < n; j++) {
+    const b = opts.bounds?.[j];
+    boundsResolved.push(b ? [b[0], b[1]] : [0, null]);
+  }
+  let col = 0;
+  const expansions = [];
+  for (let j = 0; j < n; j++) {
+    const low = boundsResolved[j][0];
+    if (low === null) {
+      const colPos = col++;
+      const colNeg = col++;
+      expansions.push({ kind: "split", colPos, colNeg });
+    } else {
+      const c0 = col++;
+      expansions.push({ kind: "shift", col: c0, shift: low });
+    }
+  }
+  const nx = col;
+  const expandRow = (row2) => {
+    const out = new Array(nx).fill(0);
+    for (let j = 0; j < n; j++) {
+      const coeff = row2[j] ?? 0;
+      if (coeff === 0) continue;
+      const e = expansions[j];
+      if (e.kind === "shift") out[e.col] += coeff;
+      else {
+        out[e.colPos] += coeff;
+        out[e.colNeg] -= coeff;
+      }
+    }
+    return out;
+  };
+  const shiftedRhs = (row2, rhsVal) => {
+    let r = rhsVal;
+    for (let j = 0; j < n; j++) {
+      const e = expansions[j];
+      if (e.kind === "shift" && e.shift !== 0) r -= (row2[j] ?? 0) * e.shift;
+    }
+    return r;
+  };
+  let constant = 0;
+  const cWork = new Array(nx).fill(0);
+  for (let j = 0; j < n; j++) {
+    const e = expansions[j];
+    if (e.kind === "shift") {
+      cWork[e.col] = c[j];
+      constant += c[j] * e.shift;
+    } else {
+      cWork[e.colPos] = c[j];
+      cWork[e.colNeg] = -c[j];
+    }
+  }
+  const ubRows = [];
+  const ubRhs = [];
+  const A_ub = opts.A_ub ?? [];
+  const b_ub = opts.b_ub ?? [];
+  for (let i = 0; i < A_ub.length; i++) {
+    ubRows.push(expandRow(A_ub[i]));
+    ubRhs.push(shiftedRhs(A_ub[i], b_ub[i]));
+  }
+  for (let j = 0; j < n; j++) {
+    const high = boundsResolved[j][1];
+    if (high === null) continue;
+    const e = expansions[j];
+    const row2 = new Array(nx).fill(0);
+    let rhsVal;
+    if (e.kind === "shift") {
+      row2[e.col] = 1;
+      rhsVal = high - e.shift;
+    } else {
+      row2[e.colPos] = 1;
+      row2[e.colNeg] = -1;
+      rhsVal = high;
+    }
+    ubRows.push(row2);
+    ubRhs.push(rhsVal);
+  }
+  const A_eq = opts.A_eq ?? [];
+  const b_eq = opts.b_eq ?? [];
+  const eqRows = [];
+  const eqRhs = [];
+  for (let i = 0; i < A_eq.length; i++) {
+    eqRows.push(expandRow(A_eq[i]));
+    eqRhs.push(shiftedRhs(A_eq[i], b_eq[i]));
+  }
+  const mUb = ubRows.length;
+  const mEq = eqRows.length;
+  const nw = nx + mUb;
+  const Aeq = [];
+  const beq = [];
+  const hasSlack = [];
+  const slackCol = [];
+  for (let i = 0; i < mUb; i++) {
+    const row2 = new Array(nw).fill(0);
+    for (let j = 0; j < nx; j++) row2[j] = ubRows[i][j];
+    row2[nx + i] = 1;
+    Aeq.push(row2);
+    beq.push(ubRhs[i]);
+    hasSlack.push(true);
+    slackCol.push(nx + i);
+  }
+  for (let i = 0; i < mEq; i++) {
+    const row2 = new Array(nw).fill(0);
+    for (let j = 0; j < nx; j++) row2[j] = eqRows[i][j];
+    Aeq.push(row2);
+    beq.push(eqRhs[i]);
+    hasSlack.push(false);
+    slackCol.push(-1);
+  }
+  const costWorkFull = new Array(nw).fill(0);
+  for (let j = 0; j < nx; j++) costWorkFull[j] = cWork[j];
+  const raw = linprogSolveTwoPhase(costWorkFull, Aeq, beq, hasSlack, slackCol);
+  if (raw.status !== "optimal") {
+    return { x: new Array(n).fill(NaN), fun: NaN, success: false, status: raw.status };
+  }
+  const x = new Array(n).fill(0);
+  for (let j = 0; j < n; j++) {
+    const e = expansions[j];
+    x[j] = e.kind === "shift" ? raw.xWork[e.col] + e.shift : raw.xWork[e.colPos] - raw.xWork[e.colNeg];
+  }
+  let fun = constant;
+  for (let j = 0; j < nx; j++) fun += cWork[j] * raw.xWork[j];
+  return { x, fun, success: true, status: "optimal" };
+}
+function linprog(c, arg22, arg3) {
+  if (Array.isArray(arg22)) {
+    return linprogOnePhaseLegacy(c, arg22, arg3);
+  }
+  return linprogTwoPhase(c, arg22);
+}
 function solvePDE(pde, domain, bc) {
   const { alpha } = pde;
   const { L, nx, nt, T } = domain;
@@ -13883,26 +14162,26 @@ function _splitSeed(baseSeed, k) {
 function _aggregateRanks(vectors, aggregation) {
   const n = vectors[0].length;
   const count2 = vectors.length;
-  const mean6 = new Float64Array(n);
+  const mean7 = new Float64Array(n);
   for (const v of vectors) {
-    for (let i = 0; i < n; i++) mean6[i] += v[i];
+    for (let i = 0; i < n; i++) mean7[i] += v[i];
   }
-  for (let i = 0; i < n; i++) mean6[i] /= count2;
+  for (let i = 0; i < n; i++) mean7[i] /= count2;
   if (aggregation === "mean") {
-    return { ranks: mean6 };
+    return { ranks: mean7 };
   }
   const std2 = new Float64Array(n);
   for (const v of vectors) {
     for (let i = 0; i < n; i++) {
-      const d = v[i] - mean6[i];
+      const d = v[i] - mean7[i];
       std2[i] += d * d;
     }
   }
   for (let i = 0; i < n; i++) std2[i] = Math.sqrt(std2[i] / count2);
   return {
-    ranks: mean6,
+    ranks: mean7,
     ranksPerRestart: vectors,
-    restartStats: { mean: mean6, std: std2 }
+    restartStats: { mean: mean7, std: std2 }
   };
 }
 function _pageRankOnce(adj, d, maxIter, tol, seed) {
@@ -14035,26 +14314,26 @@ function _betweennessOnce(adj, directed, normalise, seed) {
 function _aggregateBetweenness(vectors, aggregation) {
   const n = vectors[0].length;
   const count2 = vectors.length;
-  const mean6 = new Float64Array(n);
+  const mean7 = new Float64Array(n);
   for (const v of vectors) {
-    for (let i = 0; i < n; i++) mean6[i] += v[i];
+    for (let i = 0; i < n; i++) mean7[i] += v[i];
   }
-  for (let i = 0; i < n; i++) mean6[i] /= count2;
+  for (let i = 0; i < n; i++) mean7[i] /= count2;
   if (aggregation === "mean") {
-    return { centrality: mean6 };
+    return { centrality: mean7 };
   }
   const std2 = new Float64Array(n);
   for (const v of vectors) {
     for (let i = 0; i < n; i++) {
-      const d = v[i] - mean6[i];
+      const d = v[i] - mean7[i];
       std2[i] += d * d;
     }
   }
   for (let i = 0; i < n; i++) std2[i] = Math.sqrt(std2[i] / count2);
   return {
-    centrality: mean6,
+    centrality: mean7,
     centralityPerRestart: vectors,
-    restartStats: { mean: mean6, std: std2 }
+    restartStats: { mean: mean7, std: std2 }
   };
 }
 async function betweennessCentrality(adj, opts) {
@@ -14118,41 +14397,41 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot3 = 0;
-    for (let i = 0; i < n; i++) dot3 += v[i] * ref[i];
-    if (dot3 < 0) {
+    let dot5 = 0;
+    for (let i = 0; i < n; i++) dot5 += v[i] * ref[i];
+    if (dot5 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
     }
     return v;
   });
-  const mean6 = new Float64Array(n);
+  const mean7 = new Float64Array(n);
   for (const v of aligned) {
-    for (let i = 0; i < n; i++) mean6[i] += v[i];
+    for (let i = 0; i < n; i++) mean7[i] += v[i];
   }
-  for (let i = 0; i < n; i++) mean6[i] /= count2;
+  for (let i = 0; i < n; i++) mean7[i] /= count2;
   let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += mean6[i] * mean6[i];
+  for (let i = 0; i < n; i++) norm4 += mean7[i] * mean7[i];
   norm4 = Math.sqrt(norm4);
   if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) mean6[i] /= norm4;
+    for (let i = 0; i < n; i++) mean7[i] /= norm4;
   }
   if (aggregation === "mean") {
-    return { centrality: mean6 };
+    return { centrality: mean7 };
   }
   const std2 = new Float64Array(n);
   for (const v of aligned) {
     for (let i = 0; i < n; i++) {
-      const d = v[i] - mean6[i];
+      const d = v[i] - mean7[i];
       std2[i] += d * d;
     }
   }
   for (let i = 0; i < n; i++) std2[i] = Math.sqrt(std2[i] / count2);
   return {
-    centrality: mean6,
+    centrality: mean7,
     centralityPerRestart: aligned,
-    restartStats: { mean: mean6, std: std2 }
+    restartStats: { mean: mean7, std: std2 }
   };
 }
 async function eigenvectorCentrality(adj, opts) {
@@ -14931,7 +15210,7 @@ function hypergeometricDist(population, successes, draws) {
     for (let i = kMin; i <= kk; i++) sum3 += pmf(i);
     return Math.min(1, sum3);
   };
-  const mean6 = N * K / M;
+  const mean7 = N * K / M;
   const variance2 = N * (K / M) * ((M - K) / M) * ((M - N) / (M - 1));
   return {
     pdf: pmf,
@@ -14942,7 +15221,7 @@ function hypergeometricDist(population, successes, draws) {
       for (let k = kMin; k <= kMax; k++) if (cdf(k) >= p) return k;
       return kMax;
     },
-    mean: mean6,
+    mean: mean7,
     variance: variance2,
     sample: () => _discreteSample(cdf, Math.random, kMax),
     sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
@@ -14964,7 +15243,7 @@ function negativeBinomialDist(r, p) {
     if (k < 0) return 0;
     return Math.min(1, _betainc(p, r, Math.floor(k) + 1));
   };
-  const mean6 = r * (1 - p) / p;
+  const mean7 = r * (1 - p) / p;
   const variance2 = r * (1 - p) / (p * p);
   return {
     pdf: pmf,
@@ -14979,12 +15258,12 @@ function negativeBinomialDist(r, p) {
       }
       return Infinity;
     },
-    mean: mean6,
+    mean: mean7,
     variance: variance2,
-    sample: () => _discreteSample(cdf, Math.random, Math.ceil(mean6 + 20 * Math.sqrt(variance2) + 20)),
+    sample: () => _discreteSample(cdf, Math.random, Math.ceil(mean7 + 20 * Math.sqrt(variance2) + 20)),
     sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
       const out = new Float64Array(count2);
-      const cap = Math.ceil(mean6 + 20 * Math.sqrt(variance2) + 20);
+      const cap = Math.ceil(mean7 + 20 * Math.sqrt(variance2) + 20);
       for (let j = 0; j < count2; j++) out[j] = _discreteSample(cdf, rng, cap);
       return out;
     })
@@ -15163,8 +15442,8 @@ function _cholesky(m) {
   }
   return L;
 }
-function multivariateNormal(mean6, cov2) {
-  const k = mean6.length;
+function multivariateNormal(mean7, cov2) {
+  const k = mean7.length;
   if (cov2.length !== k || cov2.some((row2) => row2.length !== k)) {
     throw new Error("multivariateNormal: cov must be a k\xD7k matrix matching mean");
   }
@@ -15172,13 +15451,13 @@ function multivariateNormal(mean6, cov2) {
   let logDet = 0;
   for (let i = 0; i < k; i++) logDet += 2 * Math.log(L[i][i]);
   return {
-    mean: mean6,
+    mean: mean7,
     cov: cov2,
     pdf: (x) => {
       if (x.length !== k) throw new Error("multivariateNormal.pdf: x must have length k");
       const z = new Array(k).fill(0);
       for (let i = 0; i < k; i++) {
-        let s = x[i] - mean6[i];
+        let s = x[i] - mean7[i];
         for (let j = 0; j < i; j++) s -= L[i][j] * z[j];
         z[i] = s / L[i][i];
       }
@@ -15243,11 +15522,11 @@ function _bootstrapSummary(stats) {
   if (n === 0) return { bootstrapMean: NaN, bootstrapStd: NaN };
   let sum3 = 0;
   for (let i = 0; i < n; i++) sum3 += stats[i];
-  const mean6 = sum3 / n;
+  const mean7 = sum3 / n;
   let sq = 0;
-  for (let i = 0; i < n; i++) sq += (stats[i] - mean6) ** 2;
+  for (let i = 0; i < n; i++) sq += (stats[i] - mean7) ** 2;
   const std2 = n > 1 ? Math.sqrt(sq / (n - 1)) : 0;
-  return { bootstrapMean: mean6, bootstrapStd: std2 };
+  return { bootstrapMean: mean7, bootstrapStd: std2 };
 }
 function _mean(arr7) {
   let sum3 = 0;
@@ -15971,9 +16250,9 @@ function principalComponentAnalysis(data, k) {
   const explained = eigenvalues.map((ev) => totalVar > 0 ? Math.abs(ev) / totalVar : 0);
   const scores = centered.map((row2) => {
     return eigenvectors.map((ev) => {
-      let dot3 = 0;
-      for (let j = 0; j < p; j++) dot3 += row2[j] * ev[j];
-      return dot3;
+      let dot5 = 0;
+      for (let j = 0; j < p; j++) dot5 += row2[j] * ev[j];
+      return dot5;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -16014,7 +16293,7 @@ function _median(arr7) {
   const m = n >> 1;
   return n % 2 === 1 ? s[m] : (s[m - 1] + s[m]) / 2;
 }
-function leveneTest(groups, center = "median") {
+function leveneTest(groups, center2 = "median") {
   const k = groups.length;
   if (k < 2) throw new Error("leveneTest: need at least 2 groups");
   let N = 0;
@@ -16023,7 +16302,7 @@ function leveneTest(groups, center = "median") {
     N += g.length;
   }
   const z = groups.map((g) => {
-    const c = center === "median" ? _median(g) : _mean(g);
+    const c = center2 === "median" ? _median(g) : _mean(g);
     return g.map((x) => Math.abs(x - c));
   });
   const allZ = [];
@@ -16131,13 +16410,13 @@ function andersonDarlingTest(data) {
   const n = data.length;
   if (n < 8) throw new Error("andersonDarlingTest: need at least 8 observations");
   const sorted = data.slice().sort((p2, q) => p2 - q);
-  const mean6 = _mean(sorted);
+  const mean7 = _mean(sorted);
   const s = Math.sqrt(_variance(sorted, 1));
   const phi = (z) => 0.5 * erfcScalar(-z / Math.SQRT2);
   let sumTerm = 0;
   for (let i = 0; i < n; i++) {
-    const wi = (sorted[i] - mean6) / s;
-    const wj = (sorted[n - 1 - i] - mean6) / s;
+    const wi = (sorted[i] - mean7) / s;
+    const wj = (sorted[n - 1 - i] - mean7) / s;
     sumTerm += (2 * (i + 1) - 1) / n * (Math.log(phi(wi)) + Math.log(1 - phi(wj)));
   }
   const a2 = -n - sumTerm;
@@ -16584,30 +16863,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot3 = 0;
+      let dot5 = 0;
       for (let i = 0; i < len; i++) {
-        dot3 += v[i] * H[k + 1 + i][j];
+        dot5 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot3;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot5;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot3 = 0;
+      let dot5 = 0;
       for (let j = 0; j < len; j++) {
-        dot3 += H[i][k + 1 + j] * v[j];
+        dot5 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot3 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot5 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot3 = 0;
+      let dot5 = 0;
       for (let j = 0; j < len; j++) {
-        dot3 += Q2[i][k + 1 + j] * v[j];
+        dot5 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot3 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot5 * v[j];
       }
     }
   }
@@ -22399,10 +22678,10 @@ var dependencies85 = ["typed", "transpose", "conj"];
 var createCtranspose = /* @__PURE__ */ factory(
   name85,
   dependencies85,
-  ({ typed: typed3, transpose: transpose3, conj: conj3 }) => {
+  ({ typed: typed3, transpose: transpose4, conj: conj3 }) => {
     return typed3(name85, {
       any: function(x) {
-        return conj3(transpose3(x));
+        return conj3(transpose4(x));
       }
     });
   }
@@ -23392,7 +23671,7 @@ var dependencies98 = ["add", "multiply", "transpose"];
 var createCsAmd = /* @__PURE__ */ factory(
   name98,
   dependencies98,
-  ({ add: add2, multiply: multiply2, transpose: transpose3 }) => {
+  ({ add: add2, multiply: multiply2, transpose: transpose4 }) => {
     function _tryWasmAmd(a, n) {
       const wasm = wasmLoader.getModule();
       if (!wasm || !a._ptr || !a._index) return null;
@@ -23686,7 +23965,7 @@ var createCsAmd = /* @__PURE__ */ factory(
       return P2;
     };
     function _createTargetMatrix(order, a, m, n, dense) {
-      const at = transpose3(a);
+      const at = transpose4(a);
       if (order === 1 && n === m) {
         return add2(a, at);
       }
@@ -23705,7 +23984,7 @@ var createCsAmd = /* @__PURE__ */ factory(
           }
         }
         tptr[m] = p2;
-        a = transpose3(at);
+        a = transpose4(at);
         return multiply2(at, a);
       }
       return multiply2(at, a);
@@ -23806,7 +24085,7 @@ var dependencies99 = ["transpose"];
 var createCsCounts = /* @__PURE__ */ factory(
   name99,
   dependencies99,
-  ({ transpose: transpose3 }) => {
+  ({ transpose: transpose4 }) => {
     function _tryWasmCounts(a, parent, post, n) {
       const wasm = wasmLoader.getModule();
       if (!wasm || n < WASM_COUNTS_THRESHOLD || !a._index || !a._ptr) return null;
@@ -23868,7 +24147,7 @@ var createCsCounts = /* @__PURE__ */ factory(
         w[k] = -1;
       }
       const colcount = [];
-      const at = transpose3(a);
+      const at = transpose4(a);
       const tindex = at._index;
       const tptr = at._ptr;
       for (k = 0; k < n; k++) {
@@ -24037,9 +24316,9 @@ var dependencies100 = ["add", "multiply", "transpose"];
 var createCsSqr = /* @__PURE__ */ factory(
   name100,
   dependencies100,
-  ({ add: add2, multiply: multiply2, transpose: transpose3 }) => {
-    const csAmd2 = createCsAmd({ add: add2, multiply: multiply2, transpose: transpose3 });
-    const csCounts2 = createCsCounts({ transpose: transpose3 });
+  ({ add: add2, multiply: multiply2, transpose: transpose4 }) => {
+    const csAmd2 = createCsAmd({ add: add2, multiply: multiply2, transpose: transpose4 });
+    const csCounts2 = createCsCounts({ transpose: transpose4 });
     return function csSqr2(order, a, qr2) {
       const aptr = a._ptr;
       const asize = a._size;
@@ -29919,7 +30198,7 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot3,
+    dot: dot5,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
@@ -29935,7 +30214,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv2(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot3(x, x));
+              return dotDivide2(ctranspose2(x), dot5(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30014,8 +30293,8 @@ var createPinv = /* @__PURE__ */ factory(
     }
     function _rankFact(mat, rows, cols) {
       const rref = _rref(mat, rows, cols);
-      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot3(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot3(rref[i], rref[i])));
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot5(rref[j], rref[j]))));
+      const F = rref.filter((_, i) => !_isZero(dot5(rref[i], rref[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -34748,14 +35027,14 @@ var createSlu = /* @__PURE__ */ factory(
     abs: abs2,
     add: add2,
     multiply: multiply2,
-    transpose: transpose3,
+    transpose: transpose4,
     divideScalar: divideScalar2,
     subtract: subtract2,
     larger: larger2,
     largerEq: largerEq2,
     SparseMatrix
   }) => {
-    const csSqr2 = createCsSqr({ add: add2, multiply: multiply2, transpose: transpose3 });
+    const csSqr2 = createCsSqr({ add: add2, multiply: multiply2, transpose: transpose4 });
     const csLu2 = createCsLu({
       abs: abs2,
       divideScalar: divideScalar2,
@@ -35509,10 +35788,10 @@ var createVariance = /* @__PURE__ */ factory(
         }
       });
       if (num2 === 0) throw new Error("Cannot calculate variance of an empty array");
-      const mean6 = divide2(sum3, num2);
+      const mean7 = divide2(sum3, num2);
       sum3 = void 0;
       deepForEach2(array, function(value) {
-        const diff2 = subtract2(value, mean6);
+        const diff2 = subtract2(value, mean7);
         sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add2(sum3, multiply2(diff2, diff2));
       });
       if (mathIsNaN(sum3)) {
@@ -36978,7 +37257,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot3
+  dot: dot5
 }) {
   function complexEigs(arr7, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37419,7 +37698,7 @@ function createComplexEigs({
       v = subtract2(
         v,
         multiply2(
-          divideScalar2(dot3(w, v), dot3(w, w)),
+          divideScalar2(dot5(w, v), dot5(w, w)),
           w
         )
       );
@@ -37427,7 +37706,7 @@ function createComplexEigs({
     return v;
   }
   function norm4(v) {
-    return abs2(sqrt2(dot3(v, v)));
+    return abs2(sqrt2(dot5(v, v)));
   }
   function normalize2(v, type) {
     const big = type === "BigNumber";
@@ -37847,7 +38126,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot3
+    dot: dot5
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -37886,7 +38165,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot3
+      dot: dot5
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -40868,7 +41147,7 @@ var createSylvester = /* @__PURE__ */ factory(
     multiply: multiply2,
     range: range2,
     concat: concat3,
-    transpose: transpose3,
+    transpose: transpose4,
     index,
     subset: subset2,
     add: add2,
@@ -40910,7 +41189,7 @@ var createSylvester = /* @__PURE__ */ factory(
       const sB = schur2(multiply2(-1, B));
       const G = sB.T;
       const V = sB.U;
-      const D = multiply2(multiply2(transpose3(U), C), V);
+      const D = multiply2(multiply2(transpose4(U), C), V);
       const all = range2(0, m);
       const y = [];
       const hc = (a, b) => concat3(a, b, 1);
@@ -40944,7 +41223,7 @@ var createSylvester = /* @__PURE__ */ factory(
         }
       }
       const Y = matrix2(matrixFromColumns2(...y));
-      const X = multiply2(U, multiply2(Y, transpose3(V)));
+      const X = multiply2(U, multiply2(Y, transpose4(V)));
       return X;
     }
   }
@@ -40956,21 +41235,21 @@ var dependencies253 = ["typed", "matrix", "sylvester", "multiply", "transpose"];
 var createLyap = /* @__PURE__ */ factory(
   name253,
   dependencies253,
-  ({ typed: typed3, matrix: matrix2, sylvester: sylvester2, multiply: multiply2, transpose: transpose3 }) => {
+  ({ typed: typed3, matrix: matrix2, sylvester: sylvester2, multiply: multiply2, transpose: transpose4 }) => {
     return typed3(name253, {
       "Matrix, Matrix": function(A, Q2) {
-        return sylvester2(A, transpose3(A), multiply2(-1, Q2));
+        return sylvester2(A, transpose4(A), multiply2(-1, Q2));
       },
       "Array, Matrix": function(A, Q2) {
-        return sylvester2(matrix2(A), transpose3(matrix2(A)), multiply2(-1, Q2));
+        return sylvester2(matrix2(A), transpose4(matrix2(A)), multiply2(-1, Q2));
       },
       "Matrix, Array": function(A, Q2) {
-        return sylvester2(A, transpose3(A), matrix2(multiply2(-1, Q2)));
+        return sylvester2(A, transpose4(A), matrix2(multiply2(-1, Q2)));
       },
       "Array, Array": function(A, Q2) {
         return sylvester2(
           matrix2(A),
-          transpose3(matrix2(A)),
+          transpose4(matrix2(A)),
           matrix2(multiply2(-1, Q2))
         ).toArray();
       }
@@ -44978,16 +45257,16 @@ function fsolve(F, x0, opts = {}) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(`fsolve: singular Jacobian at iteration ${iter} (${msg})`);
     }
-    const residualNorm = norm24(Fx);
+    const residualNorm2 = norm24(Fx);
     let xNext = x.map((xi, i) => xi + delta[i]);
     let FxNext = F(xNext);
-    if (norm24(FxNext) >= residualNorm) {
+    if (norm24(FxNext) >= residualNorm2) {
       let trialLambda = 1;
       for (let halving = 0; halving < 20; halving++) {
         trialLambda /= 2;
         const xTrial = x.map((xi, i) => xi + trialLambda * delta[i]);
         const FxTrial = F(xTrial);
-        if (norm24(FxTrial) < residualNorm) {
+        if (norm24(FxTrial) < residualNorm2) {
           xNext = xTrial;
           FxNext = FxTrial;
           break;
@@ -45176,6 +45455,297 @@ function linearRegression(x, y) {
   return { slope, intercept, rValue, rSquared: rValue * rValue, pValue, stdErr };
 }
 
+// src/ml/ols.ts
+function transpose3(m) {
+  const rows = m.length;
+  const cols = m[0].length;
+  const out = Array.from({ length: cols }, () => new Array(rows).fill(0));
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      out[j][i] = m[i][j];
+    }
+  }
+  return out;
+}
+function matmul2(a, b) {
+  const n = a.length;
+  const k = b.length;
+  const m = b[0].length;
+  const out = Array.from({ length: n }, () => new Array(m).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let c = 0; c < k; c++) {
+      const aic = a[i][c];
+      if (aic === 0) continue;
+      for (let j = 0; j < m; j++) {
+        out[i][j] += aic * b[c][j];
+      }
+    }
+  }
+  return out;
+}
+function matVec(a, v) {
+  return a.map((row2) => row2.reduce((sum3, val, j) => sum3 + val * v[j], 0));
+}
+function invert(a) {
+  const n = a.length;
+  const M = a.map((row2, i) => [...row2, ...Array.from({ length: n }, (_, j) => i === j ? 1 : 0)]);
+  for (let col = 0; col < n; col++) {
+    let pivotRow = col;
+    let maxVal = Math.abs(M[col][col]);
+    for (let row2 = col + 1; row2 < n; row2++) {
+      if (Math.abs(M[row2][col]) > maxVal) {
+        maxVal = Math.abs(M[row2][col]);
+        pivotRow = row2;
+      }
+    }
+    if (maxVal < 1e-15) throw new Error("ols: X^T X is singular (predictors are collinear)");
+    if (pivotRow !== col) [M[col], M[pivotRow]] = [M[pivotRow], M[col]];
+    const pivot = M[col][col];
+    for (let j = 0; j < 2 * n; j++) M[col][j] /= pivot;
+    for (let row2 = 0; row2 < n; row2++) {
+      if (row2 === col) continue;
+      const factor2 = M[row2][col];
+      if (factor2 === 0) continue;
+      for (let j = 0; j < 2 * n; j++) {
+        M[row2][j] -= factor2 * M[col][j];
+      }
+    }
+  }
+  return M.map((row2) => row2.slice(n));
+}
+function ols(X, y, opts) {
+  const n = X.length;
+  if (n === 0) throw new Error("ols: empty design matrix");
+  if (y.length !== n) throw new Error(`ols: length mismatch (X has ${n} rows, y has ${y.length})`);
+  const useIntercept = opts?.intercept !== false;
+  const design = useIntercept ? X.map((row2) => [1, ...row2]) : X.map((row2) => [...row2]);
+  const p = design[0].length;
+  if (n <= p) throw new Error(`ols: need more observations (${n}) than parameters (${p})`);
+  const Xt = transpose3(design);
+  const XtX = matmul2(Xt, design);
+  const Xty = matVec(Xt, y);
+  const XtXinv = invert(XtX);
+  const coefficients = matVec(XtXinv, Xty);
+  const fitted = matVec(design, coefficients);
+  const residuals = y.map((yi, i) => yi - fitted[i]);
+  const rss = residuals.reduce((sum3, e) => sum3 + e * e, 0);
+  const yMean = y.reduce((sum3, v) => sum3 + v, 0) / n;
+  const tss = y.reduce((sum3, v) => sum3 + (v - yMean) * (v - yMean), 0);
+  const dfResid = n - p;
+  const sigma2 = rss / dfResid;
+  const stderr = XtXinv.map((row2, j) => Math.sqrt(sigma2 * row2[j]));
+  const tValues = coefficients.map((b, j) => b / stderr[j]);
+  const pValues = tValues.map((t) => 2 * (1 - studentTCDF(Math.abs(t), dfResid)));
+  const r2 = tss === 0 ? 1 : 1 - rss / tss;
+  const adjR2 = 1 - (1 - r2) * (n - 1) / dfResid;
+  const fStat = p > 1 ? (tss - rss) / (p - 1) / (rss / dfResid) : NaN;
+  return { coefficients, stderr, tValues, pValues, r2, adjR2, fStat, residuals };
+}
+
+// src/ml/regularized-regression.ts
+function validate(X, y, name254) {
+  const n = X.length;
+  if (n === 0) throw new Error(`${name254}: empty design matrix`);
+  if (y.length !== n) {
+    throw new Error(`${name254}: length mismatch (X has ${n} rows, y has ${y.length})`);
+  }
+  const p = X[0].length;
+  if (p === 0) throw new Error(`${name254}: X must have at least one predictor column`);
+  return { n, p };
+}
+function colMeans(X, n, p) {
+  const means = new Array(p).fill(0);
+  for (const row2 of X) {
+    for (let j = 0; j < p; j++) means[j] += row2[j];
+  }
+  for (let j = 0; j < p; j++) means[j] /= n;
+  return means;
+}
+function mean6(y) {
+  return y.reduce((s, v) => s + v, 0) / y.length;
+}
+function center(X, y, n, p, useIntercept) {
+  const xMean = useIntercept ? colMeans(X, n, p) : new Array(p).fill(0);
+  const yMean = useIntercept ? mean6(y) : 0;
+  const Xc = X.map((row2) => row2.map((v, j) => v - xMean[j]));
+  const yc = y.map((v) => v - yMean);
+  return { Xc, yc, xMean, yMean };
+}
+function dot2(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function softThreshold(a, lambda) {
+  if (a > lambda) return a - lambda;
+  if (a < -lambda) return a + lambda;
+  return 0;
+}
+function ridge(X, y, alpha, opts) {
+  const { n, p } = validate(X, y, "ridge");
+  if (alpha < 0) throw new Error("ridge: alpha must be non-negative");
+  const useIntercept = opts?.intercept !== false;
+  const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
+  const XtX = Array.from({ length: p }, () => new Array(p).fill(0));
+  const Xty = new Array(p).fill(0);
+  for (let j = 0; j < p; j++) {
+    for (let k = j; k < p; k++) {
+      let s = 0;
+      for (let i = 0; i < n; i++) s += Xc[i][j] * Xc[i][k];
+      XtX[j][k] = s;
+      XtX[k][j] = s;
+    }
+    XtX[j][j] += alpha;
+    for (let i = 0; i < n; i++) Xty[j] += Xc[i][j] * yc[i];
+  }
+  const coefficients = linsolve(XtX, Xty);
+  const intercept = useIntercept ? yMean - dot2(xMean, coefficients) : 0;
+  return { coefficients, intercept };
+}
+function standardize(Xc, n, p) {
+  const scale = new Array(p);
+  for (let j = 0; j < p; j++) {
+    let ss = 0;
+    for (let i = 0; i < n; i++) ss += Xc[i][j] * Xc[i][j];
+    const meanSq = ss / n;
+    scale[j] = meanSq > 1e-15 ? Math.sqrt(meanSq) : 1;
+  }
+  const Xs = Xc.map((row2) => row2.map((v, j) => v / scale[j]));
+  return { Xs, scale };
+}
+function coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol) {
+  const beta2 = new Array(p).fill(0);
+  const z = new Array(p).fill(n);
+  const residual = [...yc];
+  for (let iter = 0; iter < maxIter; iter++) {
+    let maxChange = 0;
+    for (let j = 0; j < p; j++) {
+      const col = Xs.map((row2) => row2[j]);
+      const oldBeta = beta2[j];
+      let rho = 0;
+      for (let i = 0; i < n; i++) rho += col[i] * (residual[i] + col[i] * oldBeta);
+      const newBeta = softThreshold(rho, l1) / (z[j] + l2);
+      if (newBeta !== oldBeta) {
+        const delta = newBeta - oldBeta;
+        for (let i = 0; i < n; i++) residual[i] -= col[i] * delta;
+        beta2[j] = newBeta;
+        maxChange = Math.max(maxChange, Math.abs(delta));
+      }
+    }
+    if (maxChange < tol) break;
+  }
+  return beta2;
+}
+function lasso(X, y, alpha, opts) {
+  const { n, p } = validate(X, y, "lasso");
+  if (alpha < 0) throw new Error("lasso: alpha must be non-negative");
+  const useIntercept = opts?.intercept !== false;
+  const maxIter = opts?.maxIter ?? 1e3;
+  const tol = opts?.tol ?? 1e-7;
+  const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
+  const { Xs, scale } = standardize(Xc, n, p);
+  const betaStd = coordinateDescent(Xs, yc, n, p, alpha, 0, maxIter, tol);
+  const coefficients = betaStd.map((b, j) => b / scale[j]);
+  const intercept = useIntercept ? yMean - dot2(xMean, coefficients) : 0;
+  return { coefficients, intercept };
+}
+function elasticNet(X, y, alpha, l1Ratio, opts) {
+  const { n, p } = validate(X, y, "elasticNet");
+  if (alpha < 0) throw new Error("elasticNet: alpha must be non-negative");
+  if (l1Ratio < 0 || l1Ratio > 1) throw new Error("elasticNet: l1Ratio must be in [0, 1]");
+  const useIntercept = opts?.intercept !== false;
+  const maxIter = opts?.maxIter ?? 1e3;
+  const tol = opts?.tol ?? 1e-7;
+  const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
+  const { Xs, scale } = standardize(Xc, n, p);
+  const l1 = alpha * l1Ratio;
+  const l2 = alpha * (1 - l1Ratio);
+  const betaStd = coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol);
+  const coefficients = betaStd.map((b, j) => b / scale[j]);
+  const intercept = useIntercept ? yMean - dot2(xMean, coefficients) : 0;
+  return { coefficients, intercept };
+}
+
+// src/ml/logistic-regression.ts
+function sigmoid2(z) {
+  if (z >= 0) {
+    const e2 = Math.exp(-z);
+    return 1 / (1 + e2);
+  }
+  const e = Math.exp(z);
+  return e / (1 + e);
+}
+var MAX_STEP_NORM = 25;
+function logisticRegression(X, y, opts) {
+  const n = X.length;
+  if (n === 0) throw new Error("logisticRegression: empty design matrix");
+  if (y.length !== n) {
+    throw new Error(`logisticRegression: length mismatch (X has ${n} rows, y has ${y.length})`);
+  }
+  for (const yi of y) {
+    if (yi !== 0 && yi !== 1) {
+      throw new Error("logisticRegression: y must be binary (0 or 1)");
+    }
+  }
+  const useIntercept = opts?.intercept !== false;
+  const tol = opts?.tol ?? 1e-8;
+  const maxIter = opts?.maxIter ?? 100;
+  const design = (rows) => useIntercept ? rows.map((row2) => [1, ...row2]) : rows.map((row2) => [...row2]);
+  const D = design(X);
+  const p = D[0].length;
+  let beta2 = new Array(p).fill(0);
+  for (let iter = 0; iter < maxIter; iter++) {
+    const eta = D.map((row2) => row2.reduce((s, v, j) => s + v * beta2[j], 0));
+    const probs = eta.map(sigmoid2);
+    const weights = probs.map((pi) => Math.max(pi * (1 - pi), 1e-9));
+    const XtWX = Array.from({ length: p }, () => new Array(p).fill(0));
+    for (let i = 0; i < n; i++) {
+      const w = weights[i];
+      const row2 = D[i];
+      for (let a = 0; a < p; a++) {
+        const wa = w * row2[a];
+        if (wa === 0) continue;
+        for (let b = 0; b < p; b++) {
+          XtWX[a][b] += wa * row2[b];
+        }
+      }
+    }
+    const score = new Array(p).fill(0);
+    for (let i = 0; i < n; i++) {
+      const resid = y[i] - probs[i];
+      const row2 = D[i];
+      for (let a = 0; a < p; a++) {
+        score[a] += row2[a] * resid;
+      }
+    }
+    const ridgeEps = 1e-8;
+    const regularized = XtWX.map((row2, a) => row2.map((v, b) => a === b ? v + ridgeEps : v));
+    let delta;
+    try {
+      delta = linsolve(regularized, score);
+    } catch {
+      break;
+    }
+    let stepNorm = 0;
+    for (const d of delta) stepNorm = Math.max(stepNorm, Math.abs(d));
+    if (stepNorm > MAX_STEP_NORM) {
+      const scale = MAX_STEP_NORM / stepNorm;
+      delta = delta.map((d) => d * scale);
+      stepNorm = MAX_STEP_NORM;
+    }
+    beta2 = beta2.map((b, j) => b + delta[j]);
+    if (stepNorm < tol) break;
+  }
+  const intercept = useIntercept ? beta2[0] : 0;
+  const coefficients = useIntercept ? beta2.slice(1) : beta2.slice();
+  const predictProba = (x) => {
+    const Dx = design(x);
+    return Dx.map((row2) => sigmoid2(row2.reduce((s, v, j) => s + v * beta2[j], 0)));
+  };
+  const predict = (x) => predictProba(x).map((pi) => pi >= 0.5 ? 1 : 0);
+  return { coefficients, intercept, predictProba, predict };
+}
+
 // src/optimization-extra.ts
 var _inv2 = inv;
 function nelderMead(f, x0, opts = {}) {
@@ -45344,10 +45914,10 @@ function kmeans(data, k, opts = {}) {
   if (!Number.isInteger(k) || k < 1) throw new Error("kmeans: k must be a positive integer");
   const d = data[0].length;
   if (k > n) throw new Error("kmeans: k exceeds number of points");
-  const mean6 = new Array(d).fill(0);
-  for (const p of data) for (let j = 0; j < d; j++) mean6[j] += p[j] / n;
+  const mean7 = new Array(d).fill(0);
+  for (const p of data) for (let j = 0; j < d; j++) mean7[j] += p[j] / n;
   let first = 0;
-  for (let i = 1; i < n; i++) if (dist2(data[i], mean6) < dist2(data[first], mean6)) first = i;
+  for (let i = 1; i < n; i++) if (dist2(data[i], mean7) < dist2(data[first], mean7)) first = i;
   const centroids = [data[first].slice()];
   while (centroids.length < k) {
     let best = -1;
@@ -45413,6 +45983,458 @@ function spectralClustering(adjacency, k, opts = {}) {
   return kmeans(embed, k, opts).labels;
 }
 
+// src/ml/dbscan-knn.ts
+function euclidean(a, b) {
+  let sum3 = 0;
+  for (let i = 0; i < a.length; i++) {
+    const d = a[i] - b[i];
+    sum3 += d * d;
+  }
+  return Math.sqrt(sum3);
+}
+function regionQuery(points, i, eps) {
+  const neighbors = [];
+  for (let j = 0; j < points.length; j++) {
+    if (euclidean(points[i], points[j]) <= eps) neighbors.push(j);
+  }
+  return neighbors;
+}
+function dbscan(points, eps, minPts) {
+  const n = points.length;
+  const labels = new Array(n).fill(-2);
+  let clusterId = -1;
+  for (let i = 0; i < n; i++) {
+    if (labels[i] !== -2) continue;
+    const neighbors = regionQuery(points, i, eps);
+    if (neighbors.length < minPts) {
+      labels[i] = -1;
+      continue;
+    }
+    clusterId++;
+    labels[i] = clusterId;
+    const seeds = neighbors.filter((j) => j !== i);
+    for (let s = 0; s < seeds.length; s++) {
+      const j = seeds[s];
+      if (labels[j] === -1) {
+        labels[j] = clusterId;
+      }
+      if (labels[j] !== -2) continue;
+      labels[j] = clusterId;
+      const jNeighbors = regionQuery(points, j, eps);
+      if (jNeighbors.length >= minPts) {
+        for (const k of jNeighbors) {
+          if (labels[k] === -2 || labels[k] === -1) seeds.push(k);
+        }
+      }
+    }
+  }
+  return labels;
+}
+function kNearestIndices(train, q, k) {
+  const dists = train.map((row2, i) => ({ i, d: euclidean(row2, q) }));
+  dists.sort((a, b) => a.d - b.d);
+  return dists.slice(0, Math.min(k, dists.length)).map((e) => e.i);
+}
+function knnClassify(train, labels, query, k) {
+  return query.map((q) => {
+    const idx = kNearestIndices(train, q, k);
+    const counts = /* @__PURE__ */ new Map();
+    for (const i of idx) {
+      const lbl = labels[i];
+      counts.set(lbl, (counts.get(lbl) ?? 0) + 1);
+    }
+    let bestLabel = labels[idx[0]];
+    let bestCount = -1;
+    for (const [lbl, count2] of counts) {
+      if (count2 > bestCount) {
+        bestCount = count2;
+        bestLabel = lbl;
+      }
+    }
+    const nearestLabel = labels[idx[0]];
+    if (counts.get(nearestLabel) === bestCount) {
+      bestLabel = nearestLabel;
+    }
+    return bestLabel;
+  });
+}
+function knnRegress(train, targets, query, k) {
+  return query.map((q) => {
+    const idx = kNearestIndices(train, q, k);
+    const sum3 = idx.reduce((acc, i) => acc + targets[i], 0);
+    return sum3 / idx.length;
+  });
+}
+
+// src/ml/kde.ts
+var SQRT_2PI2 = Math.sqrt(2 * Math.PI);
+function standardNormalPdf(z) {
+  return Math.exp(-0.5 * z * z) / SQRT_2PI2;
+}
+function sampleStd(samples, mean7) {
+  const n = samples.length;
+  let sumSq = 0;
+  for (const s of samples) {
+    const d = s - mean7;
+    sumSq += d * d;
+  }
+  return Math.sqrt(sumSq / (n - 1));
+}
+function percentileSorted(sorted, p) {
+  const n = sorted.length;
+  if (n === 1) return sorted[0];
+  const rank2 = p / 100 * (n - 1);
+  const lo = Math.floor(rank2);
+  const hi = Math.ceil(rank2);
+  if (lo === hi) return sorted[lo];
+  const frac = rank2 - lo;
+  return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}
+function silvermanBandwidth(samples) {
+  const n = samples.length;
+  const mean7 = samples.reduce((a, b) => a + b, 0) / n;
+  const sigma = sampleStd(samples, mean7);
+  const sorted = [...samples].sort((a, b) => a - b);
+  const iqr2 = percentileSorted(sorted, 75) - percentileSorted(sorted, 25);
+  const spread = iqr2 > 0 ? Math.min(sigma, iqr2 / 1.34) : sigma;
+  if (spread === 0) {
+    throw new Error(
+      "gaussianKDE: cannot derive a Silverman bandwidth from a constant sample (standard deviation and IQR are both 0); pass an explicit `bandwidth`."
+    );
+  }
+  return 0.9 * spread * Math.pow(n, -1 / 5);
+}
+function gaussianKDE(samples, opts = {}) {
+  if (samples.length === 0) {
+    throw new Error("gaussianKDE: `samples` must be non-empty.");
+  }
+  const bandwidth = opts.bandwidth ?? silvermanBandwidth(samples);
+  if (!(bandwidth > 0)) {
+    throw new Error("gaussianKDE: `bandwidth` must be a positive number.");
+  }
+  const n = samples.length;
+  const evaluate3 = (xs) => xs.map((x) => {
+    let sum3 = 0;
+    for (const s of samples) {
+      sum3 += standardNormalPdf((x - s) / bandwidth);
+    }
+    return sum3 / (n * bandwidth);
+  });
+  return { evaluate: evaluate3, bandwidth };
+}
+
+// src/stats/inference-extra.ts
+function chi2Contingency(table, opts = {}) {
+  const rows = table.length;
+  if (rows < 2) throw new Error("chi2Contingency: table needs at least 2 rows");
+  const cols = table[0].length;
+  if (cols < 2) throw new Error("chi2Contingency: table needs at least 2 columns");
+  for (const row2 of table) {
+    if (row2.length !== cols) throw new Error("chi2Contingency: table must be rectangular");
+  }
+  const rowTotals = new Array(rows).fill(0);
+  const colTotals = new Array(cols).fill(0);
+  let total = 0;
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      const v = table[i][j];
+      rowTotals[i] += v;
+      colTotals[j] += v;
+      total += v;
+    }
+  }
+  if (total <= 0) throw new Error("chi2Contingency: table sum must be positive");
+  const expected = Array.from({ length: rows }, () => new Array(cols).fill(0));
+  const applyCorrection = rows === 2 && cols === 2 && opts.correction !== false;
+  let chi2 = 0;
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      const e = rowTotals[i] * colTotals[j] / total;
+      expected[i][j] = e;
+      if (e <= 0) continue;
+      const o = table[i][j];
+      const diff2 = applyCorrection ? Math.max(0, Math.abs(o - e) - 0.5) : o - e;
+      chi2 += diff2 * diff2 / e;
+    }
+  }
+  const dof = (rows - 1) * (cols - 1);
+  const pValue = 1 - chiSquaredCDF(chi2, dof);
+  const cramersV = Math.sqrt(chi2 / (total * Math.min(rows - 1, cols - 1)));
+  return { chi2, pValue, dof, expected, cramersV };
+}
+function multipleTest(pValues, method) {
+  const n = pValues.length;
+  if (n === 0) return [];
+  if (method === "bonferroni") {
+    return pValues.map((p) => Math.min(1, p * n));
+  }
+  const order = pValues.map((_, i) => i).sort((a, b) => pValues[a] - pValues[b]);
+  const adjusted = new Array(n);
+  if (method === "holm") {
+    let running2 = 0;
+    for (let rank2 = 0; rank2 < n; rank2++) {
+      const idx = order[rank2];
+      running2 = Math.max(running2, (n - rank2) * pValues[idx]);
+      adjusted[idx] = Math.min(1, running2);
+    }
+    return adjusted;
+  }
+  let running = 1;
+  for (let rank2 = n - 1; rank2 >= 0; rank2--) {
+    const idx = order[rank2];
+    running = Math.min(running, n / (rank2 + 1) * pValues[idx]);
+    adjusted[idx] = Math.min(1, running);
+  }
+  return adjusted;
+}
+
+// src/numeric/bfgs.ts
+var CBRT_EPS = Math.cbrt(2220446049250313e-31);
+function numericGradient(f, x) {
+  const n = x.length;
+  const g = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const h = Math.max(1, Math.abs(x[i])) * CBRT_EPS;
+    const xp = x.slice();
+    const xm = x.slice();
+    xp[i] += h;
+    xm[i] -= h;
+    g[i] = (f(xp) - f(xm)) / (2 * h);
+  }
+  return g;
+}
+function clipToBounds(x, bounds) {
+  if (!bounds) return x;
+  return x.map((v, i) => {
+    const b = bounds[i];
+    if (!b) return v;
+    const [lo, hi] = b;
+    return Math.min(hi, Math.max(lo, v));
+  });
+}
+function dot3(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function matVec2(H, v) {
+  const n = v.length;
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    let s = 0;
+    for (let j = 0; j < n; j++) s += H[i][j] * v[j];
+    out[i] = s;
+  }
+  return out;
+}
+function bfgs(f, x0, opts = {}) {
+  const { grad, bounds, tol = 1e-8, maxIter = 500 } = opts;
+  const gradOf = grad ?? ((x2) => numericGradient(f, x2));
+  const n = x0.length;
+  const c1 = 1e-4;
+  let x = clipToBounds(x0.slice(), bounds);
+  let fx = f(x);
+  let g = gradOf(x);
+  let H = Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
+  );
+  const infNorm = (v) => v.reduce((m, c) => Math.max(m, Math.abs(c)), 0);
+  let iter = 0;
+  let converged = infNorm(g) < tol;
+  while (!converged && iter < maxIter) {
+    const d = matVec2(H, g).map((v) => -v);
+    const gd = dot3(g, d);
+    const dir = gd < 0 ? d : g.map((v) => -v);
+    const dirSlope = gd < 0 ? gd : -dot3(g, g);
+    let alpha = 1;
+    let xNew = clipToBounds(
+      x.map((v, i) => v + alpha * dir[i]),
+      bounds
+    );
+    let fNew = f(xNew);
+    let halvings = 0;
+    while (fNew > fx + c1 * alpha * dirSlope && halvings < 50) {
+      alpha *= 0.5;
+      xNew = clipToBounds(
+        x.map((v, i) => v + alpha * dir[i]),
+        bounds
+      );
+      fNew = f(xNew);
+      halvings++;
+    }
+    const gNew = gradOf(xNew);
+    const s = xNew.map((v, i) => v - x[i]);
+    const y = gNew.map((v, i) => v - g[i]);
+    const sy = dot3(s, y);
+    if (sy > 1e-12) {
+      const rho = 1 / sy;
+      const Hy = matVec2(H, y);
+      const yHy = dot3(y, Hy);
+      const HNew = Array.from({ length: n }, () => new Array(n).fill(0));
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          HNew[i][j] = H[i][j] - rho * (s[i] * Hy[j] + Hy[i] * s[j]) + rho * rho * yHy * s[i] * s[j] + rho * s[i] * s[j];
+        }
+      }
+      H = HNew;
+    }
+    x = xNew;
+    fx = fNew;
+    g = gNew;
+    iter++;
+    converged = infNorm(g) < tol;
+  }
+  return { x, fval: fx, iterations: iter, converged };
+}
+
+// src/numeric/nnls.ts
+function matVec3(A, x) {
+  const m = A.length;
+  const result = new Array(m);
+  for (let i = 0; i < m; i++) {
+    const row2 = A[i];
+    let s = 0;
+    for (let j = 0; j < row2.length; j++) s += row2[j] * x[j];
+    result[i] = s;
+  }
+  return result;
+}
+function residualNorm(A, x, b) {
+  const Ax = matVec3(A, x);
+  let s = 0;
+  for (let i = 0; i < b.length; i++) {
+    const d = Ax[i] - b[i];
+    s += d * d;
+  }
+  return Math.sqrt(s);
+}
+function nnls(A, b, opts = {}) {
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? 3 * n;
+  let x = new Array(n).fill(0);
+  const passive = /* @__PURE__ */ new Set();
+  const gradient2 = (xv) => {
+    const Ax = matVec3(A, xv);
+    const w = new Array(n).fill(0);
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let i = 0; i < m; i++) s += A[i][j] * (b[i] - Ax[i]);
+      w[j] = s;
+    }
+    return w;
+  };
+  const solvePassive = (P2) => {
+    const z = new Array(n).fill(0);
+    if (P2.length === 0) return z;
+    const Asub = A.map((row2) => P2.map((j) => row2[j]));
+    let zp;
+    try {
+      zp = leastSquares(Asub, b);
+    } catch {
+      return x.slice();
+    }
+    for (let k = 0; k < P2.length; k++) z[P2[k]] = zp[k];
+    return z;
+  };
+  let outerIter = 0;
+  while (outerIter < maxIter) {
+    const w = gradient2(x);
+    let maxW = -Infinity;
+    let maxJ = -1;
+    for (let j = 0; j < n; j++) {
+      if (!passive.has(j) && w[j] > maxW) {
+        maxW = w[j];
+        maxJ = j;
+      }
+    }
+    if (maxJ === -1 || maxW <= tol) break;
+    passive.add(maxJ);
+    let z = solvePassive(Array.from(passive));
+    let innerIter = 0;
+    while (Array.from(passive).some((j) => z[j] <= tol) && innerIter < maxIter) {
+      innerIter++;
+      let alpha = Infinity;
+      for (const j of passive) {
+        if (z[j] <= tol) {
+          const denom = x[j] - z[j];
+          if (denom > 0) alpha = Math.min(alpha, x[j] / denom);
+        }
+      }
+      if (!isFinite(alpha)) alpha = 0;
+      for (let j = 0; j < n; j++) x[j] = x[j] + alpha * (z[j] - x[j]);
+      for (const j of Array.from(passive)) {
+        if (Math.abs(x[j]) < tol) passive.delete(j);
+      }
+      z = solvePassive(Array.from(passive));
+    }
+    x = z;
+    outerIter++;
+  }
+  return { x, residual: residualNorm(A, x, b) };
+}
+function clip(v, lower, upper) {
+  return v.map((vi, i) => Math.min(Math.max(vi, lower[i]), upper[i]));
+}
+function lsqBounded(A, b, lower, upper, opts = {}) {
+  const m = A.length;
+  const n = A[0]?.length ?? 0;
+  const tol = opts.tol ?? 1e-10;
+  const maxIter = opts.maxIter ?? Math.max(200, 20 * n);
+  let x = clip(new Array(n).fill(0), lower, upper);
+  const gradient2 = (xv) => {
+    const Ax = matVec3(A, xv);
+    const r = new Array(m);
+    for (let i = 0; i < m; i++) r[i] = Ax[i] - b[i];
+    const g = new Array(n).fill(0);
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let i = 0; i < m; i++) s += A[i][j] * r[i];
+      g[j] = s;
+    }
+    return g;
+  };
+  const objective = (xv) => {
+    const r = residualNorm(A, xv, b);
+    return 0.5 * r * r;
+  };
+  for (let iter = 0; iter < maxIter; iter++) {
+    const g = gradient2(x);
+    const projFull = clip(
+      x.map((xi, i) => xi - g[i]),
+      lower,
+      upper
+    );
+    let pgNorm = 0;
+    for (let i = 0; i < n; i++) pgNorm += (x[i] - projFull[i]) ** 2;
+    pgNorm = Math.sqrt(pgNorm);
+    if (pgNorm < tol) break;
+    const fx = objective(x);
+    let alpha = 1;
+    let xNext = clip(
+      x.map((xi, i) => xi - alpha * g[i]),
+      lower,
+      upper
+    );
+    let fNext = objective(xNext);
+    let backtrack = 0;
+    while (fNext > fx && backtrack < 50) {
+      alpha /= 2;
+      xNext = clip(
+        x.map((xi, i) => xi - alpha * g[i]),
+        lower,
+        upper
+      );
+      fNext = objective(xNext);
+      backtrack++;
+    }
+    x = xNext;
+  }
+  return { x, residual: residualNorm(A, x, b) };
+}
+
 // src/cas-integration.ts
 var parse2 = parse;
 var evaluate2 = evaluate;
@@ -45671,15 +46693,15 @@ function haversine(lat1, lon1, lat2, lon2, radius = EARTH_RADIUS_KM) {
   const a = Math.sin(dPhi / 2) ** 2 + Math.cos(phi1) * Math.cos(phi2) * Math.sin(dLambda / 2) ** 2;
   return radius * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 }
-var dot2 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
-var norm3 = (a) => Math.sqrt(dot2(a, a));
+var dot4 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
+var norm3 = (a) => Math.sqrt(dot4(a, a));
 function slerp(v0, v1, t) {
   const n0 = norm3(v0);
   const n16 = norm3(v1);
   if (n0 === 0 || n16 === 0) throw new Error("slerp: input vectors must be non-zero");
   const u0 = v0.map((v) => v / n0);
   const u1 = v1.map((v) => v / n16);
-  let cos2 = dot2(u0, u1);
+  let cos2 = dot4(u0, u1);
   cos2 = cos2 > 1 ? 1 : cos2 < -1 ? -1 : cos2;
   const omega = Math.acos(cos2);
   const mag = n0 + (n16 - n0) * t;
@@ -45795,6 +46817,7 @@ export {
   betainc,
   betweennessCentrality,
   bezierCurve,
+  bfgs,
   bigint,
   bignumber,
   bin,
@@ -45835,6 +46858,7 @@ export {
   chebyshevDistance,
   chebyshevFit,
   chebyshevT,
+  chi2Contingency,
   chiSquareTest,
   chiSquaredCDF,
   chiSquaredDist,
@@ -45909,6 +46933,7 @@ export {
   curl,
   curvefit,
   dagostinoTest,
+  dbscan,
   dct,
   deepEqual,
   degree,
@@ -45949,6 +46974,7 @@ export {
   efimovFactor,
   eigenvectorCentrality,
   eigs,
+  elasticNet,
   electricConstant,
   electronMass,
   element,
@@ -46096,6 +47122,7 @@ export {
   gammaincp,
   gasConstant,
   gaussQuad,
+  gaussianKDE,
   gcd,
   generalizedEig,
   geometricPMF,
@@ -46188,6 +47215,8 @@ export {
   kldivergence,
   klitzing,
   kmeans,
+  knnClassify,
+  knnRegress,
   kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
@@ -46204,6 +47233,7 @@ export {
   laplacianMatrix,
   larger,
   largerEq,
+  lasso,
   lcm,
   leafCount,
   leastSquares,
@@ -46233,12 +47263,14 @@ export {
   logisticCDF,
   logisticPDF,
   logisticQuantile,
+  logisticRegression,
   logsumexp,
   loschmidt,
   lowRankApprox,
   lowpassFilter,
   lsolve,
   lsolveAll,
+  lsqBounded,
   lucas,
   lucasL,
   lup,
@@ -46291,6 +47323,7 @@ export {
   multiTaperPSD,
   multinomial,
   multipleComparison,
+  multipleTest,
   multiply,
   multiplyScalar,
   multivariateNormal,
@@ -46303,6 +47336,7 @@ export {
   newtonInterp,
   nextPrime,
   nintegrate,
+  nnls,
   nodeOperations,
   noncentralChi2PDF,
   norm,
@@ -46325,6 +47359,7 @@ export {
   oct,
   odeAdaptiveStep,
   odeGeneral,
+  ols,
   ones,
   or,
   orth,
@@ -46443,6 +47478,7 @@ export {
   resolve,
   resultant,
   reviver,
+  ridge,
   rightArithShift,
   rightLogShift,
   risingFactorial,