@danielsimonjr/mathts-functions 0.17.1 → 0.18.0

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

@@ -2,52 +2,58 @@
  * WebGPU fused element-wise chain.
  *
  * Why a *chain* and not a single op: a lone element-wise op on the GPU is pure
- * transfer tax — upload n floats, do one flop each, read n floats back. The
- * same memory-bound economics retired element-wise ops from the WASM backend.
- * A **fused chain** uploads once, runs every op in the chain on-device by
- * ping-ponging two storage buffers, and reads back once, so the transfer cost
- * is amortized across the whole chain.
+ * transfer tax — upload n floats, do one flop each, read n floats back. A
+ * **fused chain** uploads once, runs every op on-device by ping-ponging two
+ * storage buffers, and reads back once, so the transfer is amortized across the
+ * whole chain.
  *
- * Contract (mirrors the WASM `elementwiseChainDispatch`): this is a
- * **never-throw** best-effort fast path. It returns `null` — never rejects —
- * whenever the GPU is unavailable, not opted in, the input is too small, or the
- * chain contains an op with no GPU kernel. The caller then falls through to the
- * existing WASM/JS tiers.
+ * **Read this before reaching for the GPU:** for element-wise work the GPU is
+ * *slower* than WASM (~1.9×, measured) *and* less precise (f32 vs f64). It earns
+ * its place only where WASM cannot load. `fuseUnaryChainAsync` therefore tries
+ * WASM first. The GPU wins decisively on **compute-bound** work — see
+ * `gpuMatmul`, where O(n³) arithmetic amortizes the O(n²) transfer.
  *
- * Precision: the GPU path computes in **f32** (WGSL has no f64). This is why it
- * is gated behind the explicit `enableGpu()` opt-in.
+ * Contract (mirrors the WASM `elementwiseChainDispatch`): a **never-throw**
+ * best-effort fast path. It returns `null` — never rejects — whenever the GPU is
+ * unavailable, not opted in, the input is too small, or the chain contains an op
+ * with no GPU kernel. The caller then falls through to the CPU tiers.
  */
 import { type GPUContextOptions } from '@danielsimonjr/mathts-gpu';
-/**
- * WGSL expressions for each supported op, as a function of `x`.
- *
- * Deliberately a SUBSET of the WASM op set. `erfc` is absent: WGSL has no
- * `erfc` builtin, and hand-rolling a polynomial approximation would silently
- * change the accuracy contract. A chain containing an unsupported op returns
- * `null` and falls back, rather than quietly computing something else.
- */
 declare const WGSL_OP_BODY: {
     readonly abs: "return abs(x);";
     readonly sin: "return sin(x);";
     readonly cos: "return cos(x);";
     readonly tan: "return tan(x);";
     readonly exp: "return exp(x);";
-    readonly log: "return log(x);";
     readonly atan: "return atan(x);";
     readonly sinh: "return sinh(x);";
     readonly tanh: "return tanh(x);";
-    readonly atanh: "return atanh(x);";
-    readonly log2: "return log2(x);";
-    readonly log10: "return log(x) * 0.4342944819032518;";
-    readonly sec: "return 1.0 / cos(x);";
-    readonly csc: "return 1.0 / sin(x);";
-    readonly cot: "return 1.0 / tan(x);";
+    readonly log: "return safe_log(x);";
+    readonly log2: "return safe_log(x) * 1.4426950408889634;";
+    readonly log10: "return safe_log(x) * 0.4342944819032518;";
+    readonly atanh: "return safe_atanh(x);";
+    readonly sec: "return safe_recip(cos(x));";
+    readonly csc: "return safe_recip(sin(x));";
+    readonly cot: "return safe_recip(tan(x));";
 };
 /** Ops that have a GPU kernel. A chain outside this set falls back. */
 export type GpuElementwiseOp = keyof typeof WGSL_OP_BODY;
 export declare const GPU_ELEMENTWISE_OPS: GpuElementwiseOp[];
 /** Whether every op in the chain has a GPU kernel. */
 export declare function isGpuChainSupported(ops: readonly string[]): ops is readonly GpuElementwiseOp[];
