@danielsimonjr/mathts-functions 0.38.0 → 0.39.0

package/dist/index.js

@@ -3636,9 +3636,9 @@ function applyWindowDispatch(samples, windowName) {
   const wasm = getWasm();
   if (wasm && isAsWasm(wasm)) {
     try {
-      const out = withAsF64(wasm, [samples], (mod2, [h]) => {
-        mod2["apply_window_f64"](h, wt);
-        return asReadReturnedF64(mod2, h);
+      const out = withAsF64(wasm, [samples], (mod3, [h]) => {
+        mod3["apply_window_f64"](h, wt);
+        return asReadReturnedF64(mod3, h);
       });
       if (out && out.length === samples.length) {
         samples.set(out);
@@ -3659,9 +3659,9 @@ function welchPSDDispatch(samples, frameLength, overlap, windowName) {
         const out = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => asReadReturnedF64(
-            mod2,
-            mod2["welch_psd_f64"](
+          (mod3, [h]) => asReadReturnedF64(
+            mod3,
+            mod3["welch_psd_f64"](
               h,
               frameLength,
               overlap,
@@ -3685,9 +3685,9 @@ function bartlettPSDDispatch(samples, frameLength) {
         const out = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => asReadReturnedF64(
-            mod2,
-            mod2["bartlett_psd_f64"](h, frameLength)
+          (mod3, [h]) => asReadReturnedF64(
+            mod3,
+            mod3["bartlett_psd_f64"](h, frameLength)
           )
         );
         if (out && out.length > 0) return out;
@@ -3706,7 +3706,7 @@ function goertzelDispatch(samples, targetFreq, sampleRate) {
         const r = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => mod2["goertzel_f64"](
+          (mod3, [h]) => mod3["goertzel_f64"](
             h,
             targetFreq,
             sampleRate
@@ -3728,9 +3728,9 @@ function chirpZTransformDispatch(samples, m, phiStartRe, phiStartIm, phiStepRe,
         const interleaved = withAsF64(
           wasm,
           [samples],
-          (mod2, [h]) => asReadReturnedF64(
-            mod2,
-            mod2["chirp_z_transform_f64"](h, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm)
+          (mod3, [h]) => asReadReturnedF64(
+            mod3,
+            mod3["chirp_z_transform_f64"](h, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm)
           )
         );
         if (interleaved && interleaved.length === 2 * m) {
@@ -3749,6 +3749,139 @@ function chirpZTransformDispatch(samples, m, phiStartRe, phiStartIm, phiStepRe,
   return chirpZTransformJS(samples, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm);
 }
 
+// src/signal/wavelet-filters.ts
+var DEC_LO_TABLE = {
+  haar: [0.7071067811865476, 0.7071067811865476],
+  db1: [0.7071067811865476, 0.7071067811865476],
+  db2: [-0.12940952255126037, 0.2241438680420134, 0.8365163037378079, 0.48296291314453416],
+  db3: [
+    0.03522629188570953,
+    -0.08544127388202666,
+    -0.13501102001025458,
+    0.45987750211849154,
+    0.8068915093110925,
+    0.33267055295008263
+  ],
+  db4: [
+    -0.010597401785069032,
+    0.0328830116668852,
+    0.030841381835560764,
+    -0.18703481171909309,
+    -0.027983769416859854,
+    0.6308807679298589,
+    0.7148465705529157,
+    0.2303778133088965
+  ],
+  sym2: [-0.12940952255092145, 0.22414386804185735, 0.836516303737469, 0.48296291314469025],
+  sym3: [
+    0.035226291882100656,
+    -0.08544127388224149,
+    -0.13501102001039084,
+    0.4598775021193313,
+    0.8068915093133388,
+    0.3326705529509569
+  ],
+  sym4: [
+    -0.07576571478927333,
+    -0.02963552764599851,
+    0.49761866763201545,
+    0.8037387518059161,
+    0.29785779560527736,
+    -0.09921954357684722,
+    -0.012603967262037833,
+    0.0322231006040427
+  ],
+  coif1: [
+    -0.015655728135791993,
+    -0.07273261951252645,
+    0.3848648468648578,
+    0.8525720202116004,
+    0.3378976624574818,
+    -0.07273261951252645
+  ],
+  coif2: [
+    -720549445520347e-18,
+    -0.0018232088709110323,
+    0.005611434819368834,
+    0.02368017194684777,
+    -0.05943441864643109,
+    -0.07648859907828076,
+    0.4170051844232391,
+    0.8127236354494135,
+    0.3861100668227629,
+    -0.0673725547237256,
+    -0.04146493678687178,
+    0.01638733646320364
+  ]
+};
+var SUPPORTED_WAVELETS = Object.keys(DEC_LO_TABLE);
+function getWaveletFilters(wavelet) {
+  const decLo = DEC_LO_TABLE[wavelet];
+  if (!decLo) {
+    throw new Error(
+      `unsupported wavelet "${wavelet}". Supported families: ${SUPPORTED_WAVELETS.join(", ")}`
+    );
+  }
+  const L = decLo.length;
+  const decHi = new Array(L);
+  for (let k = 0; k < L; k++) {
+    decHi[k] = (k % 2 === 0 ? -1 : 1) * decLo[L - 1 - k];
+  }
+  const recLo = decLo.slice().reverse();
+  const recHi = decHi.slice().reverse();
+  return { decLo, decHi, recLo, recHi };
+}
+function mod2(a, m) {
+  const r = a % m;
+  return r < 0 ? r + m : r;
+}
+function dwtPeriodization(x, wavelet) {
+  const n = x.length;
+  if (n < 2) throw new Error("signal must have at least 2 samples");
+  const { decLo, decHi } = getWaveletFilters(wavelet);
+  const L = decLo.length;
+  const offset = Math.floor(L / 2);
+  const half = Math.ceil(n / 2);
+  const approx = new Array(half);
+  const detail = new Array(half);
+  for (let i = 0; i < half; i++) {
+    let sa = 0;
+    let sd = 0;
+    for (let k = 0; k < L; k++) {
+      const idx = mod2(2 * i - k + offset, n);
+      const xi = x[idx];
+      sa += decLo[k] * xi;
+      sd += decHi[k] * xi;
+    }
+    approx[i] = sa;
+    detail[i] = sd;
+  }
+  return { approx, detail };
+}
+function idwtPeriodization(approx, detail, wavelet) {
+  if (approx.length !== detail.length) {
+    throw new Error("approx and detail must have equal length");
+  }
+  const { recLo, recHi } = getWaveletFilters(wavelet);
+  const half = approx.length;
+  const n = half * 2;
+  const L = recLo.length;
+  const shift = Math.floor(L / 2) - 1;
+  const x = new Array(n);
+  for (let m = 0; m < n; m++) {
+    let s = 0;
+    for (let k = 0; k < L; k++) {
+      const idx = mod2(m - k + shift, n);
+      if (idx % 2 === 0) {
+        const j = idx / 2;
+        s += recLo[k] * approx[j] + recHi[k] * detail[j];
+      }
+    }
+    x[m] = s;
+  }
+  return x;
+}
+
 // src/typed/signal.ts
 var WASM_THRESHOLD = 64;
 function isPowerOf22(n) {
@@ -4182,7 +4315,11 @@ function dwt(x, wavelet = "haar") {
     }
     return { approx, detail };
   } else {
-    throw new Error(`dwt: unsupported wavelet "${wavelet}"`);
+    try {
+      return dwtPeriodization(x, wavelet);
+    } catch (err) {
+      throw new Error(`dwt: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
 }
 async function fft2d(x) {
@@ -4737,9 +4874,9 @@ function runBinaryBitwiseWasm(op, a, b) {
   const n = a.length;
   const names = BINARY_OPS[op];
   try {
-    return withAsI32(wasm, [a, b, new Int32Array(n)], (mod2, [ha, hb, hr]) => {
-      mod2[names.as](ha, hb, hr);
-      return asReadReturnedI32(mod2, hr);
+    return withAsI32(wasm, [a, b, new Int32Array(n)], (mod3, [ha, hb, hr]) => {
+      mod3[names.as](ha, hb, hr);
+      return asReadReturnedI32(mod3, hr);
     });
   } catch {
     return null;
@@ -4751,9 +4888,9 @@ function runUnaryBitwiseWasm(op, a) {
   const n = a.length;
   const names = UNARY_OPS[op];
   try {
-    return withAsI32(wasm, [a, new Int32Array(n)], (mod2, [ha, hr]) => {
-      mod2[names.as](ha, hr);
-      return asReadReturnedI32(mod2, hr);
+    return withAsI32(wasm, [a, new Int32Array(n)], (mod3, [ha, hr]) => {
+      mod3[names.as](ha, hr);
+      return asReadReturnedI32(mod3, hr);
     });
   } catch {
     return null;
@@ -6479,7 +6616,7 @@ function besselOrderDispatch(order, xs, asName, js) {
         const out = withAsF64(
           wasm,
           [xs],
-          (mod2, [h]) => asReadReturnedF64(mod2, mod2[asName](order, h))
+          (mod3, [h]) => asReadReturnedF64(mod3, mod3[asName](order, h))
         );
         if (out) return out;
       } catch {
@@ -6741,7 +6878,7 @@ function multiArrayDispatch(name254, inputs, js) {
         const out = withAsF64(
           wasm,
           inputs,
-          (mod2, headers) => asReadReturnedF64(mod2, mod2[name254](...headers))
+          (mod3, headers) => asReadReturnedF64(mod3, mod3[name254](...headers))
         );
         if (out) return out;
       } catch {
@@ -9162,7 +9299,7 @@ function polyMulDispatch(a, b) {
         const out = withAsF64(
           wasm,
           [a, b],
-          (mod2, [ha, hb]) => asReadReturnedF64(mod2, mod2["poly_mul_f64"](ha, hb))
+          (mod3, [ha, hb]) => asReadReturnedF64(mod3, mod3["poly_mul_f64"](ha, hb))
         );
         if (out) return out;
       } catch {
@@ -9181,9 +9318,9 @@ function polyDivModDispatch(num2, den) {
         const flat = withAsF64(
           wasm,
           [num2, den],
-          (mod2, [hn, hd]) => asReadReturnedF64(
-            mod2,
-            mod2["poly_div_mod_f64"](hn, hd)
+          (mod3, [hn, hd]) => asReadReturnedF64(
+            mod3,
+            mod3["poly_div_mod_f64"](hn, hd)
           )
         );
         if (flat) {
@@ -9284,7 +9421,7 @@ function resultantDispatch(p, q) {
         const r = withAsF64(
           wasm,
           [p, q],
-          (mod2, [hp, hq]) => mod2["poly_resultant_f64"](hp, hq)
+          (mod3, [hp, hq]) => mod3["poly_resultant_f64"](hp, hq)
         );
         if (r !== null) return r;
       } catch {
@@ -9302,7 +9439,7 @@ function discriminantDispatch(p) {
         const r = withAsF64(
           wasm,
           [p],
-          (mod2, [hp]) => mod2["poly_discriminant_f64"](hp)
+          (mod3, [hp]) => mod3["poly_discriminant_f64"](hp)
         );
         if (r !== null) return r;
       } catch {
@@ -9415,9 +9552,9 @@ function fitDispatch(xs, ys, degree2, asName, jsFallback) {
         const out = withAsF64(
           wasm,
           [xs, ys],
-          (mod2, [hx, hy]) => asReadReturnedF64(
-            mod2,
-            mod2[asName](hx, hy, degree2)
+          (mod3, [hx, hy]) => asReadReturnedF64(
+            mod3,
+            mod3[asName](hx, hy, degree2)
           )
         );
         if (out && out.length === degree2 + 1 && out.every((v) => Number.isFinite(v))) {
@@ -10948,9 +11085,9 @@ function tridiagSolveDispatch(diag2, lower, upper, rhs) {
         const result = withAsF64(
           wasm,
           [diag2, lower, upper, rhs],
-          (mod2, [hd, hl, hu, hr]) => asReadReturnedF64(
-            mod2,
-            mod2["tridiag_solve_f64"](
+          (mod3, [hd, hl, hu, hr]) => asReadReturnedF64(
+            mod3,
+            mod3["tridiag_solve_f64"](
               hd,
               hl,
               hu,
@@ -10989,9 +11126,9 @@ function dividedDifferenceDispatch(xs, ys) {
         const result = withAsF64(
           wasm,
           [xs, ys],
-          (mod2, [hx, hy]) => asReadReturnedF64(
-            mod2,
-            mod2["divided_difference_f64"](hx, hy)
+          (mod3, [hx, hy]) => asReadReturnedF64(
+            mod3,
+            mod3["divided_difference_f64"](hx, hy)
           )
         );
         if (result && result.length === n) return result;
@@ -28446,7 +28583,7 @@ var createGcd = /* @__PURE__ */ factory(
     DenseMatrix: DenseMatrix6,
     concat: concat3
   }) => {
-    const mod2 = createMod({
+    const mod3 = createMod({
       typed: typed3,
       config: config2,
       round: round2,
@@ -28532,7 +28669,7 @@ var createGcd = /* @__PURE__ */ factory(
       }
       let r;
       while (b !== 0) {
-        r = mod2(a, b);
+        r = mod3(a, b);
         a = b;
         b = r;
       }
@@ -28544,7 +28681,7 @@ var createGcd = /* @__PURE__ */ factory(
       }
       const zero = new BigNumber9(0);
       while (!b.isZero()) {
-        const r = mod2(a, b);
+        const r = mod3(a, b);
         a = b;
         b = r;
       }
@@ -30315,7 +30452,7 @@ var createInvmod = /* @__PURE__ */ factory(
     xgcd: xgcd2,
     equal: equal2,
     smaller: smaller2,
-    mod: mod2,
+    mod: mod3,
     add: add3,
     isInteger: isInteger3
   }) => {
@@ -30326,13 +30463,13 @@ var createInvmod = /* @__PURE__ */ factory(
     function invmod2(a, b) {
       if (!isInteger3(a) || !isInteger3(b))
         throw new Error("Parameters in function invmod must be integer numbers");
-      a = mod2(a, b);
+      a = mod3(a, b);
       if (equal2(b, 0)) throw new Error("Divisor must be non zero");
       const res = xgcd2(a, b);
       const resVal = res.valueOf();
       const [gcd2, invValue] = resVal;
       if (!equal2(gcd2, 1)) return NaN;
-      let inv3 = mod2(invValue, b);
+      let inv3 = mod3(invValue, b);
       if (smaller2(inv3, 0)) inv3 = add3(inv3, b);
       return inv3;
     }
@@ -44817,20 +44954,20 @@ function stirlingS1(n, k) {
   }
   return s[n][k];
 }
-function modPowBig(base, exp2, mod2) {
-  let b = (base % mod2 + mod2) % mod2;
+function modPowBig(base, exp2, mod3) {
+  let b = (base % mod3 + mod3) % mod3;
   let e = exp2;
   let result = 1n;
   while (e > 0n) {
-    if (e & 1n) result = result * b % mod2;
-    b = b * b % mod2;
+    if (e & 1n) result = result * b % mod3;
+    b = b * b % mod3;
     e >>= 1n;
   }
   return result;
 }
-function modInverseBig(a, mod2) {
+function modInverseBig(a, mod3) {
   let oldR = a;
-  let r = mod2;
+  let r = mod3;
   let oldS = 1n;
   let s = 0n;
   while (r !== 0n) {
@@ -44838,7 +44975,7 @@ function modInverseBig(a, mod2) {
     [oldR, r] = [r, oldR - q * r];
     [oldS, s] = [s, oldS - q * s];
   }
-  return (oldS % mod2 + mod2) % mod2;
+  return (oldS % mod3 + mod3) % mod3;
 }
 function discreteLog(g, h, p) {
   if (!Number.isInteger(g) || !Number.isInteger(h) || !Number.isInteger(p) || p < 2) {
@@ -46716,6 +46853,12 @@ import { eig as eig3 } from "@danielsimonjr/mathts-matrix";
 function cSub(a, b) {
   return { re: a.re - b.re, im: a.im - b.im };
 }
+function cAdd(a, b) {
+  return { re: a.re + b.re, im: a.im + b.im };
+}
+function cScale(a, s) {
+  return { re: a.re * s, im: a.im * s };
+}
 function cMul(a, b) {
   return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };
 }
@@ -46732,6 +46875,11 @@ function cZeros(n) {
     im: Array.from({ length: n }, () => new Array(n).fill(0))
   };
 }
+function cIdentity(n) {
+  const m = cZeros(n);
+  for (let i = 0; i < n; i++) m.re[i][i] = 1;
+  return m;
+}
 function cFromReal(A) {
   const n = A.length;
   return {
@@ -46798,7 +46946,81 @@ function isDiagonal(A, n) {
   }
   return true;
 }
-function funm(A, f) {
+function clusterEigenvalues(values, tol) {
+  const acc = [];
+  for (const v of values) {
+    let placed = false;
+    for (const c of acc) {
+      const rep = { re: c.sumRe / c.count, im: c.sumIm / c.count };
+      if (cAbs(cSub(v, rep)) < tol) {
+        c.sumRe += v.re;
+        c.sumIm += v.im;
+        c.count += 1;
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) acc.push({ sumRe: v.re, sumIm: v.im, count: 1 });
+  }
+  return acc.map((c) => ({
+    value: { re: c.sumRe / c.count, im: c.sumIm / c.count },
+    count: c.count
+  }));
+}
+function factorialNum(k) {
+  let r = 1;
+  for (let i = 2; i <= k; i++) r *= i;
+  return r;
+}
+function numericalDerivative2(f, z, order) {
+  const at = (dx) => f({ re: z.re + dx, im: z.im });
+  switch (order) {
+    case 1: {
+      const h = 1e-6;
+      return cScale(cSub(at(h), at(-h)), 1 / (2 * h));
+    }
+    case 2: {
+      const h = 1e-4;
+      const t = cSub(cAdd(at(h), at(-h)), cScale(at(0), 2));
+      return cScale(t, 1 / (h * h));
+    }
+    case 3: {
+      const h = 1e-3;
+      const t = cSub(cAdd(at(2 * h), cScale(at(-h), 2)), cAdd(cScale(at(h), 2), at(-2 * h)));
+      return cScale(t, 1 / (2 * h * h * h));
+    }
+    case 4: {
+      const h = 0.01;
+      let t = at(2 * h);
+      t = cSub(t, cScale(at(h), 4));
+      t = cAdd(t, cScale(at(0), 6));
+      t = cSub(t, cScale(at(-h), 4));
+      t = cAdd(t, at(-2 * h));
+      return cScale(t, 1 / (h * h * h * h));
+    }
+    default:
+      throw new Error(
+        `funm: numerical derivatives of order ${order} are not supported (eigenvalue multiplicity ${order + 1} exceeds the finite-difference stencils); supply analytic derivatives via the fDerivs argument (fDerivs[k] = f^(k+1))`
+      );
+  }
+}
+function taylorCoeffs(f, fDerivs, z, maxOrder) {
+  const coeffs = [f(z)];
+  for (let L = 1; L <= maxOrder; L++) {
+    const deriv = fDerivs && fDerivs.length >= L ? fDerivs[L - 1](z) : numericalDerivative2(f, z, L);
+    coeffs.push(cScale(deriv, 1 / factorialNum(L)));
+  }
+  return coeffs;
+}
+function cIsFinite(M) {
+  for (let i = 0; i < M.re.length; i++) {
+    for (let j = 0; j < M.re.length; j++) {
+      if (!Number.isFinite(M.re[i][j]) || !Number.isFinite(M.im[i][j])) return false;
+    }
+  }
+  return true;
+}
+function funm(A, f, fDerivs) {
   const n = A.length;
   if (n === 0) return { re: [], im: [] };
   for (const row2 of A) {
@@ -46816,29 +47038,59 @@ function funm(A, f) {
   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);
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      if (cAbs(cSub(values[i], values[j])) < tol) {
-        throw new Error(
-          "funm: matrix has repeated (or numerically indistinguishable) eigenvalues and is not diagonal \u2014 defective/non-diagonalizable matrices are not supported (Schur-Parlett block recurrence not yet implemented)"
-        );
+  const clusters = clusterEigenvalues(values, tol);
+  if (clusters.length === n) {
+    const F2 = cZeros(n);
+    for (let i = 0; i < n; i++) {
+      const lambdaI = values[i];
+      let numerator = cFromReal(A);
+      let denom = { re: 1, im: 0 };
+      let first = true;
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        const factor2 = cShiftedReal(A, values[j]);
+        numerator = first ? factor2 : cMatMul(numerator, factor2);
+        first = false;
+        denom = cMul(denom, cSub(lambdaI, values[j]));
       }
+      cAccumulate(F2, f(lambdaI), cMatScalarDiv(numerator, denom));
     }
+    return F2;
   }
-  const F = cZeros(n);
-  for (let i = 0; i < n; i++) {
-    const lambdaI = values[i];
-    let numerator = cFromReal(A);
-    let denom = { re: 1, im: 0 };
-    let first = true;
-    for (let j = 0; j < n; j++) {
-      if (j === i) continue;
-      const factor2 = cShiftedReal(A, values[j]);
-      numerator = first ? factor2 : cMatMul(numerator, factor2);
-      first = false;
-      denom = cMul(denom, cSub(lambdaI, values[j]));
+  const nodes = [];
+  const clusterIdx = [];
+  const taylor2 = clusters.map(
+    (c) => taylorCoeffs(f, fDerivs, c.value, c.count - 1)
+  );
+  clusters.forEach((c, ci) => {
+    for (let r = 0; r < c.count; r++) {
+      nodes.push(c.value);
+      clusterIdx.push(ci);
     }
-    cAccumulate(F, f(lambdaI), cMatScalarDiv(numerator, denom));
+  });
+  const dd = Array.from({ length: n }, () => new Array(n));
+  for (let i = 0; i < n; i++) dd[i][i] = taylor2[clusterIdx[i]][0];
+  for (let L = 1; L < n; L++) {
+    for (let i = 0; i + L < n; i++) {
+      const j = i + L;
+      if (clusterIdx[i] === clusterIdx[j]) {
+        dd[i][j] = taylor2[clusterIdx[i]][L];
+      } else {
+        dd[i][j] = cDiv(cSub(dd[i + 1][j], dd[i][j - 1]), cSub(nodes[j], nodes[i]));
+      }
+    }
+  }
+  const F = cZeros(n);
+  let P2 = cIdentity(n);
+  cAccumulate(F, dd[0][0], P2);
+  for (let k = 1; k < n; k++) {
+    P2 = cMatMul(P2, cShiftedReal(A, nodes[k - 1]));
+    cAccumulate(F, dd[0][k], P2);
+  }
+  if (!cIsFinite(F)) {
+    throw new Error(
+      "funm: result is non-finite \u2014 f (or one of its derivatives) is singular at a repeated eigenvalue (e.g. sqrt/log at 0), so the matrix function is undefined there"
+    );
   }
   return F;
 }
@@ -46854,11 +47106,17 @@ function complexSin(z) {
     im: Math.cos(z.re) * Math.sinh(z.im)
   };
 }
+function trigDerivs(base, n) {
+  return Array.from({ length: Math.max(0, n - 1) }, (_unused, k) => {
+    const shift = (k + 1) * Math.PI / 2;
+    return (z) => base({ re: z.re + shift, im: z.im });
+  });
+}
 function cosm(A) {
-  return funm(A, complexCos);
+  return funm(A, complexCos, trigDerivs(complexCos, A.length));
 }
 function sinm(A) {
-  return funm(A, complexSin);
+  return funm(A, complexSin, trigDerivs(complexSin, A.length));
 }
 
 // src/numeric/control-equations.ts
@@ -48658,17 +48916,17 @@ function filtfilt(b, a, x) {
   ).y.reverse();
   return back.slice(pad, pad + n);
 }
-var cAdd = (p, q) => p.add(q);
+var cAdd2 = (p, q) => p.add(q);
 var cSub2 = (p, q) => p.sub(q);
 var cMul2 = (p, q) => p.multiply(q);
 var cDiv2 = (p, q) => p.divide(q);
-var cScale = (p, s) => cMul2(p, new Complex11(s, 0));
+var cScale2 = (p, s) => cMul2(p, new Complex11(s, 0));
 function polyFromRoots(roots) {
   let c = [new Complex11(1, 0)];
   for (const r of roots) {
     const next = Array.from({ length: c.length + 1 }, () => new Complex11(0, 0));
     for (let i = 0; i < c.length; i++) {
-      next[i] = cAdd(next[i], c[i]);
+      next[i] = cAdd2(next[i], c[i]);
       next[i + 1] = cSub2(next[i + 1], cMul2(c[i], r));
     }
     c = next;
@@ -48683,8 +48941,8 @@ function relativeDegree(z, p) {
 function lp2lpZpk(z, p, k, wo) {
   const degree2 = relativeDegree(z, p);
   return {
-    z: z.map((zv) => cScale(zv, wo)),
-    p: p.map((pv) => cScale(pv, wo)),
+    z: z.map((zv) => cScale2(zv, wo)),
+    p: p.map((pv) => cScale2(pv, wo)),
     k: k * Math.pow(wo, degree2)
   };
 }
@@ -48703,8 +48961,8 @@ function lp2bpZpk(z, p, k, wo, bw) {
   const degree2 = relativeDegree(z, p);
   const wo2 = new Complex11(wo * wo, 0);
   const shift = (roots) => {
-    const lp = roots.map((r) => cScale(r, bw / 2));
-    const plus = lp.map((r) => cAdd(r, cSub2(cMul2(r, r), wo2).sqrt()));
+    const lp = roots.map((r) => cScale2(r, bw / 2));
+    const plus = lp.map((r) => cAdd2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     const minus = lp.map((r) => cSub2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     return plus.concat(minus);
   };
@@ -48718,7 +48976,7 @@ function lp2bsZpk(z, p, k, wo, bw) {
   const bw2 = new Complex11(bw / 2, 0);
   const shift = (roots) => {
     const hp = roots.map((r) => cDiv2(bw2, r));
-    const plus = hp.map((r) => cAdd(r, cSub2(cMul2(r, r), wo2).sqrt()));
+    const plus = hp.map((r) => cAdd2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     const minus = hp.map((r) => cSub2(r, cSub2(cMul2(r, r), wo2).sqrt()));
     return plus.concat(minus);
   };
@@ -48734,7 +48992,7 @@ function lp2bsZpk(z, p, k, wo, bw) {
 function bilinearZpk(z, p, k, fs) {
   const degree2 = relativeDegree(z, p);
   const fs2 = new Complex11(2 * fs, 0);
-  const zZ = z.map((zv) => cDiv2(cAdd(fs2, zv), cSub2(fs2, zv)));
+  const zZ = z.map((zv) => cDiv2(cAdd2(fs2, zv), cSub2(fs2, zv)));
   for (let i = 0; i < degree2; i++) zZ.push(new Complex11(-1, 0));
   let prodZ = new Complex11(1, 0);
   for (const zv of z) prodZ = cMul2(prodZ, cSub2(fs2, zv));
@@ -48742,7 +49000,7 @@ function bilinearZpk(z, p, k, fs) {
   for (const pv of p) prodP = cMul2(prodP, cSub2(fs2, pv));
   return {
     z: zZ,
-    p: p.map((pv) => cDiv2(cAdd(fs2, pv), cSub2(fs2, pv))),
+    p: p.map((pv) => cDiv2(cAdd2(fs2, pv), cSub2(fs2, pv))),
     k: k * cDiv2(prodZ, prodP).re
   };
 }
@@ -49008,10 +49266,10 @@ function arcJacSn(w, m) {
   let wn = w;
   for (let i = 0; i < ks.length - 1; i++) {
     const knext = ks[i + 1];
-    const comp = complementComplex(cScale(wn, ks[i]));
-    wn = cDiv2(cScale(wn, 2), cMul2(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
+    const comp = complementComplex(cScale2(wn, ks[i]));
+    wn = cDiv2(cScale2(wn, 2), cMul2(new Complex12(1 + knext, 0), new Complex12(1, 0).add(comp)));
   }
-  return cScale(cScale(wn.asin(), 2 / Math.PI), K);
+  return cScale2(cScale2(wn.asin(), 2 / Math.PI), K);
 }
 function arcJacSc1(w, m) {
   const z = arcJacSn(new Complex12(0, w), m);
@@ -49570,20 +49828,11 @@ function remez(numtaps, bands, desired) {
 
 // src/signal/wavelets.ts
 function idwt(approx, detail, wavelet = "haar") {
-  if (wavelet !== "haar" && wavelet !== "db1") {
-    throw new Error(`idwt: unsupported wavelet "${wavelet}"`);
-  }
-  if (approx.length !== detail.length) {
-    throw new Error("idwt: approx and detail must have equal length");
-  }
-  const half = approx.length;
-  const s = 1 / Math.SQRT2;
-  const x = new Array(half * 2);
-  for (let i = 0; i < half; i++) {
-    x[2 * i] = s * (approx[i] + detail[i]);
-    x[2 * i + 1] = s * (approx[i] - detail[i]);
+  try {
+    return idwtPeriodization(approx, detail, wavelet);
+  } catch (err) {
+    throw new Error(`idwt: ${err instanceof Error ? err.message : String(err)}`);
   }
-  return x;
 }
 function wavedec(x, wavelet = "haar", level = 1) {
   if (!Number.isInteger(level) || level < 1) {

package/dist/numeric/matrix-functions.d.ts

@@ -24,13 +24,23 @@
  *     any polynomial or entire function `f` (cos, sin, sqrt, exp, log, …)
  *     whenever the spectrum is simple.
  *
- * Limitation (documented, not yet implemented): matrices with repeated (or
- * numerically indistinguishable) eigenvalues that are NOT diagonal — i.e.
- * genuinely defective/non-diagonalizable matrices, or diagonalizable
- * matrices with a repeated eigenvalue and off-diagonal structure — are not
- * supported; `funm` throws rather than silently return a wrong answer. A
- * full Schur-Parlett block recurrence (Higham 2008 Ch. 9) would lift this
- * restriction; that is future work, not required by the current call sites.
+ * Defective / repeated-eigenvalue matrices (confluent Hermite interpolation):
+ *   - When eigenvalues repeat (or cluster within `EIGENVALUE_DISTINCT_REL_TOL`),
+ *     `f(A)` depends on `f` AND its derivatives at each repeated eigenvalue —
+ *     for a Jordan block `J = λI + N` (N nilpotent, `N^s = 0`),
+ *       f(J) = Σ_{k=0}^{s-1} f^(k)(λ)/k! · N^k.
+ *     `funm` builds the confluent node list (each distinct eigenvalue repeated
+ *     to its multiplicity) and evaluates the Newton divided-difference form
+ *       f(A) = Σ_k f[z_0,…,z_k] · Π_{i<k}(A − z_i I),
+ *     where a run of equal nodes contributes the Taylor coefficient
+ *     `f^(L)(z)/L!`. This subsumes the simple-spectrum Lagrange path.
+ *   - Derivatives of `f` come from the optional `fDerivs` argument
+ *     (`fDerivs[k] = f^(k+1)`, machine precision — wired for `cosm`/`sinm`) or,
+ *     when omitted, from finite-difference stencils (~1e-6 accuracy).
+ *   - `funm` throws (rather than return a wrong/`NaN` answer) only when `f` or a
+ *     derivative is genuinely singular at a repeated eigenvalue (e.g.
+ *     `sqrt`/`log` at 0) or when a needed numerical derivative order exceeds the
+ *     built-in stencils (multiplicity > 5 with no analytic derivatives).
  *
  * @packageDocumentation
  */
@@ -50,25 +60,40 @@ export type ScalarComplexFunction = (z: ComplexValue) => ComplexValue;
  * Evaluate the matrix function `f(A)` for a square real matrix `A`, returning
  * a complex matrix `{re, im}`.
  *
- * Supports diagonal matrices unconditionally (exact, elementwise), and
- * general diagonalizable matrices whose eigenvalues are pairwise distinct
- * (Lagrange-Sylvester interpolation on the spectrum — see module docs).
- * Throws for matrices with repeated or numerically indistinguishable
- * eigenvalues that are not diagonal (defective / non-diagonalizable case;
- * not yet supported — see module docs for the Schur-Parlett follow-up).
+ * Supports:
+ *   - diagonal matrices unconditionally (exact, elementwise);
+ *   - diagonalizable matrices with pairwise-distinct eigenvalues
+ *     (Lagrange-Sylvester interpolation — the fast simple-spectrum branch);
+ *   - defective / non-diagonalizable matrices with repeated (or numerically
+ *     clustered) eigenvalues, via **confluent Hermite interpolation** (Newton
+ *     divided differences over repeated eigenvalue nodes). A matrix function of
+ *     a defective matrix depends on `f` AND its derivatives at each repeated
+ *     eigenvalue (for a Jordan block `J = λI + N`, `f(J) = Σ_k f^(k)(λ)/k! · N^k`),
+ *     so this branch needs derivatives of `f`: pass them analytically via
+ *     `fDerivs` for machine precision, or they are approximated numerically.
+ *
+ * Throws (rather than return a wrong/`NaN` answer) when `f` or its derivatives
+ * are singular at a repeated eigenvalue (e.g. `sqrt`/`log` at 0), or when a
+ * needed numerical derivative order exceeds the built-in stencils.
  *
  * @param A - Square real matrix, as a plain 2-D array.
- * @param f - Scalar function to apply to each eigenvalue, e.g. `cos`, `sin`,
+ * @param f - Scalar function to apply to the spectrum, e.g. `cos`, `sin`,
  *   `sqrt`, `exp`, `log`, extended to complex arguments.
+ * @param fDerivs - Optional analytic derivatives of `f`: `fDerivs[k]` is
+ *   `f^(k+1)`. Needed only for defective matrices; when omitted, derivatives
+ *   are computed by finite differences (~1e-6 accuracy). Additive and
+ *   non-breaking — distinct-spectrum inputs never consult it.
  * @returns `{ re, im }` — the (possibly complex) matrix `f(A)`.
  */
-export declare function funm(A: number[][], f: ScalarComplexFunction): ComplexMatrix;
+export declare function funm(A: number[][], f: ScalarComplexFunction, fDerivs?: ScalarComplexFunction[]): ComplexMatrix;
 /** Complex cosine: `cos(z) = cos(re)cosh(im) - i sin(re)sinh(im)`. */
 export declare function complexCos(z: ComplexValue): ComplexValue;
 /** Complex sine: `sin(z) = sin(re)cosh(im) + i cos(re)sinh(im)`. */
 export declare function complexSin(z: ComplexValue): ComplexValue;
-/** Matrix cosine `cos(A)`, via {@link funm} with {@link complexCos}. */
+/** Matrix cosine `cos(A)`, via {@link funm} with {@link complexCos}. Passes
+ * exact analytic derivatives so defective matrices are machine-precise. */
 export declare function cosm(A: number[][]): ComplexMatrix;
-/** Matrix sine `sin(A)`, via {@link funm} with {@link complexSin}. */
+/** Matrix sine `sin(A)`, via {@link funm} with {@link complexSin}. Passes
+ * exact analytic derivatives so defective matrices are machine-precise. */
 export declare function sinm(A: number[][]): ComplexMatrix;
 //# sourceMappingURL=matrix-functions.d.ts.map

package/dist/numeric/matrix-functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix-functions.d.ts","sourceRoot":"","sources":["../../src/numeric/matrix-functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAIH,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;AAoHtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,qBAAqB,GAAG,aAAa,CAuD3E;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,YAAY,CAKxD;AAED,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,YAAY,CAKxD;AAED,wEAAwE;AACxE,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,aAAa,CAEjD;AAED,sEAAsE;AACtE,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,aAAa,CAEjD"}
+{"version":3,"file":"matrix-functions.d.ts","sourceRoot":"","sources":["../../src/numeric/matrix-functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAIH,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;AA0PtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAClB,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,qBAAqB,EACxB,OAAO,CAAC,EAAE,qBAAqB,EAAE,GAChC,aAAa,CAmGf;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,YAAY,CAKxD;AAED,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,YAAY,CAKxD;AAeD;2EAC2E;AAC3E,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,aAAa,CAEjD;AAED;2EAC2E;AAC3E,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,aAAa,CAEjD"}

package/dist/signal/wavelet-filters.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Orthogonal wavelet filter table + a general periodization-boundary filter
+ * bank, shared by `dwt` (`../typed/signal.ts`) and `idwt`/`wavedec`/`waverec`
+ * (`./wavelets.ts`). This module is a dependency-free leaf: it must not
+ * import from `typed/signal.ts` (which imports `dwt` derivatives) to avoid a
+ * cycle.
+ *
+ * Each wavelet is stored as its decomposition low-pass filter (`dec_lo`),
+ * pinned bit-for-bit against PyWavelets 1.8.0 (`pywt.Wavelet(name).dec_lo`).
+ * The other three orthogonal filters are derived by the standard QMF
+ * relations (verified against pywt's `dec_hi`/`rec_lo`/`rec_hi` for every
+ * entry below, tolerance 1e-14):
+ *
+ *   dec_hi[k] = -(-1)^k * dec_lo[L-1-k]   (alternating flip of the reverse)
+ *   rec_lo    = reverse(dec_lo)
+ *   rec_hi    = reverse(dec_hi)
+ *
+ * Boundary mode is **periodization** (matches `pywt.dwt(..., mode='periodization')`
+ * exactly, bit-for-bit, verified against pywt for signal lengths 8/15/16/32):
+ * treating the signal as circularly periodic yields exactly `ceil(N/2)`
+ * coefficients per band and admits an exact analytic inverse. The phase
+ * alignment (derived empirically against pywt, then verified across many
+ * filter lengths and signal lengths) is:
+ *
+ *   analysis:  cA[n] = sum_k decLo[k] * x[(2n - k + floor(L/2)) mod N]
+ *              cD[n] = sum_k decHi[k] * x[(2n - k + floor(L/2)) mod N]
+ *   synthesis: x[m]  = sum_k recLo[k] * cA[j] + recHi[k] * cD[j]
+ *              where idx = mod(m - k + floor(L/2) - 1, N), only when idx is
+ *              even (j = idx / 2) — odd idx contributes zero (upsampling).
+ *
+ * @packageDocumentation
+ */
+/** Wavelet names supported by `dwt`/`idwt`/`wavedec`/`waverec`. */
+export declare const SUPPORTED_WAVELETS: readonly string[];
+/** The four orthogonal filters for a wavelet family. */
+export interface WaveletFilters {
+    decLo: number[];
+    decHi: number[];
+    recLo: number[];
+    recHi: number[];
+}
+/**
+ * Looks up (and derives) the four orthogonal filters for `wavelet`.
+ *
+ * @throws if `wavelet` is not one of `SUPPORTED_WAVELETS`.
+ */
+export declare function getWaveletFilters(wavelet: string): WaveletFilters;
+/**
+ * Single-level DWT via a general orthogonal filter bank with periodization
+ * boundary handling. Matches `pywt.dwt(x, wavelet, mode='periodization')`
+ * bit-for-bit for every supported family.
+ *
+ * @param x - Input signal (length >= 2)
+ * @param wavelet - One of `SUPPORTED_WAVELETS`
+ * @returns `{ approx, detail }`, each of length `ceil(x.length / 2)`
+ */
+export declare function dwtPeriodization(x: number[], wavelet: string): {
+    approx: number[];
+    detail: number[];
+};
+/**
+ * Inverse single-level DWT (periodization boundary), the exact analytic
+ * inverse of `dwtPeriodization`. Matches
+ * `pywt.idwt(approx, detail, wavelet, mode='periodization')` bit-for-bit.
+ *
+ * @param approx - Approximation (low-pass) coefficients
+ * @param detail - Detail (high-pass) coefficients, same length as `approx`
+ * @param wavelet - One of `SUPPORTED_WAVELETS`
+ * @returns Reconstructed signal, length `2 * approx.length`
+ */
+export declare function idwtPeriodization(approx: number[], detail: number[], wavelet: string): number[];
+//# sourceMappingURL=wavelet-filters.d.ts.map

package/dist/signal/wavelet-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wavelet-filters.d.ts","sourceRoot":"","sources":["../../src/signal/wavelet-filters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAmCH,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAA8B,CAAC;AAE/E,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAejE;AAQD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EAAE,EACX,OAAO,EAAE,MAAM,GACd;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAwBxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAwB/F"}

package/dist/signal/wavelets.d.ts

@@ -2,23 +2,24 @@
  * Phase 6 Task 4 — inverse DWT, multilevel wavedec/waverec (perfect
  * reconstruction), and the continuous wavelet transform (CWT).
  *
- * `idwt`/`wavedec`/`waverec` must invert the existing `dwt` (`../typed/signal.ts`)
- * exactly, so they match its Haar convention bit-for-bit: analysis filters
- * scaled by `s = 1/sqrt(2)`, `approx[i] = s*(x[2i]+x[2i+1])`,
- * `detail[i] = s*(x[2i]-x[2i+1])`. Haar's synthesis (reconstruction) filters
- * are the time-reverse of its analysis filters — for a symmetric 2-tap filter
- * that reversal is a no-op, so the closed-form inverse below is exact:
- * `x[2i] = s*(approx[i]+detail[i])`, `x[2i+1] = s*(approx[i]-detail[i])`.
+ * `idwt` inverts `dwt` (`../typed/signal.ts`) via the shared periodization
+ * filter bank in `./wavelet-filters.ts`, which supports the full family list
+ * (`SUPPORTED_WAVELETS`: haar, db1-4, sym2-4, coif1-2) and matches
+ * `pywt.idwt(..., mode='periodization')` bit-for-bit. For Haar/db1 this is
+ * verified equivalent to the earlier hardcoded closed-form 2-tap inverse
+ * (`x[2i] = s*(approx[i]+detail[i])`, `x[2i+1] = s*(approx[i]-detail[i])`,
+ * `s = 1/sqrt(2)`) — no behavior change for existing callers.
  *
  * @packageDocumentation
  */
 /**
- * Inverse single-level discrete wavelet transform. Upsamples `approx`/`detail`
- * and combines them with the Haar synthesis filters, exactly inverting `dwt`.
+ * Inverse single-level discrete wavelet transform (periodization boundary).
+ * Exactly inverts `dwt` for every wavelet in `SUPPORTED_WAVELETS`
+ * (`./wavelet-filters.ts`): haar, db1-4, sym2-4, coif1-2.
  *
  * @param approx - Approximation (low-pass) coefficients
  * @param detail - Detail (high-pass) coefficients, same length as `approx`
- * @param wavelet - Wavelet name (currently only 'haar'/'db1', matching `dwt`)
+ * @param wavelet - Wavelet name (default 'haar'); see `SUPPORTED_WAVELETS`
  * @returns Reconstructed signal, length `2 * approx.length`
  */
 export declare function idwt(approx: number[], detail: number[], wavelet?: string): number[];
@@ -27,7 +28,8 @@ export declare function idwt(approx: number[], detail: number[], wavelet?: strin
  * approximation coefficients.
  *
  * @param x - Input signal
- * @param wavelet - Wavelet name (passed through to `dwt`)
+ * @param wavelet - Wavelet name (passed through to `dwt`); see
+ *   `SUPPORTED_WAVELETS` in `./wavelet-filters.ts`
  * @param level - Number of decomposition levels (>= 1)
  * @returns `[cA_level, cD_level, cD_{level-1}, ..., cD_1]` (pywt order)
  */

package/dist/signal/wavelets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wavelets.d.ts","sourceRoot":"","sources":["../../src/signal/wavelets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAe,GAAG,MAAM,EAAE,CAgB3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAe,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,EAAE,EAAE,CAc5F;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAE,MAAe,GAAG,MAAM,EAAE,CAU9E;AA2BD;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAiB,GAAG,MAAM,EAAE,EAAE,CAYzF"}
+{"version":3,"file":"wavelets.d.ts","sourceRoot":"","sources":["../../src/signal/wavelets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAe,GAAG,MAAM,EAAE,CAM3F;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAe,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,EAAE,EAAE,CAc5F;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAE,MAAe,GAAG,MAAM,EAAE,CAU9E;AA2BD;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAiB,GAAG,MAAM,EAAE,EAAE,CAYzF"}

package/dist/typed/signal.d.ts

@@ -125,10 +125,17 @@ export declare function dst(x: number[]): number[];
  */
 export declare function idst(X: number[]): number[];
 /**
- * Discrete wavelet transform using Haar wavelet.
+ * Single-level discrete wavelet transform (periodization boundary).
  *
- * @param x - Input signal (length must be power of 2)
- * @param wavelet - Wavelet name (currently only 'haar')
+ * Haar/db1 use a dedicated closed-form (and WASM-accelerated) 2-tap path.
+ * All other supported families (db2-4, sym2-4, coif1-2) route through the
+ * general orthogonal filter bank in `../signal/wavelet-filters.ts`, which is
+ * verified to reproduce this same Haar/db1 result bit-for-bit and to match
+ * `pywt.dwt(..., mode='periodization')` for every family.
+ *
+ * @param x - Input signal (length >= 2)
+ * @param wavelet - Wavelet name; see `SUPPORTED_WAVELETS` in
+ *   `../signal/wavelet-filters.ts` for the full list
  * @returns { approx: number[], detail: number[] }
  */
 export declare function dwt(x: number[], wavelet?: string): {

package/dist/typed/signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/typed/signal.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/typed/signal.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",