@danielsimonjr/mathts-functions 0.20.2 → 0.21.0

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,
@@ -240,7 +241,7 @@ __export(typed_exports, {
   invGaussDist: () => invGaussDist,
   isConnected: () => isConnected,
   isGpuChainSupported: () => isGpuChainSupported,
-  isGpuEnabled: () => isGpuEnabled2,
+  isGpuEnabled: () => isGpuEnabled3,
   jacobiSymbol: () => jacobiSymbol,
   jordanForm: () => jordanForm,
   jsDivergence: () => jsDivergence,
@@ -400,6 +401,7 @@ __export(typed_exports, {
   reflectVector: () => reflectVector,
   resample: () => resample,
   resetGpuElementwise: () => resetGpuElementwise,
+  resetGpuFft: () => resetGpuFft,
   residue: () => residue,
   resultant: () => resultant,
   rightArithShift: () => rightArithShift,
@@ -3256,6 +3258,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 +3757,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 +3766,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 +3840,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 +3882,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 +7529,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 +7608,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 +7621,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 +7646,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 +7660,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 +7671,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 +7685,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 +7712,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 +7776,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 +7798,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;
@@ -16135,7 +16311,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";
@@ -31758,7 +31934,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 +32073,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 +32381,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 +32421,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) {
@@ -45464,6 +45640,7 @@ export {
   fermiCoupling,
   fft,
   fft2d,
+  fftGpuDispatch,
   fibonacci,
   filter2 as filter,
   filtfilt,
@@ -45568,7 +45745,7 @@ export {
   isConnected,
   isFinite2 as isFinite,
   isGpuChainSupported,
-  isGpuEnabled2 as isGpuEnabled,
+  isGpuEnabled3 as isGpuEnabled,
   isInteger2 as isInteger,
   isNaN2 as isNaN,
   isNegative,
@@ -45832,6 +46009,7 @@ export {
   replacer,
   resample,
   resetGpuElementwise,
+  resetGpuFft,
   reshape2 as reshape,
   residue,
   resize2 as resize,

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.21.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -36,8 +36,8 @@
   "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-gpu": "^0.2.0",
+    "@danielsimonjr/mathts-matrix": "^0.4.1",
     "@danielsimonjr/mathts-parallel": "^0.3.4",
     "bignumber.js": "^9.1.2",
     "complex.js": "^2.2.5",