@danielsimonjr/mathts-functions 0.16.1 → 0.17.0

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

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * Precision: the GPU path computes in **f32** (WGSL has no f64). This is why it
+ * is gated behind the explicit `enableGpu()` opt-in.
+ */
+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);";
+};
+/** 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[];
+/**
+ * Run a fused element-wise chain on the GPU.
+ *
+ * @param ops - the chain, applied left to right (`['sin','exp']` = `exp(sin(x))`)
+ * @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 {};
+//# sourceMappingURL=elementwise-gpu.d.ts.map

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

@@ -0,0 +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"}

package/dist/index.js

@@ -22,6 +22,8 @@ __export(typed_exports, {
   CENTRALITY_WORKER_THRESHOLD: () => CENTRALITY_WORKER_THRESHOLD,
   DIST_WORKER_THRESHOLD: () => DIST_WORKER_THRESHOLD,
   GAUSS_WORKER_THRESHOLD: () => GAUSS_WORKER_THRESHOLD,
+  GPU_ELEMENTWISE_OPS: () => GPU_ELEMENTWISE_OPS,
+  GPU_MIN_ELEMENTS: () => GPU_MIN_ELEMENTS2,
   WASM_INTERP_THRESHOLD: () => WASM_INTERP_THRESHOLD,
   abs: () => abs,
   acos: () => acos,
@@ -132,6 +134,7 @@ __export(typed_exports, {
   delaunayTriangulation: () => delaunayTriangulation,
   differences: () => differences,
   digamma: () => digamma,
+  disableGpu: () => disableGpu,
   discreteUniformDist: () => discreteUniformDist,
   discriminant: () => discriminant,
   distance2D: () => distance2D,
@@ -149,12 +152,14 @@ __export(typed_exports, {
   dwt: () => dwt,
   eigenvectorCentrality: () => eigenvectorCentrality,
   element: () => element,
+  elementwiseChainGpuDispatch: () => elementwiseChainGpuDispatch,
   eliminate: () => eliminate,
   ellipticE: () => ellipticE,
   ellipticEIncomplete: () => ellipticEIncomplete,
   ellipticF: () => ellipticF,
   ellipticK: () => ellipticK,
   ellipticPi: () => ellipticPi,
+  enableGpu: () => enableGpu,
   entropy: () => entropy,
   equal: () => equal,
   equalScalar: () => equalScalar,
@@ -189,6 +194,7 @@ __export(typed_exports, {
   fullSimplify: () => fullSimplify,
   functionExpand: () => functionExpand,
   fuseUnaryChain: () => fuseUnaryChain,
+  fuseUnaryChainAsync: () => fuseUnaryChainAsync,
   gammaDist: () => gammaDist,
   gammaPDF: () => gammaPDF,
   gammainc: () => gammainc,
@@ -230,6 +236,8 @@ __export(typed_exports, {
   invFourier: () => invFourier,
   invGaussDist: () => invGaussDist,
   isConnected: () => isConnected,
+  isGpuChainSupported: () => isGpuChainSupported,
+  isGpuEnabled: () => isGpuEnabled2,
   jacobiSymbol: () => jacobiSymbol,
   jordanForm: () => jordanForm,
   jsDivergence: () => jsDivergence,
@@ -7330,6 +7338,169 @@ var typedSpecial = {
   ellipticPi
 };
 
+// src/gpu/elementwise-gpu.ts
+import {
+  getGpuDevice,
+  isGpuEnabled,
+  GPU_MIN_ELEMENTS
+} from "@danielsimonjr/mathts-gpu";
+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.
+  //
+  // 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.
+  //
+  // 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);"
+};
+var GPU_ELEMENTWISE_OPS = Object.keys(WGSL_OP_BODY);
+function isGpuChainSupported(ops) {
+  return ops.every((op) => op in WGSL_OP_BODY);
+}
+var WORKGROUP_SIZE = 256;
+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>;
+
+    fn apply(x: f32) -> f32 {
+      ${WGSL_OP_BODY[op]}
+    }
+
+    @compute @workgroup_size(${WORKGROUP_SIZE})
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let i = gid.x;
+      if (i >= arrayLength(&inp)) { 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;
+}
+async function elementwiseChainGpuDispatch(ops, xs, options) {
+  const n = xs.length;
+  if (!isGpuEnabled()) 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 bufA;
+  let bufB;
+  let staging;
+  let scopePopped = false;
+  let device;
+  try {
+    const d = await getGpuDevice(options);
+    if (!d) return null;
+    device = d;
+    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"
+    });
+    device.queue.writeBuffer(bufA, 0, input);
+    const encoder = device.createCommandEncoder({ label: "elementwise-chain" });
+    let src = bufA;
+    let dst2 = bufB;
+    for (const op of ops) {
+      const pipeline = getPipeline(device, op);
+      const bindGroup = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: src } },
+          { binding: 1, resource: { buffer: dst2 } }
+        ]
+      });
+      const pass = encoder.beginComputePass({ label: `chain:${op}` });
+      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);
+    const out = new Float32Array(staging.getMappedRange().slice(0));
+    staging.unmap();
+    return out;
+  } catch {
+    return null;
+  } finally {
+    if (device && !scopePopped) {
+      try {
+        await device.popErrorScope();
+      } catch {
+      }
+    }
+    bufA?.destroy();
+    bufB?.destroy();
+    staging?.destroy();
+  }
+}
+
 // src/typed/fused.ts
 var SCALAR = {
   abs: Math.abs,
@@ -7354,6 +7525,9 @@ var SCALAR = {
 function fuseUnaryChain(ops, xs) {
   const wasm = elementwiseChainDispatch(ops, xs);
   if (wasm) return wasm;
+  return jsChain(ops, xs);
+}
+function jsChain(ops, xs) {
   const out = Float64Array.from(xs);
   for (const op of ops) {
     const f = SCALAR[op];
@@ -7361,6 +7535,11 @@ function fuseUnaryChain(ops, xs) {
   }
   return out;
 }
+async function fuseUnaryChainAsync(ops, xs) {
+  const gpu = await elementwiseChainGpuDispatch(ops, xs);
+  if (gpu) return gpu;
+  return fuseUnaryChain(ops, xs);
+}
 
 // src/typed/distributions.ts
 import { mathTyped as mathTyped11 } from "@danielsimonjr/mathts-core";
@@ -15699,8 +15878,10 @@ var matrixSqrtm = mathTyped13("matrixSqrtm", {
 // src/typed/gpu.ts
 import { gpuMatrixBackend } from "@danielsimonjr/mathts-matrix";
 async function ensureGpu() {
-  if (gpuMatrixBackend.isAvailable()) {
+  if (!gpuMatrixBackend.isAvailable()) return;
+  try {
     await gpuMatrixBackend.initialize();
+  } catch {
   }
 }
 async function gpuMatmul(a, b) {
@@ -15720,6 +15901,9 @@ async function gpuScale(a, scalar) {
   return gpuMatrixBackend.scaleAsync(a, scalar);
 }
 
+// src/typed/index.ts
+import { enableGpu, disableGpu, isGpuEnabled as isGpuEnabled2, GPU_MIN_ELEMENTS as GPU_MIN_ELEMENTS2 } from "@danielsimonjr/mathts-gpu";
+
 // src/typed/relational.ts
 import naturalSort from "javascript-natural-sort";
 import { mathTyped as mathTyped14, Complex as Complex6, BigNumber as BigNumber6, Fraction as Fraction2 } from "@danielsimonjr/mathts-core";
@@ -41443,6 +41627,72 @@ function reviver(_key, value) {
 // src/typed/cas.ts
 import { computePool as computePool12 } from "@danielsimonjr/mathts-parallel";
 import { Complex as Complex10 } from "@danielsimonjr/mathts-core";
+function _evalNumeric(exprStr) {
+  let pos = 0;
+  const s = exprStr.replace(/\s+/g, "");
+  const parseExpr = () => {
+    let val = parseTerm();
+    while (pos < s.length) {
+      if (s[pos] === "+") {
+        pos++;
+        val += parseTerm();
+      } else if (s[pos] === "-") {
+        pos++;
+        val -= parseTerm();
+      } else break;
+    }
+    return val;
+  };
+  const parseTerm = () => {
+    let val = parseFactor();
+    while (pos < s.length) {
+      if (s[pos] === "*") {
+        pos++;
+        val *= parseFactor();
+      } else if (s[pos] === "/") {
+        pos++;
+        val /= parseFactor();
+      } else break;
+    }
+    return val;
+  };
+  const parseFactor = () => {
+    let val = parseBase();
+    if (pos < s.length && s[pos] === "^") {
+      pos++;
+      val = Math.pow(val, parseFactor());
+    }
+    return val;
+  };
+  const parseBase = () => {
+    if (s[pos] === "+") {
+      pos++;
+      return parseBase();
+    }
+    if (s[pos] === "-") {
+      pos++;
+      return -parseBase();
+    }
+    if (s[pos] === "(") {
+      pos++;
+      const val = parseExpr();
+      if (s[pos] === ")") pos++;
+      return val;
+    }
+    const start = pos;
+    while (pos < s.length && /[\d.]/.test(s[pos])) pos++;
+    if (start === pos) throw new Error();
+    return parseFloat(s.substring(start, pos));
+  };
+  try {
+    const val = parseExpr();
+    if (pos === s.length && typeof val === "number" && isFinite(val)) {
+      return String(val);
+    }
+  } catch {
+  }
+  return void 0;
+}
 function evalAt(expr, varName, value) {
   return evaluate(expr, { [varName]: value });
 }
@@ -42700,12 +42950,8 @@ function _casSimplifyOne(expr) {
   r = r.replace(/\b0\s*\*\s*[^+-]*/g, "0");
   const numericPattern = /^[\d\s+\-*/().^]+$/;
   if (numericPattern.test(r)) {
-    try {
-      const jsExpr = r.replace(/\^/g, "**");
-      const val = new Function('"use strict"; return (' + jsExpr + ")")();
-      if (typeof val === "number" && isFinite(val)) return String(val);
-    } catch {
-    }
+    const val = _evalNumeric(r);
+    if (val !== void 0) return val;
   }
   r = _combineLikeTerms(r);
   return r || "0";
