@danielsimonjr/mathts-functions 0.20.2 → 0.22.0

package/dist/arithmetic/norm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"norm.d.ts","sourceRoot":"","sources":["../../src/arithmetic/norm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D,UAAU,WAAW;IACnB,GAAG,IAAI,MAAM,CAAC;CACf;AAED,UAAU,aAAa;IACrB,GAAG,IAAI,aAAa,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,CACL,QAAQ,EAAE,CACR,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,EAC3C,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,UAAU,KACf,IAAI,EACT,SAAS,CAAC,EAAE,OAAO,GAClB,IAAI,CAAC;IACR,OAAO,IAAI,CAAC,MAAM,GAAG,aAAa,GAAG,WAAW,CAAC,EAAE,CAAC;CACrD;AAED,UAAU,UAAU;IAClB,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,UAAU,gBAAgB;IACxB,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,WAAW,EAAE,aAAa,CAAC;IAC3B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,KAAK,OAAO,CAAC;IAC1E,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,KAAK,OAAO,CAAC;IAC3E,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,UAAU,CAAC;IACtC,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,UAAU,CAAC;CACrC;AAmBD,eAAO,MAAM,UAAU,gFA+VtB,CAAC"}
+{"version":3,"file":"norm.d.ts","sourceRoot":"","sources":["../../src/arithmetic/norm.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D,UAAU,WAAW;IACnB,GAAG,IAAI,MAAM,CAAC;CACf;AAED,UAAU,aAAa;IACrB,GAAG,IAAI,aAAa,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,CACL,QAAQ,EAAE,CACR,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,EAC3C,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,UAAU,KACf,IAAI,EACT,SAAS,CAAC,EAAE,OAAO,GAClB,IAAI,CAAC;IACR,OAAO,IAAI,CAAC,MAAM,GAAG,aAAa,GAAG,WAAW,CAAC,EAAE,CAAC;CACrD;AAED,UAAU,UAAU;IAClB,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,UAAU,gBAAgB;IACxB,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,WAAW,EAAE,aAAa,CAAC;IAC3B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,KAAK,OAAO,CAAC;IAC1E,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,KAAK,OAAO,CAAC;IAC3E,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,UAAU,CAAC;IACtC,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,UAAU,CAAC;CACrC;AAmBD,eAAO,MAAM,UAAU,gFAiXtB,CAAC"}

package/dist/gpu/elementwise-gpu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elementwise-gpu.d.ts","sourceRoot":"","sources":["../../src/gpu/elementwise-gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAOL,KAAK,iBAAiB,EACvB,MAAM,2BAA2B,CAAC;AA+CnC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;CAgCR,CAAC;AAEX,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,YAAY,CAAC;AAEzD,eAAO,MAAM,mBAAmB,EAAE,SAAS,gBAAgB,EAEpC,CAAC;AAExB,sDAAsD;AACtD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,IAAI,SAAS,gBAAgB,EAAE,CAE9F;AAoCD,4DAA4D;AAC5D,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAIhD,eAAO,MAAM,cAAc,gCAAkE,CAAC;AAwG9F,uEAAuE;AACvE,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED,+CAA+C;AAC/C,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACxD;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AA4BD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,EAAE,YAAY,GAAG,YAAY,EAC/B,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAE9B;AA8ID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,EAAE,YAAY,GAAG,YAAY,EAC/B,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAExB"}
+{"version":3,"file":"elementwise-gpu.d.ts","sourceRoot":"","sources":["../../src/gpu/elementwise-gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAQL,KAAK,iBAAiB,EACvB,MAAM,2BAA2B,CAAC;AA+CnC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;CAgCR,CAAC;AAEX,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,YAAY,CAAC;AAEzD,eAAO,MAAM,mBAAmB,EAAE,SAAS,gBAAgB,EAEpC,CAAC;AAExB,sDAAsD;AACtD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,IAAI,SAAS,gBAAgB,EAAE,CAE9F;AAoCD,4DAA4D;AAC5D,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAIhD,eAAO,MAAM,cAAc,gCAAkE,CAAC;AAwG9F,uEAAuE;AACvE,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED,+CAA+C;AAC/C,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACxD;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,EAAE,YAAY,GAAG,YAAY,EAC/B,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAE9B;AA8ID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,EAAE,YAAY,GAAG,YAAY,EAC/B,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAExB"}

package/dist/gpu/fft-gpu.d.ts

@@ -0,0 +1,75 @@
+/**
+ * WebGPU FFT — Stockham autosort, radix-2, f32.
+ *
+ * Why Stockham rather than the textbook Cooley-Tukey the CPU core uses: it is
+ * **self-sorting**. Each pass reads one buffer and scatters into another, so the output
+ * comes out in natural order with **no bit-reversal permutation pass** — and a bit-reversal
+ * is a pure memory shuffle, which is the one thing a GPU is worst at. The ping-pong between
+ * two buffers is also exactly the access pattern the hardware wants.
+ *
+ * ### Is it worth it? (see `FFT_GPU_MIN_ELEMENTS` for the full table)
+ *
+ * Chrome / NVIDIA Pascal, warm JIT, against `fftCoreFloat64` — the flat f64 core that
+ * `parallelFFT` runs on this thread:
+ *
+ * | n         | CPU f64  | GPU f32  | speedup   |
+ * | --------- | -------- | -------- | --------- |
+ * | 65,536    | 16.8 ms  | 14.4 ms  | 1.17×     |
+ * | 262,144   | 53.4 ms  | 24.0 ms  | **2.23×** |
+ * | 1,048,576 | 253.1 ms | 79.7 ms  | **3.18×** |
+ * | 2,097,152 | 399.9 ms | 116.3 ms | **3.44×** |
+ *
+ * (~2.2-3.4x, and the ratio is genuinely noisy run to run — regenerate it with
+ * `gpu-fft-bench.browser.test.ts` rather than trusting a single hero number. f32 error is
+ * ~4e-7 peak-relative at every size above.)
+ *
+ * Two things decided the design:
+ *
+ *  - **The threshold is 262,144, NOT `GPU_MIN_ELEMENTS`.** At 65,536 the GPU wins by 1.17×,
+ *    which is inside the noise and nowhere near enough to justify dropping f64 for f32. An
+ *    FFT makes log2(n) passes over the data, so it amortises the upload more slowly than the
+ *    memory-bound element-wise chain does. Sharing one threshold would have been convenient
+ *    and wrong.
+ *  - **f32 accuracy holds.** Error growth across log2(n) stages was the real risk — it is why
+ *    an f32 FFT is a harder sell than an f32 element-wise chain. Measured ~4e-7 relative to
+ *    the spectrum's peak magnitude even at 20 stages, a few times f32 epsilon. Stockham is
+ *    numerically well-behaved; the error did not compound.
+ *
+ * An earlier revision of this comment claimed 5.0-8.5x. That came from a COLD-JIT CPU
+ * baseline and from comparing against a CPU path `parallelFFT` did not actually take. Both
+ * are fixed; the numbers above are warm, and measured against the path it really runs.
+ *
+ * Same never-throw contract as the rest of the GPU surface: returns `null` — never rejects —
+ * whenever the GPU is unavailable, not opted into, the input is below threshold, not a power
+ * of two, or a device limit is exceeded. The caller then uses the exact f64 CPU path.
+ *
+ * @packageDocumentation
+ */
+import { type GPUContextOptions } from '@danielsimonjr/mathts-gpu';
+/** Drop cached shaders/buffers (device loss, or between tests). */
+export declare function resetGpuFft(): void;
+/** Options for the GPU FFT. `gpu` overrides the process-global `enableGpu()` flag. */
+export interface GpuFftOptions extends GPUContextOptions {
+    /** Force the GPU on/off for this call, ignoring the global flag. */
+    gpu?: boolean;
+}
+/** Result of a GPU FFT: f32-precision values widened into the f64 container. */
+export interface GpuFftResult {
+    real: Float64Array;
+    imag: Float64Array;
+}
+/**
+ * Run an FFT on the GPU.
+ *
+ * `real`/`imag` must be the same length, a power of two, and at least `FFT_GPU_MIN_ELEMENTS`
+ * (262,144) — below that the GPU's margin (1.17× at 65,536) does not justify dropping f64 for
+ * f32, so this declines and the caller keeps the exact CPU path.
+ *
+ * Returns `null` rather than throwing whenever it cannot or should not run, so the caller
+ * simply falls through to the exact f64 CPU path.
+ *
+ * Precision: f32 (~4e-7 relative to the spectrum's peak, measured through 20 stages).
+ * `enableGpu()` is how a caller consents to that.
+ */
+export declare function fftGpuDispatch(real: Float64Array, imag: Float64Array, inverse?: boolean, options?: GpuFftOptions): Promise<GpuFftResult | null>;
+//# sourceMappingURL=fft-gpu.d.ts.map

package/dist/gpu/fft-gpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fft-gpu.d.ts","sourceRoot":"","sources":["../../src/gpu/fft-gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,EAOL,KAAK,iBAAiB,EACvB,MAAM,2BAA2B,CAAC;AAqGnC,mEAAmE;AACnE,wBAAgB,WAAW,IAAI,IAAI,CAKlC;AA6BD,sFAAsF;AACtF,MAAM,WAAW,aAAc,SAAQ,iBAAiB;IACtD,oEAAoE;IACpE,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,YAAY,EAClB,OAAO,UAAQ,EACf,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAe9B"}

package/dist/index.js

@@ -184,6 +184,7 @@ __export(typed_exports, {
   factor: () => factor,
   fallingFactorial: () => fallingFactorial,
   fft2d: () => fft2d,
+  fftGpuDispatch: () => fftGpuDispatch,
   fibonacci: () => fibonacci,
   findRoot: () => findRoot,
   fix: () => fix,
@@ -193,6 +194,7 @@ __export(typed_exports, {
   fresnelC: () => fresnelC,
   fresnelS: () => fresnelS,
   friedmanTest: () => friedmanTest,
+  fsum: () => fsum,
   fullSimplify: () => fullSimplify,
   functionExpand: () => functionExpand,
   fuseUnaryChain: () => fuseUnaryChain,
@@ -240,7 +242,7 @@ __export(typed_exports, {
   invGaussDist: () => invGaussDist,
   isConnected: () => isConnected,
   isGpuChainSupported: () => isGpuChainSupported,
-  isGpuEnabled: () => isGpuEnabled2,
+  isGpuEnabled: () => isGpuEnabled3,
   jacobiSymbol: () => jacobiSymbol,
   jordanForm: () => jordanForm,
   jsDivergence: () => jsDivergence,
@@ -312,7 +314,7 @@ __export(typed_exports, {
   nintegrate: () => nintegrate,
   noncentralChi2PDF: () => noncentralChi2PDF,
   norm: () => norm,
-  norm2: () => norm2,
+  norm2: () => norm22,
   normFro: () => normFro,
   normalCDF: () => normalCDF,
   normalDist: () => normalDist,
@@ -400,6 +402,7 @@ __export(typed_exports, {
   reflectVector: () => reflectVector,
   resample: () => resample,
   resetGpuElementwise: () => resetGpuElementwise,
+  resetGpuFft: () => resetGpuFft,
   residue: () => residue,
   resultant: () => resultant,
   rightArithShift: () => rightArithShift,
@@ -507,6 +510,7 @@ __export(typed_exports, {
 
 // src/typed/arithmetic.ts
 import { mathTyped as mathTyped2, Complex, Fraction, BigNumber, Dual } from "@danielsimonjr/mathts-core";
+import { pairwiseSum, neumaierSum, norm2 } from "@danielsimonjr/mathts-core";
 import { DenseMatrix as DenseMatrix2, backendManager as backendManager2, singularValues } from "@danielsimonjr/mathts-matrix";
 
 // src/factories/matrix-bridge.ts
@@ -2018,11 +2022,10 @@ function vectorNorm(arr7, p = 2) {
   if (p === Infinity) return Math.max(...arr7.map((x) => Math.abs(x)));
   if (p === -Infinity) return Math.min(...arr7.map((x) => Math.abs(x)));
   if (p === 0) return arr7.filter((x) => x !== 0).length;
-  if (p === 2) return Math.sqrt(arr7.reduce((sum3, x) => sum3 + x * x, 0));
-  return Math.pow(
-    arr7.reduce((sum3, x) => sum3 + Math.pow(Math.abs(x), p), 0),
-    1 / p
-  );
+  if (p === 2) return norm2(arr7);
+  const terms = new Array(arr7.length);
+  for (let i = 0; i < arr7.length; i++) terms[i] = Math.pow(Math.abs(arr7[i]), p);
+  return Math.pow(pairwiseSum(terms), 1 / p);
 }
 function matrixNorm(data, p = "fro") {
   const rows = data.length;
@@ -2079,9 +2082,7 @@ var norm = mathTyped2("norm", {
     if (computePool.shouldParallelize(a.length, "norm")) {
       return (await computePool.norm(a)).result;
     }
-    let s = 0;
-    for (let i = 0; i < a.length; i++) s += a[i] * a[i];
-    return Math.sqrt(s);
+    return norm2(a);
   }
 });
 var sinh = mathTyped2("sinh", {
@@ -2213,15 +2214,28 @@ var max = mathTyped2("max", {
     return m;
   }
 });
+var fsum = mathTyped2("fsum", {
+  Array: (arr7) => neumaierSum(arr7),
+  Float64Array: (a) => neumaierSum(a)
+});
 var sum = mathTyped2("sum", {
-  Array: (arr7) => {
-    let total = 0;
-    for (let i = 0; i < arr7.length; i++) {
-      total += arr7[i];
-    }
-    return total;
-  },
-  // Parallel Float64Array sum
+  // PAIRWISE summation, not `total += arr[i]`.
+  //
+  // Naive accumulation lets the running total grow large while the addends stay small, so each
+  // addition rounds off a bit more of the total: error grows as O(n)*eps. Measured on 1e6 copies
+  // of 0.1 (exact answer 100000):
+  //
+  //     naive (what shipped)  relative error 1.3e-11
+  //     pairwise (this)       relative error 2.9e-16   <- identical to NumPy's np.sum
+  //
+  // We were ~46,000x less accurate than NumPy on a bog-standard `sum`, and `mean`/`std`/`variance`
+  // all inherit it. Pairwise costs the same number of additions — the naive loop was simply worse.
+  // For catastrophic cancellation (e.g. [1e16, 1, -1e16], which pairwise AND np.sum both
+  // annihilate to 0) use `fsum`.
+  Array: (arr7) => pairwiseSum(arr7),
+  // Float64Array: the pool's sequential branch is pairwise too (see ComputePool.sum), and its
+  // parallel branch sums per-chunk then combines — blocked summation, which is pairwise-like.
+  // Either way the O(n) drift is gone.
   Float64Array: async (a) => {
     const result = await computePool.sum(a);
     return result.result;
@@ -2230,11 +2244,7 @@ var sum = mathTyped2("sum", {
 var mean = mathTyped2("mean", {
   Array: (arr7) => {
     if (arr7.length === 0) return NaN;
-    let total = 0;
-    for (let i = 0; i < arr7.length; i++) {
-      total += arr7[i];
-    }
-    return total / arr7.length;
+    return pairwiseSum(arr7) / arr7.length;
   },
   // Parallel Float64Array mean
   Float64Array: async (a) => {
@@ -3256,6 +3266,179 @@ function fftCoreFloat64(realIn, imagIn, inverse = false) {
   return { real, imag };
 }
 
+// src/gpu/fft-gpu.ts
+import {
+  getGpuDevice,
+  getGlobalGPUContext,
+  isGpuEnabled,
+  ShaderManager,
+  BufferPool,
+  serializeGpu
+} from "@danielsimonjr/mathts-gpu";
+var WORKGROUP_SIZE = 64;
+var FFT_GPU_MIN_ELEMENTS = 262144;
+var SHADER_KEY = "fft:stockham";
+var STOCKHAM_WGSL = `
+  @group(0) @binding(0) var<storage, read> src: array<vec2<f32>>;
+  @group(0) @binding(1) var<storage, read_write> dst: array<vec2<f32>>;
+  @group(0) @binding(2) var<uniform> params: vec4<u32>; // n, ns, inverse, _
+
+  fn cmul(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+    return vec2<f32>(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
+  }
+
+  @compute @workgroup_size(${WORKGROUP_SIZE})
+  fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let n = params.x;
+    let ns = params.y;
+    let half = n / 2u;
+    let i = gid.x;
+    if (i >= half) { return; }
+
+    // -1 forward, +1 inverse \u2014 the same sign convention as the CPU core, so the two
+    // implementations agree on which direction is which.
+    let sgn = select(-1.0, 1.0, params.z == 1u);
+    let angle = sgn * 2.0 * 3.14159265358979323846 * f32(i % ns) / f32(ns * 2u);
+    let tw = vec2<f32>(cos(angle), sin(angle));
+
+    let v0 = src[i];
+    let v1 = cmul(src[i + half], tw);
+
+    let idxD = (i / ns) * ns * 2u + (i % ns);
+    dst[idxD] = v0 + v1;
+    dst[idxD + ns] = v0 - v1;
+  }
+`;
+var resources = null;
+async function getResources(options) {
+  const device = await getGpuDevice(options);
+  if (!device) return null;
+  if (resources && resources.device === device) return resources;
+  if (resources) resetGpuFft();
+  const ctx = getGlobalGPUContext();
+  const shaders = new ShaderManager(ctx);
+  shaders.registerShader(SHADER_KEY, STOCKHAM_WGSL);
+  shaders.precompileRegistered();
+  resources = { device, shaders, pool: new BufferPool(ctx), stageUniforms: /* @__PURE__ */ new Map() };
+  return resources;
+}
+function resetGpuFft() {
+  if (!resources) return;
+  for (const bufs of resources.stageUniforms.values()) bufs.forEach((b) => b.destroy());
+  resources.pool.destroy();
+  resources = null;
+}
+function stageUniformsFor(res, n, inverse) {
+  const key = `${n}:${inverse ? 1 : 0}`;
+  const cached = res.stageUniforms.get(key);
+  if (cached) return cached;
+  const stages = Math.log2(n);
+  const bufs = [];
+  for (let s = 0, ns = 1; s < stages; s++, ns *= 2) {
+    const u = res.device.createBuffer({
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: `fft-stage-${s}`
+    });
+    res.device.queue.writeBuffer(u, 0, new Uint32Array([n, ns, inverse ? 1 : 0, 0]));
+    bufs.push(u);
+  }
+  res.stageUniforms.set(key, bufs);
+  return bufs;
+}
+var isPowerOf2 = (n) => n > 0 && (n & n - 1) === 0;
+function fftGpuDispatch(real, imag, inverse = false, options) {
+  const n = real.length;
+  if (!(options?.gpu ?? isGpuEnabled())) return Promise.resolve(null);
+  if (imag.length !== n) return Promise.resolve(null);
+  if (n < FFT_GPU_MIN_ELEMENTS) return Promise.resolve(null);
+  if (!isPowerOf2(n)) return Promise.resolve(null);
+  return serializeGpu(() => fftGpuDispatchImpl(real, imag, inverse, options));
+}
+async function fftGpuDispatchImpl(real, imag, inverse, options) {
+  const n = real.length;
+  const bytes = n * 8;
+  const workgroups = Math.ceil(n / 2 / WORKGROUP_SIZE);
+  let res;
+  let bufA;
+  let bufB;
+  let staging;
+  let scopePushed = false;
+  let scopePopped = false;
+  try {
+    const r = await getResources(options);
+    if (!r) return null;
+    res = r;
+    const { device, shaders, pool } = r;
+    const limits = device.limits;
+    if (workgroups > limits.maxComputeWorkgroupsPerDimension) return null;
+    if (bytes > limits.maxStorageBufferBindingSize) return null;
+    if (bytes > limits.maxBufferSize) return null;
+    const stageUniforms = stageUniformsFor(r, n, inverse);
+    const input = new Float32Array(n * 2);
+    for (let i = 0; i < n; i++) {
+      input[i * 2] = real[i];
+      input[i * 2 + 1] = imag[i];
+    }
+    device.pushErrorScope("validation");
+    scopePushed = true;
+    bufA = pool.acquireStorageBuffer(bytes, "fft-a", true, true);
+    bufB = pool.acquireStorageBuffer(bytes, "fft-b", true, true);
+    staging = pool.acquireStagingBuffer(bytes, "fft-staging");
+    device.queue.writeBuffer(bufA, 0, input);
+    const pipeline = shaders.getRegisteredPipeline(SHADER_KEY);
+    const encoder = device.createCommandEncoder({ label: "fft-stockham" });
+    let src = bufA;
+    let dst2 = bufB;
+    for (let s = 0; s < stageUniforms.length; s++) {
+      const bindGroup = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: src } },
+          { binding: 1, resource: { buffer: dst2 } },
+          { binding: 2, resource: { buffer: stageUniforms[s] } }
+        ]
+      });
+      const pass = encoder.beginComputePass({ label: `fft-stage-${s}` });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bindGroup);
+      pass.dispatchWorkgroups(workgroups);
+      pass.end();
+      [src, dst2] = [dst2, src];
+    }
+    encoder.copyBufferToBuffer(src, 0, staging, 0, bytes);
+    device.queue.submit([encoder.finish()]);
+    const validationError = await device.popErrorScope();
+    scopePopped = true;
+    if (validationError) return null;
+    await staging.mapAsync(GPUMapMode.READ, 0, bytes);
+    const packed = new Float32Array(staging.getMappedRange(0, bytes).slice(0));
+    staging.unmap();
+    const outRe = new Float64Array(n);
+    const outIm = new Float64Array(n);
+    const scale = inverse ? 1 / n : 1;
+    for (let i = 0; i < n; i++) {
+      outRe[i] = packed[i * 2] * scale;
+      outIm[i] = packed[i * 2 + 1] * scale;
+    }
+    return { real: outRe, imag: outIm };
+  } catch {
+    return null;
+  } finally {
+    if (res && scopePushed && !scopePopped) {
+      try {
+        await res.device.popErrorScope();
+      } catch {
+      }
+    }
+    if (res) {
+      if (bufA) res.pool.release(bufA);
+      if (bufB) res.pool.release(bufB);
+      if (staging) res.pool.release(staging);
+    }
+  }
+}
+
 // src/typed/signal.ts
 import { computePool as computePool4 } from "@danielsimonjr/mathts-parallel";
 
@@ -3582,7 +3765,7 @@ function chirpZTransformDispatch(samples, m, phiStartRe, phiStartIm, phiStepRe,
 
 // src/typed/signal.ts
 var WASM_THRESHOLD = 64;
-function isPowerOf2(n) {
+function isPowerOf22(n) {
   return n > 0 && (n & n - 1) === 0;
 }
 function nextPowerOf2(n) {
@@ -3591,7 +3774,7 @@ function nextPowerOf2(n) {
 }
 async function fourStepFFT(real, imag, inverse) {
   const N = real.length;
-  if (N < 4 || !isPowerOf2(N)) {
+  if (N < 4 || !isPowerOf22(N)) {
     return fftCoreFloat64(real, imag, inverse);
   }
   const bits = Math.round(Math.log2(N));
@@ -3665,23 +3848,29 @@ var parallelFFT = mathTyped5("parallelFFT", {
     const real = new Float64Array(paddedLength);
     const imag = new Float64Array(paddedLength);
     real.set(signal);
-    const result = computePool4.shouldParallelize(paddedLength) ? await fourStepFFT(real, imag, false) : fftCoreFloat64(real, imag, false);
+    const gpu = await fftGpuDispatch(real, imag, false);
+    if (gpu) return { real: gpu.real, imag: gpu.imag, originalLength: n };
+    const result = computePool4.shouldParallelize(paddedLength, "parallelFFT") ? await fourStepFFT(real, imag, false) : fftCoreFloat64(real, imag, false);
     return { ...result, originalLength: n };
   }
 });
 var parallelIFFT = mathTyped5("parallelIFFT", {
   // IFFT from real/imag arrays
   "Float64Array, Float64Array": async (real, imag) => {
-    return computePool4.shouldParallelize(real.length) ? fourStepFFT(real, imag, true) : fftCoreFloat64(real, imag, true);
+    const gpu = await fftGpuDispatch(real, imag, true);
+    if (gpu) return gpu;
+    return computePool4.shouldParallelize(real.length, "parallelFFT") ? fourStepFFT(real, imag, true) : fftCoreFloat64(real, imag, true);
   },
   // IFFT from object with real/imag
   Object: async (spectrum) => {
-    return computePool4.shouldParallelize(spectrum.real.length) ? fourStepFFT(spectrum.real, spectrum.imag, true) : fftCoreFloat64(spectrum.real, spectrum.imag, true);
+    const gpu = await fftGpuDispatch(spectrum.real, spectrum.imag, true);
+    if (gpu) return gpu;
+    return computePool4.shouldParallelize(spectrum.real.length, "parallelFFT") ? fourStepFFT(spectrum.real, spectrum.imag, true) : fftCoreFloat64(spectrum.real, spectrum.imag, true);
   }
 });
 var parallelFFTMagnitude = mathTyped5("parallelFFTMagnitude", {
   "Float64Array, Float64Array": async (real, imag) => {
-    if (computePool4.shouldParallelize(real.length)) {
+    if (computePool4.shouldParallelize(real.length, "parallelFFT")) {
       const r = await computePool4.applyKernel2(
         real,
         imag,
@@ -3701,7 +3890,7 @@ var parallelFFTMagnitude = mathTyped5("parallelFFTMagnitude", {
 });
 var parallelFFTPower = mathTyped5("parallelFFTPower", {
   "Float64Array, Float64Array": async (real, imag) => {
-    if (computePool4.shouldParallelize(real.length)) {
+    if (computePool4.shouldParallelize(real.length, "parallelFFT")) {
       const r = await computePool4.applyKernel2(real, imag, "(re, im) => re * re + im * im");
       return r.result;
     }
@@ -7348,12 +7537,13 @@ var typedSpecial = {
 
 // src/gpu/elementwise-gpu.ts
 import {
-  getGpuDevice,
-  getGlobalGPUContext,
-  isGpuEnabled,
+  getGpuDevice as getGpuDevice2,
+  getGlobalGPUContext as getGlobalGPUContext2,
+  isGpuEnabled as isGpuEnabled2,
   GPU_MIN_ELEMENTS,
-  ShaderManager,
-  BufferPool
+  ShaderManager as ShaderManager2,
+  BufferPool as BufferPool2,
+  serializeGpu as serializeGpu2
 } from "@danielsimonjr/mathts-gpu";
 var WGSL_IEEE = `
   // NaN / \xB1Inf are supplied through the UNIFORM, not written as literals.
@@ -7426,7 +7616,7 @@ var GPU_ELEMENTWISE_OPS = Object.keys(
 function isGpuChainSupported(ops) {
   return ops.every((op) => op in WGSL_OP_BODY);
 }
-var WORKGROUP_SIZE = 256;
+var WORKGROUP_SIZE2 = 256;
 function wgslFor(op) {
   return `
     @group(0) @binding(0) var<storage, read> inp: array<f32>;
@@ -7439,7 +7629,7 @@ function wgslFor(op) {
       ${WGSL_OP_BODY[op]}
     }
 
-    @compute @workgroup_size(${WORKGROUP_SIZE})
+    @compute @workgroup_size(${WORKGROUP_SIZE2})
     fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
       let i = gid.x;
       if (i >= params.x) { return; }
@@ -7464,12 +7654,12 @@ function wgslForReduce(r) {
     ${WGSL_IEEE}
 
     // NOTE: "shared" is a RESERVED WORD in WGSL \u2014 this must not be named that.
-    var<workgroup> sdata: array<f32, ${WORKGROUP_SIZE}>;
+    var<workgroup> sdata: array<f32, ${WORKGROUP_SIZE2}>;
 
     fn identity() -> f32 { return ${identity2}; }
     fn combine(a: f32, b: f32) -> f32 { return ${combine2}; }
 
-    @compute @workgroup_size(${WORKGROUP_SIZE})
+    @compute @workgroup_size(${WORKGROUP_SIZE2})
     fn main(@builtin(global_invocation_id) gid: vec3<u32>,
             @builtin(local_invocation_id) lid: vec3<u32>,
             @builtin(workgroup_id) wid: vec3<u32>) {
@@ -7478,7 +7668,7 @@ function wgslForReduce(r) {
       sdata[lid.x] = v;
       workgroupBarrier();
 
-      var s: u32 = ${WORKGROUP_SIZE}u / 2u;
+      var s: u32 = ${WORKGROUP_SIZE2}u / 2u;
       loop {
         if (s == 0u) { break; }
         if (lid.x < s) { sdata[lid.x] = combine(sdata[lid.x], sdata[lid.x + s]); }
@@ -7489,13 +7679,13 @@ function wgslForReduce(r) {
     }
   `;
 }
-var resources = null;
-async function getResources(options) {
-  const device = await getGpuDevice(options);
+var resources2 = null;
+async function getResources2(options) {
+  const device = await getGpuDevice2(options);
   if (!device) return null;
-  if (resources && resources.device === device) return resources;
-  const ctx = getGlobalGPUContext();
-  const shaders = new ShaderManager(ctx);
+  if (resources2 && resources2.device === device) return resources2;
+  const ctx = getGlobalGPUContext2();
+  const shaders = new ShaderManager2(ctx);
   for (const op of GPU_ELEMENTWISE_OPS) {
     shaders.registerShader(op, wgslFor(op));
   }
@@ -7503,31 +7693,25 @@ async function getResources(options) {
     shaders.registerShader(reduceKey(r), wgslForReduce(r));
   }
   shaders.precompileRegistered();
-  resources = { device, shaders, pool: new BufferPool(ctx) };
-  return resources;
+  resources2 = { device, shaders, pool: new BufferPool2(ctx) };
+  return resources2;
 }
 function resetGpuElementwise() {
-  resources?.pool.destroy();
-  resources = null;
-}
-var gpuQueue = Promise.resolve();
-function serializeGpu(run) {
-  const next = gpuQueue.then(run, run);
-  gpuQueue = next.catch(() => void 0);
-  return next;
+  resources2?.pool.destroy();
+  resources2 = null;
 }
 function elementwiseChainGpuDispatch(ops, xs, options) {
-  return serializeGpu(() => chainGpuDispatchImpl(ops, xs, options));
+  return serializeGpu2(() => chainGpuDispatchImpl(ops, xs, options));
 }
 async function chainGpuDispatchImpl(ops, xs, options) {
   const n = xs.length;
-  const enabled = options?.gpu ?? isGpuEnabled();
+  const enabled = options?.gpu ?? isGpuEnabled2();
   if (!enabled) return null;
   if (ops.length === 0) return null;
   if (n < GPU_MIN_ELEMENTS) return null;
   if (!isGpuChainSupported(ops)) return null;
   const bytes = n * 4;
-  const workgroups = Math.ceil(n / WORKGROUP_SIZE);
+  const workgroups = Math.ceil(n / WORKGROUP_SIZE2);
   let res;
   let bufA;
   let bufB;
@@ -7536,7 +7720,7 @@ async function chainGpuDispatchImpl(ops, xs, options) {
   let scopePushed = false;
   let scopePopped = false;
   try {
-    const r = await getResources(options);
+    const r = await getResources2(options);
     if (!r) return null;
     res = r;
     const { device, shaders, pool } = r;
@@ -7600,18 +7784,18 @@ async function chainGpuDispatchImpl(ops, xs, options) {
   }
 }
 function elementwiseChainReduceGpuDispatch(ops, xs, reduce3, options) {
-  return serializeGpu(() => chainReduceGpuDispatchImpl(ops, xs, reduce3, options));
+  return serializeGpu2(() => chainReduceGpuDispatchImpl(ops, xs, reduce3, options));
 }
 async function chainReduceGpuDispatchImpl(ops, xs, reduce3, options) {
   const n = xs.length;
-  const enabled = options?.gpu ?? isGpuEnabled();
+  const enabled = options?.gpu ?? isGpuEnabled2();
   if (!enabled) return null;
   if (ops.length === 0) return null;
   if (n < GPU_MIN_ELEMENTS) return null;
   if (!isGpuChainSupported(ops)) return null;
   if (!GPU_REDUCE_OPS.includes(reduce3)) return null;
   const bytes = n * 4;
-  const workgroups = Math.ceil(n / WORKGROUP_SIZE);
+  const workgroups = Math.ceil(n / WORKGROUP_SIZE2);
   const partialBytes = workgroups * 4;
   let res;
   let bufA;
@@ -7622,7 +7806,7 @@ async function chainReduceGpuDispatchImpl(ops, xs, reduce3, options) {
   let scopePushed = false;
   let scopePopped = false;
   try {
-    const r = await getResources(options);
+    const r = await getResources2(options);
     if (!r) return null;
     res = r;
     const { device, shaders, pool } = r;
@@ -16071,7 +16255,7 @@ var pinv = mathTyped13("pinv", {
 var cond = mathTyped13("cond", {
   Array: (A) => matrixCond(A)
 });
-var norm2 = mathTyped13("norm2", {
+var norm22 = mathTyped13("norm2", {
   Array: (A) => matrixNorm2(A)
 });
 var normFro = mathTyped13("normFro", {
@@ -16135,7 +16319,7 @@ async function gpuScale(a, scalar) {
 }
 
 // src/typed/index.ts
-import { enableGpu, disableGpu, isGpuEnabled as isGpuEnabled2, GPU_MIN_ELEMENTS as GPU_MIN_ELEMENTS2 } from "@danielsimonjr/mathts-gpu";
+import { enableGpu, disableGpu, isGpuEnabled as isGpuEnabled3, GPU_MIN_ELEMENTS as GPU_MIN_ELEMENTS2 } from "@danielsimonjr/mathts-gpu";
 
 // src/typed/relational.ts
 import naturalSort from "javascript-natural-sort";
@@ -26172,7 +26356,7 @@ var createCumSum = /* @__PURE__ */ factory(
 );
 
 // src/statistics/sum.ts
-var WASM_SUM_THRESHOLD = 100;
+import { pairwiseSum as pairwiseSum2 } from "@danielsimonjr/mathts-core";
 function isFlatNumberArray3(arr7) {
   for (let i = 0; i < arr7.length; i++) {
     if (typeof arr7[i] !== "number") {
@@ -26205,21 +26389,8 @@ var createSum = /* @__PURE__ */ factory(
       }
     });
     function _sum(array) {
-      if (Array.isArray(array) && array.length >= WASM_SUM_THRESHOLD) {
-        if (isFlatNumberArray3(array)) {
-          const wasm = wasmLoader.getModule();
-          if (wasm) {
-            try {
-              const alloc = wasmLoader.allocateFloat64Array(array);
-              try {
-                return wasm.statsSum(alloc.ptr, array.length);
-              } finally {
-                wasmLoader.free(alloc.ptr);
-              }
-            } catch {
-            }
-          }
-        }
+      if (Array.isArray(array) && isFlatNumberArray3(array)) {
+        return pairwiseSum2(array);
       }
       let sum3;
       deepForEach2(array, function(value) {
@@ -31758,7 +31929,7 @@ var createSplitUnit = /* @__PURE__ */ factory(
 
 // src/matrix/fft.ts
 var FAST_FFT_THRESHOLD = 64;
-function isPowerOf22(n) {
+function isPowerOf23(n) {
   return n > 0 && (n & n - 1) === 0;
 }
 function complexToInterleaved(arr7, _complex) {
@@ -31897,7 +32068,7 @@ var createFft = /* @__PURE__ */ factory(
     function _fft(arr7, len) {
       const length = len ?? arr7.length;
       if (length === 1) return [arr7[0]];
-      if (length === arr7.length && length >= FAST_FFT_THRESHOLD && isPowerOf22(length)) {
+      if (length === arr7.length && length >= FAST_FFT_THRESHOLD && isPowerOf23(length)) {
         const interleaved = complexToInterleaved(arr7, complex2);
         if (interleaved) {
           const real = new Float64Array(length);
@@ -32205,7 +32376,7 @@ var createDivide = /* @__PURE__ */ factory(
 
 // src/matrix/ifft.ts
 var FAST_IFFT_THRESHOLD = 64;
-function isPowerOf23(n) {
+function isPowerOf24(n) {
   return n > 0 && (n & n - 1) === 0;
 }
 function complexToInterleaved2(arr7, _complex) {
@@ -32245,7 +32416,7 @@ var createIfft = /* @__PURE__ */ factory(
         const totalSize = size2.reduce((acc, curr) => acc * curr, 1);
         if (size2.length === 1) {
           const length = size2[0];
-          if (length >= FAST_IFFT_THRESHOLD && isPowerOf23(length)) {
+          if (length >= FAST_IFFT_THRESHOLD && isPowerOf24(length)) {
             const arrData = isMatrix(arr7) ? arr7.valueOf() : arr7;
             const interleaved = complexToInterleaved2(arrData, complex2);
             if (interleaved) {
@@ -39550,6 +39721,7 @@ var createDerivative = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/norm.ts
+import { norm2 as norm23 } from "@danielsimonjr/mathts-core";
 var WASM_NORM_THRESHOLD = 100;
 var name245 = "norm";
 var dependencies245 = [
@@ -39746,6 +39918,12 @@ var createNorm = /* @__PURE__ */ factory(
       throw new Error("Unsupported parameter value " + p);
     }
     function _norm(x, p) {
+      if ((p === 2 || p === "fro") && x.size().length === 1) {
+        const v = x.valueOf();
+        if (v.every((e) => typeof e === "number")) {
+          return norm23(v);
+        }
+      }
       const sizeX = x.size();
       if (sizeX.length === 1) {
         return _vectorNorm(x, p);
@@ -44678,7 +44856,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
   let x = Array.from(x0);
   let lambda = 1e-3;
   const h = 1e-7;
-  const norm22 = (v) => v.reduce((s, c) => s + c * c, 0);
+  const norm24 = (v) => v.reduce((s, c) => s + c * c, 0);
   const jacobian2 = (xc, r0) => {
     const m = r0.length;
     const J = Array.from({ length: m }, () => new Array(n).fill(0));
@@ -44691,7 +44869,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
     return J;
   };
   let r = residual(x);
-  let cost = norm22(r);
+  let cost = norm24(r);
   let iter = 0;
   for (; iter < maxIter; iter++) {
     const J = jacobian2(x, r);
@@ -44722,7 +44900,7 @@ function levenbergMarquardt(residual, x0, opts = {}) {
     }
     const xNew = x.map((v, i) => v + delta[i]);
     const rNew = residual(xNew);
-    const costNew = norm22(rNew);
+    const costNew = norm24(rNew);
     if (costNew < cost) {
       x = xNew;
       r = rNew;
@@ -45464,6 +45642,7 @@ export {
   fermiCoupling,
   fft,
   fft2d,
+  fftGpuDispatch,
   fibonacci,
   filter2 as filter,
   filtfilt,
@@ -45484,6 +45663,7 @@ export {
   fresnelC,
   fresnelS,
   friedmanTest,
+  fsum,
   fullSimplify,
   functionExpand,
   fuseUnaryChain,
@@ -45568,7 +45748,7 @@ export {
   isConnected,
   isFinite2 as isFinite,
   isGpuChainSupported,
-  isGpuEnabled2 as isGpuEnabled,
+  isGpuEnabled3 as isGpuEnabled,
   isInteger2 as isInteger,
   isNaN2 as isNaN,
   isNegative,
@@ -45705,7 +45885,7 @@ export {
   nodeOperations,
   noncentralChi2PDF,
   norm,
-  norm2,
+  norm22 as norm2,
   normFro,
   normalCDF,
   normalDist,
@@ -45832,6 +46012,7 @@ export {
   replacer,
   resample,
   resetGpuElementwise,
+  resetGpuFft,
   reshape2 as reshape,
   residue,
   resize2 as resize,

package/dist/statistics/sum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sum.d.ts","sourceRoot":"","sources":["../../src/statistics/sum.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA2BvD,UAAU,eAAe;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,aAAa,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,qBAAqB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACnD;AAKD,eAAO,MAAM,SAAS,yEAmHrB,CAAC"}
+{"version":3,"file":"sum.d.ts","sourceRoot":"","sources":["../../src/statistics/sum.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA0BvD,UAAU,eAAe;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,aAAa,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,qBAAqB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACnD;AAKD,eAAO,MAAM,SAAS,yEAmHrB,CAAC"}

package/dist/typed/arithmetic.d.ts

@@ -186,6 +186,20 @@ export declare const max: import("typed-function").TypedFunction;
 /**
  * Sum with parallel array support
  */
+/**
+ * Exactly-rounded sum — the equivalent of Python's `math.fsum` / NumPy's `math.fsum` idiom.
+ *
+ * `sum` uses pairwise summation, which is accurate to ~machine epsilon and free. But pairwise
+ * cannot recover a value that has already been annihilated by catastrophic cancellation:
+ *
+ *     sum([1e16, 1, -1e16])   ->  0     (so does np.sum — the 1 is lost the moment it meets 1e16)
+ *     fsum([1e16, 1, -1e16])  ->  1     (exact)
+ *
+ * Neumaier compensation tracks the low-order bits each addition discards and folds them back in.
+ * ~2-4x slower than `sum`, so it is opt-in. Reach for it when the result is a small difference of
+ * large terms: conservation checks, residuals, long-running accumulators.
+ */
+export declare const fsum: import("typed-function").TypedFunction;
 export declare const sum: import("typed-function").TypedFunction;
 /**
  * Mean with parallel array support

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

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

package/dist/typed/index.d.ts

@@ -48,6 +48,7 @@ export { cond } from './matrix-ops.js';
 export * from './gpu.js';
 export { enableGpu, disableGpu, isGpuEnabled, GPU_MIN_ELEMENTS } from '@danielsimonjr/mathts-gpu';
 export { elementwiseChainGpuDispatch, elementwiseChainReduceGpuDispatch, GPU_REDUCE_OPS, type GpuReduceOp, isGpuChainSupported, resetGpuElementwise, GPU_ELEMENTWISE_OPS, type GpuElementwiseOp, type GpuChainOptions, } from '../gpu/elementwise-gpu.js';
+export { fftGpuDispatch, resetGpuFft, type GpuFftOptions, type GpuFftResult, } from '../gpu/fft-gpu.js';
 export * from './relational.js';
 export { typedRelational } from './relational.js';
 export * from './string.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5C,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGxD,cAAc,eAAe,CAAC;AAG9B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,kBAAkB,CAAC;AAGjC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,YAAY,CAAC;AAG3B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,iBAAiB,CAAC;AAWhC,cAAc,iBAAiB,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAGvC,cAAc,UAAU,CAAC;AAIzB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClG,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,cAAc,EACd,KAAK,WAAW,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,2BAA2B,CAAC;AAInC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAsCtC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5C,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGxD,cAAc,eAAe,CAAC;AAG9B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,kBAAkB,CAAC;AAGjC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,YAAY,CAAC;AAG3B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,iBAAiB,CAAC;AAWhC,cAAc,iBAAiB,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAGvC,cAAc,UAAU,CAAC;AAIzB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClG,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,cAAc,EACd,KAAK,WAAW,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EACL,cAAc,EACd,WAAW,EACX,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,mBAAmB,CAAC;AAI3B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAsCtC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B1B,CAAC"}

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.20.2",
+  "version": "0.22.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -34,11 +34,11 @@
     "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.6.0",
-    "@danielsimonjr/mathts-expression": "^0.6.0",
-    "@danielsimonjr/mathts-gpu": "^0.1.1",
-    "@danielsimonjr/mathts-matrix": "^0.4.0",
-    "@danielsimonjr/mathts-parallel": "^0.3.4",
+    "@danielsimonjr/mathts-core": "^0.7.0",
+    "@danielsimonjr/mathts-expression": "^0.6.1",
+    "@danielsimonjr/mathts-gpu": "^0.2.0",
+    "@danielsimonjr/mathts-matrix": "^0.4.2",
+    "@danielsimonjr/mathts-parallel": "^0.4.0",
     "bignumber.js": "^9.1.2",
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",