wgblas 2.1.0 → 2.2.1

package/src/idamax/idamax.mjs

@@ -14,14 +14,12 @@ import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { splitDoubleDouble } from "../util/f64.mjs";
 import { WGS } from "../util/constants.mjs";
-import { requireSameDevice } from "../util/device.mjs";
-
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function idamax(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "idamax", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
@@ -37,9 +35,22 @@ export async function idamax(device, n, x, incx) {
     );
 
   // Concatenated f64 helpers (WGSL has no #include); ddAbs is unconditional in idamax.wgsl, so x is split as-is.
-  const f64Deps = ["f64/dekker", "f64/utils/abs", "f64/utils/greater", "f64/utils/equal"];
-  const pipelineMain = await getPipeline(device, [...f64Deps, "idamax"], "idamax_main");
-  const pipelineReduce = await getPipeline(device, [...f64Deps, "reduction/argmaxF64"], "reduce_f64");
+  const f64Deps = [
+    "f64/dekker",
+    "f64/utils/abs",
+    "f64/utils/greater",
+    "f64/utils/equal",
+  ];
+  const pipelineMain = await getPipeline(
+    device,
+    [...f64Deps, "idamax"],
+    "idamax_main",
+  );
+  const pipelineReduce = await getPipeline(
+    device,
+    [...f64Deps, "reduction/argmaxF64"],
+    "reduce_f64",
+  );
 
   let xHiBuffer = null;
   let xLoBuffer = null;
@@ -59,11 +70,24 @@ export async function idamax(device, n, x, incx) {
       xHiBuffer = uploadBuffer(device, hi, "idamax-xHi", false);
       xLoBuffer = uploadBuffer(device, lo, "idamax-xLo", false);
     }
-    partialsValHiBuffer = createStorageBuffer(device, 2 * WGS * 4, "idamax-partials-val-hi");
-    partialsValLoBuffer = createStorageBuffer(device, 2 * WGS * 4, "idamax-partials-val-lo");
-    partialsIdxBuffer = createStorageBuffer(device, 2 * WGS * 4, "idamax-partials-idx");
+    partialsValHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "idamax-partials-val-hi",
+    );
+    partialsValLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "idamax-partials-val-lo",
+    );
+    partialsIdxBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "idamax-partials-idx",
+    );
     resultBuffer = createResultBuffer(device, 4, "idamax-result"); // u32 index
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -79,7 +103,8 @@ export async function idamax(device, n, x, incx) {
       partialsIdxBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
       pipelineMain,
       bgMain,
       2 * WGS,
@@ -87,13 +112,18 @@ export async function idamax(device, n, x, incx) {
 
     submit(device, enc1);
 
-    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
-      partialsValHiBuffer,
-      partialsValLoBuffer,
-      partialsIdxBuffer,
-      resultBuffer,
-    ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [
+        partialsValHiBuffer,
+        partialsValLoBuffer,
+        partialsIdxBuffer,
+        resultBuffer,
+      ],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
       pipelineReduce,
       bgReduce,
       1,

package/src/init.mjs

@@ -21,7 +21,8 @@ const _meta = new WeakMap();
 // never mention one (GpuVector.from(data), GpuMatrix.from(data, ...)).
 let _primary = null;
 
-const optionsKey = ({ powerPreference, benchmark }) => `${powerPreference}::${benchmark}`;
+const optionsKey = ({ powerPreference, benchmark }) =>
+  `${powerPreference}::${benchmark}`;
 
 // ── Public API ───────────────────────────────────────────────────────────────
 
@@ -53,7 +54,9 @@ export async function init({
       _dumpShaders = dumpShaders;
     } else {
       if (dumpShaders)
-        console.warn("dumpShaders has no effect in the browser — see init()'s docs.");
+        console.warn(
+          "dumpShaders has no effect in the browser — see init()'s docs.",
+        );
       _gpu = navigator.gpu;
     }
   } else if (dumpShaders !== _dumpShaders && typeof window === "undefined") {
@@ -62,7 +65,7 @@ export async function init({
     // init() cannot change it.
     console.warn(
       `dumpShaders: ${dumpShaders} was requested, but the WebGPU instance was already created with ` +
-      `dumpShaders: ${_dumpShaders}. The first init() call fixes this for the process.`,
+        `dumpShaders: ${_dumpShaders}. The first init() call fixes this for the process.`,
     );
   }
 

package/src/isamax/isamax.mjs

@@ -13,14 +13,12 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { WGS } from "../util/constants.mjs";
-import { requireSameDevice } from "../util/device.mjs";
-
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function isamax(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "isamax", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
@@ -45,16 +43,19 @@ export async function isamax(device, n, x, incx) {
 
   try {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "isamax-x", false);
-    partialsValBuffer = createStorageBuffer(device,
+    partialsValBuffer = createStorageBuffer(
+      device,
       2 * WGS * 4,
       "isamax-partials-val",
     ); //to hold 2*WGS partial max values of f32
-    partialsIdxBuffer = createStorageBuffer(device,
+    partialsIdxBuffer = createStorageBuffer(
+      device,
       2 * WGS * 4,
       "isamax-partials-idx",
     ); //to hold 2*WGS partial max indices of u32
     resultBuffer = createResultBuffer(device, 4, "isamax-result"); // u32 index
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -68,7 +69,8 @@ export async function isamax(device, n, x, incx) {
       partialsIdxBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
       pipelineMain,
       bgMain,
       2 * WGS,
@@ -76,12 +78,13 @@ export async function isamax(device, n, x, incx) {
 
     submit(device, enc1);
 
-    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
-      partialsValBuffer,
-      partialsIdxBuffer,
-      resultBuffer,
-    ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [partialsValBuffer, partialsIdxBuffer, resultBuffer],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
       pipelineReduce,
       bgReduce,
       1,

package/src/random/random.d.mts

@@ -4,22 +4,19 @@
  * @param n - number of elements
  * @param low - lower bound (default: -1)
  * @param high - upper bound (default: 1)
+ * @param seed - omit for genuine randomness (`Math.random`, the default);
+ *   pass any number for a deterministic, reproducible sequence (mulberry32) —
+ *   useful for regression tests that need "random-looking" data without
+ *   flaking between runs
  *
- * @example Default range [-1, 1)
- * ```js
- * import { randomFloat32Array } from "wgblas";
+ * **Default range [-1, 1):**
+ * {@includeCode ../../examples/randomfloat32array/randomfloat32array.js}
  *
- * const x = randomFloat32Array(4);
- * console.log(x); // Float32Array [ -0.42, 0.81, -0.07, 0.55 ]
- * ```
+ * **Custom range [0, 10):**
+ * {@includeCode ../../examples/randomfloat32array-custom/randomfloat32array-custom.js}
  *
- * @example Custom range [0, 10)
- * ```js
- * import { randomFloat32Array } from "wgblas";
- *
- * const x = randomFloat32Array(4, 0, 10);
- * console.log(x);
- * ```
+ * **Seeded (deterministic):**
+ * {@includeCode ../../examples/randomfloat32array-seeded/randomfloat32array-seeded.js}
  * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/random/random.mjs#L1">Source code: random.mjs (L1)</a>
  * @category Utilities
  */
@@ -27,6 +24,7 @@ export declare function randomFloat32Array(
   n: number,
   low?: number,
   high?: number,
+  seed?: number,
 ): Float32Array;
 
 /**
@@ -35,22 +33,19 @@ export declare function randomFloat32Array(
  * @param n - number of elements
  * @param low - lower bound (default: -1)
  * @param high - upper bound (default: 1)
+ * @param seed - omit for genuine randomness (`Math.random`, the default);
+ *   pass any number for a deterministic, reproducible sequence (mulberry32) —
+ *   useful for regression tests that need "random-looking" data without
+ *   flaking between runs
  *
- * @example Default range [-1, 1)
- * ```js
- * import { randomFloat64Array } from "wgblas";
- *
- * const x = randomFloat64Array(4);
- * console.log(x); // Float64Array [ -0.42, 0.81, -0.07, 0.55 ]
- * ```
+ * **Default range [-1, 1):**
+ * {@includeCode ../../examples/randomfloat64array/randomfloat64array.js}
  *
- * @example Custom range [0, 10)
- * ```js
- * import { randomFloat64Array } from "wgblas";
+ * **Custom range [0, 10):**
+ * {@includeCode ../../examples/randomfloat64array-custom/randomfloat64array-custom.js}
  *
- * const x = randomFloat64Array(4, 0, 10);
- * console.log(x);
- * ```
+ * **Seeded (deterministic):**
+ * {@includeCode ../../examples/randomfloat64array-seeded/randomfloat64array-seeded.js}
  * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/random/random.mjs#L7">Source code: random.mjs (L7)</a>
  * @category Utilities
  */
@@ -58,16 +53,20 @@ export declare function randomFloat64Array(
   n: number,
   low?: number,
   high?: number,
+  seed?: number,
 ): Float64Array;
 
 /**
- * Returns a Float32Array of n*lda elements, row-major with leading dimension
- * `lda`, representing an actual lower- or upper-triangular matrix for a
- * triangular routine (`strmv`/`strsv`) example: entries in the `uplo`
- * triangle are uniform in `[low, high)`, the n diagonal entries
- * (`A[i*lda+i]`) are uniform in `[diagLow, diagHigh)` — kept well away from 0
- * so a triangular solve doesn't divide by a near-zero pivot — and every entry
- * in the other triangle is 0.
+ * Returns a Float32Array of n*lda elements, with leading dimension `lda`
+ * under the given `layout`, representing an actual lower- or
+ * upper-triangular matrix for a triangular routine (`strmv`/`strsv`)
+ * example: entries in the `uplo` triangle are uniform in `[low, high)`, the
+ * n diagonal entries are uniform in `[diagLow, diagHigh)` — kept well away
+ * from 0 so a triangular solve doesn't divide by a near-zero pivot — and
+ * every entry in the other triangle is 0. `uplo` always describes the
+ * logical triangle, regardless of storage order: only the flat index each
+ * (row, col) maps to changes between layouts (`A[row*lda+col]` for
+ * row-major, `A[col*lda+row]` for column-major).
  *
  * @param n - matrix order (rows/cols read by the triangular routine)
  * @param lda - leading dimension; throws if `lda < n`
@@ -76,15 +75,12 @@ export declare function randomFloat64Array(
  * @param high - upper bound for off-diagonal entries (default: 1)
  * @param diagLow - lower bound for diagonal entries (default: 5)
  * @param diagHigh - upper bound for diagonal entries (default: 15)
+ * @param layout - `'row-major'` or `'column-major'` storage order (default: `'row-major'`)
  *
- * @example
- * ```js
- * import { randomTriangularFloat32Array } from "wgblas";
+ * {@includeCode ../../examples/randomtriangularfloat32array/randomtriangularfloat32array.js}
  *
- * const n = 4, lda = n;
- * const A = randomTriangularFloat32Array(n, lda, "lower");
- * console.log(A);
- * ```
+ * **Column-major storage:**
+ * {@includeCode ../../examples/randomtriangularfloat32array-columnmajor/randomtriangularfloat32array-columnmajor.js}
  * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/random/random.mjs#L13">Source code: random.mjs (L13)</a>
  * @category Utilities
  */
@@ -96,4 +92,5 @@ export declare function randomTriangularFloat32Array(
   high?: number,
   diagLow?: number,
   diagHigh?: number,
+  layout?: 'row-major' | 'column-major',
 ): Float32Array;

package/src/random/random.mjs

@@ -1,28 +1,60 @@
-export function randomFloat32Array(n, low = -1, high = 1) {
+// mulberry32: a small, fast, deterministic PRNG — not cryptographic, but
+// good enough distribution for test/benchmark data. Returns a () => number
+// generator producing values in [0, 1), same contract as Math.random.
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function () {
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export function randomFloat32Array(n, low = -1, high = 1, seed) {
   const x = new Float32Array(n);
-  for (let i = 0; i < n; i++) x[i] = low + Math.random() * (high - low);
+  const next = seed === undefined ? Math.random : mulberry32(seed);
+  for (let i = 0; i < n; i++) x[i] = low + next() * (high - low);
   return x;
 }
 
-export function randomFloat64Array(n, low = -1, high = 1) {
+export function randomFloat64Array(n, low = -1, high = 1, seed) {
   const x = new Float64Array(n);
-  for (let i = 0; i < n; i++) x[i] = low + Math.random() * (high - low);
+  const next = seed === undefined ? Math.random : mulberry32(seed);
+  for (let i = 0; i < n; i++) x[i] = low + next() * (high - low);
   return x;
 }
 
-export function randomTriangularFloat32Array(n, lda, uplo = "lower", low = -1, high = 1, diagLow = 5, diagHigh = 15) {
+export function randomTriangularFloat32Array(
+  n,
+  lda,
+  uplo = "lower",
+  low = -1,
+  high = 1,
+  diagLow = 5,
+  diagHigh = 15,
+  layout = "row-major",
+) {
   if (uplo !== "lower" && uplo !== "upper")
     throw new Error("uplo must be 'lower' or 'upper'.");
+  if (layout !== "row-major" && layout !== "column-major")
+    throw new Error("layout must be 'row-major' or 'column-major'.");
   if (lda < n) throw new Error("lda must be >= n.");
 
+  // Row-major stores row i at A[i*lda+j]; column-major stores column j at
+  // A[j*lda+i] instead. `uplo` describes the logical triangle (unaffected by
+  // storage order) — only which flat index each (i, j) maps to changes.
+  const isColMajor = layout === "column-major";
+  const idx = (i, j) => (isColMajor ? j * lda + i : i * lda + j);
+
   const A = new Float32Array(n * lda);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
       if (i === j) continue;
       const inTriangle = uplo === "lower" ? j < i : j > i;
-      if (inTriangle) A[i * lda + j] = low + Math.random() * (high - low);
+      if (inTriangle) A[idx(i, j)] = low + Math.random() * (high - low);
     }
-    A[i * lda + i] = diagLow + Math.random() * (diagHigh - diagLow);
+    A[idx(i, i)] = diagLow + Math.random() * (diagHigh - diagLow);
   }
   return A;
 }

package/src/sasum/sasum.mjs

@@ -13,14 +13,12 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { WGS } from "../util/constants.mjs";
-import { requireSameDevice } from "../util/device.mjs";
-
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function sasum(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "sasum", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
@@ -46,7 +44,8 @@ export async function sasum(device, n, x, incx) {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sasum-x", false);
     partialsBuffer = createStorageBuffer(device, 2 * WGS * 4, "sasum-partials"); // 2*WGS partial sums of f32
     resultBuffer = createResultBuffer(device, 4, "sasum-result"); // final f32 scalar
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -59,7 +58,8 @@ export async function sasum(device, n, x, incx) {
       partialsBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
       pipelineMain,
       bgMain,
       2 * WGS,
@@ -67,11 +67,13 @@ export async function sasum(device, n, x, incx) {
 
     submit(device, enc1);
 
-    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
-      partialsBuffer,
-      resultBuffer,
-    ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [partialsBuffer, resultBuffer],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
       pipelineReduce,
       bgReduce,
       1,

package/src/saxpy/saxpy.mjs

@@ -11,14 +11,13 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
-import { requireSameDevice } from "../util/device.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function saxpy(device, n, alpha, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
   const yIsGpu = y instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "saxpy", { x, y });
   if (
     !Number.isInteger(n) ||
@@ -26,8 +25,7 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
     !Number.isInteger(incy)
   )
     throw new Error("n, incx, and incy must be integers.");
-  if (typeof alpha !== "number")
-    throw new Error("alpha must be a number.");
+  if (typeof alpha !== "number") throw new Error("alpha must be a number.");
   if (Number.isNaN(alpha)) throw new Error("alpha must not be NaN.");
   if (!Number.isFinite(alpha)) throw new Error("alpha must be finite.");
   if (incx <= 0 || incy <= 0)
@@ -60,7 +58,8 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
   try {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "saxpy-x", false);
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "saxpy-y", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: alpha, type: "f32" },
@@ -75,7 +74,8 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(device,
+    const { commandEncoder, ts } = runComputePass(
+      device,
       pipeline,
       bindGroup,
       calcWorkgroups(device, n),
@@ -86,7 +86,8 @@ export async function saxpy(device, n, alpha, x, incx, y, incy) {
 
     const gpuTimeMs = await extractTimestamp(ts);
 
-    if (yIsGpu && xIsGpu) {
+    if (yIsGpu) {
+      // xIsGpu === yIsGpu, enforced above
       if (gpuTimeMs !== undefined) return { gpuTimeMs };
       return {};
     }

package/src/scopy/scopy.mjs

@@ -11,14 +11,13 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
-import { requireSameDevice } from "../util/device.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function scopy(device, n, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
   const yIsGpu = y instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "scopy", { x, y });
   if (
     !Number.isInteger(n) ||
@@ -56,7 +55,8 @@ export async function scopy(device, n, x, incx, y, incy) {
   try {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "scopy-x", false);
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "scopy-y", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -70,7 +70,8 @@ export async function scopy(device, n, x, incx, y, incy) {
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(device,
+    const { commandEncoder, ts } = runComputePass(
+      device,
       pipeline,
       bindGroup,
       calcWorkgroups(device, n),
@@ -81,7 +82,8 @@ export async function scopy(device, n, x, incx, y, incy) {
 
     const gpuTimeMs = await extractTimestamp(ts);
 
-    if (yIsGpu && xIsGpu) {
+    if (yIsGpu) {
+      // xIsGpu === yIsGpu, enforced above
       if (gpuTimeMs !== undefined) return { gpuTimeMs };
       return {};
     }

package/src/sdot/sdot.mjs

@@ -13,15 +13,13 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { WGS } from "../util/constants.mjs";
-import { requireSameDevice } from "../util/device.mjs";
-
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function sdot(device, n, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
   const yIsGpu = y instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "sdot", { x, y });
   if (
     !Number.isInteger(n) ||
@@ -64,7 +62,8 @@ export async function sdot(device, n, x, incx, y, incy) {
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "sdot-y", false);
     partialsBuffer = createStorageBuffer(device, 2 * WGS * 4, "sdot-partials"); //to hold 2*WGS partial sums of f32
     resultBuffer = createResultBuffer(device, 4, "sdot-result"); //to hold the final float32 dot product
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -79,7 +78,8 @@ export async function sdot(device, n, x, incx, y, incy) {
       partialsBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
       pipelineMain,
       bgMain,
       2 * WGS,
@@ -87,11 +87,13 @@ export async function sdot(device, n, x, incx, y, incy) {
 
     submit(device, enc1);
 
-    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
-      partialsBuffer,
-      resultBuffer,
-    ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [partialsBuffer, resultBuffer],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
       pipelineReduce,
       bgReduce,
       1,

package/src/sgemm/sgemm.d.mts

@@ -1,7 +1,7 @@
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
 /**
- * Performs the matrix-matrix operation C = alpha * op(A) * op(B) + beta * C
+ * Performs the matrix-matrix operation $$C \leftarrow \alpha \mathrm{op}(A) \mathrm{op}(B) + \beta C$$
  *
  * - `transA/transB='no-transpose'`: op(A) = A (m×k), op(B) = B (k×n)
  * - `transA/transB='transpose'`:    op(A) = A^T,     op(B) = B^T
@@ -57,7 +57,7 @@ export declare function sgemm(
 ): Promise<{ C: Float32Array; gpuTimeMs?: number }>;
 
 /**
- * Performs the matrix-matrix operation C = alpha * op(A) * op(B) + beta * C
+ * Performs the matrix-matrix operation $$C \leftarrow \alpha \mathrm{op}(A) \mathrm{op}(B) + \beta C$$
  *
  * A, B, and C are all kept GPU-resident. Each matrix's own `layout` (set at
  * `GpuMatrix.from` time) determines the operation — there is no separate