@@ -42879,6 +43125,72 @@ function casSimplify(input) {
     return Promise.resolve(strs.map(_casSimplifyOne));
   }
   return computePool12.map(strs, (exprStr) => {
+    function _evalNumeric2(exprStr2) {
+      let pos = 0;
+      const s = exprStr2.replace(/\s+/g, "");
+      const parseExpr = () => {
+        let val = parseTerm();
+        while (pos < s.length) {
+          if (s[pos] === "+") {
+            pos++;
+            val += parseTerm();
+          } else if (s[pos] === "-") {
+            pos++;
+            val -= parseTerm();
+          } else break;
+        }
+        return val;
+      };
+      const parseTerm = () => {
+        let val = parseFactor();
+        while (pos < s.length) {
+          if (s[pos] === "*") {
+            pos++;
+            val *= parseFactor();
+          } else if (s[pos] === "/") {
+            pos++;
+            val /= parseFactor();
+          } else break;
+        }
+        return val;
+      };
+      const parseFactor = () => {
+        let val = parseBase();
+        if (pos < s.length && s[pos] === "^") {
+          pos++;
+          val = Math.pow(val, parseFactor());
+        }
+        return val;
+      };
+      const parseBase = () => {
+        if (s[pos] === "+") {
+          pos++;
+          return parseBase();
+        }
+        if (s[pos] === "-") {
+          pos++;
+          return -parseBase();
+        }
+        if (s[pos] === "(") {
+          pos++;
+          const val = parseExpr();
+          if (s[pos] === ")") pos++;
+          return val;
+        }
+        const start = pos;
+        while (pos < s.length && /[\d.]/.test(s[pos])) pos++;
+        if (start === pos) throw new Error();
+        return parseFloat(s.substring(start, pos));
+      };
+      try {
+        const val = parseExpr();
+        if (pos === s.length && typeof val === "number" && isFinite(val)) {
+          return String(val);
+        }
+      } catch {
+      }
+      return void 0;
+    }
     function _combineLikeTermsW(expr) {
       const normalised = expr.replace(/\s*-\s*/g, " + -");
       const rawTerms = normalised.split(/\s*\+\s*/);
@@ -42932,12 +43244,8 @@ function casSimplify(input) {
     r = r.replace(/\s*\+\s*0\b/g, "");
     r = r.replace(/\b0\s*\*\s*[^+-]*/g, "0");
     if (/^[\d\s+\-*/().^]+$/.test(r)) {
-      try {
-        const jsExpr = r.replace(/\^/g, "**");
-        const val = new Function('"use strict"; return (' + jsExpr + ")")();
-        if (typeof val === "number" && isFinite(val)) return String(val);
-      } catch {
-      }
+      const val = _evalNumeric2(r);
+      if (val !== void 0) return val;
     }
     return _combineLikeTermsW(r) || "0";
   }).then((r) => r.result);
@@ -44585,6 +44893,8 @@ export {
   DIST_WORKER_THRESHOLD,
   EARTH_RADIUS_KM,
   GAUSS_WORKER_THRESHOLD,
+  GPU_ELEMENTWISE_OPS,
+  GPU_MIN_ELEMENTS2 as GPU_MIN_ELEMENTS,
   WASM_INTERP_THRESHOLD,
   abs,
   acf,
@@ -44772,6 +45082,7 @@ export {
   differences,
   digamma,
   directionalDerivative,
+  disableGpu,
   discreteUniformDist,
   discriminant,
   distance,
@@ -44800,12 +45111,14 @@ export {
   electronMass,
   element,
   elementaryCharge,
+  elementwiseChainGpuDispatch,
   eliminate,
   ellipticE,
   ellipticEIncomplete,
   ellipticF,
   ellipticK,
   ellipticPi,
+  enableGpu,
   entropy,
   equal,
   equalScalar,
@@ -44926,6 +45239,7 @@ export {
   fullSimplify,
   functionExpand,
   fuseUnaryChain,
+  fuseUnaryChainAsync,
   gamma,
   gammaCDF,
   gammaDist,
@@ -45004,6 +45318,8 @@ export {
   isBounded,
   isConnected,
   isFinite2 as isFinite,
+  isGpuChainSupported,
+  isGpuEnabled2 as isGpuEnabled,
   isInteger2 as isInteger,
   isNaN2 as isNaN,
   isNegative,

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

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

package/dist/typed/fused.d.ts

@@ -18,4 +18,23 @@ import { type WasmElementwiseOp } from '../wasm/elementwise/wasm-bridge.js';
  * WASM when possible. Returns a new `Float64Array`; never mutates `xs`.
  */
 export declare function fuseUnaryChain(ops: WasmElementwiseOp[], xs: Float64Array): Float64Array;
+/**
+ * Async sibling of {@link fuseUnaryChain} that may run the chain on the **GPU**.
+ *
+ * This exists as a separate, `async` entry point rather than changing
+ * `fuseUnaryChain`, because a GPU dispatch is inherently asynchronous and
+ * `fuseUnaryChain`'s synchronous signature is public API.
+ *
+ * Tiers, in order: **GPU (f32)** → WASM (f64) → JS (f64).
+ *
+ * The GPU tier engages only when the caller has opted in via `enableGpu()`, a
+ * device is available, the array clears `GPU_MIN_ELEMENTS`, and every op in the
+ * chain has a GPU kernel. Otherwise this behaves exactly like `fuseUnaryChain`.
+ *
+ * **Precision:** when the GPU tier engages the result is a `Float32Array`
+ * (~7 significant digits); otherwise it is an exact-f64 `Float64Array`. The
+ * return type tells you which path ran — that is the precision contract, and it
+ * is why the GPU tier is opt-in rather than automatic.
+ */
+export declare function fuseUnaryChainAsync(ops: WasmElementwiseOp[], xs: Float64Array): Promise<Float64Array | Float32Array>;
 //# 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;AAyB5C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CASvF"}
+{"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;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,iBAAiB,EAAE,EACxB,EAAE,EAAE,YAAY,GACf,OAAO,CAAC,YAAY,GAAG,YAAY,CAAC,CAItC"}

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

@@ -1 +1 @@
-{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["../../src/typed/gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAShE;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGpF;AAED;;;;;;;;;GASG;AACH,wBAAsB,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGjF;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGvE;AAED;;;;;;;;;GASG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAGnF"}
+{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["../../src/typed/gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAqBhE;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGpF;AAED;;;;;;;;;GASG;AACH,wBAAsB,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGjF;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAGvE;AAED;;;;;;;;;GASG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAGnF"}

package/dist/typed/index.d.ts

@@ -46,6 +46,8 @@ export * from './hypothesis.js';
 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 * 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,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,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -35,7 +35,8 @@
   "dependencies": {
     "@danielsimonjr/mathts-core": "^0.6.0",
     "@danielsimonjr/mathts-expression": "^0.6.0",
-    "@danielsimonjr/mathts-matrix": "^0.2.2",
+    "@danielsimonjr/mathts-gpu": "^0.1.0",
+    "@danielsimonjr/mathts-matrix": "^0.3.0",
     "@danielsimonjr/mathts-parallel": "^0.3.3",
     "bignumber.js": "^9.1.2",
     "complex.js": "^2.2.5",
@@ -49,6 +50,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.2",
+    "@webgpu/types": "^0.1.67",
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^4.1.5"