@danielsimonjr/mathts-functions 0.30.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 dot4 = 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, dot4 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot5 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot4 = 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, dot4 / (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 dot4 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot4 * 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 dot4 = 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 = dot4 / magSq;
+  const scale = dot5 / magSq;
   return onto.map((c) => c * scale);
 }
 function distance2D(a, b) {
@@ -14162,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) {
@@ -14314,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) {
@@ -14397,41 +14397,41 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot4 = 0;
-    for (let i = 0; i < n; i++) dot4 += v[i] * ref[i];
-    if (dot4 < 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) {
@@ -15210,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,
@@ -15221,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) => {
@@ -15243,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,
@@ -15258,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;
     })
@@ -15442,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");
   }
@@ -15451,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];
       }
@@ -15522,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;
@@ -16250,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 dot4 = 0;
-      for (let j = 0; j < p; j++) dot4 += row2[j] * ev[j];
-      return dot4;
+      let dot5 = 0;
+      for (let j = 0; j < p; j++) dot5 += row2[j] * ev[j];
+      return dot5;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -16293,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;
@@ -16302,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 = [];
@@ -16410,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;
@@ -16863,30 +16863,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot4 = 0;
+      let dot5 = 0;
       for (let i = 0; i < len; i++) {
-        dot4 += 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] * dot4;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot5;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot4 = 0;
+      let dot5 = 0;
       for (let j = 0; j < len; j++) {
-        dot4 += 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 * dot4 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot5 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot4 = 0;
+      let dot5 = 0;
       for (let j = 0; j < len; j++) {
-        dot4 += 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 * dot4 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot5 * v[j];
       }
     }
   }
@@ -22678,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));
       }
     });
   }
@@ -23671,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;
@@ -23965,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);
       }
@@ -23984,7 +23984,7 @@ var createCsAmd = /* @__PURE__ */ factory(
           }
         }
         tptr[m] = p2;
-        a = transpose3(at);
+        a = transpose4(at);
         return multiply2(at, a);
       }
       return multiply2(at, a);
