@danielsimonjr/mathts-functions 0.54.0 → 0.56.0

package/dist/index.js

@@ -440,6 +440,7 @@ __export(typed_exports, {
   smallerEq: () => smallerEq,
   solveBVP: () => solveBVP,
   solveDAE: () => solveDAE,
+  solveDDE: () => solveDDE,
   solveODESystem: () => solveODESystem,
   solvePDE: () => solvePDE,
   solveParabolicPDE: () => solveParabolicPDE,
@@ -3917,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];
@@ -3950,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];
@@ -4188,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);
@@ -4206,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);
@@ -4235,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);
@@ -4264,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);
@@ -4293,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;
   }
@@ -4445,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);
@@ -4470,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];
@@ -10399,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) {
@@ -10500,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)) {
@@ -13507,6 +13508,172 @@ function solveDAE(f, g, tspan, y0, z0, options = {}) {
   };
 }
 
+// src/numeric/solveDDE.ts
+function _arr2(v) {
+  return Array.isArray(v) ? v.slice() : [v];
+}
+function _hermite2(ta, tb, ya, yb, fa, fb, t) {
+  const h = tb - ta;
+  const theta = h === 0 ? 0 : (t - ta) / h;
+  const th2 = theta * theta;
+  const th3 = th2 * theta;
+  const h00 = 2 * th3 - 3 * th2 + 1;
+  const h10 = th3 - 2 * th2 + theta;
+  const h01 = -2 * th3 + 3 * th2;
+  const h11 = th3 - th2;
+  return ya.map((_, i) => h00 * ya[i] + h10 * h * fa[i] + h01 * yb[i] + h11 * h * fb[i]);
+}
+function _wrms2(v, scale4) {
+  let s = 0;
+  for (let i = 0; i < v.length; i++) {
+    const q = v[i] / scale4[i];
+    s += q * q;
+  }
+  return Math.sqrt(s / v.length);
+}
+var _BS23_B = [2 / 9, 1 / 3, 4 / 9, 0];
+var _BS23_BP = [7 / 24, 1 / 4, 1 / 3, 1 / 8];
+var _BS23_DB = _BS23_B.map((b, i) => b - _BS23_BP[i]);
+function solveDDE(f, tspan, history, delays, options = {}) {
+  const t0 = tspan[0];
+  const tf = tspan[1];
+  if (!(typeof t0 === "number" && typeof tf === "number")) {
+    throw new Error("solveDDE: tspan must be [t0, T] numbers");
+  }
+  if (!(tf > t0)) {
+    throw new Error("solveDDE: require T > t0 (forward integration)");
+  }
+  if (!Array.isArray(delays) || delays.length === 0) {
+    throw new Error("solveDDE: at least one delay \u03C4 must be given");
+  }
+  if (!delays.every((d) => typeof d === "number" && d > 0)) {
+    throw new Error("solveDDE: every delay \u03C4 must be a positive number");
+  }
+  const histFn = typeof history === "function" ? (s) => _arr2(history(s)) : () => _arr2(history);
+  const y0raw = typeof history === "function" ? history(t0) : history;
+  const yScalar = !Array.isArray(y0raw);
+  const y0 = _arr2(y0raw);
+  const n = y0.length;
+  const minTau = Math.min(...delays);
+  const rtol = options.tol ?? 1e-6;
+  const atol = options.atol ?? rtol * 1e-3;
+  const maxIter = options.maxIter ?? 1e5;
+  const maxStep = options.maxStep ?? Infinity;
+  const minStepOpt = options.minStep ?? 0;
+  const Ts = [t0];
+  const Ys = [y0.slice()];
+  const Fs = [];
+  function _locate(s) {
+    let lo = 0;
+    let hi = Ts.length - 1;
+    if (s <= Ts[0]) return 0;
+    if (s >= Ts[hi]) return hi - 1;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (Ts[mid] <= s) lo = mid;
+      else hi = mid;
+    }
+    return lo;
+  }
+  function delayedState(s) {
+    if (s <= t0) return histFn(s);
+    const i = _locate(s);
+    return _hermite2(Ts[i], Ts[i + 1], Ys[i], Ys[i + 1], Fs[i], Fs[i + 1], s);
+  }
+  function fEval(t2, y2) {
+    const yd = delays.map((tau2) => delayedState(t2 - tau2));
+    const r = f(t2, y2, yd);
+    const out = Array.isArray(r) ? r : [r];
+    if (out.length !== n) {
+      throw new Error(
+        `solveDDE: f must return ${n} value(s) (matching the state); got ${out.length}`
+      );
+    }
+    return out;
+  }
+  function nextBreakpoint(t2) {
+    let best = Infinity;
+    for (const tau2 of delays) {
+      let m = Math.floor((t2 - t0) / tau2) + 1;
+      let cand = t0 + m * tau2;
+      while (cand <= t2 + 1e-12 * Math.max(1, Math.abs(t2))) {
+        m += 1;
+        cand = t0 + m * tau2;
+      }
+      if (cand < best) best = cand;
+    }
+    return best;
+  }
+  Fs[0] = fEval(t0, y0);
+  const rms = (v) => Math.sqrt(v.reduce((a, x) => a + x * x, 0) / Math.max(1, v.length));
+  let h;
+  if (options.firstStep !== void 0) {
+    h = Math.abs(options.firstStep);
+  } else {
+    const d0 = rms(y0);
+    const d1 = rms(Fs[0]);
+    h = d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1);
+  }
+  h = Math.min(h, minTau, maxStep, tf - t0);
+  let t = t0;
+  let y = y0.slice();
+  let f0 = Fs[0];
+  let iter = 0;
+  while (t < tf && iter < maxIter) {
+    iter += 1;
+    const nb = nextBreakpoint(t);
+    let hmax = Math.min(minTau, maxStep, tf - t);
+    if (nb < tf) hmax = Math.min(hmax, nb - t);
+    if (h > hmax) h = hmax;
+    const minStep = Math.max(minStepOpt, 1e-13 * Math.max(1, Math.abs(t)));
+    if (h < minStep) h = Math.min(minStep, hmax);
+    const k1 = f0;
+    const k2 = fEval(
+      t + 0.5 * h,
+      y.map((yi, i) => yi + 0.5 * h * k1[i])
+    );
+    const k3 = fEval(
+      t + 0.75 * h,
+      y.map((yi, i) => yi + 0.75 * h * k2[i])
+    );
+    const yNew = y.map(
+      (yi, i) => yi + h * (_BS23_B[0] * k1[i] + _BS23_B[1] * k2[i] + _BS23_B[2] * k3[i])
+    );
+    const k4 = fEval(t + h, yNew);
+    const scale4 = y.map((yi, i) => atol + rtol * Math.max(Math.abs(yi), Math.abs(yNew[i])));
+    const err = yNew.map(
+      (_, i) => h * (_BS23_DB[0] * k1[i] + _BS23_DB[1] * k2[i] + _BS23_DB[2] * k3[i] + _BS23_DB[3] * k4[i])
+    );
+    const errNorm = _wrms2(err, scale4);
+    if (errNorm <= 1 || h <= minStep) {
+      t += h;
+      y = yNew;
+      f0 = k4;
+      Ts.push(t);
+      Ys.push(y.slice());
+      Fs.push(f0);
+    }
+    const factor2 = errNorm === 0 ? 5 : 0.9 * Math.pow(errNorm, -1 / 3);
+    h *= Math.min(5, Math.max(0.2, factor2));
+  }
+  if (iter >= maxIter) {
+    throw new Error(
+      "solveDDE: maximum number of steps reached \u2014 try loosening tol or raising maxIter"
+    );
+  }
+  const yInterp = (tq) => {
+    const s = tq <= t0 ? t0 : tq >= t ? t : tq;
+    const i = _locate(s);
+    const val = _hermite2(Ts[i], Ts[i + 1], Ys[i], Ys[i + 1], Fs[i], Fs[i + 1], s);
+    return yScalar ? val[0] : val;
+  };
+  return {
+    t: Ts,
+    y: yScalar ? Ys.map((v) => v[0]) : Ys,
+    yInterp
+  };
+}
+
 // src/typed/numeric.ts
 var NUMERIC_WASM_THRESHOLD = 16;
 function findRoot(f, a, b, opts) {
@@ -16851,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;
@@ -16866,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,
@@ -17534,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;
@@ -17558,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;
@@ -18089,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);
@@ -18108,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;
@@ -18129,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 };
 }
