@danielsimonjr/mathts-functions 0.48.0 → 0.50.0

package/dist/index.js

@@ -112,7 +112,7 @@ __export(typed_exports, {
   cond: () => cond,
   conj: () => conj,
   connectedComponents: () => connectedComponents,
-  convexHull: () => convexHull,
+  convexHull2D: () => convexHull2D,
   convexHull3D: () => convexHull3D,
   convolve: () => convolve,
   coordinateTransform: () => coordinateTransform,
@@ -2281,9 +2281,9 @@ var mean = mathTyped2("mean", {
     return result.result;
   }
 });
-function varianceFromM2(m2, n, norm4) {
+function varianceFromM2(m2, n, norm5) {
   if (n === 0) return NaN;
-  switch (norm4) {
+  switch (norm5) {
     case "biased":
       return m2 / (n + 1);
     case "uncorrected":
@@ -2298,31 +2298,31 @@ function m2OfArray(arr10) {
 }
 var variance = mathTyped2("variance", {
   Array: (arr10) => varianceFromM2(m2OfArray(arr10), arr10.length, "unbiased"),
-  "Array, string": (arr10, norm4) => varianceFromM2(m2OfArray(arr10), arr10.length, norm4),
+  "Array, string": (arr10, norm5) => varianceFromM2(m2OfArray(arr10), arr10.length, norm5),
   // Parallel Float64Array variance. computePool returns POPULATION variance
   // (sum2/n); recover sum2 = pop·n and renormalize for the requested convention.
   Float64Array: async (a) => {
     const result = await computePool.variance(a);
     return varianceFromM2(result.result.variance * a.length, a.length, "unbiased");
   },
-  "Float64Array, string": async (a, norm4) => {
+  "Float64Array, string": async (a, norm5) => {
     const result = await computePool.variance(a);
-    return varianceFromM2(result.result.variance * a.length, a.length, norm4);
+    return varianceFromM2(result.result.variance * a.length, a.length, norm5);
   }
 });
 var std = mathTyped2("std", {
   Array: (arr10) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, "unbiased")),
-  "Array, string": (arr10, norm4) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, norm4)),
+  "Array, string": (arr10, norm5) => Math.sqrt(varianceFromM2(m2OfArray(arr10), arr10.length, norm5)),
   // Parallel Float64Array std — derive from the (renormalized) variance so the
   // convention matches the Array path and parallelStatStd.
   Float64Array: async (a) => {
     const result = await computePool.variance(a);
     return Math.sqrt(varianceFromM2(result.result.variance * a.length, a.length, "unbiased"));
   },
-  "Float64Array, string": async (a, norm4) => {
+  "Float64Array, string": async (a, norm5) => {
     const result = await computePool.variance(a);
     return Math.sqrt(
-      varianceFromM2(result.result.variance * a.length, a.length, norm4)
+      varianceFromM2(result.result.variance * a.length, a.length, norm5)
     );
   }
 });
@@ -3589,8 +3589,8 @@ function welchPSDJS(samples, frameLength, overlap, windowType) {
     start += hop;
   }
   if (numFrames === 0) return new Float64Array(0);
-  const norm4 = numFrames * frameLength * winPower;
-  for (let k = 0; k < psdLen; k++) psd[k] /= norm4;
+  const norm5 = numFrames * frameLength * winPower;
+  for (let k = 0; k < psdLen; k++) psd[k] /= norm5;
   for (let k = 1; k < psdLen - 1; k++) psd[k] *= 2;
   return psd;
 }
@@ -8551,18 +8551,18 @@ import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
 var GEOMETRY_WASM_THRESHOLD = 32;
 var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
-  const dot8 = v1[0] * v2[0] + v1[1] * v2[1];
+  const dot9 = 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, dot8 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot9 / (mag1 * mag2))));
 }
 function angle3D(v1, v2) {
-  const dot8 = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+  const dot9 = 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, dot8 / (mag1 * mag2))));
+  return Math.acos(Math.max(-1, Math.min(1, dot9 / (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]];
@@ -8584,7 +8584,7 @@ function polygonArea(vertices) {
   }
   return Math.abs(area2) / 2;
 }
-function convexHull(points) {
+function convexHull2D(points) {
   const n = points.length;
   if (n <= 1) return points.slice();
   if (n === 2) return points.slice();
@@ -8606,12 +8606,12 @@ function convexHull(points) {
   } else {
     sorted = points.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]);
   }
-  function cross3(o, a, b) {
+  function cross4(o, a, b) {
     return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
   }
   const lower = [];
   for (const p of sorted) {
-    while (lower.length >= 2 && cross3(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+    while (lower.length >= 2 && cross4(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
       lower.pop();
     }
     lower.push(p);
@@ -8619,7 +8619,7 @@ function convexHull(points) {
   const upper = [];
   for (let i = sorted.length - 1; i >= 0; i--) {
     const p = sorted[i];
-    while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+    while (upper.length >= 2 && cross4(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
       upper.pop();
     }
     upper.push(p);
@@ -8667,14 +8667,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 dot8 = v.reduce((s, c, i) => s + c * n[i], 0);
-  return v.map((c, i) => c - 2 * dot8 * n[i]);
+  const dot9 = v.reduce((s, c, i) => s + c * n[i], 0);
+  return v.map((c, i) => c - 2 * dot9 * n[i]);
 }
 function projectVector(v, onto) {
-  const dot8 = v.reduce((s, c, i) => s + c * onto[i], 0);
+  const dot9 = 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 scale4 = dot8 / magSq;
+  const scale4 = dot9 / magSq;
   return onto.map((c) => c * scale4);
 }
 function distance2D(a, b) {
@@ -8750,10 +8750,10 @@ function centroid(vertices) {
   let cy = 0;
   for (let i = 0; i < n; i++) {
     const j = (i + 1) % n;
-    const cross3 = vertices[i][0] * vertices[j][1] - vertices[j][0] * vertices[i][1];
-    signedArea += cross3;
-    cx += (vertices[i][0] + vertices[j][0]) * cross3;
-    cy += (vertices[i][1] + vertices[j][1]) * cross3;
+    const cross4 = vertices[i][0] * vertices[j][1] - vertices[j][0] * vertices[i][1];
+    signedArea += cross4;
+    cx += (vertices[i][0] + vertices[j][0]) * cross4;
+    cy += (vertices[i][1] + vertices[j][1]) * cross4;
   }
   signedArea /= 2;
   cx /= 6 * signedArea;
@@ -8840,37 +8840,6 @@ function minkowskiDistance(a, b, p) {
 function delaunayTriangulation(points) {
   const n = points.length;
   if (n < 3) return [];
-  if (n >= GEOMETRY_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(n * 2);
-        for (let i = 0; i < n; i++) {
-          flat[i * 2] = points[i][0];
-          flat[i * 2 + 1] = points[i][1];
-        }
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flat);
-        const maxTris = 2 * n;
-        const trisAlloc = wasmLoader.allocateInt32ArrayEmpty(maxTris * 3);
-        try {
-          const numTris = wasm.delaunay_wasm(ptsAlloc.ptr, n, trisAlloc.ptr);
-          const result = [];
-          for (let i = 0; i < numTris; i++) {
-            result.push([
-              trisAlloc.array[i * 3],
-              trisAlloc.array[i * 3 + 1],
-              trisAlloc.array[i * 3 + 2]
-            ]);
-          }
-          return result;
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(trisAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const p of points) {
     minX = Math.min(minX, p[0]);
@@ -15157,11 +15126,11 @@ function _eigenvectorOnce(adj, maxIter, tol, seed) {
         if (adj[j][i] > 0) next[i] += adj[j][i] * x[j];
       }
     }
-    let norm4 = 0;
-    for (let i = 0; i < n; i++) norm4 += next[i] * next[i];
-    norm4 = Math.sqrt(norm4);
-    if (norm4 < 1e-15) break;
-    for (let i = 0; i < n; i++) next[i] /= norm4;
+    let norm5 = 0;
+    for (let i = 0; i < n; i++) norm5 += next[i] * next[i];
+    norm5 = Math.sqrt(norm5);
+    if (norm5 < 1e-15) break;
+    for (let i = 0; i < n; i++) next[i] /= norm5;
     let delta = 0;
     for (let i = 0; i < n; i++) delta = Math.max(delta, Math.abs(next[i] - x[i]));
     x = next;
@@ -15174,9 +15143,9 @@ function _aggregateEigenvector(vectors, aggregation) {
   const count2 = vectors.length;
   const ref = vectors[0];
   const aligned = vectors.map((v) => {
-    let dot8 = 0;
-    for (let i = 0; i < n; i++) dot8 += v[i] * ref[i];
-    if (dot8 < 0) {
+    let dot9 = 0;
+    for (let i = 0; i < n; i++) dot9 += v[i] * ref[i];
+    if (dot9 < 0) {
       const flipped = new Float64Array(n);
       for (let i = 0; i < n; i++) flipped[i] = -v[i];
       return flipped;
@@ -15188,11 +15157,11 @@ function _aggregateEigenvector(vectors, aggregation) {
     for (let i = 0; i < n; i++) mean7[i] += v[i];
   }
   for (let i = 0; i < n; i++) mean7[i] /= count2;
-  let norm4 = 0;
-  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++) mean7[i] /= norm4;
+  let norm5 = 0;
+  for (let i = 0; i < n; i++) norm5 += mean7[i] * mean7[i];
+  norm5 = Math.sqrt(norm5);
+  if (norm5 > 1e-15) {
+    for (let i = 0; i < n; i++) mean7[i] /= norm5;
   }
   if (aggregation === "mean") {
     return { centrality: mean7 };
@@ -17103,11 +17072,11 @@ function principalComponentAnalysis(data, k) {
           Av[i] += A[i][j] * v[j];
         }
       }
-      let norm4 = 0;
-      for (let i = 0; i < p; i++) norm4 += Av[i] * Av[i];
-      norm4 = Math.sqrt(norm4);
-      if (norm4 === 0) break;
-      const vNew = Av.map((x) => x / norm4);
+      let norm5 = 0;
+      for (let i = 0; i < p; i++) norm5 += Av[i] * Av[i];
+      norm5 = Math.sqrt(norm5);
+      if (norm5 === 0) break;
+      const vNew = Av.map((x) => x / norm5);
       let diff2 = 0;
       for (let i = 0; i < p; i++) diff2 += (vNew[i] - v[i]) ** 2;
       v = vNew;
@@ -17132,9 +17101,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 dot8 = 0;
-      for (let j = 0; j < p; j++) dot8 += row2[j] * ev[j];
-      return dot8;
+      let dot9 = 0;
+      for (let j = 0; j < p; j++) dot9 += row2[j] * ev[j];
+      return dot9;
     });
   });
   return { components: eigenvectors, explained, scores };
@@ -17733,30 +17702,30 @@ function hessenbergForm(A) {
     if (normV < 1e-30) continue;
     const beta2 = 2 / normV;
     for (let j = k; j < n; j++) {
-      let dot8 = 0;
+      let dot9 = 0;
       for (let i = 0; i < len; i++) {
-        dot8 += v[i] * H[k + 1 + i][j];
+        dot9 += v[i] * H[k + 1 + i][j];
       }
       for (let i = 0; i < len; i++) {
-        H[k + 1 + i][j] -= beta2 * v[i] * dot8;
+        H[k + 1 + i][j] -= beta2 * v[i] * dot9;
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot8 = 0;
+      let dot9 = 0;
       for (let j = 0; j < len; j++) {
-        dot8 += H[i][k + 1 + j] * v[j];
+        dot9 += H[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        H[i][k + 1 + j] -= beta2 * dot8 * v[j];
+        H[i][k + 1 + j] -= beta2 * dot9 * v[j];
       }
     }
     for (let i = 0; i < n; i++) {
-      let dot8 = 0;
+      let dot9 = 0;
       for (let j = 0; j < len; j++) {
-        dot8 += Q2[i][k + 1 + j] * v[j];
+        dot9 += Q2[i][k + 1 + j] * v[j];
       }
       for (let j = 0; j < len; j++) {
-        Q2[i][k + 1 + j] -= beta2 * dot8 * v[j];
+        Q2[i][k + 1 + j] -= beta2 * dot9 * v[j];
       }
     }
   }
@@ -18125,11 +18094,11 @@ function findKernelVector(A, n, tol) {
       }
     }
   }
-  let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += v[i] * v[i];
-  norm4 = Math.sqrt(norm4);
-  if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) v[i] /= norm4;
+  let norm5 = 0;
+  for (let i = 0; i < n; i++) norm5 += v[i] * v[i];
+  norm5 = Math.sqrt(norm5);
+  if (norm5 > 1e-15) {
+    for (let i = 0; i < n; i++) v[i] /= norm5;
   }
   return v;
 }
@@ -18166,11 +18135,11 @@ async function solveApprox(A, b, n) {
     }
   }
   const x = M.map((row2) => row2[n]);
-  let norm4 = 0;
-  for (let i = 0; i < n; i++) norm4 += x[i] * x[i];
-  norm4 = Math.sqrt(norm4);
-  if (norm4 > 1e-15) {
-    for (let i = 0; i < n; i++) x[i] /= norm4;
+  let norm5 = 0;
+  for (let i = 0; i < n; i++) norm5 += x[i] * x[i];
+  norm5 = Math.sqrt(norm5);
+  if (norm5 > 1e-15) {
+    for (let i = 0; i < n; i++) x[i] /= norm5;
   }
   return x;
 }
@@ -30180,7 +30149,7 @@ var createPinv = /* @__PURE__ */ factory(
     deepEqual: deepEqual3,
     equal: equal2,
     dotDivide: dotDivide2,
-    dot: dot8,
+    dot: dot9,
     ctranspose: ctranspose2,
     divideScalar: divideScalar2,
     multiply: multiply2,
@@ -30196,7 +30165,7 @@ var createPinv = /* @__PURE__ */ factory(
             if (size2[0] === 1) {
               return inv3(x);
             } else {
-              return dotDivide2(ctranspose2(x), dot8(x, x));
+              return dotDivide2(ctranspose2(x), dot9(x, x));
             }
           case 2: {
             if (_isZeros(x)) return ctranspose2(x);
@@ -30275,8 +30244,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(dot8(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot8(rref[i], rref[i])));
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot9(rref[j], rref[j]))));
+      const F = rref.filter((_, i) => !_isZero(dot9(rref[i], rref[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -31747,9 +31716,9 @@ var dependencies187 = ["typed", "factorial"];
 var createPermutations = /* @__PURE__ */ factory(
   name187,
   dependencies187,
-  ({ typed: typed3, factorial: factorial5 }) => {
+  ({ typed: typed3, factorial: factorial6 }) => {
     return typed3(name187, {
-      "number | BigNumber": factorial5,
+      "number | BigNumber": factorial6,
       "number, number": function(n, k) {
         if (!isInteger(n) || n < 0) {
           throw new TypeError("Positive integer value expected in function permutations");
@@ -35973,7 +35942,7 @@ var dependencies224 = ["typed", "add", "divide", "multiply", "factorial", "isInt
 var createMultinomial = /* @__PURE__ */ factory(
   name224,
   dependencies224,
-  ({ typed: typed3, add: add4, divide: divide2, multiply: multiply2, factorial: factorial5, isInteger: isInteger3, isPositive: isPositive2 }) => {
+  ({ typed: typed3, add: add4, divide: divide2, multiply: multiply2, factorial: factorial6, isInteger: isInteger3, isPositive: isPositive2 }) => {
     return typed3(name224, {
       "Array | Matrix": function(a) {
         let sum3 = 0;
@@ -35983,9 +35952,9 @@ var createMultinomial = /* @__PURE__ */ factory(
             throw new TypeError("Positive integer value expected in function multinomial");
           }
           sum3 = add4(sum3, ai);
-          denom = multiply2(denom, factorial5(ai));
+          denom = multiply2(denom, factorial6(ai));
         });
-        return divide2(factorial5(sum3), denom);
+        return divide2(factorial6(sum3), denom);
       }
     });
   }
@@ -37042,7 +37011,7 @@ var createZeta = /* @__PURE__ */ factory(
     multiply: multiply2,
     pow: pow2,
     divide: divide2,
-    factorial: factorial5,
+    factorial: factorial6,
     equal: equal2,
     smallerEq: smallerEq2,
     isBounded: isBounded2,
@@ -37120,8 +37089,8 @@ var createZeta = /* @__PURE__ */ factory(
       let S = k;
       for (let j = k; smallerEq2(j, n); j = add4(j, 1)) {
         const factor2 = divide2(
-          multiply2(factorial5(add4(n, subtract3(j, 1))), pow2(4, j)),
-          multiply2(factorial5(subtract3(n, j)), factorial5(multiply2(2, j)))
+          multiply2(factorial6(add4(n, subtract3(j, 1))), pow2(4, j)),
+          multiply2(factorial6(subtract3(n, j)), factorial6(multiply2(2, j)))
         );
         S = add4(S, factor2);
       }
@@ -37197,7 +37166,7 @@ function createComplexEigs({
   larger: larger2,
   smaller: smaller2,
   matrixFromColumns: _matrixFromColumns,
-  dot: dot8
+  dot: dot9
 }) {
   function complexEigs(arr10, N, prec, type, findVectors = true) {
     if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
@@ -37568,11 +37537,11 @@ function createComplexEigs({
       M[i] = Array(N).fill(0);
     }
     let I2 = 0;
-    for (const sub2 of arr10) {
-      const n = sub2.length;
+    for (const sub3 of arr10) {
+      const n = sub3.length;
       for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
-          M[I2 + i][I2 + j] = sub2[i][j];
+          M[I2 + i][I2 + j] = sub3[i][j];
         }
       }
       I2 += n;
@@ -37598,7 +37567,7 @@ function createComplexEigs({
       } catch {
         continue;
       }
-      if (larger2(norm4(b), largeNum)) {
+      if (larger2(norm5(b), largeNum)) {
         break;
       }
     }
@@ -37608,13 +37577,13 @@ function createComplexEigs({
     i = 0;
     while (true) {
       const c = usolve2(A, b);
-      if (smaller2(norm4(orthogonalComplement(b, [c])), prec)) {
+      if (smaller2(norm5(orthogonalComplement(b, [c])), prec)) {
         break;
       }
       if (++i >= 10) {
         return null;
       }
-      b = normalize2(c, type);
+      b = normalize3(c, type);
     }
     return b;
   }
@@ -37629,7 +37598,7 @@ function createComplexEigs({
       v = v.map((n) => complex3(n));
     }
     v = orthogonalComplement(v, orthog);
-    return normalize2(v, type);
+    return normalize3(v, type);
   }
   function orthogonalComplement(v, orthog) {
     const vectorShape = size2(v);
@@ -37638,21 +37607,21 @@ function createComplexEigs({
       v = subtract3(
         v,
         multiply2(
-          divideScalar2(dot8(w, v), dot8(w, w)),
+          divideScalar2(dot9(w, v), dot9(w, w)),
           w
         )
       );
     }
     return v;
   }
-  function norm4(v) {
-    return abs2(sqrt2(dot8(v, v)));
+  function norm5(v) {
+    return abs2(sqrt2(dot9(v, v)));
   }
-  function normalize2(v, type) {
+  function normalize3(v, type) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
-    return multiply2(divideScalar2(one, norm4(v)), v);
+    return multiply2(divideScalar2(one, norm5(v)), v);
   }
   return complexEigs;
 }
@@ -38066,7 +38035,7 @@ var createEigs = /* @__PURE__ */ factory(
     re: re3,
     smaller: smaller2,
     matrixFromColumns: matrixFromColumns2,
-    dot: dot8
+    dot: dot9
   }) => {
     const doRealSymmetric = createRealSymmetric({
       config: config2,
@@ -38105,7 +38074,7 @@ var createEigs = /* @__PURE__ */ factory(
       larger: larger2,
       smaller: smaller2,
       matrixFromColumns: matrixFromColumns2,
-      dot: dot8
+      dot: dot9
     });
     return typed3("eigs", {
       // The conversion to matrix in the first two implementations,
@@ -40852,7 +40821,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
     multiplyScalar: multiplyScalar2,
     addScalar: addScalar2,
     unaryMinus: unaryMinus2,
-    norm: norm4,
+    norm: norm5,
     BigNumber: BigNumber9,
     matrix: matrix2,
     DenseMatrix: DenseMatrix7,
@@ -40926,7 +40895,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
       return data;
     }
     function _rotationMatrix3x3(theta, v, format4) {
-      const normV = norm4(v);
+      const normV = norm5(v);
       if (normV === 0) {
         throw new RangeError("Rotation around zero vector");
       }
@@ -42963,11 +42932,11 @@ function multivariateTaylor(expr, vars, x0, n = 1) {
         const fmp = evalWith(expr, s);
         s[vars[j]] = x0[j] - h;
         const fmm = evalWith(expr, s);
-        const cross3 = (fpp - fpm - fmp + fmm) / (4 * h * h);
-        if (Math.abs(cross3) < 1e-12) continue;
+        const cross4 = (fpp - fpm - fmp + fmm) / (4 * h * h);
+        if (Math.abs(cross4) < 1e-12) continue;
         const xi = x0[i] === 0 ? vars[i] : `(${vars[i]} - ${formatCoeff(x0[i])})`;
         const xj = x0[j] === 0 ? vars[j] : `(${vars[j]} - ${formatCoeff(x0[j])})`;
-        terms.push(`${formatCoeff(cross3)}*${xi}*${xj}`);
+        terms.push(`${formatCoeff(cross4)}*${xi}*${xj}`);
       }
     }
   }
@@ -45950,12 +45919,12 @@ function svds(A, k = 1, opts) {
 }
 
 // src/numeric/structured-solvers.ts
-function thomasSolve(sub2, diag2, sup, d) {
+function thomasSolve(sub3, diag2, sup, d) {
   const n = diag2.length;
   if (n === 0) return [];
-  if (sub2.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
+  if (sub3.length !== n - 1 || sup.length !== n - 1 || d.length !== n) {
     throw new Error(
-      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub2.length}, sup=${sup.length}, d=${d.length}`
+      `thomasSolve: expected sub/sup of length ${n - 1} and d of length ${n}, got sub=${sub3.length}, sup=${sup.length}, d=${d.length}`
     );
   }
   const cp = new Array(n).fill(0);
@@ -45964,12 +45933,12 @@ function thomasSolve(sub2, diag2, sup, d) {
   cp[0] = n > 1 ? sup[0] / diag2[0] : 0;
   dp[0] = d[0] / diag2[0];
   for (let i = 1; i < n; i++) {
-    const m = diag2[i] - sub2[i - 1] * cp[i - 1];
+    const m = diag2[i] - sub3[i - 1] * cp[i - 1];
     if (m === 0) {
       throw new Error(`thomasSolve: zero pivot at row ${i} (no pivoting is performed)`);
     }
     cp[i] = i < n - 1 ? sup[i] / m : 0;
-    dp[i] = (d[i] - sub2[i - 1] * dp[i - 1]) / m;
+    dp[i] = (d[i] - sub3[i - 1] * dp[i - 1]) / m;
   }
   const x = new Array(n);
   x[n - 1] = dp[n - 1];
@@ -47554,17 +47523,17 @@ function nelderMead(f, x0, opts = {}) {
     return c;
   };
   const add4 = (a, b, s) => a.map((v, i) => v + s * b[i]);
-  const sub2 = (a, b) => a.map((v, i) => v - b[i]);
+  const sub3 = (a, b) => a.map((v, i) => v - b[i]);
   for (; iter < maxIter; iter++) {
     const order = fv.map((_, i) => i).sort((i, j) => fv[i] - fv[j]);
     simplex = order.map((i) => simplex[i]);
     fv = order.map((i) => fv[i]);
     if (Math.abs(fv[n] - fv[0]) <= tol * (Math.abs(fv[0]) + tol)) break;
     const c = centroid2(simplex.slice(0, n));
-    const xr = add4(c, sub2(c, simplex[n]), alpha);
+    const xr = add4(c, sub3(c, simplex[n]), alpha);
     const fr = f(xr);
     if (fr < fv[0]) {
-      const xe = add4(c, sub2(c, simplex[n]), gamma2);
+      const xe = add4(c, sub3(c, simplex[n]), gamma2);
       const fe = f(xe);
       if (fe < fr) {
         simplex[n] = xe;
@@ -47577,14 +47546,14 @@ function nelderMead(f, x0, opts = {}) {
       simplex[n] = xr;
       fv[n] = fr;
     } else {
-      const xc = add4(c, sub2(simplex[n], c), rho);
+      const xc = add4(c, sub3(simplex[n], c), rho);
       const fc = f(xc);
       if (fc < fv[n]) {
         simplex[n] = xc;
         fv[n] = fc;
       } else {
         for (let i = 1; i <= n; i++) {
-          simplex[i] = add4(simplex[0], sub2(simplex[i], simplex[0]), sigma);
+          simplex[i] = add4(simplex[0], sub3(simplex[i], simplex[0]), sigma);
           fv[i] = f(simplex[i]);
         }
       }
@@ -50204,12 +50173,12 @@ function rickerWavelet(points, scale4) {
   return out;
 }
 function morletWavelet(points, scale4) {
-  const norm4 = 1 / (Math.sqrt(scale4) * Math.pow(Math.PI, 0.25));
+  const norm5 = 1 / (Math.sqrt(scale4) * Math.pow(Math.PI, 0.25));
   const out = new Array(points);
   const center3 = (points - 1) / 2;
   for (let i = 0; i < points; i++) {
     const t = (i - center3) / scale4;
-    out[i] = norm4 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
+    out[i] = norm5 * Math.cos(5 * t) * Math.exp(-(t * t) / 2);
   }
   return out;
 }
@@ -50756,6 +50725,264 @@ function segmentSegmentClosest(p1, p2, q1, q2) {
   return { point1, point2, distance: distance2 };
 }
 
+// src/geometry/hull.ts
+function hull2DIndices(points) {
+  const n = points.length;
+  const order = Array.from({ length: n }, (_, i) => i).sort(
+    (a, b) => points[a][0] - points[b][0] || points[a][1] - points[b][1]
+  );
+  const cross4 = (o, a, b) => (points[a][0] - points[o][0]) * (points[b][1] - points[o][1]) - (points[a][1] - points[o][1]) * (points[b][0] - points[o][0]);
+  const lower = [];
+  for (const i of order) {
+    while (lower.length >= 2 && cross4(lower[lower.length - 2], lower[lower.length - 1], i) <= 0) {
+      lower.pop();
+    }
+    lower.push(i);
+  }
+  const upper = [];
+  for (let k = order.length - 1; k >= 0; k--) {
+    const i = order[k];
+    while (upper.length >= 2 && cross4(upper[upper.length - 2], upper[upper.length - 1], i) <= 0) {
+      upper.pop();
+    }
+    upper.push(i);
+  }
+  lower.pop();
+  upper.pop();
+  return lower.concat(upper);
+}
+function convexHull2D2(points) {
+  const vertices = hull2DIndices(points);
+  const m = vertices.length;
+  const simplices = [];
+  let signedArea = 0;
+  let perimeter = 0;
+  for (let k = 0; k < m; k++) {
+    const i = vertices[k];
+    const j = vertices[(k + 1) % m];
+    simplices.push([i, j]);
+    const a = points[i];
+    const b = points[j];
+    signedArea += a[0] * b[1] - b[0] * a[1];
+    perimeter += Math.hypot(b[0] - a[0], b[1] - a[1]);
+  }
+  return { vertices, simplices, area: perimeter, volume: Math.abs(signedArea) / 2 };
+}
+function convexHull3DResult(points) {
+  const faces = convexHull3D(points);
+  const vertexSet = /* @__PURE__ */ new Set();
+  let volume6 = 0;
+  let surface = 0;
+  for (const [ia, ib, ic] of faces) {
+    vertexSet.add(ia);
+    vertexSet.add(ib);
+    vertexSet.add(ic);
+    const a = points[ia];
+    const b = points[ib];
+    const c = points[ic];
+    volume6 += a[0] * (b[1] * c[2] - b[2] * c[1]) - a[1] * (b[0] * c[2] - b[2] * c[0]) + a[2] * (b[0] * c[1] - b[1] * c[0]);
+    const ux = b[0] - a[0];
+    const uy = b[1] - a[1];
+    const uz = b[2] - a[2];
+    const vx = c[0] - a[0];
+    const vy = c[1] - a[1];
+    const vz = c[2] - a[2];
+    const cx = uy * vz - uz * vy;
+    const cy = uz * vx - ux * vz;
+    const cz = ux * vy - uy * vx;
+    surface += Math.hypot(cx, cy, cz) / 2;
+  }
+  return {
+    vertices: Array.from(vertexSet).sort((a, b) => a - b),
+    simplices: faces.map((f) => [...f]),
+    area: surface,
+    volume: Math.abs(volume6) / 6
+  };
+}
+function convexHull(points) {
+  if (!Array.isArray(points) || points.length === 0) {
+    throw new Error("convexHull: requires a non-empty array of points");
+  }
+  const dim = points[0].length;
+  if (dim === 2) {
+    if (points.length < 3) throw new Error("convexHull: 2-D hull requires at least 3 points");
+    return convexHull2D2(points);
+  }
+  if (dim === 3) {
+    if (points.length < 4) throw new Error("convexHull: 3-D hull requires at least 4 points");
+    return convexHull3DResult(points);
+  }
+  throw new Error(`convexHull: only 2-D and 3-D point sets are supported (got dimension ${dim})`);
+}
+
+// src/geometry/delaunay.ts
+function delaunay(points) {
+  if (!Array.isArray(points) || points.length < 3) {
+    throw new Error("delaunay: requires at least 3 points");
+  }
+  if (points[0].length !== 2) {
+    throw new Error("delaunay: only 2-D point sets are supported");
+  }
+  return { simplices: delaunayTriangulation(points).map((t) => [...t]) };
+}
+
+// src/geometry/voronoi.ts
+function circumcenter(a, b, c) {
+  const d = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1]));
+  if (Math.abs(d) < 1e-15) return null;
+  const a2 = a[0] * a[0] + a[1] * a[1];
+  const b2 = b[0] * b[0] + b[1] * b[1];
+  const c2 = c[0] * c[0] + c[1] * c[1];
+  const ux = (a2 * (b[1] - c[1]) + b2 * (c[1] - a[1]) + c2 * (a[1] - b[1])) / d;
+  const uy = (a2 * (c[0] - b[0]) + b2 * (a[0] - c[0]) + c2 * (b[0] - a[0])) / d;
+  return [ux, uy];
+}
+function voronoi(points) {
+  const { simplices: tris } = delaunay(points);
+  const vertices = [];
+  const simplices = [];
+  const regions = Array.from({ length: points.length }, () => []);
+  for (const t of tris) {
+    const cc = circumcenter(points[t[0]], points[t[1]], points[t[2]]);
+    if (cc === null) continue;
+    const vIdx = vertices.length;
+    vertices.push(cc);
+    simplices.push([...t]);
+    for (const p of t) regions[p].push(vIdx);
+  }
+  return { vertices, simplices, regions };
+}
+
+// src/geometry/alpha-shape.ts
+function circumradius(a, b, c) {
+  const d = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1]));
+  if (Math.abs(d) < 1e-15) return Infinity;
+  const a2 = a[0] * a[0] + a[1] * a[1];
+  const b2 = b[0] * b[0] + b[1] * b[1];
+  const c2 = c[0] * c[0] + c[1] * c[1];
+  const ux = (a2 * (b[1] - c[1]) + b2 * (c[1] - a[1]) + c2 * (a[1] - b[1])) / d;
+  const uy = (a2 * (c[0] - b[0]) + b2 * (a[0] - c[0]) + c2 * (b[0] - a[0])) / d;
+  return Math.hypot(a[0] - ux, a[1] - uy);
+}
+function alphaShape(points, alpha) {
+  if (!(alpha > 0)) throw new Error("alphaShape: alpha must be positive");
+  const { simplices: tris } = delaunay(points);
+  const threshold = 1 / alpha;
+  const triangles = [];
+  const edgeCount = /* @__PURE__ */ new Map();
+  for (const t of tris) {
+    if (circumradius(points[t[0]], points[t[1]], points[t[2]]) > threshold) continue;
+    triangles.push([...t]);
+    const es = [
+      [t[0], t[1]],
+      [t[1], t[2]],
+      [t[2], t[0]]
+    ];
+    for (const [u, v] of es) {
+      const key = `${Math.min(u, v)},${Math.max(u, v)}`;
+      edgeCount.set(key, (edgeCount.get(key) ?? 0) + 1);
+    }
+  }
+  const edges = [];
+  for (const [key, count2] of edgeCount) {
+    if (count2 === 1) {
+      const [lo, hi] = key.split(",").map(Number);
+      edges.push([lo, hi]);
+    }
+  }
+  return { triangles, edges };
+}
+
+// src/geometry/spherical-voronoi.ts
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function cross3(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]];
+}
+function dot8(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function norm4(a) {
+  return Math.hypot(a[0], a[1], a[2]);
+}
+function normalize2(a) {
+  const n = norm4(a) || 1;
+  return [a[0] / n, a[1] / n, a[2] / n];
+}
+function geodesicAngle(u, v) {
+  return Math.atan2(norm4(cross3(u, v)), dot8(u, v));
+}
+function sphericalTriangleArea(a, b, c) {
+  const A = geodesicAngle(b, c);
+  const B = geodesicAngle(a, c);
+  const C = geodesicAngle(a, b);
+  const s = (A + B + C) / 2;
+  const t = Math.tan(s / 2) * Math.tan((s - A) / 2) * Math.tan((s - B) / 2) * Math.tan((s - C) / 2);
+  return 4 * Math.atan(Math.sqrt(Math.max(0, t)));
+}
+function sphericalVoronoi(points, radius = 1, center3 = [0, 0, 0]) {
+  if (!Array.isArray(points) || points.length < 4) {
+    throw new Error("sphericalVoronoi: requires at least 4 points");
+  }
+  if (points[0].length !== 3) {
+    throw new Error("sphericalVoronoi: only 3-D point sets are supported");
+  }
+  const gen = points.map((p) => normalize2(sub2(p, center3)));
+  const faces = convexHull3D(points);
+  const vertices = [];
+  const vertDir = [];
+  const incident = Array.from({ length: points.length }, () => []);
+  faces.forEach((f, fi) => {
+    const a = gen[f[0]];
+    const b = gen[f[1]];
+    const c = gen[f[2]];
+    let nrm = cross3(sub2(b, a), sub2(c, a));
+    if (dot8(nrm, a) < 0) nrm = [-nrm[0], -nrm[1], -nrm[2]];
+    const dir = normalize2(nrm);
+    vertDir.push(dir);
+    vertices.push([
+      center3[0] + radius * dir[0],
+      center3[1] + radius * dir[1],
+      center3[2] + radius * dir[2]
+    ]);
+    for (const p of f) incident[p].push(fi);
+  });
+  const regions = [];
+  const areas = [];
+  for (let g = 0; g < points.length; g++) {
+    const gdir = gen[g];
+    const facs = incident[g];
+    let ref = null;
+    const withAngle = facs.map((fi) => {
+      const d = vertDir[fi];
+      const tang = normalize2(
+        sub2(d, [gdir[0] * dot8(d, gdir), gdir[1] * dot8(d, gdir), gdir[2] * dot8(d, gdir)])
+      );
+      if (ref === null) {
+        ref = tang;
+        return { fi, ang: 0 };
+      }
+      const x = dot8(tang, ref);
+      const y = dot8(cross3(gdir, ref), tang);
+      let ang = Math.atan2(y, x);
+      if (ang < 0) ang += 2 * Math.PI;
+      return { fi, ang };
+    });
+    withAngle.sort((p, q) => p.ang - q.ang);
+    const ring = withAngle.map((w) => w.fi);
+    regions.push(ring);
+    let area2 = 0;
+    for (let k = 0; k < ring.length; k++) {
+      const v1 = vertDir[ring[k]];
+      const v2 = vertDir[ring[(k + 1) % ring.length]];
+      area2 += sphericalTriangleArea(gdir, v1, v2);
+    }
+    areas.push(area2 * radius * radius);
+  }
+  return { vertices, regions, areas };
+}
+
 // src/stats/inference-extra2.ts
 var TWO_PI = 2 * Math.PI;
 function noncentralChi2CDF(x, df, nc) {
@@ -51137,6 +51364,161 @@ function barnesG(z) {
   return Math.exp(lnG);
 }
 
+// src/special/wave-functions.ts
+var RELTOL3 = 1e-16;
+function cMul3(a, b) {
+  return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };
+}
+function cInv(a) {
+  const d = a.re * a.re + a.im * a.im;
+  return { re: a.re / d, im: -a.im / d };
+}
+function cLog(a) {
+  return { re: 0.5 * Math.log(a.re * a.re + a.im * a.im), im: Math.atan2(a.im, a.re) };
+}
+function cSin(a) {
+  return { re: Math.sin(a.re) * Math.cosh(a.im), im: Math.cos(a.re) * Math.sinh(a.im) };
+}
+var LANCZOS_G = 7;
+var LANCZOS_C = [
+  0.9999999999998099,
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9984369578019572e-21,
+  15056327351493116e-23
+];
+function lnGammaComplex(z) {
+  if (z.re < 0.5) {
+    const sinPiZ = cSin({ re: Math.PI * z.re, im: Math.PI * z.im });
+    const lnSin = cLog(sinPiZ);
+    const rest = lnGammaComplex({ re: 1 - z.re, im: -z.im });
+    return { re: Math.log(Math.PI) - lnSin.re - rest.re, im: -lnSin.im - rest.im };
+  }
+  const x = { re: z.re - 1, im: z.im };
+  let sum3 = { re: LANCZOS_C[0], im: 0 };
+  for (let i = 1; i < LANCZOS_G + 2; i++) {
+    const dr = x.re + i;
+    const di = x.im;
+    const denom = dr * dr + di * di;
+    sum3 = { re: sum3.re + LANCZOS_C[i] * dr / denom, im: sum3.im - LANCZOS_C[i] * di / denom };
+  }
+  const t = { re: x.re + LANCZOS_G + 0.5, im: x.im };
+  const lnT = cLog(t);
+  const lnSum = cLog(sum3);
+  const half = { re: x.re + 0.5, im: x.im };
+  const p = cMul3(half, lnT);
+  return {
+    re: 0.5 * Math.log(2 * Math.PI) + p.re - t.re + lnSum.re,
+    im: p.im - t.im + lnSum.im
+  };
+}
+function factorial5(n) {
+  let r = 1;
+  for (let i = 2; i <= n; i++) r *= i;
+  return r;
+}
+function riemannSiegelTheta(t) {
+  const lg = lnGammaComplex({ re: 0.25, im: t / 2 });
+  return lg.im - t / 2 * Math.log(Math.PI);
+}
+function borweinD(k, n) {
+  let S = k;
+  for (let j = k; j <= n; j++) {
+    S += factorial5(n + j - 1) * Math.pow(4, j) / (factorial5(n - j) * factorial5(2 * j));
+  }
+  return n * S;
+}
+function zetaCriticalLine(t) {
+  const n = Math.round(1.3 * 20 + 0.9 * Math.abs(t));
+  const ln2 = Math.LN2;
+  const mag = Math.SQRT2;
+  const den = { re: 1 - mag * Math.cos(t * ln2), im: mag * Math.sin(t * ln2) };
+  const d0 = borweinD(0, n);
+  const c = cInv(cMul3({ re: d0, im: 0 }, den));
+  let Sr = 0;
+  let Si = 0;
+  for (let k = 1; k <= n; k++) {
+    const sign3 = (k - 1) % 2 === 0 ? 1 : -1;
+    const dk = borweinD(k, n);
+    const lnk = Math.log(k);
+    const kpow = 1 / Math.sqrt(k);
+    Sr += sign3 * dk * kpow * Math.cos(t * lnk);
+    Si += sign3 * dk * kpow * -Math.sin(t * lnk);
+  }
+  return cMul3(c, { re: Sr, im: Si });
+}
+function siegelZ(t) {
+  const at = Math.abs(t);
+  const z = zetaCriticalLine(at);
+  const th = riemannSiegelTheta(at);
+  return Math.cos(th) * z.re - Math.sin(th) * z.im;
+}
+function riemannSiegelZ(t) {
+  return siegelZ(t);
+}
+var LERCH_MAX_TERMS = 2e5;
+function lerchPhi(z, s, a) {
+  if (Math.abs(z) >= 1) {
+    throw new Error("lerchPhi: only |z| < 1 is supported (analytic continuation not implemented)");
+  }
+  if (a <= 0) {
+    throw new Error("lerchPhi: a must be > 0");
+  }
+  let sum3 = 0;
+  let zk = 1;
+  for (let k = 0; k < LERCH_MAX_TERMS; k++) {
+    const term = zk / Math.pow(a + k, s);
+    sum3 += term;
+    if (k > 1 && Math.abs(term) < Math.abs(sum3) * RELTOL3) break;
+    zk *= z;
+  }
+  return sum3;
+}
+function recipGamma(y) {
+  if (y > 0) return Math.exp(-_lgamma(y));
+  if (y === Math.floor(y)) return 0;
+  return Math.sin(Math.PI * y) * Math.exp(_lgamma(1 - y)) / Math.PI;
+}
+function parabolicCylinderD(nu, x) {
+  const z = x * x / 2;
+  const even = recipGamma((1 - nu) / 2) * hyp1f1(-nu / 2, 0.5, z);
+  const odd = recipGamma(-nu / 2) * hyp1f1((1 - nu) / 2, 1.5, z);
+  return Math.pow(2, nu / 2) * Math.exp(-(x * x) / 4) * (Math.sqrt(Math.PI) * even - Math.sqrt(2 * Math.PI) * x * odd);
+}
+var COULOMB_MAX_TERMS = 5e3;
+function coulombC(L, eta) {
+  const lg = lnGammaComplex({ re: L + 1, im: eta });
+  const absGamma = Math.exp(lg.re);
+  return Math.pow(2, L) * Math.exp(-Math.PI * eta / 2) * absGamma / Math.exp(_lgamma(2 * L + 2));
+}
+function coulombF(L, eta, rho) {
+  if (rho < 0) {
+    throw new Error("coulombF: rho must be >= 0");
+  }
+  if (L < 0) {
+    throw new Error("coulombF: L must be >= 0");
+  }
+  if (rho === 0) return 0;
+  let aPrev2 = 0;
+  let aPrev1 = 1;
+  let sum3 = 1;
+  let rhoK = 1;
+  for (let k = 1; k < COULOMB_MAX_TERMS; k++) {
+    const ak = (2 * eta * aPrev1 - aPrev2) / (k * (k + 2 * L + 1));
+    rhoK *= rho;
+    const term = ak * rhoK;
+    sum3 += term;
+    aPrev2 = aPrev1;
+    aPrev1 = ak;
+    if (k > 2 && term !== 0 && Math.abs(term) < Math.abs(sum3) * RELTOL3) break;
+  }
+  return coulombC(L, eta) * Math.pow(rho, L + 1) * sum3;
+}
+
 // src/graph/traversal-centrality.ts
 function bfs(adj, start) {
   const n = adj.length;
@@ -51810,9 +52192,9 @@ function katzCentrality(adj, alpha, beta2 = 1) {
     sum3 += xi;
     sumSq += xi * xi;
   }
-  const norm4 = Math.sign(sum3) * Math.sqrt(sumSq);
-  if (norm4 === 0) return x;
-  return x.map((xi) => xi / norm4);
+  const norm5 = Math.sign(sum3) * Math.sqrt(sumSq);
+  if (norm5 === 0) return x;
+  return x.map((xi) => xi / norm5);
 }
 function isIsomorphic(graphA, graphB) {
   const n = graphA.length;
@@ -52367,6 +52749,7 @@ export {
   adjacencyMatrix,
   airyAi,
   airyBi,
+  alphaShape,
   and,
   andersonDarlingTest,
   angle2D,
@@ -52511,6 +52894,7 @@ export {
   connectedComponents,
   continuedFraction,
   convexHull,
+  convexHull2D,
   convexHull3D,
   convolve,
   coordinateTransform,
@@ -52525,6 +52909,7 @@ export {
   coth,
   coulomb,
   coulombConstant,
+  coulombF,
   count,
   cov,
   createUnit,
@@ -52561,6 +52946,7 @@ export {
   deconvolve,
   deepEqual,
   degree,
+  delaunay,
   delaunayTriangulation,
   derivative,
   derivativeAt,
@@ -52914,6 +53300,7 @@ export {
   leftShift,
   legendreFit,
   legendreP,
+  lerchPhi,
   levenbergMarquardt,
   leveneTest,
   lfilter,
@@ -53056,6 +53443,7 @@ export {
   pacf,
   padeApproximant,
   pageRank,
+  parabolicCylinderD,
   parallelAutoCorr,
   parallelConv,
   parallelFFT,
@@ -53186,6 +53574,7 @@ export {
   rfft,
   rfftfreq,
   ridge,
+  riemannSiegelZ,
   rightArithShift,
   rightLogShift,
   risingFactorial,
@@ -53228,6 +53617,7 @@ export {
   shapiroWilkTest,
   shortestPath,
   shouldParallelize,
+  siegelZ,
   sigmoid,
   sign,
   simplify,
@@ -53263,6 +53653,7 @@ export {
   spectralClustering,
   spectrogram,
   speedOfLight,
+  sphericalVoronoi,
   splitUnit,
   sqrt,
   sqrtm,
@@ -53366,6 +53757,7 @@ export {
   variance,
   variation,
   vonMisesPDF,
+  voronoi,
   voronoiDiagram,
   wavedec,
   waverec,