@danielsimonjr/mathts-functions 0.55.0 → 0.57.0

package/dist/index.js

@@ -3918,32 +3918,32 @@ function nextPowerOf2(n) {
   return Math.pow(2, Math.ceil(Math.log2(n)));
 }
 async function fourStepFFT(real, imag, inverse) {
-  const N = real.length;
-  if (N < 4 || !isPowerOf22(N)) {
+  const N2 = real.length;
+  if (N2 < 4 || !isPowerOf22(N2)) {
     return fftCoreFloat64(real, imag, inverse);
   }
-  const bits = Math.round(Math.log2(N));
+  const bits = Math.round(Math.log2(N2));
   const bits1 = bits >> 1;
   const N1 = 1 << bits1;
-  const N2 = N / N1;
+  const N22 = N2 / N1;
   const sign3 = inverse ? 1 : -1;
-  const aReal = new Float64Array(N2 * N1);
-  const aImag = new Float64Array(N2 * N1);
-  for (let n26 = 0; n26 < N2; n26++) {
+  const aReal = new Float64Array(N22 * N1);
+  const aImag = new Float64Array(N22 * N1);
+  for (let n26 = 0; n26 < N22; n26++) {
     const base = n26 * N1;
     for (let n16 = 0; n16 < N1; n16++) {
-      const src = N2 * n16 + n26;
+      const src = N22 * n16 + n26;
       aReal[base + n16] = real[src];
       aImag[base + n16] = imag[src];
     }
   }
-  const stepA = await computePool4.fftBatch(aReal, aImag, N2, N1, inverse);
+  const stepA = await computePool4.fftBatch(aReal, aImag, N22, N1, inverse);
   const aOutReal = stepA.result.real;
   const aOutImag = stepA.result.imag;
-  const cReal = new Float64Array(N1 * N2);
-  const cImag = new Float64Array(N1 * N2);
-  const twN = sign3 * 2 * Math.PI / N;
-  for (let n26 = 0; n26 < N2; n26++) {
+  const cReal = new Float64Array(N1 * N22);
+  const cImag = new Float64Array(N1 * N22);
+  const twN = sign3 * 2 * Math.PI / N2;
+  for (let n26 = 0; n26 < N22; n26++) {
     const aBase = n26 * N1;
     for (let k1 = 0; k1 < N1; k1++) {
       const ar = aOutReal[aBase + k1];
@@ -3951,19 +3951,19 @@ async function fourStepFFT(real, imag, inverse) {
       const ang = twN * n26 * k1;
       const wr = Math.cos(ang);
       const wi = Math.sin(ang);
-      const dst2 = k1 * N2 + n26;
+      const dst2 = k1 * N22 + n26;
       cReal[dst2] = ar * wr - ai * wi;
       cImag[dst2] = ar * wi + ai * wr;
     }
   }
-  const stepC = await computePool4.fftBatch(cReal, cImag, N1, N2, inverse);
+  const stepC = await computePool4.fftBatch(cReal, cImag, N1, N22, inverse);
   const cOutReal = stepC.result.real;
   const cOutImag = stepC.result.imag;
-  const outReal = new Float64Array(N);
-  const outImag = new Float64Array(N);
+  const outReal = new Float64Array(N2);
+  const outImag = new Float64Array(N2);
   for (let k1 = 0; k1 < N1; k1++) {
-    const cBase = k1 * N2;
-    for (let k2 = 0; k2 < N2; k2++) {
+    const cBase = k1 * N22;
+    for (let k2 = 0; k2 < N22; k2++) {
       const dst2 = N1 * k2 + k1;
       outReal[dst2] = cOutReal[cBase + k2];
       outImag[dst2] = cOutImag[cBase + k2];
@@ -4189,15 +4189,15 @@ function unwrapPhase(phase) {
   return result;
 }
 function dct(x) {
-  const N = x.length;
-  if (N >= WASM_THRESHOLD) {
+  const N2 = x.length;
+  if (N2 >= WASM_THRESHOLD) {
     const wasm = wasmLoader.getModule();
     if (wasm) {
       try {
         const inAlloc = wasmLoader.allocateFloat64Array(x);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
+        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
         try {
-          wasm.dct_wasm(inAlloc.ptr, outAlloc.ptr, N);
+          wasm.dct_wasm(inAlloc.ptr, outAlloc.ptr, N2);
           return Array.from(outAlloc.array);
         } finally {
           wasmLoader.free(inAlloc.ptr);
@@ -4207,26 +4207,26 @@ function dct(x) {
       }
     }
   }
-  const result = new Array(N);
-  for (let k = 0; k < N; k++) {
+  const result = new Array(N2);
+  for (let k = 0; k < N2; k++) {
     let sum3 = 0;
-    for (let n = 0; n < N; n++) {
-      sum3 += x[n] * Math.cos(Math.PI / N * (n + 0.5) * k);
+    for (let n = 0; n < N2; n++) {
+      sum3 += x[n] * Math.cos(Math.PI / N2 * (n + 0.5) * k);
     }
-    result[k] = sum3 * (k === 0 ? Math.sqrt(1 / N) : Math.sqrt(2 / N));
+    result[k] = sum3 * (k === 0 ? Math.sqrt(1 / N2) : Math.sqrt(2 / N2));
   }
   return result;
 }
 function idct(X) {
-  const N = X.length;
-  if (N >= WASM_THRESHOLD) {
+  const N2 = X.length;
+  if (N2 >= WASM_THRESHOLD) {
     const wasm = wasmLoader.getModule();
     if (wasm) {
       try {
         const inAlloc = wasmLoader.allocateFloat64Array(X);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
+        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
         try {
-          wasm.idct_wasm(inAlloc.ptr, outAlloc.ptr, N);
+          wasm.idct_wasm(inAlloc.ptr, outAlloc.ptr, N2);
           return Array.from(outAlloc.array);
         } finally {
           wasmLoader.free(inAlloc.ptr);
@@ -4236,26 +4236,26 @@ function idct(X) {
       }
     }
   }
-  const result = new Array(N);
-  for (let n = 0; n < N; n++) {
-    let sum3 = X[0] * Math.sqrt(1 / N);
-    for (let k = 1; k < N; k++) {
-      sum3 += X[k] * Math.sqrt(2 / N) * Math.cos(Math.PI / N * (n + 0.5) * k);
+  const result = new Array(N2);
+  for (let n = 0; n < N2; n++) {
+    let sum3 = X[0] * Math.sqrt(1 / N2);
+    for (let k = 1; k < N2; k++) {
+      sum3 += X[k] * Math.sqrt(2 / N2) * Math.cos(Math.PI / N2 * (n + 0.5) * k);
     }
     result[n] = sum3;
   }
   return result;
 }
 function dst(x) {
-  const N = x.length;
-  if (N >= WASM_THRESHOLD) {
+  const N2 = x.length;
+  if (N2 >= WASM_THRESHOLD) {
     const wasm = wasmLoader.getModule();
     if (wasm) {
       try {
         const inAlloc = wasmLoader.allocateFloat64Array(x);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
+        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
         try {
-          wasm.dst_wasm(inAlloc.ptr, outAlloc.ptr, N);
+          wasm.dst_wasm(inAlloc.ptr, outAlloc.ptr, N2);
           return Array.from(outAlloc.array);
         } finally {
           wasmLoader.free(inAlloc.ptr);
@@ -4265,26 +4265,26 @@ function dst(x) {
       }
     }
   }
-  const result = new Array(N);
-  for (let k = 0; k < N; k++) {
+  const result = new Array(N2);
+  for (let k = 0; k < N2; k++) {
     let sum3 = 0;
-    for (let n = 0; n < N; n++) {
-      sum3 += x[n] * Math.sin(Math.PI / N * (n + 0.5) * (k + 1));
+    for (let n = 0; n < N2; n++) {
+      sum3 += x[n] * Math.sin(Math.PI / N2 * (n + 0.5) * (k + 1));
     }
-    result[k] = sum3 * Math.sqrt(2 / N);
+    result[k] = sum3 * Math.sqrt(2 / N2);
   }
   return result;
 }
 function idst(X) {
-  const N = X.length;
-  if (N >= WASM_THRESHOLD) {
+  const N2 = X.length;
+  if (N2 >= WASM_THRESHOLD) {
     const wasm = wasmLoader.getModule();
     if (wasm) {
       try {
         const inAlloc = wasmLoader.allocateFloat64Array(X);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
+        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
         try {
-          wasm.idst_wasm(inAlloc.ptr, outAlloc.ptr, N);
+          wasm.idst_wasm(inAlloc.ptr, outAlloc.ptr, N2);
           return Array.from(outAlloc.array);
         } finally {
           wasmLoader.free(inAlloc.ptr);
@@ -4294,12 +4294,12 @@ function idst(X) {
       }
     }
   }
-  const result = new Array(N);
-  for (let n = 0; n < N; n++) {
+  const result = new Array(N2);
+  for (let n = 0; n < N2; n++) {
     let sum3 = 0;
-    for (let k = 0; k < N; k++) {
-      const factor2 = k === N - 1 ? Math.sqrt(1 / N) : Math.sqrt(2 / N);
-      sum3 += X[k] * factor2 * Math.sin(Math.PI / N * (n + 0.5) * (k + 1));
+    for (let k = 0; k < N2; k++) {
+      const factor2 = k === N2 - 1 ? Math.sqrt(1 / N2) : Math.sqrt(2 / N2);
+      sum3 += X[k] * factor2 * Math.sin(Math.PI / N2 * (n + 0.5) * (k + 1));
     }
     result[n] = sum3;
   }
@@ -4446,20 +4446,20 @@ function invFourier(F, omega, t) {
 }
 function hilbertTransform(x) {
   const n = x.length;
-  const N = nextPowerOf2(n);
-  if (N >= WASM_THRESHOLD) {
+  const N2 = nextPowerOf2(n);
+  if (N2 >= WASM_THRESHOLD) {
     const wasm = wasmLoader.getModule();
     if (wasm) {
       try {
-        const paddedInput = new Array(N).fill(0);
+        const paddedInput = new Array(N2).fill(0);
         for (let i = 0; i < n; i++) paddedInput[i] = x[i];
-        const zeros4 = new Array(N).fill(0);
+        const zeros4 = new Array(N2).fill(0);
         const inReAlloc = wasmLoader.allocateFloat64Array(paddedInput);
         const inImAlloc = wasmLoader.allocateFloat64Array(zeros4);
-        const outReAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
-        const outImAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
+        const outReAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
+        const outImAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
         try {
-          wasm.hilbert_wasm(inReAlloc.ptr, inImAlloc.ptr, outReAlloc.ptr, outImAlloc.ptr, N);
+          wasm.hilbert_wasm(inReAlloc.ptr, inImAlloc.ptr, outReAlloc.ptr, outImAlloc.ptr, N2);
           return Array.from(outImAlloc.array.slice(0, n));
         } finally {
           wasmLoader.free(inReAlloc.ptr);
@@ -4471,16 +4471,16 @@ function hilbertTransform(x) {
       }
     }
   }
-  const real = new Float64Array(N);
-  const imag = new Float64Array(N);
+  const real = new Float64Array(N2);
+  const imag = new Float64Array(N2);
   for (let i = 0; i < n; i++) real[i] = x[i];
   const spectrum = fftCoreFloat64(real, imag, false);
-  const hReal = new Float64Array(N);
-  const hImag = new Float64Array(N);
+  const hReal = new Float64Array(N2);
+  const hImag = new Float64Array(N2);
   hReal[0] = spectrum.real[0];
   hImag[0] = spectrum.imag[0];
-  if (N > 1) {
-    const half = N / 2;
+  if (N2 > 1) {
+    const half = N2 / 2;
     for (let i = 1; i < half; i++) {
       hReal[i] = 2 * spectrum.real[i];
       hImag[i] = 2 * spectrum.imag[i];
@@ -10400,10 +10400,10 @@ function cancel(expr) {
         if (dens.length > 0) {
           const numStr = nums.length ? nums.join("*") : "1";
           const denStr = dens.join("*");
-          const N = polyToDense(polyFromExpression(numStr, [v]));
+          const N2 = polyToDense(polyFromExpression(numStr, [v]));
           const D = polyToDense(polyFromExpression(denStr, [v]));
-          if (N.every(isNearInt) && D.every(isNearInt)) {
-            const Nint = N.map((c) => Math.round(c));
+          if (N2.every(isNearInt) && D.every(isNearInt)) {
+            const Nint = N2.map((c) => Math.round(c));
             const Dint = D.map((c) => Math.round(c));
             const g = polynomialGCD(Nint, Dint);
             if (degree(g) >= 1) {
@@ -10501,10 +10501,10 @@ function apart(expr) {
         if (dens.length > 0) {
           const numStr = nums.length ? nums.join("*") : "1";
           const denStr = dens.join("*");
-          const N = polyToDense(polyFromExpression(numStr, [v]));
+          const N2 = polyToDense(polyFromExpression(numStr, [v]));
           const D = polyToDense(polyFromExpression(denStr, [v]));
-          if (degree(D) >= 1 && N.every(isNearInt) && D.every(isNearInt)) {
-            let Nint = N.map((c) => Math.round(c));
+          if (degree(D) >= 1 && N2.every(isNearInt) && D.every(isNearInt)) {
+            let Nint = N2.map((c) => Math.round(c));
             const Dint = D.map((c) => Math.round(c));
             let quotientPrefix = "";
             if (degree(Nint) >= degree(Dint)) {
@@ -13454,8 +13454,8 @@ function solveDAE(f, g, tspan, y0, z0, options = {}) {
       for (let it = 0; it < 12; it++) {
         const R0 = residual(wc);
         const J = newtonMatrix(tNew, wc, c0, residual, R0);
-        const solve2 = _factorSolver(J, n);
-        const dw = solve2(R0.map((v) => -v));
+        const solve4 = _factorSolver(J, n);
+        const dw = solve4(R0.map((v) => -v));
         if (!dw.every((v) => Number.isFinite(v))) break;
         for (let i = 0; i < n; i++) {
           wc[i] += dw[i];
@@ -17018,13 +17018,13 @@ function hypergeometricDist(population, successes, draws) {
   }
   const M = population;
   const K = successes;
-  const N = draws;
-  const kMin = Math.max(0, N - (M - K));
-  const kMax = Math.min(K, N);
+  const N2 = draws;
+  const kMin = Math.max(0, N2 - (M - K));
+  const kMax = Math.min(K, N2);
   const useExact = M <= 1e3;
   const pmf = (k) => {
     if (!Number.isInteger(k) || k < kMin || k > kMax) return 0;
-    return useExact ? _choose(K, k) * _choose(M - K, N - k) / _choose(M, N) : Math.exp(_logChoose(K, k) + _logChoose(M - K, N - k) - _logChoose(M, N));
+    return useExact ? _choose(K, k) * _choose(M - K, N2 - k) / _choose(M, N2) : Math.exp(_logChoose(K, k) + _logChoose(M - K, N2 - k) - _logChoose(M, N2));
   };
   const cdf = (k) => {
     if (k < kMin) return 0;
@@ -17033,8 +17033,8 @@ function hypergeometricDist(population, successes, draws) {
     for (let i = kMin; i <= kk; i++) sum3 += pmf(i);
     return Math.min(1, sum3);
   };
-  const mean7 = N * K / M;
-  const variance2 = N * (K / M) * ((M - K) / M) * ((M - N) / (M - 1));
+  const mean7 = N2 * K / M;
+  const variance2 = N2 * (K / M) * ((M - K) / M) * ((M - N2) / (M - 1));
   return {
     pdf: pmf,
     cdf,
@@ -17701,19 +17701,19 @@ async function chiSquareTest(observed, expected, opts) {
 function anova(groups) {
   if (groups.length < 2) throw new Error("anova: need at least 2 groups");
   const k = groups.length;
-  let N = 0;
+  let N2 = 0;
   let grandSum = 0;
   const groupMeans = [];
   const groupSizes = [];
   for (const group of groups) {
     if (group.length < 1) throw new Error("anova: each group must have at least 1 element");
     groupSizes.push(group.length);
-    N += group.length;
+    N2 += group.length;
     const m = _mean(group);
     groupMeans.push(m);
     for (const x of group) grandSum += x;
   }
-  const grandMean = grandSum / N;
+  const grandMean = grandSum / N2;
   let ssBetween = 0;
   for (let i = 0; i < k; i++) {
     ssBetween += groupSizes[i] * (groupMeans[i] - grandMean) ** 2;
@@ -17725,7 +17725,7 @@ function anova(groups) {
     }
   }
   const dfBetween = k - 1;
-  const dfWithin = N - k;
+  const dfWithin = N2 - k;
   if (dfWithin <= 0) throw new Error("anova: insufficient degrees of freedom");
   const msBetween = ssBetween / dfBetween;
   const msWithin = ssWithin / dfWithin;
@@ -18256,10 +18256,10 @@ function _median(arr10) {
 function leveneTest(groups, center3 = "median") {
   const k = groups.length;
   if (k < 2) throw new Error("leveneTest: need at least 2 groups");
-  let N = 0;
+  let N2 = 0;
   for (const g of groups) {
     if (g.length < 1) throw new Error("leveneTest: every group must be non-empty");
-    N += g.length;
+    N2 += g.length;
   }
   const z = groups.map((g) => {
     const c = center3 === "median" ? _median(g) : _mean(g);
@@ -18275,16 +18275,16 @@ function leveneTest(groups, center3 = "median") {
     num2 += zi.length * (zBarI - zBarAll) * (zBarI - zBarAll);
     for (const v of zi) den += (v - zBarI) * (v - zBarI);
   }
-  const W = (N - k) / (k - 1) * (num2 / den);
-  return { statistic: W, pValue: _fPValue(W, k - 1, N - k), degreesOfFreedom: [k - 1, N - k] };
+  const W = (N2 - k) / (k - 1) * (num2 / den);
+  return { statistic: W, pValue: _fPValue(W, k - 1, N2 - k), degreesOfFreedom: [k - 1, N2 - k] };
 }
 function bartlettTest(groups) {
   const k = groups.length;
   if (k < 2) throw new Error("bartlettTest: need at least 2 groups");
-  let N = 0;
+  let N2 = 0;
   for (const g of groups) {
     if (g.length < 2) throw new Error("bartlettTest: every group needs \u22652 observations");
-    N += g.length;
+    N2 += g.length;
   }
   let pooledNum = 0;
   let sumLnVar = 0;
@@ -18296,9 +18296,9 @@ function bartlettTest(groups) {
     sumLnVar += (ni - 1) * Math.log(si2);
     sumInv += 1 / (ni - 1);
   }
-  const sp2 = pooledNum / (N - k);
-  const numerator = (N - k) * Math.log(sp2) - sumLnVar;
-  const C = 1 + (sumInv - 1 / (N - k)) / (3 * (k - 1));
+  const sp2 = pooledNum / (N2 - k);
+  const numerator = (N2 - k) * Math.log(sp2) - sumLnVar;
+  const C = 1 + (sumInv - 1 / (N2 - k)) / (3 * (k - 1));
   const T = numerator / C;
   return { statistic: T, pValue: _chiSquaredPValue(T, k - 1), degreesOfFreedom: k - 1 };
 }
@@ -21938,8 +21938,8 @@ function nearlyEqual2(a, b, relTol = 1e-9, absTol = 0) {
   }
   const ax = x.abs();
   const ay = y.abs();
-  const maxAbs = ax.greaterThanOrEqual(ay) ? ax : ay;
-  const relBound = maxAbs.mul(relTol);
+  const maxAbs2 = ax.greaterThanOrEqual(ay) ? ax : ay;
+  const relBound = maxAbs2.mul(relTol);
   const diff2 = x.sub(y).abs();
   return diff2.lessThanOrEqual(relBound) || diff2.lessThanOrEqual(absTol);
 }
@@ -23119,7 +23119,7 @@ var createDot = /* @__PURE__ */ factory(
       return xLen;
     }
     function _denseDot(a, b) {
-      const N = _validateDim(a, b);
+      const N2 = _validateDim(a, b);
       const adata = isMatrix(a) ? a._data : a;
       const adt = isMatrix(a) ? a._datatype || a.getDataType() : void 0;
       const bdata = isMatrix(b) ? b._data : b;
@@ -23138,28 +23138,28 @@ var createDot = /* @__PURE__ */ factory(
       }
       if (!aIsColumn && !bIsColumn) {
         let c = mul(conj3(adata[0]), bdata[0]);
-        for (let i = 1; i < N; i++) {
+        for (let i = 1; i < N2; i++) {
           c = add4(c, mul(conj3(adata[i]), bdata[i]));
         }
         return c;
       }
       if (!aIsColumn && bIsColumn) {
         let c = mul(conj3(adata[0]), bdata[0][0]);
-        for (let i = 1; i < N; i++) {
+        for (let i = 1; i < N2; i++) {
           c = add4(c, mul(conj3(adata[i]), bdata[i][0]));
         }
         return c;
       }
       if (aIsColumn && !bIsColumn) {
         let c = mul(conj3(adata[0][0]), bdata[0]);
-        for (let i = 1; i < N; i++) {
+        for (let i = 1; i < N2; i++) {
           c = add4(c, mul(conj3(adata[i][0]), bdata[i]));
         }
         return c;
       }
       {
         let c = mul(conj3(adata[0][0]), bdata[0][0]);
-        for (let i = 1; i < N; i++) {
+        for (let i = 1; i < N2; i++) {
           c = add4(c, mul(conj3(adata[i][0]), bdata[i][0]));
         }
         return c;
@@ -24155,20 +24155,20 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
     function _createArray(arr10) {
       if (arr10.length === 0)
         throw new TypeError("At least one column is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr10[0]);
+      const N2 = checkVectorTypeAndReturnLength(arr10[0]);
       const result = [];
-      for (let i = 0; i < N; i++) {
+      for (let i = 0; i < N2; i++) {
         result[i] = [];
       }
       for (const col of arr10) {
         const colLength = checkVectorTypeAndReturnLength(col);
-        if (colLength !== N) {
+        if (colLength !== N2) {
           throw new TypeError(
-            "The vectors had different length: " + (N | 0) + " \u2260 " + (colLength | 0)
+            "The vectors had different length: " + (N2 | 0) + " \u2260 " + (colLength | 0)
           );
         }
         const f = flatten5(col);
-        for (let i = 0; i < N; i++) {
+        for (let i = 0; i < N2; i++) {
           result[i].push(f[i]);
         }
       }
@@ -24224,13 +24224,13 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
     function _createArray(arr10) {
       if (arr10.length === 0)
         throw new TypeError("At least one row is needed to construct a matrix.");
-      const N = checkVectorTypeAndReturnLength(arr10[0]);
+      const N2 = checkVectorTypeAndReturnLength(arr10[0]);
       const result = [];
       for (const row2 of arr10) {
         const rowLength = checkVectorTypeAndReturnLength(row2);
-        if (rowLength !== N) {
+        if (rowLength !== N2) {
           throw new TypeError(
-            "The vectors had different length: " + (N | 0) + " \u2260 " + (rowLength | 0)
+            "The vectors had different length: " + (N2 | 0) + " \u2260 " + (rowLength | 0)
           );
         }
         result.push(flatten5(row2));
@@ -38253,20 +38253,20 @@ function createComplexEigs({
   matrixFromColumns: _matrixFromColumns,
   dot: dot9
 }) {
-  function complexEigs(arr10, N, prec, type, findVectors = true) {
-    if (!findVectors && type === "number" && N * N >= WASM_EIGS_THRESHOLD) {
+  function complexEigs(arr10, N2, prec, type, findVectors = true) {
+    if (!findVectors && type === "number" && N2 * N2 >= WASM_EIGS_THRESHOLD) {
       const wasm = wasmLoader.getModule();
       if (wasm) {
         try {
-          const flat = flattenToFloat648(arr10, N, N);
+          const flat = flattenToFloat648(arr10, N2, N2);
           const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
-          const eigenvaluesRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
-          const eigenvaluesImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
-          const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(N * N);
+          const eigenvaluesRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
+          const eigenvaluesImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
+          const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2 * N2);
           try {
             const iterations = wasm.qrAlgorithm(
               matrixAlloc.ptr,
-              N,
+              N2,
               eigenvaluesRealAlloc.ptr,
               eigenvaluesImagAlloc.ptr,
               workAlloc.ptr,
@@ -38276,7 +38276,7 @@ function createComplexEigs({
             );
             if (iterations >= 0) {
               const values2 = [];
-              for (let i = 0; i < N; i++) {
+              for (let i = 0; i < N2; i++) {
                 const re3 = eigenvaluesRealAlloc.array[i];
                 const im3 = eigenvaluesImagAlloc.array[i];
                 if (Math.abs(im3) < 1e-14) {
@@ -38302,16 +38302,16 @@ function createComplexEigs({
         }
       }
     }
-    const R = balance(arr10, N, prec, type, findVectors);
-    reduceToHessenberg(arr10, N, prec, type, findVectors, R);
-    const { values, C } = iterateUntilTriangular(arr10, N, prec, type, findVectors);
+    const R = balance(arr10, N2, prec, type, findVectors);
+    reduceToHessenberg(arr10, N2, prec, type, findVectors, R);
+    const { values, C } = iterateUntilTriangular(arr10, N2, prec, type, findVectors);
     if (findVectors) {
-      const eigenvectors = findEigenvectors(arr10, N, C, R, values, prec, type);
+      const eigenvectors = findEigenvectors(arr10, N2, C, R, values, prec, type);
       return { values, eigenvectors };
     }
     return { values };
   }
-  function balance(arr10, N, _prec, type, findVectors) {
+  function balance(arr10, N2, _prec, type, findVectors) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const realzero = big ? bignumber2(0) : 0;
@@ -38321,24 +38321,24 @@ function createComplexEigs({
     const radixSq = multiplyScalar2(radix, radix);
     let Rdiag;
     if (findVectors) {
-      Rdiag = Array(N).fill(one);
+      Rdiag = Array(N2).fill(one);
     }
     let last2 = false;
     while (!last2) {
       last2 = true;
-      for (let i = 0; i < N; i++) {
+      for (let i = 0; i < N2; i++) {
         let colNorm = realzero;
-        let rowNorm = realzero;
-        for (let j = 0; j < N; j++) {
+        let rowNorm2 = realzero;
+        for (let j = 0; j < N2; j++) {
           if (i === j) continue;
           colNorm = addScalar2(colNorm, abs2(arr10[j][i]));
-          rowNorm = addScalar2(rowNorm, abs2(arr10[i][j]));
+          rowNorm2 = addScalar2(rowNorm2, abs2(arr10[i][j]));
         }
-        if (!equal2(colNorm, 0) && !equal2(rowNorm, 0)) {
+        if (!equal2(colNorm, 0) && !equal2(rowNorm2, 0)) {
           let f = realone;
           let c = colNorm;
-          const rowDivRadix = divideScalar2(rowNorm, radix);
-          const rowMulRadix = multiplyScalar2(rowNorm, radix);
+          const rowDivRadix = divideScalar2(rowNorm2, radix);
+          const rowMulRadix = multiplyScalar2(rowNorm2, radix);
           while (smaller2(c, rowDivRadix)) {
             c = multiplyScalar2(c, radixSq);
             f = multiplyScalar2(f, radix);
@@ -38348,13 +38348,13 @@ function createComplexEigs({
             f = divideScalar2(f, radix);
           }
           const condition = smaller2(
-            divideScalar2(addScalar2(c, rowNorm), f),
-            multiplyScalar2(addScalar2(colNorm, rowNorm), 0.95)
+            divideScalar2(addScalar2(c, rowNorm2), f),
+            multiplyScalar2(addScalar2(colNorm, rowNorm2), 0.95)
           );
           if (condition) {
             last2 = false;
             const g = divideScalar2(1, f);
-            for (let j = 0; j < N; j++) {
+            for (let j = 0; j < N2; j++) {
               if (i === j) {
                 continue;
               }
@@ -38370,17 +38370,17 @@ function createComplexEigs({
     }
     return findVectors ? diag2(Rdiag) : null;
   }
-  function reduceToHessenberg(arr10, N, prec, type, findVectors, R) {
+  function reduceToHessenberg(arr10, N2, prec, type, findVectors, R) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const zero = big ? bignumber2(0) : cplx ? complex3(0) : 0;
     if (big) {
       prec = bignumber2(prec);
     }
-    for (let i = 0; i < N - 2; i++) {
+    for (let i = 0; i < N2 - 2; i++) {
       let maxIndex = 0;
       let max2 = zero;
-      for (let j = i + 1; j < N; j++) {
+      for (let j = i + 1; j < N2; j++) {
         const el = arr10[j][i];
         if (smaller2(abs2(max2), abs2(el))) {
           max2 = el;
@@ -38394,7 +38394,7 @@ function createComplexEigs({
         const tmp1 = arr10[maxIndex];
         arr10[maxIndex] = arr10[i + 1];
         arr10[i + 1] = tmp1;
-        for (let j = 0; j < N; j++) {
+        for (let j = 0; j < N2; j++) {
           const tmp2 = arr10[j][maxIndex];
           arr10[j][maxIndex] = arr10[j][i + 1];
           arr10[j][i + 1] = tmp2;
@@ -38405,26 +38405,26 @@ function createComplexEigs({
           R[i + 1] = tmp3;
         }
       }
-      for (let j = i + 2; j < N; j++) {
+      for (let j = i + 2; j < N2; j++) {
         const n = divideScalar2(arr10[j][i], max2);
         if (n === 0) {
           continue;
         }
-        for (let k = 0; k < N; k++) {
+        for (let k = 0; k < N2; k++) {
           arr10[j][k] = subtract3(arr10[j][k], multiplyScalar2(n, arr10[i + 1][k]));
         }
-        for (let k = 0; k < N; k++) {
+        for (let k = 0; k < N2; k++) {
           arr10[k][i + 1] = addScalar2(arr10[k][i + 1], multiplyScalar2(n, arr10[k][j]));
         }
         if (findVectors) {
-          for (let k = 0; k < N; k++) {
+          for (let k = 0; k < N2; k++) {
             R[j][k] = subtract3(R[j][k], multiplyScalar2(n, R[i + 1][k]));
           }
         }
       }
     }
   }
-  function iterateUntilTriangular(A, N, prec, type, findVectors) {
+  function iterateUntilTriangular(A, N2, prec, type, findVectors) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
     const one = big ? bignumber2(1) : cplx ? complex3(1) : 1;
@@ -38433,9 +38433,9 @@ function createComplexEigs({
     }
     let arr10 = clone(A);
     const lambdas = [];
-    let n = N;
+    let n = N2;
     const Sdiag = [];
-    let Qtotal = findVectors ? diag2(Array(N).fill(one)) : void 0;
+    let Qtotal = findVectors ? diag2(Array(N2).fill(one)) : void 0;
     let Qpartial = findVectors ? diag2(Array(n).fill(one)) : void 0;
     let lastConvergenceBefore = 0;
     while (lastConvergenceBefore <= 100) {
@@ -38457,7 +38457,7 @@ function createComplexEigs({
         lambdas.push(arr10[n - 1][n - 1]);
         if (findVectors) {
           Sdiag.unshift([[1]]);
-          inflateMatrix(Qpartial, N);
+          inflateMatrix(Qpartial, N2);
           Qtotal = multiply2(Qtotal, Qpartial);
           if (n > 1) {
             Qpartial = diag2(Array(n - 1).fill(one));
@@ -38490,7 +38490,7 @@ function createComplexEigs({
               type
             )
           );
-          inflateMatrix(Qpartial, N);
+          inflateMatrix(Qpartial, N2);
           Qtotal = multiply2(Qtotal, Qpartial);
           if (n > 2) {
             Qpartial = diag2(Array(n - 2).fill(one));
@@ -38517,10 +38517,10 @@ function createComplexEigs({
       err.vectors = [];
       throw err;
     }
-    const C = findVectors ? multiply2(Qtotal, blockDiag(Sdiag, N)) : void 0;
+    const C = findVectors ? multiply2(Qtotal, blockDiag(Sdiag, N2)) : void 0;
     return { values: lambdas, C };
   }
-  function findEigenvectors(A, N, C, R, values, prec, type) {
+  function findEigenvectors(A, N2, C, R, values, prec, type) {
     const Cinv = inv3(C);
     const U = multiply2(multiply2(Cinv, A), C);
     const big = type === "BigNumber";
@@ -38540,8 +38540,8 @@ function createComplexEigs({
     }
     const vectors = [];
     const len = uniqueValues.length;
-    const b = Array(N).fill(zero);
-    const E = diag2(Array(N).fill(one));
+    const b = Array(N2).fill(zero);
+    const E = diag2(Array(N2).fill(one));
     for (let i = 0; i < len; i++) {
       const lambda = uniqueValues[i];
       const S = subtract3(
@@ -38551,7 +38551,7 @@ function createComplexEigs({
       let solutions = usolveAll2(S, b);
       solutions.shift();
       while (solutions.length < multiplicities[i]) {
-        const approxVec = inverseIterate(S, N, solutions, prec, type);
+        const approxVec = inverseIterate(S, N2, solutions, prec, type);
         if (approxVec === null) {
           break;
         }
@@ -38606,20 +38606,20 @@ function createComplexEigs({
       ];
     }
   }
-  function inflateMatrix(arr10, N) {
+  function inflateMatrix(arr10, N2) {
     for (let i = 0; i < arr10.length; i++) {
-      arr10[i].push(...Array(N - arr10[i].length).fill(0));
+      arr10[i].push(...Array(N2 - arr10[i].length).fill(0));
     }
-    for (let i = arr10.length; i < N; i++) {
-      arr10.push(Array(N).fill(0));
+    for (let i = arr10.length; i < N2; i++) {
+      arr10.push(Array(N2).fill(0));
       arr10[i][i] = 1;
     }
     return arr10;
   }
-  function blockDiag(arr10, N) {
+  function blockDiag(arr10, N2) {
     const M = [];
-    for (let i = 0; i < N; i++) {
-      M[i] = Array(N).fill(0);
+    for (let i = 0; i < N2; i++) {
+      M[i] = Array(N2).fill(0);
     }
     let I2 = 0;
     for (const sub3 of arr10) {
@@ -38641,12 +38641,12 @@ function createComplexEigs({
     }
     return -1;
   }
-  function inverseIterate(A, N, orthog, prec, type) {
+  function inverseIterate(A, N2, orthog, prec, type) {
     const largeNum = type === "BigNumber" ? bignumber2(1e3) : 1e3;
     let b;
     let i = 0;
     for (; i < 5; ++i) {
-      b = randomOrthogonalVector(N, orthog, type);
+      b = randomOrthogonalVector(N2, orthog, type);
       try {
         b = usolve2(A, b);
       } catch {
@@ -38672,10 +38672,10 @@ function createComplexEigs({
     }
     return b;
   }
-  function randomOrthogonalVector(N, orthog, type) {
+  function randomOrthogonalVector(N2, orthog, type) {
     const big = type === "BigNumber";
     const cplx = type === "Complex";
-    let v = Array(N).fill(0).map(() => 2 * Math.random() - 1);
+    let v = Array(N2).fill(0).map(() => 2 * Math.random() - 1);
     if (big) {
       v = v.map((n) => bignumber2(n));
     }
@@ -38758,19 +38758,19 @@ function createRealSymmetric({
     throw TypeError("Unsupported data type: " + type);
   }
   function diag2(x, precision, computeVectors) {
-    const N = x.length;
+    const N2 = x.length;
     const wasm = wasmLoader.getModule();
-    if (wasm && N * N >= WASM_EIGS_THRESHOLD2) {
+    if (wasm && N2 * N2 >= WASM_EIGS_THRESHOLD2) {
       try {
-        const flat = flattenToFloat649(x, N, N);
+        const flat = flattenToFloat649(x, N2, N2);
         const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
-        const eigenvaluesAlloc = wasmLoader.allocateFloat64ArrayEmpty(N);
-        const eigenvectorsAlloc = computeVectors ? wasmLoader.allocateFloat64ArrayEmpty(N * N) : { ptr: 0, array: new Float64Array(0) };
-        const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(N * N);
+        const eigenvaluesAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
+        const eigenvectorsAlloc = computeVectors ? wasmLoader.allocateFloat64ArrayEmpty(N2 * N2) : { ptr: 0, array: new Float64Array(0) };
+        const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2 * N2);
         try {
           const iterations = wasm.eigsSymmetric(
             matrixAlloc.ptr,
-            N,
+            N2,
             eigenvaluesAlloc.ptr,
             eigenvectorsAlloc.ptr,
             workAlloc.ptr,
@@ -38779,8 +38779,8 @@ function createRealSymmetric({
             precision
           );
           if (iterations >= 0) {
-            const values = Array(N);
-            for (let i = 0; i < N; i++) {
+            const values = Array(N2);
+            for (let i = 0; i < N2; i++) {
               values[i] = eigenvaluesAlloc.array[i];
             }
             if (!computeVectors) {
@@ -38790,9 +38790,9 @@ function createRealSymmetric({
             const eigenvectors = [];
             const sortedIndices = values.map((v, i) => ({ v, i })).sort((a, b) => Math.abs(a.v) - Math.abs(b.v)).map((x2) => x2.i);
             for (const origIdx of sortedIndices) {
-              const vector = Array(N);
-              for (let i = 0; i < N; i++) {
-                vector[i] = eigenvectorsAlloc.array[i * N + origIdx];
+              const vector = Array(N2);
+              for (let i = 0; i < N2; i++) {
+                vector[i] = eigenvectorsAlloc.array[i * N2 + origIdx];
               }
               eigenvectors.push({
                 value: values[origIdx],
@@ -38815,13 +38815,13 @@ function createRealSymmetric({
       } catch {
       }
     }
-    const e0 = Math.abs(precision / N);
+    const e0 = Math.abs(precision / N2);
     let psi;
     let Sij;
     if (computeVectors) {
-      Sij = new Array(N);
-      for (let i = 0; i < N; i++) {
-        Sij[i] = Array(N).fill(0);
+      Sij = new Array(N2);
+      for (let i = 0; i < N2; i++) {
+        Sij[i] = Array(N2).fill(0);
         Sij[i][i] = 1;
       }
     }
@@ -38834,21 +38834,21 @@ function createRealSymmetric({
       if (computeVectors) Sij = Sij1(Sij, psi, i, j);
       Vab = getAij(x);
     }
-    const Ei = Array(N).fill(0);
-    for (let i = 0; i < N; i++) {
+    const Ei = Array(N2).fill(0);
+    for (let i = 0; i < N2; i++) {
       Ei[i] = x[i][i];
     }
     return sorting(clone(Ei), Sij, computeVectors);
   }
   function diagBig(x, precision, computeVectors) {
-    const N = x.length;
-    const e0 = abs2(multiplyScalar2(precision, bignumber2(1 / N)));
+    const N2 = x.length;
+    const e0 = abs2(multiplyScalar2(precision, bignumber2(1 / N2)));
     let psi;
     let Sij;
     if (computeVectors) {
-      Sij = new Array(N);
-      for (let i = 0; i < N; i++) {
-        Sij[i] = Array(N).fill(bignumber2(0));
+      Sij = new Array(N2);
+      for (let i = 0; i < N2; i++) {
+        Sij[i] = Array(N2).fill(bignumber2(0));
         Sij[i][i] = bignumber2(1);
       }
     }
@@ -38861,8 +38861,8 @@ function createRealSymmetric({
       if (computeVectors) Sij = Sij1Big(Sij, psi, i, j);
       Vab = getAijBig(x);
     }
-    const Ei = Array(N).fill(bignumber2(0));
-    for (let i = 0; i < N; i++) {
+    const Ei = Array(N2).fill(bignumber2(0));
+    for (let i = 0; i < N2; i++) {
       Ei[i] = x[i][i];
     }
     return sorting(clone(Ei), Sij, computeVectors);
@@ -38887,45 +38887,45 @@ function createRealSymmetric({
     }
   }
   function Sij1(Sij, theta, i, j) {
-    const N = Sij.length;
+    const N2 = Sij.length;
     const c = Math.cos(theta);
     const s = Math.sin(theta);
-    const Ski = Array(N).fill(0);
-    const Skj = Array(N).fill(0);
-    for (let k = 0; k < N; k++) {
+    const Ski = Array(N2).fill(0);
+    const Skj = Array(N2).fill(0);
+    for (let k = 0; k < N2; k++) {
       Ski[k] = c * Sij[k][i] - s * Sij[k][j];
       Skj[k] = s * Sij[k][i] + c * Sij[k][j];
     }
-    for (let k = 0; k < N; k++) {
+    for (let k = 0; k < N2; k++) {
       Sij[k][i] = Ski[k];
       Sij[k][j] = Skj[k];
     }
     return Sij;
   }
   function Sij1Big(Sij, theta, i, j) {
-    const N = Sij.length;
+    const N2 = Sij.length;
     const c = cos2(theta);
     const s = sin2(theta);
-    const Ski = Array(N).fill(bignumber2(0));
-    const Skj = Array(N).fill(bignumber2(0));
-    for (let k = 0; k < N; k++) {
+    const Ski = Array(N2).fill(bignumber2(0));
+    const Skj = Array(N2).fill(bignumber2(0));
+    for (let k = 0; k < N2; k++) {
       Ski[k] = subtract3(multiplyScalar2(c, Sij[k][i]), multiplyScalar2(s, Sij[k][j]));
       Skj[k] = addScalar2(multiplyScalar2(s, Sij[k][i]), multiplyScalar2(c, Sij[k][j]));
     }
-    for (let k = 0; k < N; k++) {
+    for (let k = 0; k < N2; k++) {
       Sij[k][i] = Ski[k];
       Sij[k][j] = Skj[k];
     }
     return Sij;
   }
   function x1Big(Hij, theta, i, j) {
-    const N = Hij.length;
+    const N2 = Hij.length;
     const c = bignumber2(cos2(theta).toString());
     const s = bignumber2(sin2(theta).toString());
     const c2 = multiplyScalar2(c, c);
     const s2 = multiplyScalar2(s, s);
-    const Aki = Array(N).fill(bignumber2(0));
-    const Akj = Array(N).fill(bignumber2(0));
+    const Aki = Array(N2).fill(bignumber2(0));
+    const Akj = Array(N2).fill(bignumber2(0));
     const csHij = multiply2(bignumber2(2), c, s, Hij[i][j]);
     const Aii = addScalar2(
       subtract3(multiplyScalar2(c2, Hij[i][i]), csHij),
@@ -38936,7 +38936,7 @@ function createRealSymmetric({
       csHij,
       multiplyScalar2(c2, Hij[j][j])
     );
-    for (let k = 0; k < N; k++) {
+    for (let k = 0; k < N2; k++) {
       Aki[k] = subtract3(multiplyScalar2(c, Hij[i][k]), multiplyScalar2(s, Hij[j][k]));
       Akj[k] = addScalar2(multiplyScalar2(s, Hij[i][k]), multiplyScalar2(c, Hij[j][k]));
     }
@@ -38944,7 +38944,7 @@ function createRealSymmetric({
     Hij[j][j] = Ajj;
     Hij[i][j] = bignumber2(0);
     Hij[j][i] = bignumber2(0);
-    for (let k = 0; k < N; k++) {
+    for (let k = 0; k < N2; k++) {
       if (k !== i && k !== j) {
         Hij[i][k] = Aki[k];
         Hij[k][i] = Aki[k];
@@ -38955,16 +38955,16 @@ function createRealSymmetric({
     return Hij;
   }
   function x1(Hij, theta, i, j) {
-    const N = Hij.length;
+    const N2 = Hij.length;
     const c = Math.cos(theta);
     const s = Math.sin(theta);
     const c2 = c * c;
     const s2 = s * s;
-    const Aki = Array(N).fill(0);
-    const Akj = Array(N).fill(0);
+    const Aki = Array(N2).fill(0);
+    const Akj = Array(N2).fill(0);
     const Aii = c2 * Hij[i][i] - 2 * c * s * Hij[i][j] + s2 * Hij[j][j];
     const Ajj = s2 * Hij[i][i] + 2 * c * s * Hij[i][j] + c2 * Hij[j][j];
-    for (let k = 0; k < N; k++) {
+    for (let k = 0; k < N2; k++) {
       Aki[k] = c * Hij[i][k] - s * Hij[j][k];
       Akj[k] = s * Hij[i][k] + c * Hij[j][k];
     }
@@ -38972,7 +38972,7 @@ function createRealSymmetric({
     Hij[j][j] = Ajj;
     Hij[i][j] = 0;
     Hij[j][i] = 0;
-    for (let k = 0; k < N; k++) {
+    for (let k = 0; k < N2; k++) {
       if (k !== i && k !== j) {
         Hij[i][k] = Aki[k];
         Hij[k][i] = Aki[k];
@@ -38983,11 +38983,11 @@ function createRealSymmetric({
     return Hij;
   }
   function getAij(Mij) {
-    const N = Mij.length;
+    const N2 = Mij.length;
     let maxMij = 0;
     let maxIJ = [0, 1];
-    for (let i = 0; i < N; i++) {
-      for (let j = i + 1; j < N; j++) {
+    for (let i = 0; i < N2; i++) {
+      for (let j = i + 1; j < N2; j++) {
         if (Math.abs(maxMij) < Math.abs(Mij[i][j])) {
           maxMij = Math.abs(Mij[i][j]);
           maxIJ = [i, j];
@@ -38997,11 +38997,11 @@ function createRealSymmetric({
     return [maxIJ, maxMij];
   }
   function getAijBig(Mij) {
-    const N = Mij.length;
+    const N2 = Mij.length;
     let maxMij = bignumber2(0);
     let maxIJ = [0, 1];
-    for (let i = 0; i < N; i++) {
-      for (let j = i + 1; j < N; j++) {
+    for (let i = 0; i < N2; i++) {
+      for (let j = i + 1; j < N2; j++) {
         if (bigLt(abs2(maxMij), abs2(Mij[i][j]))) {
           maxMij = abs2(Mij[i][j]);
           maxIJ = [i, j];
@@ -39011,16 +39011,16 @@ function createRealSymmetric({
     return [maxIJ, maxMij];
   }
   function sorting(E, S, computeVectors) {
-    const N = E.length;
-    const values = Array(N);
+    const N2 = E.length;
+    const values = Array(N2);
     let vecs;
     if (computeVectors) {
-      vecs = Array(N);
-      for (let k = 0; k < N; k++) {
-        vecs[k] = Array(N);
+      vecs = Array(N2);
+      for (let k = 0; k < N2; k++) {
+        vecs[k] = Array(N2);
       }
     }
-    for (let i = 0; i < N; i++) {
+    for (let i = 0; i < N2; i++) {
       let minID = 0;
       let minE = E[0];
       for (let j = 0; j < E.length; j++) {
@@ -39031,7 +39031,7 @@ function createRealSymmetric({
       }
       values[i] = E.splice(minID, 1)[0];
       if (computeVectors) {
-        for (let k = 0; k < N; k++) {
+        for (let k = 0; k < N2; k++) {
           vecs[i][k] = S[k][minID];
           S[k].splice(minID, 1);
         }
@@ -39220,26 +39220,26 @@ var createEigs = /* @__PURE__ */ factory(
       if (asize.length !== 2 || asize[0] !== asize[1]) {
         throw new RangeError(`Matrix must be square (size: ${formatGeneric(asize, {})})`);
       }
-      const N = asize[0];
-      if (isReal(arr10, N, prec)) {
-        coerceReal(arr10, N);
-        if (isSymmetric(arr10, N, prec)) {
-          const type2 = coerceTypes(mat, arr10, N);
+      const N2 = asize[0];
+      if (isReal(arr10, N2, prec)) {
+        coerceReal(arr10, N2);
+        if (isSymmetric(arr10, N2, prec)) {
+          const type2 = coerceTypes(mat, arr10, N2);
           return doRealSymmetric(
             arr10,
-            N,
+            N2,
             prec,
             type2,
             computeVectors
           );
         }
       }
-      const type = coerceTypes(mat, arr10, N);
-      return doComplexEigs(arr10, N, prec, type, computeVectors);
+      const type = coerceTypes(mat, arr10, N2);
+      return doComplexEigs(arr10, N2, prec, type, computeVectors);
     }
-    function isSymmetric(arr10, N, prec) {
-      for (let i = 0; i < N; i++) {
-        for (let j = i; j < N; j++) {
+    function isSymmetric(arr10, N2, prec) {
+      for (let i = 0; i < N2; i++) {
+        for (let j = i; j < N2; j++) {
           if (larger2(bignumber2(abs2(subtract3(arr10[i][j], arr10[j][i]))), prec)) {
             return false;
           }
@@ -39247,9 +39247,9 @@ var createEigs = /* @__PURE__ */ factory(
       }
       return true;
     }
-    function isReal(arr10, N, prec) {
-      for (let i = 0; i < N; i++) {
-        for (let j = 0; j < N; j++) {
+    function isReal(arr10, N2, prec) {
+      for (let i = 0; i < N2; i++) {
+        for (let j = 0; j < N2; j++) {
           if (larger2(bignumber2(abs2(im3(arr10[i][j]))), prec)) {
             return false;
           }
@@ -39257,14 +39257,14 @@ var createEigs = /* @__PURE__ */ factory(
       }
       return true;
     }
-    function coerceReal(arr10, N) {
-      for (let i = 0; i < N; i++) {
-        for (let j = 0; j < N; j++) {
+    function coerceReal(arr10, N2) {
+      for (let i = 0; i < N2; i++) {
+        for (let j = 0; j < N2; j++) {
           arr10[i][j] = re3(arr10[i][j]);
         }
       }
     }
-    function coerceTypes(mat, arr10, N) {
+    function coerceTypes(mat, arr10, N2) {
       const type = mat.datatype();
       if (type === "number" || type === "BigNumber" || type === "Complex") {
         return type;
@@ -39272,8 +39272,8 @@ var createEigs = /* @__PURE__ */ factory(
       let hasNumber = false;
       let hasBig = false;
       let hasComplex = false;
-      for (let i = 0; i < N; i++) {
-        for (let j = 0; j < N; j++) {
+      for (let i = 0; i < N2; i++) {
+        for (let j = 0; j < N2; j++) {
           const el = arr10[i][j];
           if (isNumber(el) || isFraction(el)) {
             hasNumber = true;
@@ -39290,24 +39290,24 @@ var createEigs = /* @__PURE__ */ factory(
         console.warn("Complex BigNumbers not supported, this operation will lose precission.");
       }
       if (hasComplex) {
-        for (let i = 0; i < N; i++) {
-          for (let j = 0; j < N; j++) {
+        for (let i = 0; i < N2; i++) {
+          for (let j = 0; j < N2; j++) {
             arr10[i][j] = complex3(arr10[i][j]);
           }
         }
         return "Complex";
       }
       if (hasBig) {
-        for (let i = 0; i < N; i++) {
-          for (let j = 0; j < N; j++) {
+        for (let i = 0; i < N2; i++) {
+          for (let j = 0; j < N2; j++) {
             arr10[i][j] = bignumber2(arr10[i][j]);
           }
         }
         return "BigNumber";
       }
       if (hasNumber) {
-        for (let i = 0; i < N; i++) {
-          for (let j = 0; j < N; j++) {
+        for (let i = 0; i < N2; i++) {
+          for (let j = 0; j < N2; j++) {
             arr10[i][j] = number2(arr10[i][j]);
           }
         }
@@ -43585,12 +43585,12 @@ function numericalDerivative(expr, varName, x0, k, h = 1e-4, scope) {
   return (deriv1 - deriv2) / (2 * h);
 }
 function taylorCoefficients(expr, varName, x0, n) {
-  const N = Math.max(1 << Math.ceil(Math.log2(2 * (n + 1))), 16);
+  const N2 = Math.max(1 << Math.ceil(Math.log2(2 * (n + 1))), 16);
   const r = 0.5;
-  const fRe = new Array(N);
-  const fIm = new Array(N);
-  for (let j = 0; j < N; j++) {
-    const ang = 2 * Math.PI * j / N;
+  const fRe = new Array(N2);
+  const fIm = new Array(N2);
+  for (let j = 0; j < N2; j++) {
+    const ang = 2 * Math.PI * j / N2;
     const z = new Complex10(x0 + r * Math.cos(ang), r * Math.sin(ang));
     const val = evaluate(expr, { [varName]: z });
     if (typeof val === "number") {
@@ -43604,11 +43604,11 @@ function taylorCoefficients(expr, varName, x0, n) {
   const a = new Array(n + 1);
   for (let k = 0; k <= n; k++) {
     let sRe = 0;
-    for (let j = 0; j < N; j++) {
-      const ang = -2 * Math.PI * j * k / N;
+    for (let j = 0; j < N2; j++) {
+      const ang = -2 * Math.PI * j * k / N2;
       sRe += fRe[j] * Math.cos(ang) - fIm[j] * Math.sin(ang);
     }
-    a[k] = sRe / (N * Math.pow(r, k));
+    a[k] = sRe / (N2 * Math.pow(r, k));
   }
   return a;
 }
@@ -43935,10 +43935,10 @@ function inverseLaplace(expr, s, t) {
   return `L^-1{${trimmed}}(${t})`;
 }
 function fourierSeries(expr, varName, n) {
-  const N = 1e3;
-  const dx = 2 * Math.PI / N;
+  const N2 = 1e3;
+  const dx = 2 * Math.PI / N2;
   let a0Sum = 0;
-  for (let i = 0; i < N; i++) {
+  for (let i = 0; i < N2; i++) {
     const x = -Math.PI + i * dx;
     a0Sum += evalAt(expr, varName, x);
   }
@@ -43948,7 +43948,7 @@ function fourierSeries(expr, varName, n) {
   for (let k = 1; k <= n; k++) {
     let akSum = 0;
     let bkSum = 0;
-    for (let i = 0; i < N; i++) {
+    for (let i = 0; i < N2; i++) {
       const x = -Math.PI + i * dx;
       const fx = evalAt(expr, varName, x);
       akSum += fx * Math.cos(k * x);
@@ -45398,18 +45398,18 @@ function kroneckerSymbol(a, n) {
   }
   if (nn === 1) return sign3;
   let aa = (a % nn + nn) % nn;
-  let N = nn;
+  let N2 = nn;
   let jac = 1;
   while (aa !== 0) {
     while (aa % 2 === 0) {
       aa /= 2;
-      if (N % 8 === 3 || N % 8 === 5) jac = -jac;
+      if (N2 % 8 === 3 || N2 % 8 === 5) jac = -jac;
     }
-    [aa, N] = [N, aa];
-    if (aa % 4 === 3 && N % 4 === 3) jac = -jac;
-    aa = aa % N;
+    [aa, N2] = [N2, aa];
+    if (aa % 4 === 3 && N2 % 4 === 3) jac = -jac;
+    aa = aa % N2;
   }
-  return sign3 * (N === 1 ? jac : 0);
+  return sign3 * (N2 === 1 ? jac : 0);
 }
 function combinationsGen(arr10, k) {
   const n = arr10.length;
@@ -45954,7 +45954,7 @@ function kruskalWallis(...groups) {
   const arrs = groups.map(arr2).filter((g) => g.length > 0);
   if (arrs.length < 2) throw new Error("kruskalWallis: need at least 2 non-empty groups");
   const pooled = arrs.flat();
-  const N = pooled.length;
+  const N2 = pooled.length;
   const ranks = rankdata(pooled);
   let offset = 0;
   let sumRanksSq = 0;
@@ -45964,8 +45964,8 @@ function kruskalWallis(...groups) {
     sumRanksSq += rsum * rsum / g.length;
     offset += g.length;
   }
-  let H = 12 / (N * (N + 1)) * sumRanksSq - 3 * (N + 1);
-  const correction = 1 - tieTerm(pooled) / (N * N * N - N);
+  let H = 12 / (N2 * (N2 + 1)) * sumRanksSq - 3 * (N2 + 1);
+  const correction = 1 - tieTerm(pooled) / (N2 * N2 * N2 - N2);
   if (correction !== 0) H /= correction;
   const df = arrs.length - 1;
   return { statistic: H, pValue: 1 - chiSquaredCDF(H, df), df };
@@ -46002,8 +46002,8 @@ function fisherExact(table) {
   const r1 = a + b;
   const r2 = c + d;
   const c1 = a + c;
-  const N = a + b + c + d;
-  const logHyper = (k) => logChoose(r1, k) + logChoose(r2, c1 - k) - logChoose(N, c1);
+  const N2 = a + b + c + d;
+  const logHyper = (k) => logChoose(r1, k) + logChoose(r2, c1 - k) - logChoose(N2, c1);
   const logPObs = logHyper(a);
   const lo = Math.max(0, c1 - r2);
   const hi = Math.min(r1, c1);
@@ -46053,8 +46053,8 @@ function tukeyHSD(groups, alpha = 0.05) {
   const k = gs.length;
   if (k < 2) throw new Error("tukeyHSD: need at least 2 groups");
   const means = gs.map(mean3);
-  const N = gs.reduce((s, g) => s + g.length, 0);
-  const dfErr = N - k;
+  const N2 = gs.reduce((s, g) => s + g.length, 0);
+  const dfErr = N2 - k;
   if (dfErr <= 0)
     throw new Error("tukeyHSD: residual df must be > 0 (groups must hold more observations than groups)");
   const sse = gs.reduce((s, g) => s + sampleVar(g) * (g.length - 1), 0);
@@ -46103,9 +46103,9 @@ function triu(A, k = 0) {
 }
 function vander(x, n, increasing = false) {
   const v = arr3(x);
-  const N = n ?? v.length;
+  const N2 = n ?? v.length;
   return v.map(
-    (xi) => Array.from({ length: N }, (_, j) => Math.pow(xi, increasing ? j : N - 1 - j))
+    (xi) => Array.from({ length: N2 }, (_, j) => Math.pow(xi, increasing ? j : N2 - 1 - j))
   );
 }
 function toeplitz(c, r) {
@@ -47419,8 +47419,8 @@ function funm(A, f, fDerivs) {
     return out;
   }
   const { values } = eig3(A, { computeVectors: false });
-  const maxAbs = values.reduce((m, v) => Math.max(m, cAbs(v)), 0);
-  const tol = EIGENVALUE_DISTINCT_REL_TOL * Math.max(1, maxAbs);
+  const maxAbs2 = values.reduce((m, v) => Math.max(m, cAbs(v)), 0);
+  const tol = EIGENVALUE_DISTINCT_REL_TOL * Math.max(1, maxAbs2);
   const clusters = clusterEigenvalues(values, tol);
   if (clusters.length === n) {
     const F2 = cZeros(n);
@@ -47584,7 +47584,7 @@ function maxAbsDiff(A, B) {
     for (let j = 0; j < m; j++) d = Math.max(d, Math.abs(A[i][j] - B[i][j]));
   return d;
 }
-function sylvesterOperator(M, N) {
+function sylvesterOperator(M, N2) {
   const n = M.length;
   const n26 = n * n;
   const L = zeros3(n26, n26);
@@ -47595,7 +47595,7 @@ function sylvesterOperator(M, N) {
         const mip = M[i][p];
         if (mip === 0) continue;
         for (let q = 0; q < n; q++) {
-          L[row2][p * n + q] = mip * N[q][j];
+          L[row2][p * n + q] = mip * N2[q][j];
         }
       }
     }
@@ -47870,8 +47870,8 @@ function findSpan(n, p, u, U) {
   return mid;
 }
 function basisFuns(span, u, p, U) {
-  const N = new Array(p + 1);
-  N[0] = 1;
+  const N2 = new Array(p + 1);
+  N2[0] = 1;
   const left = new Array(p + 1);
   const right = new Array(p + 1);
   for (let j = 1; j <= p; j++) {
@@ -47879,13 +47879,13 @@ function basisFuns(span, u, p, U) {
     right[j] = U[span + j] - u;
     let saved = 0;
     for (let r = 0; r < j; r++) {
-      const temp = N[r] / (right[r + 1] + left[j - r]);
-      N[r] = saved + right[r + 1] * temp;
+      const temp = N2[r] / (right[r + 1] + left[j - r]);
+      N2[r] = saved + right[r + 1] * temp;
       saved = left[j - r] * temp;
     }
-    N[j] = saved;
+    N2[j] = saved;
   }
-  return N;
+  return N2;
 }
 function validateXY(x, y) {
   if (x.length !== y.length) throw new Error("bsplineFit: x and y must have the same length");
@@ -47898,8 +47898,8 @@ function buildDesignMatrix(x, t, k, numCoef) {
   const A = Array.from({ length: n }, () => new Array(numCoef).fill(0));
   for (let i = 0; i < n; i++) {
     const span = findSpan(numCoef - 1, k, x[i], t);
-    const N = basisFuns(span, x[i], k, t);
-    for (let j = 0; j <= k; j++) A[i][span - k + j] = N[j];
+    const N2 = basisFuns(span, x[i], k, t);
+    for (let j = 0; j <= k; j++) A[i][span - k + j] = N2[j];
   }
   return A;
 }
@@ -47948,9 +47948,9 @@ function bsplineEval(spline, xnew) {
   const nLast = c.length - 1;
   const evalOne = (x) => {
     const span = findSpan(nLast, k, x, t);
-    const N = basisFuns(span, x, k, t);
+    const N2 = basisFuns(span, x, k, t);
     let val = 0;
-    for (let j = 0; j <= k; j++) val += N[j] * c[span - k + j];
+    for (let j = 0; j <= k; j++) val += N2[j] * c[span - k + j];
     return val;
   };
   return Array.isArray(xnew) ? xnew.map(evalOne) : evalOne(xnew);
@@ -49758,18 +49758,18 @@ function analogToDigital(proto, Wn, btype) {
   ({ z, p, k } = bilinearZpk(z, p, k, fs));
   return zpkToTf(z, p, k);
 }
-function buttap(N) {
+function buttap(N2) {
   const p = [];
-  for (let k = 0; k < N; k++) {
-    const m = -N + 1 + 2 * k;
-    const theta = Math.PI * m / (2 * N);
+  for (let k = 0; k < N2; k++) {
+    const m = -N2 + 1 + 2 * k;
+    const theta = Math.PI * m / (2 * N2);
     p.push(new Complex11(-Math.cos(theta), -Math.sin(theta)));
   }
   return { z: [], p, k: 1 };
 }
-function butter(N, Wn, btype = "low") {
-  if (!Number.isInteger(N) || N < 1) throw new Error("butter: order N must be a positive integer");
-  return analogToDigital(buttap(N), Wn, btype);
+function butter(N2, Wn, btype = "low") {
+  if (!Number.isInteger(N2) || N2 < 1) throw new Error("butter: order N must be a positive integer");
+  return analogToDigital(buttap(N2), Wn, btype);
 }
 
 // src/signal/fft.ts
@@ -49981,39 +49981,39 @@ function jacobiDN(u, m) {
 
 // src/signal/iir-design.ts
 var arr8 = (x) => Array.isArray(x) ? x : Array.from(x);
-function cheb1ap(N, rp) {
+function cheb1ap(N2, rp) {
   const eps = Math.sqrt(Math.pow(10, 0.1 * rp) - 1);
-  const mu = 1 / N * Math.asinh(1 / eps);
+  const mu = 1 / N2 * Math.asinh(1 / eps);
   const p = [];
-  for (let m = -N + 1; m < N; m += 2) {
-    const theta = Math.PI * m / (2 * N);
+  for (let m = -N2 + 1; m < N2; m += 2) {
+    const theta = Math.PI * m / (2 * N2);
     p.push(new Complex12(-Math.sinh(mu) * Math.cos(theta), -Math.cosh(mu) * Math.sin(theta)));
   }
   let prod2 = new Complex12(1, 0);
   for (const pv of p) prod2 = cMul2(prod2, pv.negate());
   let k = prod2.re;
-  if (N % 2 === 0) k /= Math.sqrt(1 + eps * eps);
+  if (N2 % 2 === 0) k /= Math.sqrt(1 + eps * eps);
   return { z: [], p, k };
 }
-function cheby1(N, rp, Wn, btype = "low") {
-  if (!Number.isInteger(N) || N < 1) throw new Error("cheby1: order N must be a positive integer");
+function cheby1(N2, rp, Wn, btype = "low") {
+  if (!Number.isInteger(N2) || N2 < 1) throw new Error("cheby1: order N must be a positive integer");
   if (!(rp > 0)) throw new Error("cheby1: rp (passband ripple, dB) must be positive");
-  return analogToDigital(cheb1ap(N, rp), Wn, btype);
+  return analogToDigital(cheb1ap(N2, rp), Wn, btype);
 }
-function cheb2ap(N, rs) {
+function cheb2ap(N2, rs) {
   const de = 1 / Math.sqrt(Math.pow(10, 0.1 * rs) - 1);
-  const mu = Math.asinh(1 / de) / N;
+  const mu = Math.asinh(1 / de) / N2;
   const mVals = [];
-  if (N % 2) {
-    for (let m = -N + 1; m < 0; m += 2) mVals.push(m);
-    for (let m = 2; m < N; m += 2) mVals.push(m);
+  if (N2 % 2) {
+    for (let m = -N2 + 1; m < 0; m += 2) mVals.push(m);
+    for (let m = 2; m < N2; m += 2) mVals.push(m);
   } else {
-    for (let m = -N + 1; m < N; m += 2) mVals.push(m);
+    for (let m = -N2 + 1; m < N2; m += 2) mVals.push(m);
   }
-  const z = mVals.map((m) => new Complex12(0, 1 / Math.sin(m * Math.PI / (2 * N))));
+  const z = mVals.map((m) => new Complex12(0, 1 / Math.sin(m * Math.PI / (2 * N2))));
   const p = [];
-  for (let m = -N + 1; m < N; m += 2) {
-    const theta = Math.PI * m / (2 * N);
+  for (let m = -N2 + 1; m < N2; m += 2) {
+    const theta = Math.PI * m / (2 * N2);
     const s = new Complex12(Math.sinh(mu) * Math.cos(theta), Math.cosh(mu) * Math.sin(theta));
     p.push(cDiv2(new Complex12(1, 0), s).negate());
   }
@@ -50024,17 +50024,17 @@ function cheb2ap(N, rs) {
   const k = cDiv2(prodP, prodZ).re;
   return { z, p, k };
 }
-function cheby2(N, rs, Wn, btype = "low") {
-  if (!Number.isInteger(N) || N < 1) throw new Error("cheby2: order N must be a positive integer");
+function cheby2(N2, rs, Wn, btype = "low") {
+  if (!Number.isInteger(N2) || N2 < 1) throw new Error("cheby2: order N must be a positive integer");
   if (!(rs > 0)) throw new Error("cheby2: rs (stopband attenuation, dB) must be positive");
-  return analogToDigital(cheb2ap(N, rs), Wn, btype);
+  return analogToDigital(cheb2ap(N2, rs), Wn, btype);
 }
 var ELLIPDEG_MMAX = 7;
-function ellipdeg(N, m1) {
+function ellipdeg(N2, m1) {
   const K1 = ellipticKScalar(m1);
   const K1p = ellipticKScalar(1 - m1);
   const q1 = Math.exp(-Math.PI * K1p / K1);
-  const q = Math.pow(q1, 1 / N);
+  const q = Math.pow(q1, 1 / N2);
   let num2 = 0;
   for (let i = 0; i <= ELLIPDEG_MMAX; i++) num2 += Math.pow(q, i * (i + 1));
   let den = 1;
@@ -50085,8 +50085,8 @@ function arcJacSc1(w, m) {
     throw new Error("ellip: elliptic filter design failed to converge (arcJacSc1)");
   return z.im;
 }
-function ellipap(N, rp, rs) {
-  if (N === 1) {
+function ellipap(N2, rp, rs) {
+  if (N2 === 1) {
     const p = -Math.sqrt(1 / (Math.pow(10, 0.1 * rp) - 1));
     return { z: [], p: [new Complex12(p, 0)], k: -p };
   }
@@ -50095,16 +50095,16 @@ function ellipap(N, rp, rs) {
   const ck1Sq = epsSq / (Math.pow(10, 0.1 * rs) - 1);
   if (ck1Sq <= 0) throw new Error("ellip: cannot design a filter with the given rp/rs");
   const val0 = ellipticKScalar(ck1Sq);
-  const m = ellipdeg(N, ck1Sq);
+  const m = ellipdeg(N2, ck1Sq);
   const capk = ellipticKScalar(m);
   const j = [];
-  for (let v = 1 - N % 2; v < N; v += 2) j.push(v);
+  for (let v = 1 - N2 % 2; v < N2; v += 2) j.push(v);
   const EPSILON = 2e-16;
   const s = [];
   const c = [];
   const d = [];
   for (const jv of j) {
-    const u = jv * capk / N;
+    const u = jv * capk / N2;
     s.push(jacobiSN(u, m));
     c.push(jacobiCN(u, m));
     d.push(jacobiDN(u, m));
@@ -50115,7 +50115,7 @@ function ellipap(N, rp, rs) {
   }
   const zFull = zHalf.concat(zHalf.map((zv) => new Complex12(zv.re, -zv.im)));
   const rr = arcJacSc1(1 / eps, ck1Sq);
-  const v0 = capk * rr / (N * val0);
+  const v0 = capk * rr / (N2 * val0);
   const sv = jacobiSN(v0, 1 - m);
   const cv = jacobiCN(v0, 1 - m);
   const dv = jacobiDN(v0, 1 - m);
@@ -50126,7 +50126,7 @@ function ellipap(N, rp, rs) {
     pHalf.push(new Complex12(num2.re / den, num2.im / den));
   }
   let pFull;
-  if (N % 2) {
+  if (N2 % 2) {
     const sumP2 = pHalf.reduce((acc, pv) => acc + pv.re * pv.re + pv.im * pv.im, 0);
     const thresh = EPSILON * Math.sqrt(sumP2);
     const newp = pHalf.filter((pv) => Math.abs(pv.im) > thresh);
@@ -50139,14 +50139,14 @@ function ellipap(N, rp, rs) {
   let prodZ = new Complex12(1, 0);
   for (const zv of zFull) prodZ = cMul2(prodZ, zv.negate());
   let k = cDiv2(prodP, prodZ).re;
-  if (N % 2 === 0) k /= Math.sqrt(1 + epsSq);
+  if (N2 % 2 === 0) k /= Math.sqrt(1 + epsSq);
   return { z: zFull, p: pFull, k };
 }
-function ellip(N, rp, rs, Wn, btype = "low") {
-  if (!Number.isInteger(N) || N < 1) throw new Error("ellip: order N must be a positive integer");
+function ellip(N2, rp, rs, Wn, btype = "low") {
+  if (!Number.isInteger(N2) || N2 < 1) throw new Error("ellip: order N must be a positive integer");
   if (!(rp > 0)) throw new Error("ellip: rp (passband ripple, dB) must be positive");
   if (!(rs > 0)) throw new Error("ellip: rs (stopband attenuation, dB) must be positive");
-  return analogToDigital(ellipap(N, rp, rs), Wn, btype);
+  return analogToDigital(ellipap(N2, rp, rs), Wn, btype);
 }
 function polyMul2(p, q) {
   const res = new Array(p.length + q.length - 1).fill(0);
@@ -50174,7 +50174,7 @@ function bilinear(bIn, aIn, fs) {
   const aTrim = trimLeadingZeros(arr8(aIn));
   const Q2 = bTrim.length - 1;
   const P2 = aTrim.length - 1;
-  const N = Math.max(P2, Q2);
+  const N2 = Math.max(P2, Q2);
   const kappa = 2 * fs;
   const zp1 = [1, 1];
   const zm1 = [-kappa, kappa];
@@ -50183,7 +50183,7 @@ function bilinear(bIn, aIn, fs) {
     const bq = bTrim[Q2 - q];
     numerator = polyAdd2(
       numerator,
-      polyMul2(polyPow2(zp1, N - q), polyPow2(zm1, q)).map((v) => v * bq)
+      polyMul2(polyPow2(zp1, N2 - q), polyPow2(zm1, q)).map((v) => v * bq)
     );
   }
   let denominator = [0];
@@ -50191,7 +50191,7 @@ function bilinear(bIn, aIn, fs) {
     const ap = aTrim[P2 - p];
     denominator = polyAdd2(
       denominator,
-      polyMul2(polyPow2(zp1, N - p), polyPow2(zm1, p)).map((v) => v * ap)
+      polyMul2(polyPow2(zp1, N2 - p), polyPow2(zm1, p)).map((v) => v * ap)
     );
   }
   const bDesc = numerator.slice().reverse();
@@ -50332,23 +50332,23 @@ function buttord(wp, ws, gpass, gstop) {
     const nat1 = (stopb[1] * stopb[1] - passb[0] * passb[1]) / (stopb[1] * (passb[0] - passb[1]));
     nat = Math.min(Math.abs(nat0), Math.abs(nat1));
   }
-  const N = Math.ceil(Math.log10((GSTOP - 1) / (GPASS - 1)) / (2 * Math.log10(nat)));
-  const W0 = Math.pow(GPASS - 1, -1 / (2 * N));
+  const N2 = Math.ceil(Math.log10((GSTOP - 1) / (GPASS - 1)) / (2 * Math.log10(nat)));
+  const W0 = Math.pow(GPASS - 1, -1 / (2 * N2));
   const toDigital = (WN) => Math.atan(WN) * 2 / Math.PI;
-  if (filterType === 1) return { N, Wn: toDigital(W0 * passb[0]) };
-  if (filterType === 2) return { N, Wn: toDigital(passb[0] / W0) };
+  if (filterType === 1) return { N: N2, Wn: toDigital(W0 * passb[0]) };
+  if (filterType === 2) return { N: N2, Wn: toDigital(passb[0] / W0) };
   if (filterType === 3) {
     const discr = Math.sqrt(Math.pow(passb[1] - passb[0], 2) + 4 * W0 * W0 * passb[0] * passb[1]);
     const wn0 = (passb[1] - passb[0] + discr) / (2 * W0);
     const wn1 = (passb[1] - passb[0] - discr) / (2 * W0);
     const sorted2 = [Math.abs(wn0), Math.abs(wn1)].sort((x, y) => x - y);
-    return { N, Wn: [toDigital(sorted2[0]), toDigital(sorted2[1])] };
+    return { N: N2, Wn: [toDigital(sorted2[0]), toDigital(sorted2[1])] };
   }
   const w0s = [-W0, W0].map(
     (s) => -s * ((passb[1] - passb[0]) / 2) + Math.sqrt(s * s / 4 * Math.pow(passb[1] - passb[0], 2) + passb[0] * passb[1])
   );
   const sorted = w0s.map(Math.abs).sort((x, y) => x - y);
-  return { N, Wn: [toDigital(sorted[0]), toDigital(sorted[1])] };
+  return { N: N2, Wn: [toDigital(sorted[0]), toDigital(sorted[1])] };
 }
 function toComplex(x) {
   return x instanceof Complex12 ? x : new Complex12(x, 0);
@@ -51091,13 +51091,13 @@ function savgol(x, windowLength, polyorder) {
 function deconvolve(signal, divisor) {
   const s = arr9(signal);
   const d = arr9(divisor);
-  const N = s.length;
+  const N2 = s.length;
   const D = d.length;
   if (D === 0) throw new Error("deconvolve: divisor must be non-empty");
   if (d[0] === 0) throw new Error("deconvolve: divisor[0] (leading coefficient) must be nonzero");
-  if (D > N) return { quotient: [], remainder: s.slice() };
+  if (D > N2) return { quotient: [], remainder: s.slice() };
   const remainder = s.slice();
-  const quotient = new Array(N - D + 1).fill(0);
+  const quotient = new Array(N2 - D + 1).fill(0);
   for (let i = 0; i < quotient.length; i++) {
     const c = remainder[i] / d[0];
     quotient[i] = c;
@@ -52068,6 +52068,177 @@ function sphericalVoronoi(points, radius = 1, center3 = [0, 0, 0]) {
   return { vertices, regions, areas };
 }
 
+// src/geometry/halfspace-intersection.ts
+var STRICT_INTERIOR_REL = 1e-12;
+var BOUNDED_REL = 1e-9;
+var TIGHT_REL = 1e-9;
+var DEDUP_SIG = 9;
+var SINGULAR_REL = 1e-12;
+function maxAbs(points) {
+  let m = 0;
+  for (const p of points) {
+    for (const x of p) {
+      const a = Math.abs(x);
+      if (a > m) m = a;
+    }
+  }
+  return m;
+}
+function rowNorm(row2) {
+  let s = 0;
+  for (const x of row2) s += x * x;
+  return Math.sqrt(s);
+}
+function isSingular(det2, a) {
+  let bound = 1;
+  for (const row2 of a) bound *= rowNorm(row2);
+  return bound === 0 || Math.abs(det2) <= SINGULAR_REL * bound;
+}
+function solve2(a, c) {
+  const det2 = a[0][0] * a[1][1] - a[0][1] * a[1][0];
+  if (isSingular(det2, a)) return null;
+  return [(c[0] * a[1][1] - c[1] * a[0][1]) / det2, (a[0][0] * c[1] - a[1][0] * c[0]) / det2];
+}
+function solve3(a, c) {
+  const det2 = a[0][0] * (a[1][1] * a[2][2] - a[1][2] * a[2][1]) - a[0][1] * (a[1][0] * a[2][2] - a[1][2] * a[2][0]) + a[0][2] * (a[1][0] * a[2][1] - a[1][1] * a[2][0]);
+  if (isSingular(det2, a)) return null;
+  const detFor = (col) => {
+    const m = a.map((row2, i) => row2.map((v, j) => j === col ? c[i] : v));
+    return m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+  };
+  return [detFor(0) / det2, detFor(1) / det2, detFor(2) / det2];
+}
+function originStrictlyInside(dual, hull, dim) {
+  for (const simplex of hull.simplices) {
+    const p0 = dual[simplex[0]];
+    if (dim === 2) {
+      const p1 = dual[simplex[1]];
+      const ex = p1[0] - p0[0];
+      const ey = p1[1] - p0[1];
+      const edgeLen = Math.hypot(ex, ey);
+      if (edgeLen === 0) continue;
+      const dist = (ex * (0 - p0[1]) - ey * (0 - p0[0])) / edgeLen;
+      if (dist <= BOUNDED_REL) return false;
+    } else {
+      const p1 = dual[simplex[1]];
+      const p2 = dual[simplex[2]];
+      const ux = p1[0] - p0[0];
+      const uy = p1[1] - p0[1];
+      const uz = p1[2] - p0[2];
+      const vx = p2[0] - p0[0];
+      const vy = p2[1] - p0[1];
+      const vz = p2[2] - p0[2];
+      const nx = uy * vz - uz * vy;
+      const ny = uz * vx - ux * vz;
+      const nz = ux * vy - uy * vx;
+      const nLen = Math.hypot(nx, ny, nz);
+      if (nLen === 0) continue;
+      const dist = -(p0[0] * nx + p0[1] * ny + p0[2] * nz) / nLen;
+      if (dist >= -BOUNDED_REL) return false;
+    }
+  }
+  return true;
+}
+function halfspaceIntersection(halfspaces, interiorPoint) {
+  if (!Array.isArray(halfspaces) || halfspaces.length === 0) {
+    throw new Error("halfspaceIntersection: requires a non-empty array of halfspaces");
+  }
+  if (!Array.isArray(interiorPoint)) {
+    throw new Error("halfspaceIntersection: interiorPoint must be a coordinate array");
+  }
+  const dim = interiorPoint.length;
+  if (dim !== 2 && dim !== 3) {
+    throw new Error(
+      `halfspaceIntersection: only 2-D and 3-D polytopes are supported (got dimension ${dim}). The general n-D case requires an n-D convex hull or the double-description method, which is not yet implemented.`
+    );
+  }
+  for (const hs of halfspaces) {
+    if (!Array.isArray(hs) || hs.length !== dim + 1) {
+      throw new Error(
+        `halfspaceIntersection: each halfspace must be a row [a_1..a_${dim}, b] of length ${dim + 1}`
+      );
+    }
+  }
+  if (halfspaces.length < dim + 1) {
+    throw new Error(
+      `halfspaceIntersection: the polytope is unbounded \u2014 a bounded ${dim}-D polytope needs at least ${dim + 1} halfspaces (got ${halfspaces.length}); fewer cannot enclose a bounded region`
+    );
+  }
+  const offsets = [];
+  const offsetScales = [];
+  for (const hs of halfspaces) {
+    let s = hs[dim];
+    let mag = Math.abs(hs[dim]);
+    for (let j = 0; j < dim; j++) {
+      const term = hs[j] * interiorPoint[j];
+      s += term;
+      mag += Math.abs(term);
+    }
+    offsets.push(s);
+    offsetScales.push(mag);
+  }
+  for (let i = 0; i < offsets.length; i++) {
+    if (offsets[i] >= -STRICT_INTERIOR_REL * offsetScales[i]) {
+      throw new Error(
+        `halfspaceIntersection: interiorPoint is not strictly interior \u2014 halfspace ${i} gives a\xB7x\u2080 + b = ${offsets[i]} (must be < 0)`
+      );
+    }
+  }
+  const dual = halfspaces.map((hs, i) => {
+    const d = -offsets[i];
+    const y = new Array(dim);
+    for (let j = 0; j < dim; j++) y[j] = hs[j] / d;
+    return y;
+  });
+  const dualScale = maxAbs(dual);
+  const dualN = dualScale > 0 && Number.isFinite(dualScale) ? dual.map((y) => y.map((x) => x / dualScale)) : dual;
+  const hull = convexHull(dualN);
+  if (!originStrictlyInside(dualN, hull, dim)) {
+    throw new Error(
+      "halfspaceIntersection: the polytope is unbounded (the halfspace normals do not positively span the space); vertex enumeration requires a bounded polytope"
+    );
+  }
+  const candidates = [];
+  for (const simplex of hull.simplices) {
+    const aRows = simplex.map((idx) => halfspaces[idx].slice(0, dim));
+    const cVals = simplex.map((idx) => -halfspaces[idx][dim]);
+    const v = dim === 2 ? solve2(aRows, cVals) : solve3(aRows, cVals);
+    if (v === null) continue;
+    if (!v.every((x) => Number.isFinite(x))) continue;
+    candidates.push(v);
+  }
+  const vertScale = maxAbs(candidates);
+  const quantum = vertScale > 0 ? vertScale * Math.pow(10, -DEDUP_SIG) : 0;
+  const vertices = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of candidates) {
+    const key = quantum > 0 ? v.map((x) => Math.round(x / quantum)).join(",") : v.join(",");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    vertices.push(v);
+  }
+  if (dim === 2 && vertices.length > 2) {
+    const cx = vertices.reduce((s, v) => s + v[0], 0) / vertices.length;
+    const cy = vertices.reduce((s, v) => s + v[1], 0) / vertices.length;
+    vertices.sort((p, q) => Math.atan2(p[1] - cy, p[0] - cx) - Math.atan2(q[1] - cy, q[0] - cx));
+  }
+  const incidences = vertices.map((v) => {
+    const tight = [];
+    for (let i = 0; i < halfspaces.length; i++) {
+      let s = halfspaces[i][dim];
+      let mag = Math.abs(halfspaces[i][dim]);
+      for (let j = 0; j < dim; j++) {
+        const term = halfspaces[i][j] * v[j];
+        s += term;
+        mag += Math.abs(term);
+      }
+      if (Math.abs(s) <= TIGHT_REL * mag) tight.push(i);
+    }
+    return tight;
+  });
+  return { vertices, incidences };
+}
+
 // src/stats/inference-extra2.ts
 var TWO_PI = 2 * Math.PI;
 function noncentralChi2CDF(x, df, nc) {
@@ -52182,7 +52353,7 @@ function cochranQ(data) {
   if (k < 2) throw new Error("cochranQ: need at least 2 treatments (columns)");
   const colSums = new Array(k).fill(0);
   const rowSums = new Array(n).fill(0);
-  let N = 0;
+  let N2 = 0;
   for (let i = 0; i < n; i++) {
     if (data[i].length !== k) throw new Error("cochranQ: data must be rectangular");
     let rowSum = 0;
@@ -52191,15 +52362,15 @@ function cochranQ(data) {
       rowSum += data[i][j];
     }
     rowSums[i] = rowSum;
-    N += rowSum;
+    N2 += rowSum;
   }
   let sumC2 = 0;
   for (let j = 0; j < k; j++) sumC2 += colSums[j] * colSums[j];
   let sumR2 = 0;
   for (let i = 0; i < n; i++) sumR2 += rowSums[i] * rowSums[i];
   const dof = k - 1;
-  const denominator = k * N - sumR2;
-  const Q2 = denominator !== 0 ? dof * (k * sumC2 - N * N) / denominator : 0;
+  const denominator = k * N2 - sumR2;
+  const Q2 = denominator !== 0 ? dof * (k * sumC2 - N2 * N2) / denominator : 0;
   const pValue = 1 - chiSquaredCDF(Q2, dof);
   return { Q: Q2, pValue, dof };
 }
@@ -52682,6 +52853,106 @@ function coulombFG(L, eta, rho) {
   return coulombSteed(L, eta, rho);
 }
 
+// src/special/mathieu.ts
+import { eig as eig4 } from "@danielsimonjr/mathts-matrix";
+var N = 50;
+function harmonicsFor(cls) {
+  const h = new Int32Array(N);
+  for (let k = 0; k < N; k++) {
+    switch (cls) {
+      case "even-cos":
+        h[k] = 2 * k;
+        break;
+      case "odd-cos":
+      case "odd-sin":
+        h[k] = 2 * k + 1;
+        break;
+      case "even-sin":
+        h[k] = 2 * k + 2;
+        break;
+    }
+  }
+  return h;
+}
+function buildMatrix(cls, q) {
+  const A = Array.from({ length: N }, () => new Array(N).fill(0));
+  const h = harmonicsFor(cls);
+  for (let k = 0; k < N; k++) A[k][k] = h[k] * h[k];
+  if (cls === "odd-cos") A[0][0] = 1 + q;
+  else if (cls === "odd-sin") A[0][0] = 1 - q;
+  for (let k = 0; k < N - 1; k++) {
+    const off = cls === "even-cos" && k === 0 ? q * Math.SQRT2 : q;
+    A[k][k + 1] = off;
+    A[k + 1][k] = off;
+  }
+  return A;
+}
+var modeCache = /* @__PURE__ */ new Map();
+function solveClass(cls, q) {
+  const key = `${cls}:${q}`;
+  const cached = modeCache.get(key);
+  if (cached) return cached;
+  const harmonics = harmonicsFor(cls);
+  const { values, vectors } = eig4(buildMatrix(cls, q));
+  const order = values.map((_, i) => i).sort((i, j) => values[i].re - values[j].re);
+  const modes = order.map((idx, m) => {
+    const g = vectors[idx];
+    const coeffs = new Float64Array(N);
+    if (cls === "even-cos") {
+      coeffs[0] = g[0];
+      for (let k = 1; k < N; k++) coeffs[k] = Math.SQRT2 * g[k];
+    } else {
+      for (let k = 0; k < N; k++) coeffs[k] = g[k];
+    }
+    let norm28 = 0;
+    for (let k = 0; k < N; k++) {
+      const w = cls === "even-cos" && k === 0 ? 2 : 1;
+      norm28 += w * coeffs[k] * coeffs[k];
+    }
+    const scale4 = 1 / Math.sqrt(norm28);
+    const sign3 = coeffs[m] < 0 ? -scale4 : scale4;
+    for (let k = 0; k < N; k++) coeffs[k] *= sign3;
+    return { a: values[idx].re, coeffs, harmonics };
+  });
+  modeCache.set(key, modes);
+  return modes;
+}
+function checkOrder(n, min2, name254) {
+  if (!Number.isInteger(n) || n < min2) {
+    throw new Error(`${name254}: order n must be an integer \u2265 ${min2}, got ${n}`);
+  }
+}
+function mathieuA(n, q) {
+  checkOrder(n, 0, "mathieuA");
+  const cls = n % 2 === 0 ? "even-cos" : "odd-cos";
+  const m = Math.floor(n / 2);
+  return solveClass(cls, q)[m].a;
+}
+function mathieuB(n, q) {
+  checkOrder(n, 1, "mathieuB");
+  const cls = n % 2 === 0 ? "even-sin" : "odd-sin";
+  const m = Math.floor((n - (n % 2 === 0 ? 2 : 1)) / 2);
+  return solveClass(cls, q)[m].a;
+}
+function evalSeries(mode2, x, basis) {
+  let s = 0;
+  const { coeffs, harmonics } = mode2;
+  for (let k = 0; k < N; k++) s += coeffs[k] * basis(harmonics[k] * x);
+  return s;
+}
+function mathieuCe(n, q, x) {
+  checkOrder(n, 0, "mathieuCe");
+  const cls = n % 2 === 0 ? "even-cos" : "odd-cos";
+  const m = Math.floor(n / 2);
+  return evalSeries(solveClass(cls, q)[m], x, Math.cos);
+}
+function mathieuSe(n, q, x) {
+  checkOrder(n, 1, "mathieuSe");
+  const cls = n % 2 === 0 ? "even-sin" : "odd-sin";
+  const m = Math.floor((n - (n % 2 === 0 ? 2 : 1)) / 2);
+  return evalSeries(solveClass(cls, q)[m], x, Math.sin);
+}
+
 // src/graph/traversal-centrality.ts
 function bfs(adj, start) {
   const n = adj.length;
@@ -53143,8 +53414,8 @@ var Interval = class {
     if (this.hi <= 0) {
       return outward(this.hi ** n, this.lo ** n);
     }
-    const maxAbs = Math.max(Math.abs(this.lo), Math.abs(this.hi));
-    return outward(0, maxAbs ** n);
+    const maxAbs2 = Math.max(Math.abs(this.lo), Math.abs(this.hi));
+    return outward(0, maxAbs2 ** n);
   }
 };
 function interval(lo, hi) {
@@ -54346,6 +54617,7 @@ export {
   groebnerBasis,
   groupDelay,
   gumbelDist,
+  halfspaceIntersection,
   halley,
   harmonicCentrality,
   harmonicNumber,
@@ -54512,6 +54784,10 @@ export {
   mannWhitneyTest,
   map2 as map,
   mapSlices,
+  mathieuA,
+  mathieuB,
+  mathieuCe,
+  mathieuSe,
   matmul,
   matrix,
   matrixExpm,