@@ -22952,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;
@@ -22971,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;
@@ -23988,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]);
         }
       }
@@ -24057,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));
@@ -38086,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,
@@ -38109,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) {
@@ -38135,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;
@@ -38154,15 +38321,15 @@ 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++) {
+        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]));
@@ -38187,7 +38354,7 @@ function createComplexEigs({
           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;
               }
@@ -38203,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;
@@ -38227,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;
@@ -38238,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;
@@ -38266,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) {
@@ -38290,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));
@@ -38323,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));
@@ -38350,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";
@@ -38373,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(
@@ -38384,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;
         }
@@ -38439,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) {
@@ -38474,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 {
@@ -38505,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));
     }
@@ -38591,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,
@@ -38612,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) {
@@ -38623,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],
@@ -38648,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;
       }
     }
@@ -38667,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);
       }
     }
@@ -38694,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);
@@ -38720,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),
@@ -38769,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]));
     }
@@ -38777,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];
@@ -38788,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];
     }
@@ -38805,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];
@@ -38816,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];
@@ -38830,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];
@@ -38844,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++) {
@@ -38864,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);
         }
@@ -39053,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;
           }
@@ -39080,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;
           }
@@ -39090,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;
@@ -39105,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;
@@ -39123,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]);
           }
         }
@@ -43418,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") {
@@ -43437,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;
 }
@@ -43768,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);
   }
@@ -43781,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);
@@ -45231,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;
@@ -45787,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;
@@ -45797,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 };
@@ -45835,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);
@@ -45886,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);
@@ -45936,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) {
@@ -47417,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);
@@ -47428,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];
         }
       }
     }
@@ -47703,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++) {
@@ -47712,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");
@@ -47731,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;
 }
@@ -47781,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);
@@ -49591,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
@@ -49814,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());
   }
@@ -49857,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;
@@ -49918,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 };
   }
@@ -49928,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));
@@ -49948,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);
@@ -49959,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);
@@ -49972,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);
@@ -50007,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];
@@ -50016,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];
@@ -50024,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();
@@ -50165,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);
@@ -50924,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;
@@ -52015,7 +52182,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;
@@ -52024,15 +52191,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 };
 }
@@ -52515,6 +52682,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;
@@ -54345,6 +54612,10 @@ export {
   mannWhitneyTest,
   map2 as map,
   mapSlices,
+  mathieuA,
+  mathieuB,
+  mathieuCe,
+  mathieuSe,
   matmul,
   matrix,
   matrixExpm,
@@ -54641,6 +54912,7 @@ export {
   solveBVP,
   solveBanded,
   solveDAE,
+  solveDDE,
   solveODE,
   solveODESystem,
   solvePDE,