@@ -24085,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;
@@ -24147,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++) {
@@ -24316,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;
@@ -30198,7 +30198,7 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot4,
+    dot: dot5,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
@@ -30214,7 +30214,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv2(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot4(x, x));
+              return dotDivide2(ctranspose2(x), dot5(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30293,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(dot4(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot4(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) {
@@ -35027,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,
@@ -35788,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)) {
@@ -37257,7 +37257,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot4
+  dot: dot5
 }) {
   function complexEigs(arr7, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37698,7 +37698,7 @@ function createComplexEigs({
       v = subtract2(
         v,
         multiply2(
-          divideScalar2(dot4(w, v), dot4(w, w)),
+          divideScalar2(dot5(w, v), dot5(w, w)),
           w
         )
       );
@@ -37706,7 +37706,7 @@ function createComplexEigs({
     return v;
   }
   function norm4(v) {
-    return abs2(sqrt2(dot4(v, v)));
+    return abs2(sqrt2(dot5(v, v)));
   }
   function normalize2(v, type) {
     const big = type === "BigNumber";
@@ -38126,7 +38126,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot4
+    dot: dot5
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -38165,7 +38165,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot4
+      dot: dot5
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -41147,7 +41147,7 @@ var createSylvester = /* @__PURE__ */ factory(
     multiply: multiply2,
     range: range2,
     concat: concat3,
-    transpose: transpose3,
+    transpose: transpose4,
     index,
     subset: subset2,
     add: add2,
@@ -41189,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);
@@ -41223,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;
     }
   }
@@ -41235,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();
       }
@@ -45455,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 = {}) {
@@ -45623,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;
@@ -45692,6 +45983,211 @@ 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) {
@@ -45716,12 +46212,12 @@ function clipToBounds(x, bounds) {
     return Math.min(hi, Math.max(lo, v));
   });
 }
-function dot2(a, b) {
+function dot3(a, b) {
   let s = 0;
   for (let i = 0; i < a.length; i++) s += a[i] * b[i];
   return s;
 }
-function matVec(H, v) {
+function matVec2(H, v) {
   const n = v.length;
   const out = new Array(n);
   for (let i = 0; i < n; i++) {
@@ -45747,10 +46243,10 @@ function bfgs(f, x0, opts = {}) {
   let iter = 0;
   let converged = infNorm(g) < tol;
   while (!converged && iter < maxIter) {
-    const d = matVec(H, g).map((v) => -v);
-    const gd = dot2(g, d);
+    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 : -dot2(g, g);
+    const dirSlope = gd < 0 ? gd : -dot3(g, g);
     let alpha = 1;
     let xNew = clipToBounds(
       x.map((v, i) => v + alpha * dir[i]),
@@ -45770,11 +46266,11 @@ function bfgs(f, x0, opts = {}) {
     const gNew = gradOf(xNew);
     const s = xNew.map((v, i) => v - x[i]);
     const y = gNew.map((v, i) => v - g[i]);
-    const sy = dot2(s, y);
+    const sy = dot3(s, y);
     if (sy > 1e-12) {
       const rho = 1 / sy;
-      const Hy = matVec(H, y);
-      const yHy = dot2(y, Hy);
+      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++) {
@@ -45793,7 +46289,7 @@ function bfgs(f, x0, opts = {}) {
 }
 
 // src/numeric/nnls.ts
-function matVec2(A, x) {
+function matVec3(A, x) {
   const m = A.length;
   const result = new Array(m);
   for (let i = 0; i < m; i++) {
@@ -45805,7 +46301,7 @@ function matVec2(A, x) {
   return result;
 }
 function residualNorm(A, x, b) {
-  const Ax = matVec2(A, x);
+  const Ax = matVec3(A, x);
   let s = 0;
   for (let i = 0; i < b.length; i++) {
     const d = Ax[i] - b[i];
@@ -45821,7 +46317,7 @@ function nnls(A, b, opts = {}) {
   let x = new Array(n).fill(0);
   const passive = /* @__PURE__ */ new Set();
   const gradient2 = (xv) => {
-    const Ax = matVec2(A, xv);
+    const Ax = matVec3(A, xv);
     const w = new Array(n).fill(0);
     for (let j = 0; j < n; j++) {
       let s = 0;
@@ -45889,7 +46385,7 @@ function lsqBounded(A, b, lower, upper, opts = {}) {
   const maxIter = opts.maxIter ?? Math.max(200, 20 * n);
   let x = clip(new Array(n).fill(0), lower, upper);
   const gradient2 = (xv) => {
-    const Ax = matVec2(A, 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);
@@ -46197,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 dot3 = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
-var norm3 = (a) => Math.sqrt(dot3(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 = dot3(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;
@@ -46362,6 +46858,7 @@ export {
   chebyshevDistance,
   chebyshevFit,
   chebyshevT,
+  chi2Contingency,
   chiSquareTest,
   chiSquaredCDF,
   chiSquaredDist,
@@ -46436,6 +46933,7 @@ export {
   curl,
   curvefit,
   dagostinoTest,
+  dbscan,
   dct,
   deepEqual,
   degree,
@@ -46476,6 +46974,7 @@ export {
   efimovFactor,
   eigenvectorCentrality,
   eigs,
+  elasticNet,
   electricConstant,
   electronMass,
   element,
@@ -46623,6 +47122,7 @@ export {
   gammaincp,
   gasConstant,
   gaussQuad,
+  gaussianKDE,
   gcd,
   generalizedEig,
   geometricPMF,
@@ -46715,6 +47215,8 @@ export {
   kldivergence,
   klitzing,
   kmeans,
+  knnClassify,
+  knnRegress,
   kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
@@ -46731,6 +47233,7 @@ export {
   laplacianMatrix,
   larger,
   largerEq,
+  lasso,
   lcm,
   leafCount,
   leastSquares,
@@ -46760,6 +47263,7 @@ export {
   logisticCDF,
   logisticPDF,
   logisticQuantile,
+  logisticRegression,
   logsumexp,
   loschmidt,
   lowRankApprox,
@@ -46819,6 +47323,7 @@ export {
   multiTaperPSD,
   multinomial,
   multipleComparison,
+  multipleTest,
   multiply,
   multiplyScalar,
   multivariateNormal,
@@ -46854,6 +47359,7 @@ export {
   oct,
   odeAdaptiveStep,
   odeGeneral,
+  ols,
   ones,
   or,
   orth,
@@ -46972,6 +47478,7 @@ export {
   resolve,
   resultant,
   reviver,
+  ridge,
   rightArithShift,
   rightLogShift,
   risingFactorial,