@danielsimonjr/mathts-functions 0.18.0 → 0.20.0

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

@@ -7,11 +7,18 @@
  * storage buffers, and reads back once, so the transfer is amortized across the
  * whole chain.
  *
- * **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.
+ * **Read this before reaching for the GPU:** for element-wise chains the GPU is
+ * the *fastest* tier (3.2–8.3× over WASM — see the table on
+ * `fuseUnaryChainAsync`), but it computes in **f32** where every CPU tier is
+ * f64-exact. That is the whole trade, and `enableGpu()` is how a caller consents
+ * to it. `fuseUnaryChainAsync` therefore tries the GPU first, but only when the
+ * flag is on; with it off (the default) the GPU never runs.
+ *
+ * An earlier revision of this comment claimed the GPU was ~1.9× *slower* than
+ * WASM. That was an artifact of a `Float32Array.from()` in this very file — the
+ * generic `Array.from` path, which cost 433 ms at n=2²⁰ where the constructor
+ * costs 5.9 ms. Do not re-derive a tier ranking from a single tier's number; see
+ * `gpu-vs-wasm.browser.test.ts`, which measures all three in one run.
  *
  * Contract (mirrors the WASM `elementwiseChainDispatch`): a **never-throw**
  * best-effort fast path. It returns `null` — never rejects — whenever the GPU is
@@ -38,9 +45,12 @@ declare const WGSL_OP_BODY: {
 };
 /** 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[];
+export declare const GPU_ELEMENTWISE_OPS: readonly GpuElementwiseOp[];
 /** Whether every op in the chain has a GPU kernel. */
 export declare function isGpuChainSupported(ops: readonly string[]): ops is readonly GpuElementwiseOp[];
+/** Reductions that can be fused onto the end of a chain. */
+export type GpuReduceOp = 'sum' | 'max' | 'min';
+export declare const GPU_REDUCE_OPS: readonly ["sum", "max", "min"];
 /** Drop the cached shaders/buffers (device loss, or between tests). */
 export declare function resetGpuElementwise(): void;
 /** Options for a GPU element-wise dispatch. */