+/** Drop the cached shaders/buffers (device loss, or between tests). */
+export declare function resetGpuElementwise(): void;
+/** Options for a GPU element-wise dispatch. */
+export interface GpuChainOptions extends GPUContextOptions {
+    /**
+     * Per-call override of the global `enableGpu()` flag.
+     *
+     * The global flag is process-wide mutable state: any dependency that calls
+     * `enableGpu()` would otherwise change *your* call's behaviour. Passing `gpu`
+     * explicitly makes a call self-describing and immune to that.
+     */
+    gpu?: boolean;
+}
 /**
  * Run a fused element-wise chain on the GPU.
  *
@@ -55,6 +61,6 @@ export declare function isGpuChainSupported(ops: readonly string[]): ops is read
  * @param xs  - input samples
  * @returns the f32 results, or `null` to signal "fall back to another tier"
  */
-export declare function elementwiseChainGpuDispatch(ops: readonly string[], xs: Float64Array | Float32Array, options?: GPUContextOptions): Promise<Float32Array | null>;
+export declare function elementwiseChainGpuDispatch(ops: readonly string[], xs: Float64Array | Float32Array, options?: GpuChainOptions): Promise<Float32Array | null>;
 export {};
 //# sourceMappingURL=elementwise-gpu.d.ts.map

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;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;GAOG;AACH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;CAkCR,CAAC;AAEX,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,YAAY,CAAC;AAEzD,eAAO,MAAM,mBAAmB,EAAgC,gBAAgB,EAAE,CAAC;AAEnF,sDAAsD;AACtD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,IAAI,SAAS,gBAAgB,EAAE,CAE9F;AA8CD;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,EAAE,YAAY,GAAG,YAAY,EAC/B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAuH9B"}
+{"version":3,"file":"elementwise-gpu.d.ts","sourceRoot":"","sources":["../../src/gpu/elementwise-gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;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,EAAgC,gBAAgB,EAAE,CAAC;AAEnF,sDAAsD;AACtD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,IAAI,SAAS,gBAAgB,EAAE,CAE9F;AAsED,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,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,EAAE,YAAY,GAAG,YAAY,EAC/B,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAuH9B"}

package/dist/index.js

@@ -396,6 +396,7 @@ __export(typed_exports, {
   reduce: () => reduce,
   reflectVector: () => reflectVector,
   resample: () => resample,
+  resetGpuElementwise: () => resetGpuElementwise,
   residue: () => residue,
   resultant: () => resultant,
   rightArithShift: () => rightArithShift,
@@ -7341,41 +7342,76 @@ var typedSpecial = {
 // src/gpu/elementwise-gpu.ts
 import {
   getGpuDevice,
+  getGlobalGPUContext,
   isGpuEnabled,
-  GPU_MIN_ELEMENTS
+  GPU_MIN_ELEMENTS,
+  ShaderManager,
+  BufferPool
 } from "@danielsimonjr/mathts-gpu";
+var WGSL_IEEE = `
+  // NaN / \xB1Inf are supplied through the UNIFORM, not written as literals.
+  //
+  // WGSL const-folds \`bitcast<f32>(0x7fc00000u)\` even inside a function body and
+  // then rejects the result: "value nan cannot be represented as 'f32'" \u2014 a const
+  // expression may not BE NaN or Inf. Reading the bit pattern from \`params\` (a
+  // runtime uniform) is not const-foldable, so the bitcast survives to runtime.
+  // params = (n, nanBits, posInfBits, negInfBits).
+  fn nan_f32() -> f32 { return bitcast<f32>(params.y); }
+  fn pos_inf() -> f32 { return bitcast<f32>(params.z); }
+  fn neg_inf() -> f32 { return bitcast<f32>(params.w); }
+
+  fn safe_log(x: f32) -> f32 {
+    if (x < 0.0) { return nan_f32(); }
+    if (x == 0.0) { return neg_inf(); }
+    return log(x);
+  }
+  fn safe_atanh(x: f32) -> f32 {
+    if (x > 1.0 || x < -1.0) { return nan_f32(); }
+    if (x == 1.0) { return pos_inf(); }
+    if (x == -1.0) { return neg_inf(); }
+    return atanh(x);
+  }
+  // 1/d with IEEE division-by-zero semantics (JS: 1/0 = +Inf, 1/-0 = -Inf).
+  fn safe_recip(d: f32) -> f32 {
+    if (d == 0.0) {
+      // Distinguish +0 from -0 by its sign bit, as IEEE division does.
+      if ((bitcast<u32>(d) & 0x80000000u) != 0u) { return neg_inf(); }
+      return pos_inf();
+    }
+    return 1.0 / d;
+  }
+`;
 var WGSL_OP_BODY = {
   abs: "return abs(x);",
   sin: "return sin(x);",
   cos: "return cos(x);",
   tan: "return tan(x);",
   exp: "return exp(x);",
-  log: "return log(x);",
   atan: "return atan(x);",
   sinh: "return sinh(x);",
   tanh: "return tanh(x);",
-  atanh: "return atanh(x);",
-  log2: "return log2(x);",
-  // WGSL has no log10 builtin; log(x) * 1/ln(10).
-  log10: "return log(x) * 0.4342944819032518;",
-  // NOTE — `expm1` and `log1p` are DELIBERATELY ABSENT, like `erfc`.
-  //
-  // WGSL has no builtin for either. The naive identities (`exp(x)-1`,
-  // `log(1+x)`) are catastrophically wrong near zero in f32: `1.0 + 1e-8`
-  // rounds to exactly 1.0f, so `log(1+x)` returns 0 where the true value is
-  // 1e-8 — a 100% relative error.
+  // Domain-guarded: WGSL says indeterminate outside the domain; JS does not.
+  log: "return safe_log(x);",
+  log2: "return safe_log(x) * 1.4426950408889634;",
+  // ln(x) / ln(2)
+  log10: "return safe_log(x) * 0.4342944819032518;",
+  // ln(x) / ln(10)
+  atanh: "return safe_atanh(x);",
+  sec: "return safe_recip(cos(x));",
+  csc: "return safe_recip(sin(x));",
+  cot: "return safe_recip(tan(x));"
+  // NOTE — `expm1`, `log1p` and `erfc` are DELIBERATELY ABSENT.
   //
-  // The standard Kahan-compensated forms were implemented and MEASURED on real
-  // hardware (NVIDIA Pascal). They still scored 38% (expm1) and 62% (log1p) max
-  // relative error over x in [1e-9, 1e-3], because the compensation relies on
-  // `log()` being accurate for arguments near 1.0, and the GPU's fast-math
-  // `log()` is not.
+  // WGSL has no builtin for any of them. For expm1/log1p the naive identities
+  // (`exp(x)-1`, `log(1+x)`) are catastrophically wrong near zero in f32
+  // (`1.0 + 1e-8` rounds to exactly 1.0f, so `log(1+x)` returns 0 where the true
+  // value is 1e-8 — 100% relative error), and the standard Kahan-compensated
+  // forms were implemented and MEASURED on real hardware: still 38% (expm1) and
+  // 62% (log1p) max relative error, because the compensation needs an accurate
+  // `log()` near 1.0 and the GPU's fast-math `log()` is not.
   //
-  // An f32 fast path is allowed to be less precise. It is not allowed to be
-  // WRONG. Chains containing these fall back to the exact WASM/JS tiers.
-  sec: "return 1.0 / cos(x);",
-  csc: "return 1.0 / sin(x);",
-  cot: "return 1.0 / tan(x);"
+  // An f32 fast path may be less precise. It may not be WRONG. Chains containing
+  // these fall back to the exact WASM/JS tiers.
 };
 var GPU_ELEMENTWISE_OPS = Object.keys(WGSL_OP_BODY);
 function isGpuChainSupported(ops) {
@@ -7386,6 +7422,9 @@ function wgslFor(op) {
   return `
     @group(0) @binding(0) var<storage, read> inp: array<f32>;
     @group(0) @binding(1) var<storage, read_write> outp: array<f32>;
+    @group(0) @binding(2) var<uniform> params: vec4<u32>; // n, nanBits, +infBits, -infBits
+
+    ${WGSL_IEEE}
 
     fn apply(x: f32) -> f32 {
       ${WGSL_OP_BODY[op]}
@@ -7394,80 +7433,72 @@ function wgslFor(op) {
     @compute @workgroup_size(${WORKGROUP_SIZE})
     fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
       let i = gid.x;
-      if (i >= arrayLength(&inp)) { return; }
+      if (i >= params.x) { return; }
       outp[i] = apply(inp[i]);
     }
   `;
 }
-var pipelineCache = /* @__PURE__ */ new WeakMap();
-function getPipeline(device, op) {
-  let byOp = pipelineCache.get(device);
-  if (!byOp) {
-    byOp = /* @__PURE__ */ new Map();
-    pipelineCache.set(device, byOp);
-  }
-  const cached = byOp.get(op);
-  if (cached) return cached;
-  const pipeline = device.createComputePipeline({
-    label: `elementwise:${op}`,
-    layout: "auto",
-    compute: {
-      module: device.createShaderModule({ code: wgslFor(op), label: `elementwise:${op}` }),
-      entryPoint: "main"
-    }
-  });
-  byOp.set(op, pipeline);
-  return pipeline;
+var resources = null;
+async function getResources(options) {
+  const device = await getGpuDevice(options);
+  if (!device) return null;
+  if (resources && resources.device === device) return resources;
+  const ctx = getGlobalGPUContext();
+  const shaders = new ShaderManager(ctx);
+  for (const op of GPU_ELEMENTWISE_OPS) {
+    shaders.registerShader(op, wgslFor(op));
+  }
+  shaders.precompileRegistered();
+  resources = { device, shaders, pool: new BufferPool(ctx) };
+  return resources;
+}
+function resetGpuElementwise() {
+  resources?.pool.destroy();
+  resources = null;
 }
 async function elementwiseChainGpuDispatch(ops, xs, options) {
   const n = xs.length;
-  if (!isGpuEnabled()) return null;
+  const enabled = options?.gpu ?? isGpuEnabled();
+  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);
+  let res;
   let bufA;
   let bufB;
   let staging;
+  let params;
   let scopePopped = false;
-  let device;
   try {
-    const d = await getGpuDevice(options);
-    if (!d) return null;
-    device = d;
+    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 input = xs instanceof Float32Array ? xs : Float32Array.from(xs);
     device.pushErrorScope("validation");
-    bufA = device.createBuffer({
-      size: bytes,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
-      label: "chain-a"
-    });
-    bufB = device.createBuffer({
-      size: bytes,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
-      label: "chain-b"
-    });
-    staging = device.createBuffer({
-      size: bytes,
-      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-      label: "chain-staging"
-    });
+    bufA = pool.acquireStorageBuffer(bytes, "chain-a", true, true);
+    bufB = pool.acquireStorageBuffer(bytes, "chain-b", true, true);
+    staging = pool.acquireStagingBuffer(bytes, "chain-staging");
+    params = pool.acquireUniformBuffer(16, "chain-params");
     device.queue.writeBuffer(bufA, 0, input);
+    device.queue.writeBuffer(params, 0, new Uint32Array([n, 2143289344, 2139095040, 4286578688]));
     const encoder = device.createCommandEncoder({ label: "elementwise-chain" });
     let src = bufA;
     let dst2 = bufB;
     for (const op of ops) {
-      const pipeline = getPipeline(device, op);
+      const pipeline = shaders.getRegisteredPipeline(op);
       const bindGroup = device.createBindGroup({
         layout: pipeline.getBindGroupLayout(0),
         entries: [
           { binding: 0, resource: { buffer: src } },
-          { binding: 1, resource: { buffer: dst2 } }
+          { binding: 1, resource: { buffer: dst2 } },
+          { binding: 2, resource: { buffer: params } }
         ]
       });
       const pass = encoder.beginComputePass({ label: `chain:${op}` });
@@ -7482,22 +7513,25 @@ async function elementwiseChainGpuDispatch(ops, xs, options) {
     const validationError = await device.popErrorScope();
     scopePopped = true;
     if (validationError) return null;
-    await staging.mapAsync(GPUMapMode.READ);
-    const out = new Float32Array(staging.getMappedRange().slice(0));
+    await staging.mapAsync(GPUMapMode.READ, 0, bytes);
+    const out = new Float32Array(staging.getMappedRange(0, bytes).slice(0));
     staging.unmap();
     return out;
   } catch {
     return null;
   } finally {
-    if (device && !scopePopped) {
+    if (res && !scopePopped) {
       try {
-        await device.popErrorScope();
+        await res.device.popErrorScope();
       } catch {
       }
     }
-    bufA?.destroy();
-    bufB?.destroy();
-    staging?.destroy();
+    if (res) {
+      if (bufA) res.pool.release(bufA);
+      if (bufB) res.pool.release(bufB);
+      if (staging) res.pool.release(staging);
+      if (params) res.pool.release(params);
+    }
   }
 }
 
@@ -7535,11 +7569,11 @@ function jsChain(ops, xs) {
   }
   return out;
 }
-async function fuseUnaryChainAsync(ops, xs) {
+async function fuseUnaryChainAsync(ops, xs, options) {
   const wasm = elementwiseChainDispatch(ops, xs);
   if (wasm) return wasm;
-  const gpu = await elementwiseChainGpuDispatch(ops, xs);
-  if (gpu) return gpu;
+  const gpu = await elementwiseChainGpuDispatch(ops, xs, options);
+  if (gpu) return Float64Array.from(gpu);
   return jsChain(ops, xs);
 }
 
@@ -30739,7 +30773,16 @@ var ObjectWrappingMap = class {
   [Symbol.toStringTag] = "ObjectWrappingMap";
   constructor(object) {
     this.wrappedObject = object;
-    this[Symbol.iterator] = this.entries;
+  }
+  /**
+   * Declared as a real method rather than assigned in the constructor through a
+   * cast. The old form satisfied the runtime but never appeared in the emitted
+   * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
+   * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
+   * implements interface 'Map'... '[Symbol.iterator]' is missing").
+   */
+  [Symbol.iterator]() {
+    return this.entries();
   }
   // @ts-expect-error: Implementation is compatible but TS can't infer it
   keys() {
@@ -45584,6 +45627,7 @@ export {
   reflectVector,
   replacer,
   resample,
+  resetGpuElementwise,
   reshape2 as reshape,
   residue,
   resize2 as resize,

package/dist/typed/fused.d.ts

@@ -13,6 +13,7 @@
  * array is below threshold, so the result is always correct.
  */
 import { type WasmElementwiseOp } from '../wasm/elementwise/wasm-bridge.js';
+import { type GpuChainOptions } from '../gpu/elementwise-gpu.js';
 /**
  * Apply `ops` left-to-right over `xs` (i.e. `ops[last](…ops[0](x))`), fused in
  * WASM when possible. Returns a new `Float64Array`; never mutates `xs`.
@@ -51,9 +52,17 @@ export declare function fuseUnaryChain(ops: WasmElementwiseOp[], xs: Float64Arra
  * (The GPU *does* win decisively for compute-bound work like a large matmul —
  * see `gpuMatmul`. This ordering is specific to memory-bound element-wise work.)
  *
- * **Precision:** the result is a `Float32Array` only when the GPU tier ran
- * (~7 significant digits); otherwise it is an exact-f64 `Float64Array`. The
- * return type tells you which path ran.
+ * **Precision.** Always returns a `Float64Array`. When the GPU tier runs, the
+ * *values* carry f32 precision (~7 significant digits) even though the container
+ * is f64 — the GPU cannot compute in f64 at all.
+ *
+ * It previously returned `Float64Array | Float32Array` to encode which path ran.
+ * That union was a footgun: `.map` / `.filter` / `.set` on it are TS2349 errors,
+ * so **every** caller had to narrow with `instanceof` before touching the result,
+ * and `new Float64Array(r.buffer)` silently produced garbage when the f32 branch
+ * hit. A narrowing tax on 100% of callers, for a branch most never take, is a bad
+ * trade. Callers who specifically want the raw f32 buffer can call
+ * `elementwiseChainGpuDispatch` directly — it is exported for exactly that.
  */
-export declare function fuseUnaryChainAsync(ops: WasmElementwiseOp[], xs: Float64Array): Promise<Float64Array | Float32Array>;
+export declare function fuseUnaryChainAsync(ops: WasmElementwiseOp[], xs: Float64Array, options?: GpuChainOptions): Promise<Float64Array>;
 //# sourceMappingURL=fused.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fused.d.ts","sourceRoot":"","sources":["../../src/typed/fused.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oCAAoC,CAAC;AA0B5C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CAIvF;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,iBAAiB,EAAE,EACxB,EAAE,EAAE,YAAY,GACf,OAAO,CAAC,YAAY,GAAG,YAAY,CAAC,CAUtC"}
+{"version":3,"file":"fused.d.ts","sourceRoot":"","sources":["../../src/typed/fused.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAA+B,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAyB9F;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CAIvF;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,iBAAiB,EAAE,EACxB,EAAE,EAAE,YAAY,EAChB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,CAAC,CAUvB"}

package/dist/typed/index.d.ts

@@ -47,7 +47,7 @@ export * from './matrix-ops.js';
 export { cond } from './matrix-ops.js';
 export * from './gpu.js';
 export { enableGpu, disableGpu, isGpuEnabled, GPU_MIN_ELEMENTS } from '@danielsimonjr/mathts-gpu';
-export { elementwiseChainGpuDispatch, isGpuChainSupported, GPU_ELEMENTWISE_OPS, type GpuElementwiseOp, } from '../gpu/elementwise-gpu.js';
+export { elementwiseChainGpuDispatch, isGpuChainSupported, resetGpuElementwise, GPU_ELEMENTWISE_OPS, type GpuElementwiseOp, type GpuChainOptions, } from '../gpu/elementwise-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,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,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,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"}

package/dist/utils/map.d.ts

@@ -6,10 +6,25 @@
  * will stop using this method, as all objects will be Maps, rather than
  * more security prone objects.
  */
+/**
+ * The iterator type `Map` itself declares, derived from the installed TS lib
+ * rather than hard-coded: older libs say `IterableIterator<[K, V]>`, TS >= 5.6
+ * says `MapIterator<[K, V]>` (which additionally requires `[Symbol.dispose]`).
+ * Deriving it keeps `implements Map<K, V>` honest on every TS version.
+ */
+type MapEntryIterator<K, V> = ReturnType<Map<K, V>[typeof Symbol.iterator]>;
 export declare class ObjectWrappingMap<K = string, V = unknown> implements Map<K, V> {
     wrappedObject: Record<string, V>;
     readonly [Symbol.toStringTag]: string;
     constructor(object: Record<string, V>);
+    /**
+     * Declared as a real method rather than assigned in the constructor through a
+     * cast. The old form satisfied the runtime but never appeared in the emitted
+     * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
+     * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
+     * implements interface 'Map'... '[Symbol.iterator]' is missing").
+     */
+    [Symbol.iterator](): MapEntryIterator<K, V>;
     keys(): IterableIterator<K>;
     get(key: K): V | undefined;
     set(key: K, value: V): this;
@@ -46,6 +61,8 @@ export declare class PartitionedMap<K = unknown, V = unknown> implements Map<K,
      * @param bKeys - Set of keys that should be read/written to map b
      */
     constructor(a: Map<K, V>, b: Map<K, V>, bKeys: Set<K>);
+    /** See the note on `ObjectWrappingMap[Symbol.iterator]` — same fix. */
+    [Symbol.iterator](): MapEntryIterator<K, V>;
     get(key: K): V | undefined;
     set(key: K, value: V): this;
     has(key: K): boolean;
@@ -85,4 +102,5 @@ export declare function assign<K = unknown, V = unknown>(map: Map<K, V>, ...obje
  * `map.ts` — that import was the sole edge closing the `is`/`map` cycle.
  */
 export declare function isObjectWrappingMap(object: unknown): object is ObjectWrappingMap;
+export {};
 //# sourceMappingURL=map.d.ts.map

package/dist/utils/map.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -16,6 +16,7 @@
   },
   "files": [
     "dist",
+    "types",
     "README.md"
   ],
   "scripts": {
@@ -35,8 +36,8 @@
   "dependencies": {
     "@danielsimonjr/mathts-core": "^0.6.0",
     "@danielsimonjr/mathts-expression": "^0.6.0",
-    "@danielsimonjr/mathts-gpu": "^0.1.0",
-    "@danielsimonjr/mathts-matrix": "^0.3.1",
+    "@danielsimonjr/mathts-gpu": "^0.1.1",
+    "@danielsimonjr/mathts-matrix": "^0.3.2",
     "@danielsimonjr/mathts-parallel": "^0.3.4",
     "bignumber.js": "^9.1.2",
     "complex.js": "^2.2.5",

package/types/assemblyscript.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Ambient type declarations for AssemblyScript builtins.
+ * These types are provided by the AssemblyScript compiler at build time
+ * but need declarations for TypeScript type-checking when WASM files
+ * are transitively included via imports from src/function/.
+ */
+
+// AssemblyScript numeric types
+declare type usize = number;
+declare type i64 = number;
+declare type u8 = number;
+declare type u32 = number;
+declare type f32 = number;
+
+// f64: type alias + namespace with constants
+declare type f64 = number;
+declare namespace f64 {
+  const NaN: f64;
+  const POSITIVE_INFINITY: f64;
+  const NEGATIVE_INFINITY: f64;
+  const MAX_VALUE: f64;
+  const MIN_VALUE: f64;
+}
+
+// i32: type alias + namespace with builtins
+declare type i32 = number;
+declare namespace i32 {
+  function clz(value: i32): i32;
+  function ctz(value: i32): i32;
+  function rotl(value: i32, shift: i32): i32;
+  function rotr(value: i32, shift: i32): i32;
+  const MAX_VALUE: i32;
+  const MIN_VALUE: i32;
+}
+
+/** SIMD 128-bit vector type */
+declare type v128 = object;
+
+/** v128 SIMD intrinsics namespace */
+declare namespace v128 {
+  function load(ptr: usize, immOffset?: u32, immAlign?: u32): v128;
+  function store(ptr: usize, value: v128, immOffset?: u32, immAlign?: u32): void;
+  function splat<T>(value: T): v128;
+  function extract_lane<T>(vec: v128, idx: u8): T;
+  function replace_lane<T>(vec: v128, idx: u8, value: T): v128;
+  function add<T>(a: v128, b: v128): v128;
+  function sub<T>(a: v128, b: v128): v128;
+  function mul<T>(a: v128, b: v128): v128;
+  function div<T>(a: v128, b: v128): v128;
+  function neg<T>(a: v128): v128;
+  function abs<T>(a: v128): v128;
+  function sqrt<T>(a: v128): v128;
+  function min<T>(a: v128, b: v128): v128;
+  function max<T>(a: v128, b: v128): v128;
+  function and(a: v128, b: v128): v128;
+  function or(a: v128, b: v128): v128;
+  function xor(a: v128, b: v128): v128;
+  function not(a: v128): v128;
+  function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;
+  function swizzle(a: v128, s: v128): v128;
+}
+
+/** f64x2 SIMD namespace (2 x f64 packed into v128) */
+declare namespace f64x2 {
+  function splat(value: f64): v128;
+  function extract_lane(vec: v128, idx: 0 | 1): f64;
+  function replace_lane(vec: v128, idx: 0 | 1, value: f64): v128;
+  function add(a: v128, b: v128): v128;
+  function sub(a: v128, b: v128): v128;
+  function mul(a: v128, b: v128): v128;
+  function div(a: v128, b: v128): v128;
+  function neg(a: v128): v128;
+  function abs(a: v128): v128;
+  function sqrt(a: v128): v128;
+  function min(a: v128, b: v128): v128;
+  function max(a: v128, b: v128): v128;
+}
+
+// AssemblyScript type cast functions (e.g., f64(intValue) converts i32 to f64)
+declare function f64(value: number): number;
+declare function i32(value: number): number;
+declare function i64(value: number): number;
+declare function u32(value: number): number;
+
+// AssemblyScript builtins
+declare function unchecked<T>(expr: T): T;
+declare function changetype<T>(value: unknown): T;
+declare function isFinite<T>(value: T): boolean;
+declare function isNaN<T>(value: T): boolean;
+declare function sizeof<T>(): usize;
+declare function assert<T>(value: T, message?: string): T;
+declare function idof<T>(): u32;
+
+// AssemblyScript memory intrinsics
+declare function load<T>(ptr: usize, immOffset?: u32): T;
+declare function store<T>(ptr: usize, value: T, immOffset?: u32): void;
+
+declare namespace memory {
+  function grow(pages: i32): i32;
+  function size(): i32;
+}