@@ -62,5 +72,49 @@ export interface GpuChainOptions extends GPUContextOptions {
  * @returns the f32 results, or `null` to signal "fall back to another tier"
  */
 export declare function elementwiseChainGpuDispatch(ops: readonly string[], xs: Float64Array | Float32Array, options?: GpuChainOptions): Promise<Float32Array | null>;
+/**
+ * Apply `ops` on the GPU and **reduce the result on-device**, returning a single
+ * number instead of an array.
+ *
+ * The point is the readback, not the arithmetic: reducing on the device replaces
+ * an **n-float** transfer back to the CPU with an **n/256-float** one. Measured
+ * end-to-end through THIS function (not a prototype), NVIDIA Pascal,
+ * `sum(exp(sin(x)))`:
+ *
+ * | n         | WASM chain + JS sum | GPU chain + JS sum | fused GPU reduce |
+ * | --------- | ------------------- | ------------------ | ---------------- |
+ * | 262,144   |             25.6 ms |            16.7 ms |    **9.9 ms**    |
+ * | 1,048,576 |             96.8 ms |            34.3 ms |   **25.4 ms**    |
+ * | 4,194,304 |            260.0 ms |           100.0 ms |   **72.2 ms**    |
+ *
+ * **1.35-1.7x** over the shipped GPU path, **2.6-3.8x** over the CPU tier.
+ *
+ * Quote the **1.39x at n=2^22** if you quote one number: it is the only ratio here that
+ * reproduces run to run (1.31-1.39x over four runs). The 1.7x is the n=262,144 row, and
+ * that size swings 1.19-2.83x between runs — the GPU work is short enough that fixed
+ * costs dominate. A headline should not be a lucky sample.
+ *
+ * Why not more: a bare-WGSL prototype of this hit ~2x, but it pre-converted its
+ * input outside the timed region. The real f64->f32 conversion is an n-scaling cost
+ * that BOTH paths pay, so it dilutes the ratio as n grows (the absolute saving is
+ * steady: ~28 ms at n=2^22). The prototype's number was not a lie, it was measuring
+ * a workload no caller has. Quote the numbers above, not those.
+ *
+ * **An empty `ops` is declined on purpose.** A *standalone* GPU reduction uploads
+ * n floats to produce one number — pure transfer tax, measured 3-9x SLOWER than a
+ * plain JS sum. There is no chain to amortise the upload against, so this returns
+ * `null` and lets the caller use the CPU, which is genuinely the faster path. The
+ * upload is only worth paying for when real work rides along with it.
+ *
+ * Same never-throw contract as {@link elementwiseChainGpuDispatch}: returns `null`
+ * — never rejects — whenever the GPU is unavailable, not opted into, the input is
+ * below `GPU_MIN_ELEMENTS`, an op has no kernel, or a device limit is exceeded.
+ *
+ * Precision: f32, like every GPU path here. For `sum` the tree reduction is
+ * pairwise, so its error grows O(log n) rather than the O(n) of a sequential
+ * accumulate — it is better-conditioned than the JS loop it replaces, even though
+ * it works in f32.
+ */
+export declare function elementwiseChainReduceGpuDispatch(ops: readonly string[], xs: Float64Array | Float32Array, reduce: GpuReduceOp, options?: GpuChainOptions): Promise<number | 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;;;;;;;;;;;;;;;;;;;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"}
+{"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"}

package/dist/index.js

@@ -24,6 +24,7 @@ __export(typed_exports, {
   GAUSS_WORKER_THRESHOLD: () => GAUSS_WORKER_THRESHOLD,
   GPU_ELEMENTWISE_OPS: () => GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS: () => GPU_MIN_ELEMENTS2,
+  GPU_REDUCE_OPS: () => GPU_REDUCE_OPS,
   WASM_INTERP_THRESHOLD: () => WASM_INTERP_THRESHOLD,
   abs: () => abs,
   acos: () => acos,
@@ -153,6 +154,7 @@ __export(typed_exports, {
   eigenvectorCentrality: () => eigenvectorCentrality,
   element: () => element,
   elementwiseChainGpuDispatch: () => elementwiseChainGpuDispatch,
+  elementwiseChainReduceGpuDispatch: () => elementwiseChainReduceGpuDispatch,
   eliminate: () => eliminate,
   ellipticE: () => ellipticE,
   ellipticEIncomplete: () => ellipticEIncomplete,
@@ -195,6 +197,7 @@ __export(typed_exports, {
   functionExpand: () => functionExpand,
   fuseUnaryChain: () => fuseUnaryChain,
   fuseUnaryChainAsync: () => fuseUnaryChainAsync,
+  fuseUnaryChainReduceAsync: () => fuseUnaryChainReduceAsync,
   gammaDist: () => gammaDist,
   gammaPDF: () => gammaPDF,
   gammainc: () => gammainc,
@@ -7413,7 +7416,9 @@ var WGSL_OP_BODY = {
   // 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);
+var GPU_ELEMENTWISE_OPS = Object.keys(
+  WGSL_OP_BODY
+);
 function isGpuChainSupported(ops) {
   return ops.every((op) => op in WGSL_OP_BODY);
 }
@@ -7438,6 +7443,48 @@ function wgslFor(op) {
     }
   `;
 }
+var GPU_REDUCE_OPS = ["sum", "max", "min"];
+var reduceKey = (r) => `reduce:${r}`;
+var WGSL_REDUCE = {
+  sum: { identity: "0.0", combine: "a + b" },
+  max: { identity: "neg_inf()", combine: "max(a, b)" },
+  min: { identity: "pos_inf()", combine: "min(a, b)" }
+};
+function wgslForReduce(r) {
+  const { identity: identity2, combine: combine2 } = WGSL_REDUCE[r];
+  return `
+    @group(0) @binding(0) var<storage, read> inp: array<f32>;
+    @group(0) @binding(1) var<storage, read_write> partials: array<f32>;
+    @group(0) @binding(2) var<uniform> params: vec4<u32>; // n, nanBits, +infBits, -infBits
+
+    ${WGSL_IEEE}
+
+    // NOTE: "shared" is a RESERVED WORD in WGSL \u2014 this must not be named that.
+    var<workgroup> sdata: array<f32, ${WORKGROUP_SIZE}>;
+
+    fn identity() -> f32 { return ${identity2}; }
+    fn combine(a: f32, b: f32) -> f32 { return ${combine2}; }
+
+    @compute @workgroup_size(${WORKGROUP_SIZE})
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>,
+            @builtin(local_invocation_id) lid: vec3<u32>,
+            @builtin(workgroup_id) wid: vec3<u32>) {
+      var v: f32 = identity();
+      if (gid.x < params.x) { v = inp[gid.x]; }
+      sdata[lid.x] = v;
+      workgroupBarrier();
+
+      var s: u32 = ${WORKGROUP_SIZE}u / 2u;
+      loop {
+        if (s == 0u) { break; }
+        if (lid.x < s) { sdata[lid.x] = combine(sdata[lid.x], sdata[lid.x + s]); }
+        workgroupBarrier();
+        s = s >> 1u;
+      }
+      if (lid.x == 0u) { partials[wid.x] = sdata[0]; }
+    }
+  `;
+}
 var resources = null;
 async function getResources(options) {
   const device = await getGpuDevice(options);
@@ -7448,6 +7495,9 @@ async function getResources(options) {
   for (const op of GPU_ELEMENTWISE_OPS) {
     shaders.registerShader(op, wgslFor(op));
   }
+  for (const r of GPU_REDUCE_OPS) {
+    shaders.registerShader(reduceKey(r), wgslForReduce(r));
+  }
   shaders.precompileRegistered();
   resources = { device, shaders, pool: new BufferPool(ctx) };
   return resources;
@@ -7456,7 +7506,16 @@ function resetGpuElementwise() {
   resources?.pool.destroy();
   resources = null;
 }
-async function elementwiseChainGpuDispatch(ops, xs, options) {
+var gpuQueue = Promise.resolve();
+function serializeGpu(run) {
+  const next = gpuQueue.then(run, run);
+  gpuQueue = next.catch(() => void 0);
+  return next;
+}
+function elementwiseChainGpuDispatch(ops, xs, options) {
+  return serializeGpu(() => chainGpuDispatchImpl(ops, xs, options));
+}
+async function chainGpuDispatchImpl(ops, xs, options) {
   const n = xs.length;
   const enabled = options?.gpu ?? isGpuEnabled();
   if (!enabled) return null;
@@ -7470,6 +7529,7 @@ async function elementwiseChainGpuDispatch(ops, xs, options) {
   let bufB;
   let staging;
   let params;
+  let scopePushed = false;
   let scopePopped = false;
   try {
     const r = await getResources(options);
@@ -7480,8 +7540,9 @@ async function elementwiseChainGpuDispatch(ops, xs, options) {
     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);
+    const input = xs instanceof Float32Array ? xs : new Float32Array(xs);
     device.pushErrorScope("validation");
+    scopePushed = true;
     bufA = pool.acquireStorageBuffer(bytes, "chain-a", true, true);
     bufB = pool.acquireStorageBuffer(bytes, "chain-b", true, true);
     staging = pool.acquireStagingBuffer(bytes, "chain-staging");
@@ -7520,7 +7581,7 @@ async function elementwiseChainGpuDispatch(ops, xs, options) {
   } catch {
     return null;
   } finally {
-    if (res && !scopePopped) {
+    if (res && scopePushed && !scopePopped) {
       try {
         await res.device.popErrorScope();
       } catch {
@@ -7534,6 +7595,120 @@ async function elementwiseChainGpuDispatch(ops, xs, options) {
     }
   }
 }
+function elementwiseChainReduceGpuDispatch(ops, xs, reduce3, options) {
+  return serializeGpu(() => chainReduceGpuDispatchImpl(ops, xs, reduce3, options));
+}
+async function chainReduceGpuDispatchImpl(ops, xs, reduce3, options) {
+  const n = xs.length;
+  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;
+  if (!GPU_REDUCE_OPS.includes(reduce3)) return null;
+  const bytes = n * 4;
+  const workgroups = Math.ceil(n / WORKGROUP_SIZE);
+  const partialBytes = workgroups * 4;
+  let res;
+  let bufA;
+  let bufB;
+  let partials;
+  let staging;
+  let params;
+  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 input = xs instanceof Float32Array ? xs : new Float32Array(xs);
+    device.pushErrorScope("validation");
+    scopePushed = true;
+    bufA = pool.acquireStorageBuffer(bytes, "chain-a", true, true);
+    bufB = pool.acquireStorageBuffer(bytes, "chain-b", true, true);
+    partials = pool.acquireStorageBuffer(partialBytes, "reduce-partials", true, true);
+    staging = pool.acquireStagingBuffer(partialBytes, "reduce-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-reduce" });
+    let src = bufA;
+    let dst2 = bufB;
+    for (const op of ops) {
+      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: 2, resource: { buffer: params } }
+        ]
+      });
+      const pass = encoder.beginComputePass({ label: `chain:${op}` });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bindGroup);
+      pass.dispatchWorkgroups(workgroups);
+      pass.end();
+      [src, dst2] = [dst2, src];
+    }
+    const reducePipeline = shaders.getRegisteredPipeline(reduceKey(reduce3));
+    const reduceBind = device.createBindGroup({
+      layout: reducePipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: src } },
+        { binding: 1, resource: { buffer: partials } },
+        { binding: 2, resource: { buffer: params } }
+      ]
+    });
+    const reducePass = encoder.beginComputePass({ label: `reduce:${reduce3}` });
+    reducePass.setPipeline(reducePipeline);
+    reducePass.setBindGroup(0, reduceBind);
+    reducePass.dispatchWorkgroups(workgroups);
+    reducePass.end();
+    encoder.copyBufferToBuffer(partials, 0, staging, 0, partialBytes);
+    device.queue.submit([encoder.finish()]);
+    const validationError = await device.popErrorScope();
+    scopePopped = true;
+    if (validationError) return null;
+    await staging.mapAsync(GPUMapMode.READ, 0, partialBytes);
+    const parts = new Float32Array(staging.getMappedRange(0, partialBytes).slice(0));
+    staging.unmap();
+    return foldPartials(parts, reduce3);
+  } 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 (partials) res.pool.release(partials);
+      if (staging) res.pool.release(staging);
+      if (params) res.pool.release(params);
+    }
+  }
+}
+function foldPartials(parts, reduce3) {
+  if (reduce3 === "sum") {
+    let acc2 = 0;
+    for (let i = 0; i < parts.length; i++) acc2 += parts[i];
+    return acc2;
+  }
+  let acc = reduce3 === "max" ? -Infinity : Infinity;
+  for (let i = 0; i < parts.length; i++) {
+    acc = reduce3 === "max" ? Math.max(acc, parts[i]) : Math.min(acc, parts[i]);
+  }
+  return acc;
+}
 
 // src/typed/fused.ts
 var SCALAR = {
@@ -7562,7 +7737,7 @@ function fuseUnaryChain(ops, xs) {
   return jsChain(ops, xs);
 }
 function jsChain(ops, xs) {
-  const out = Float64Array.from(xs);
+  const out = new Float64Array(xs);
   for (const op of ops) {
     const f = SCALAR[op];
     for (let i = 0; i < out.length; i++) out[i] = f(out[i]);
@@ -7570,12 +7745,30 @@ function jsChain(ops, xs) {
   return out;
 }
 async function fuseUnaryChainAsync(ops, xs, options) {
+  const gpu = await elementwiseChainGpuDispatch(ops, xs, options);
+  if (gpu) return new Float64Array(gpu);
   const wasm = elementwiseChainDispatch(ops, xs);
   if (wasm) return wasm;
-  const gpu = await elementwiseChainGpuDispatch(ops, xs, options);
-  if (gpu) return Float64Array.from(gpu);
   return jsChain(ops, xs);
 }
+async function fuseUnaryChainReduceAsync(ops, xs, reduce3, options) {
+  const gpu = await elementwiseChainReduceGpuDispatch(ops, xs, reduce3, options);
+  if (gpu !== null) return gpu;
+  const chained = elementwiseChainDispatch(ops, xs) ?? jsChain(ops, xs);
+  return reduceF64(chained, reduce3);
+}
+function reduceF64(xs, reduce3) {
+  if (reduce3 === "sum") {
+    let acc2 = 0;
+    for (let i = 0; i < xs.length; i++) acc2 += xs[i];
+    return acc2;
+  }
+  let acc = reduce3 === "max" ? -Infinity : Infinity;
+  for (let i = 0; i < xs.length; i++) {
+    acc = reduce3 === "max" ? Math.max(acc, xs[i]) : Math.min(acc, xs[i]);
+  }
+  return acc;
+}
 
 // src/typed/distributions.ts
 import { mathTyped as mathTyped11 } from "@danielsimonjr/mathts-core";
@@ -44940,6 +45133,7 @@ export {
   GAUSS_WORKER_THRESHOLD,
   GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS2 as GPU_MIN_ELEMENTS,
+  GPU_REDUCE_OPS,
   WASM_INTERP_THRESHOLD,
   abs,
   acf,
@@ -45157,6 +45351,7 @@ export {
   element,
   elementaryCharge,
   elementwiseChainGpuDispatch,
+  elementwiseChainReduceGpuDispatch,
   eliminate,
   ellipticE,
   ellipticEIncomplete,
@@ -45285,6 +45480,7 @@ export {
   functionExpand,
   fuseUnaryChain,
   fuseUnaryChainAsync,
+  fuseUnaryChainReduceAsync,
   gamma,
   gammaCDF,
   gammaDist,

package/dist/typed/fused.d.ts

@@ -13,7 +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';
+import { type GpuChainOptions, type GpuReduceOp } 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`.
@@ -26,31 +26,49 @@ export declare function fuseUnaryChain(ops: WasmElementwiseOp[], xs: Float64Arra
  * `fuseUnaryChain`, because a GPU dispatch is inherently asynchronous and
  * `fuseUnaryChain`'s synchronous signature is public API.
  *
- * Tiers, in order: **WASM (f64) → GPU (f32) → JS (f64)**.
+ * Tiers, in order: **GPU (f32, opt-in) → WASM (f64) → JS (f64)**.
  *
- * ### Why WASM is tried BEFORE the GPU
+ * ### Why the GPU is tried first — but ONLY when explicitly enabled
  *
- * Measured in Chrome on an NVIDIA Pascal adapter, chain `sin→exp→tanh→cos`:
+ * Chain `sin→exp→tanh→cos`, 5 reps. ONE run, 2026-07-13, Chrome on an NVIDIA
+ * Pascal adapter — the same run quoted in the CHANGELOG and the reference docs, so
+ * the three tables agree. Pinned by `gpu-vs-wasm.browser.test.ts`:
  *
- * | n         | JS      | WASM    | GPU     | GPU vs WASM |
- * | --------- | ------- | ------- | ------- | ----------- |
- * | 65,536    | 90 ms   | 16 ms   | 28 ms   | **0.57×**   |
- * | 262,144   | 400 ms  | 60 ms   | 103 ms  | **0.59×**   |
- * | 1,048,576 | 1613 ms | 250 ms  | 457 ms  | **0.55×**   |
+ * | n         | JS     | WASM   | GPU        | GPU vs WASM |
+ * | --------- | ------ | ------ | ---------- | ----------- |
+ * | 65,536    | 44 ms  | 17 ms  | **5.2 ms** | **3.2×**    |
+ * | 262,144   | 185 ms | 63 ms  | **7.5 ms** | **8.3×**    |
+ * | 1,048,576 | 711 ms | 256 ms | **35 ms**  | **7.2×**    |
  *
- * **WASM is ~1.8× faster than the GPU — and it is f64-exact while the GPU is
- * f32.** For element-wise chains the GPU is therefore both slower *and* less
- * precise, so it must never pre-empt WASM. (An earlier revision had GPU first;
- * that only looked like a win because a separate bug meant WASM never loaded in
- * browsers, making the baseline pure JS.)
+ * The GPU is the fastest tier by a wide margin. It is nevertheless **last-resort
+ * by default**, because it computes in f32 while every other tier is f64-exact.
+ * `enableGpu()` is how a caller consents to that trade: precision for speed. With
+ * the flag off — the default — this function is exactly WASM → JS and returns
+ * bit-identical f64 results, so opting out costs nothing.
  *
- * The GPU still earns its place where WASM is **unavailable** — there it beats
- * the JS scalar pass ~2–2.5×. It engages only when the caller opted in via
- * `enableGpu()`, WASM declined, a device exists, the array clears
- * `GPU_MIN_ELEMENTS`, and every op has a GPU kernel.
+ * ### Provenance of these numbers (read before changing the order)
  *
- * (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.)
+ * This ordering has been wrong twice, both times from a benchmark measuring
+ * something other than what it claimed:
+ *
+ *  1. GPU-first was first adopted on a "2.3-2.9x faster than JS" result. That
+ *     baseline was pure JS only because a *separate* bug meant WASM never loaded
+ *     in browsers. Fixing WASM revealed it beat the GPU, so the order was flipped
+ *     to WASM-first.
+ *  2. That flip was also wrong. The GPU figure it rested on was inflated by
+ *     `Float32Array.from(f64array)` in the dispatch — the generic `Array.from`
+ *     path, which runs ToNumber per element. Naming the denominators, because they
+ *     differ: the *conversion* alone was 73x slower (433 ms vs 5.9 ms at n=2^20),
+ *     which made the *end-to-end dispatch* 12.2x slower (439.80 ms -> 36.06 ms).
+ *     With that fixed, the GPU wins outright, as above.
+ *
+ * The lesson both times: a tier's number is only as good as the tier it is
+ * compared against. Re-measure ALL THREE tiers in one run before touching this
+ * order — `gpu-vs-wasm.browser.test.ts` does exactly that and fails loudly if the
+ * ranking changes.
+ *
+ * (The GPU also wins decisively for compute-bound work like a large matmul — see
+ * `gpuMatmul`. It is not merely a memory-bound-work story.)
  *
  * **Precision.** Always returns a `Float64Array`. When the GPU tier runs, the
  * *values* carry f32 precision (~7 significant digits) even though the container
@@ -65,4 +83,25 @@ export declare function fuseUnaryChain(ops: WasmElementwiseOp[], xs: Float64Arra
  * `elementwiseChainGpuDispatch` directly — it is exported for exactly that.
  */
 export declare function fuseUnaryChainAsync(ops: WasmElementwiseOp[], xs: Float64Array, options?: GpuChainOptions): Promise<Float64Array>;
+/**
+ * Apply `ops` and then reduce to a single number — `sum(exp(sin(x)))` and friends.
+ *
+ * Tiers: **GPU (f32, opt-in) → WASM chain + JS reduce → JS chain + JS reduce.**
+ *
+ * When the GPU tier runs, the reduction happens **on the device**, so only n/256
+ * floats cross the bus instead of n. That is the whole reason this function exists.
+ * Measured end-to-end for `sum(exp(sin(x)))` on an NVIDIA Pascal adapter: **1.35-1.7x**
+ * faster than `fuseUnaryChainAsync(...)` followed by a JS loop, and **2.6-3.8x** faster
+ * than the CPU tier. (See `elementwiseChainReduceGpuDispatch` for the full table and
+ * for why the ratio shrinks as n grows.)
+ *
+ * Reach for it only when you want the **scalar**. If you also need the transformed
+ * array, use `fuseUnaryChainAsync` — you have to pay the n-float readback anyway, and
+ * summing it in JS afterwards costs almost nothing on top.
+ *
+ * Precision follows the tier that ran: f32 (~7 significant digits) on the GPU, exact
+ * f64 on WASM/JS. `enableGpu()` is the consent; with the flag off this is a pure f64
+ * computation.
+ */
+export declare function fuseUnaryChainReduceAsync(ops: WasmElementwiseOp[], xs: Float64Array, reduce: GpuReduceOp, options?: GpuChainOptions): Promise<number>;
 //# 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;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"}
+{"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,EAGL,KAAK,eAAe,EACpB,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAyBnC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CAIvF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,iBAAiB,EAAE,EACxB,EAAE,EAAE,YAAY,EAChB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,iBAAiB,EAAE,EACxB,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC,CAQjB"}

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, resetGpuElementwise, GPU_ELEMENTWISE_OPS, type GpuElementwiseOp, type GpuChainOptions, } from '../gpu/elementwise-gpu.js';
+export { elementwiseChainGpuDispatch, elementwiseChainReduceGpuDispatch, GPU_REDUCE_OPS, type GpuReduceOp, 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,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,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/package.json

@@ -1,76 +1,76 @@
-{
-  "name": "@danielsimonjr/mathts-functions",
-  "version": "0.18.0",
-  "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "types",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json && node scripts/copy-wasm.mjs",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:diff": "node tests/diff-special.test.mjs && node tests/diff-elementwise.test.mjs && node tests/diff-fusion.test.mjs",
-    "golden:gen": "python -X utf8 tests/golden/gen_special_goldens.py",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "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.3.2",
-    "@danielsimonjr/mathts-parallel": "^0.3.4",
-    "bignumber.js": "^9.1.2",
-    "complex.js": "^2.2.5",
-    "decimal.js": "^10.4.3",
-    "escape-latex": "^1.2.0",
-    "fraction.js": "^5.2.1",
-    "javascript-natural-sort": "^0.7.1",
-    "seedrandom": "^3.0.5",
-    "tiny-emitter": "^2.1.0",
-    "typed-function": "github:danielsimonjr/typed-function"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "@webgpu/types": "^0.1.67",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "functions"
-  },
-  "keywords": [
-    "math",
-    "typescript",
-    "functions",
-    "arithmetic",
-    "algebra",
-    "trigonometry",
-    "statistics"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-functions",
+  "version": "0.20.0",
+  "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "types",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json && node scripts/copy-wasm.mjs",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:diff": "node tests/diff-special.test.mjs && node tests/diff-elementwise.test.mjs && node tests/diff-fusion.test.mjs",
+    "golden:gen": "python -X utf8 tests/golden/gen_special_goldens.py",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "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",
+    "bignumber.js": "^9.1.2",
+    "complex.js": "^2.2.5",
+    "decimal.js": "^10.4.3",
+    "escape-latex": "^1.2.0",
+    "fraction.js": "^5.2.1",
+    "javascript-natural-sort": "^0.7.1",
+    "seedrandom": "^3.0.5",
+    "tiny-emitter": "^2.1.0",
+    "typed-function": "github:danielsimonjr/typed-function"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@webgpu/types": "^0.1.67",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "functions"
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "functions",
+    "arithmetic",
+    "algebra",
+    "trigonometry",
+    "statistics"
+  ]
+}