wgblas 2.1.0 → 2.2.1

package/src/sgemm/sgemm.mjs

@@ -13,19 +13,37 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 import { requireWorkgroupCount } from "../util/workgroup.mjs";
-import { BM_SMALL, BN_SMALL, BM_LARGE, BN_LARGE, LARGE_TILE_WORKGROUP_THRESHOLD } from "../util/constants.mjs";
-import { requireSameDevice } from "../util/device.mjs";
-
+import {
+  BM_SMALL,
+  BN_SMALL,
+  BM_LARGE,
+  BN_LARGE,
+  LARGE_TILE_WORKGROUP_THRESHOLD,
+} from "../util/constants.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function sgemm(
-  device, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, layout = "row-major",
+  device,
+  transA,
+  transB,
+  m,
+  n,
+  k,
+  alpha,
+  A,
+  lda,
+  B,
+  ldb,
+  beta,
+  C,
+  ldc,
+  layout = "row-major",
 ) {
   let AIsGpu = A instanceof GpuMatrix;
   let BIsGpu = B instanceof GpuMatrix;
   const CIsGpu = C instanceof GpuMatrix;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "sgemm", { A, B, C });
   if (transA !== "no-transpose" && transA !== "transpose")
     throw new Error("transA must be 'no-transpose' or 'transpose'.");
@@ -33,12 +51,10 @@ export async function sgemm(
     throw new Error("transB must be 'no-transpose' or 'transpose'.");
   if (layout !== "row-major" && layout !== "column-major")
     throw new Error("layout must be 'row-major' or 'column-major'.");
-  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 (typeof beta !== "number")
-    throw new Error("beta must be a number.");
+  if (typeof beta !== "number") throw new Error("beta must be a number.");
   if (Number.isNaN(beta)) throw new Error("beta must not be NaN.");
   if (!Number.isFinite(beta)) throw new Error("beta must be finite.");
   if (
@@ -60,7 +76,10 @@ export async function sgemm(
     throw new Error("C must be a GpuMatrix when A or B is a GpuMatrix.");
   if (CIsGpu && (!AIsGpu || !BIsGpu))
     throw new Error("A and B must be GpuMatrix when C is a GpuMatrix.");
-  if (m < 0 || n < 0 || k < 0) throw new Error("m, n, and k must be non-negative.");
+  if (m < 0 || n < 0 || k < 0)
+    throw new Error("m, n, and k must be non-negative.");
+  if (lda <= 0 || ldb <= 0 || ldc <= 0)
+    throw new Error("lda, ldb, and ldc must be positive.");
   if (m === 0 || n === 0) return CIsGpu ? {} : { C };
 
   // GpuMatrix's own .layout wins over the shared `layout` argument.
@@ -75,14 +94,19 @@ export async function sgemm(
   const aOuter = transA === "no-transpose" ? aRows : aCols; // # of stored chunks
   const aInner = transA === "no-transpose" ? aCols : aRows; // required chunk length
   if (lda < aInner)
-    throw new Error(`lda must be >= ${effLayoutA === "column-major" ? "rows" : "cols"} of A as stored.`);
+    throw new Error(
+      `lda must be >= ${effLayoutA === "column-major" ? "rows" : "cols"} of A as stored.`,
+    );
   if (AIsGpu) {
-    if (lda !== A.lda) throw new Error("lda must match A.lda when A is a GpuMatrix.");
+    if (lda !== A.lda)
+      throw new Error("lda must match A.lda when A is a GpuMatrix.");
     const [aLogRows, aLogCols] = transA === "no-transpose" ? [m, k] : [k, m];
     if (A.rows < aLogRows || A.cols < aLogCols)
       throw new Error("A is too small for the given m, k, and transA.");
   } else if (A.length < (aOuter - 1) * lda + aInner) {
-    throw new Error("A does not have enough elements for the given dimensions and lda.");
+    throw new Error(
+      "A does not have enough elements for the given dimensions and lda.",
+    );
   }
 
   // B: same reasoning as A, with op(B) = k x n.
@@ -91,26 +115,37 @@ export async function sgemm(
   const bOuter = transB === "no-transpose" ? bRows : bCols;
   const bInner = transB === "no-transpose" ? bCols : bRows;
   if (ldb < bInner)
-    throw new Error(`ldb must be >= ${effLayoutB === "column-major" ? "rows" : "cols"} of B as stored.`);
+    throw new Error(
+      `ldb must be >= ${effLayoutB === "column-major" ? "rows" : "cols"} of B as stored.`,
+    );
   if (BIsGpu) {
-    if (ldb !== B.lda) throw new Error("ldb must match B.lda when B is a GpuMatrix.");
+    if (ldb !== B.lda)
+      throw new Error("ldb must match B.lda when B is a GpuMatrix.");
     const [bLogRows, bLogCols] = transB === "no-transpose" ? [k, n] : [n, k];
     if (B.rows < bLogRows || B.cols < bLogCols)
       throw new Error("B is too small for the given n, k, and transB.");
   } else if (B.length < (bOuter - 1) * ldb + bInner) {
-    throw new Error("B does not have enough elements for the given dimensions and ldb.");
+    throw new Error(
+      "B does not have enough elements for the given dimensions and ldb.",
+    );
   }
 
   // C: always m x n (no trans flag) — layout only affects lda/storage order.
   const cOuter = effLayoutC === "column-major" ? n : m;
   const cInner = effLayoutC === "column-major" ? m : n;
   if (ldc < cInner)
-    throw new Error(`ldc must be >= ${effLayoutC === "column-major" ? "rows" : "cols"} of C as stored.`);
+    throw new Error(
+      `ldc must be >= ${effLayoutC === "column-major" ? "rows" : "cols"} of C as stored.`,
+    );
   if (CIsGpu) {
-    if (ldc !== C.lda) throw new Error("ldc must match C.lda when C is a GpuMatrix.");
-    if (C.rows < m || C.cols < n) throw new Error("C is too small for the given m and n.");
+    if (ldc !== C.lda)
+      throw new Error("ldc must match C.lda when C is a GpuMatrix.");
+    if (C.rows < m || C.cols < n)
+      throw new Error("C is too small for the given m and n.");
   } else if (C.length < (cOuter - 1) * ldc + cInner) {
-    throw new Error("C does not have enough elements for the given dimensions and ldc.");
+    throw new Error(
+      "C does not have enough elements for the given dimensions and ldc.",
+    );
   }
 
   // Column-major A/B reinterpreted row-major is A^T/B^T — flip the trans flag.
@@ -136,7 +171,10 @@ export async function sgemm(
   const largeWgY = Math.ceil(m / BM_LARGE);
   const useLargeTile = largeWgX * largeWgY >= LARGE_TILE_WORKGROUP_THRESHOLD;
 
-  const pipeline = await getPipeline(device, useLargeTile ? "sgemm_large" : "sgemm_small");
+  const pipeline = await getPipeline(
+    device,
+    useLargeTile ? "sgemm_large" : "sgemm_small",
+  );
 
   const ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "sgemm-A", false);
   const BBuffer = BIsGpu ? B._buf : uploadBuffer(device, B, "sgemm-B", false);
@@ -147,13 +185,14 @@ export async function sgemm(
   const bNot = transB === "no-transpose";
   const useVecA = aNot && vec4Usable(ABuffer, lda, m, k); // transposed-A vec stores bank-conflict smem — measured slower than scalar
   const useVecB = vec4Usable(BBuffer, ldb, bNot ? k : n, bNot ? n : k);
-  const paramsBuffer = createParamsBuffer(device,
+  const paramsBuffer = createParamsBuffer(
+    device,
     [
-      { value: m,   type: "u32" },
-      { value: n,   type: "u32" },
-      { value: k,   type: "u32" },
+      { value: m, type: "u32" },
+      { value: n, type: "u32" },
+      { value: k, type: "u32" },
       { value: alpha, type: "f32" },
-      { value: beta,  type: "f32" },
+      { value: beta, type: "f32" },
       { value: lda, type: "u32" },
       { value: ldb, type: "u32" },
       { value: ldc, type: "u32" },
@@ -177,15 +216,32 @@ export async function sgemm(
 
     const wgCount = useLargeTile
       ? {
-        x: requireWorkgroupCount(device, largeWgX, "sgemm", "x"),
-        y: requireWorkgroupCount(device, largeWgY, "sgemm", "y"),
-      }
+          x: requireWorkgroupCount(device, largeWgX, "sgemm", "x"),
+          y: requireWorkgroupCount(device, largeWgY, "sgemm", "y"),
+        }
       : {
-        x: requireWorkgroupCount(device, Math.ceil(n / BN_SMALL), "sgemm", "x"),
-        y: requireWorkgroupCount(device, Math.ceil(m / BM_SMALL), "sgemm", "y"),
-      };
-    const { commandEncoder, ts } = runComputePass(device, pipeline, bindGroup, wgCount);
-    const readBuffer = CIsGpu ? null : stageReadback(device, commandEncoder, CBuffer);
+          x: requireWorkgroupCount(
+            device,
+            Math.ceil(n / BN_SMALL),
+            "sgemm",
+            "x",
+          ),
+          y: requireWorkgroupCount(
+            device,
+            Math.ceil(m / BM_SMALL),
+            "sgemm",
+            "y",
+          ),
+        };
+    const { commandEncoder, ts } = runComputePass(
+      device,
+      pipeline,
+      bindGroup,
+      wgCount,
+    );
+    const readBuffer = CIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, CBuffer);
 
     submit(device, commandEncoder);
 

package/src/sgemmtr/sgemmtr.d.mts

@@ -1,7 +1,8 @@
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
 /**
- * Performs the matrix-matrix operation C := uplo(alpha * op(A) * op(B) + beta * C) —
+ * Performs the matrix-matrix operation $$C \leftarrow \mathrm{uplo}(\alpha \mathrm{op}(A) \mathrm{op}(B) + \beta C)$$
+ *
  * `sgemm`'s operation, but only the triangle of C named by `uplo` is read or
  * written (`'lower'`: `col <= row`, `'upper'`: `col >= row`; C need not be
  * square — the test applies over the full m×n grid).
@@ -57,7 +58,7 @@ export declare function sgemmtr(
 ): Promise<{ C: Float32Array; gpuTimeMs?: number }>;
 
 /**
- * Performs the matrix-matrix operation C := uplo(alpha * op(A) * op(B) + beta * C)
+ * Performs the matrix-matrix operation $$C \leftarrow \mathrm{uplo}(\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

package/src/sgemmtr/sgemmtr.mjs

@@ -11,19 +11,38 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 import { requireWorkgroupCount } from "../util/workgroup.mjs";
-import { BM_SMALL, BN_SMALL, BM_LARGE, BN_LARGE, LARGE_TILE_WORKGROUP_THRESHOLD } from "../util/constants.mjs";
-import { requireSameDevice } from "../util/device.mjs";
-
+import {
+  BM_SMALL,
+  BN_SMALL,
+  BM_LARGE,
+  BN_LARGE,
+  LARGE_TILE_WORKGROUP_THRESHOLD,
+} from "../util/constants.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function sgemmtr(
-  device, uplo, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, layout = "row-major",
+  device,
+  uplo,
+  transA,
+  transB,
+  m,
+  n,
+  k,
+  alpha,
+  A,
+  lda,
+  B,
+  ldb,
+  beta,
+  C,
+  ldc,
+  layout = "row-major",
 ) {
   let AIsGpu = A instanceof GpuMatrix;
   let BIsGpu = B instanceof GpuMatrix;
   const CIsGpu = C instanceof GpuMatrix;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "sgemmtr", { A, B, C });
   if (uplo !== "lower" && uplo !== "upper")
     throw new Error("uplo must be 'lower' or 'upper'.");
@@ -33,12 +52,10 @@ export async function sgemmtr(
     throw new Error("transB must be 'no-transpose' or 'transpose'.");
   if (layout !== "row-major" && layout !== "column-major")
     throw new Error("layout must be 'row-major' or 'column-major'.");
-  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 (typeof beta !== "number")
-    throw new Error("beta must be a number.");
+  if (typeof beta !== "number") throw new Error("beta must be a number.");
   if (Number.isNaN(beta)) throw new Error("beta must not be NaN.");
   if (!Number.isFinite(beta)) throw new Error("beta must be finite.");
   if (
@@ -60,7 +77,10 @@ export async function sgemmtr(
     throw new Error("C must be a GpuMatrix when A or B is a GpuMatrix.");
   if (CIsGpu && (!AIsGpu || !BIsGpu))
     throw new Error("A and B must be GpuMatrix when C is a GpuMatrix.");
-  if (m < 0 || n < 0 || k < 0) throw new Error("m, n, and k must be non-negative.");
+  if (m < 0 || n < 0 || k < 0)
+    throw new Error("m, n, and k must be non-negative.");
+  if (lda <= 0 || ldb <= 0 || ldc <= 0)
+    throw new Error("lda, ldb, and ldc must be positive.");
   if (m === 0 || n === 0) return CIsGpu ? {} : { C };
 
   // GpuMatrix's own .layout wins over the shared `layout` argument.
@@ -75,14 +95,19 @@ export async function sgemmtr(
   const aOuter = transA === "no-transpose" ? aRows : aCols; // # of stored chunks
   const aInner = transA === "no-transpose" ? aCols : aRows; // required chunk length
   if (lda < aInner)
-    throw new Error(`lda must be >= ${effLayoutA === "column-major" ? "rows" : "cols"} of A as stored.`);
+    throw new Error(
+      `lda must be >= ${effLayoutA === "column-major" ? "rows" : "cols"} of A as stored.`,
+    );
   if (AIsGpu) {
-    if (lda !== A.lda) throw new Error("lda must match A.lda when A is a GpuMatrix.");
+    if (lda !== A.lda)
+      throw new Error("lda must match A.lda when A is a GpuMatrix.");
     const [aLogRows, aLogCols] = transA === "no-transpose" ? [m, k] : [k, m];
     if (A.rows < aLogRows || A.cols < aLogCols)
       throw new Error("A is too small for the given m, k, and transA.");
   } else if (A.length < (aOuter - 1) * lda + aInner) {
-    throw new Error("A does not have enough elements for the given dimensions and lda.");
+    throw new Error(
+      "A does not have enough elements for the given dimensions and lda.",
+    );
   }
 
   // B: same reasoning as A, with op(B) = k x n.
@@ -91,26 +116,37 @@ export async function sgemmtr(
   const bOuter = transB === "no-transpose" ? bRows : bCols;
   const bInner = transB === "no-transpose" ? bCols : bRows;
   if (ldb < bInner)
-    throw new Error(`ldb must be >= ${effLayoutB === "column-major" ? "rows" : "cols"} of B as stored.`);
+    throw new Error(
+      `ldb must be >= ${effLayoutB === "column-major" ? "rows" : "cols"} of B as stored.`,
+    );
   if (BIsGpu) {
-    if (ldb !== B.lda) throw new Error("ldb must match B.lda when B is a GpuMatrix.");
+    if (ldb !== B.lda)
+      throw new Error("ldb must match B.lda when B is a GpuMatrix.");
     const [bLogRows, bLogCols] = transB === "no-transpose" ? [k, n] : [n, k];
     if (B.rows < bLogRows || B.cols < bLogCols)
       throw new Error("B is too small for the given n, k, and transB.");
   } else if (B.length < (bOuter - 1) * ldb + bInner) {
-    throw new Error("B does not have enough elements for the given dimensions and ldb.");
+    throw new Error(
+      "B does not have enough elements for the given dimensions and ldb.",
+    );
   }
 
   // C: always m x n (no trans flag) — layout only affects lda/storage order.
   const cOuter = effLayoutC === "column-major" ? n : m;
   const cInner = effLayoutC === "column-major" ? m : n;
   if (ldc < cInner)
-    throw new Error(`ldc must be >= ${effLayoutC === "column-major" ? "rows" : "cols"} of C as stored.`);
+    throw new Error(
+      `ldc must be >= ${effLayoutC === "column-major" ? "rows" : "cols"} of C as stored.`,
+    );
   if (CIsGpu) {
-    if (ldc !== C.lda) throw new Error("ldc must match C.lda when C is a GpuMatrix.");
-    if (C.rows < m || C.cols < n) throw new Error("C is too small for the given m and n.");
+    if (ldc !== C.lda)
+      throw new Error("ldc must match C.lda when C is a GpuMatrix.");
+    if (C.rows < m || C.cols < n)
+      throw new Error("C is too small for the given m and n.");
   } else if (C.length < (cOuter - 1) * ldc + cInner) {
-    throw new Error("C does not have enough elements for the given dimensions and ldc.");
+    throw new Error(
+      "C does not have enough elements for the given dimensions and ldc.",
+    );
   }
 
   // Column-major A/B reinterpreted row-major is A^T/B^T — flip the trans flag.
@@ -141,18 +177,22 @@ export async function sgemmtr(
   const largeWgY = Math.ceil(m / BM_LARGE);
   const useLargeTile = largeWgX * largeWgY >= LARGE_TILE_WORKGROUP_THRESHOLD;
 
-  const pipeline = await getPipeline(device, useLargeTile ? "sgemmtr_large" : "sgemmtr_small");
+  const pipeline = await getPipeline(
+    device,
+    useLargeTile ? "sgemmtr_large" : "sgemmtr_small",
+  );
 
   const ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "sgemmtr-A", false);
   const BBuffer = BIsGpu ? B._buf : uploadBuffer(device, B, "sgemmtr-B", false);
   const CBuffer = CIsGpu ? C._buf : uploadBuffer(device, C, "sgemmtr-C", true);
-  const paramsBuffer = createParamsBuffer(device,
+  const paramsBuffer = createParamsBuffer(
+    device,
     [
-      { value: m,   type: "u32" },
-      { value: n,   type: "u32" },
-      { value: k,   type: "u32" },
+      { value: m, type: "u32" },
+      { value: n, type: "u32" },
+      { value: k, type: "u32" },
       { value: alpha, type: "f32" },
-      { value: beta,  type: "f32" },
+      { value: beta, type: "f32" },
       { value: lda, type: "u32" },
       { value: ldb, type: "u32" },
       { value: ldc, type: "u32" },
@@ -173,15 +213,32 @@ export async function sgemmtr(
 
     const wgCount = useLargeTile
       ? {
-        x: requireWorkgroupCount(device, largeWgX, "sgemmtr", "x"),
-        y: requireWorkgroupCount(device, largeWgY, "sgemmtr", "y"),
-      }
+          x: requireWorkgroupCount(device, largeWgX, "sgemmtr", "x"),
+          y: requireWorkgroupCount(device, largeWgY, "sgemmtr", "y"),
+        }
       : {
-        x: requireWorkgroupCount(device, Math.ceil(n / BN_SMALL), "sgemmtr", "x"),
-        y: requireWorkgroupCount(device, Math.ceil(m / BM_SMALL), "sgemmtr", "y"),
-      };
-    const { commandEncoder, ts } = runComputePass(device, pipeline, bindGroup, wgCount);
-    const readBuffer = CIsGpu ? null : stageReadback(device, commandEncoder, CBuffer);
+          x: requireWorkgroupCount(
+            device,
+            Math.ceil(n / BN_SMALL),
+            "sgemmtr",
+            "x",
+          ),
+          y: requireWorkgroupCount(
+            device,
+            Math.ceil(m / BM_SMALL),
+            "sgemmtr",
+            "y",
+          ),
+        };
+    const { commandEncoder, ts } = runComputePass(
+      device,
+      pipeline,
+      bindGroup,
+      wgCount,
+    );
+    const readBuffer = CIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, CBuffer);
 
     submit(device, commandEncoder);
 

package/src/sgemv/sgemv.d.mts

@@ -2,7 +2,7 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
 /**
- * Performs the matrix-vector operation y = alpha * op(A) * x + beta * y
+ * Performs the matrix-vector operation $$y \leftarrow \alpha \mathrm{op}(A) x + \beta y$$
  *
  * - `trans='no-transpose'`: op(A) = A,   x is length n, y is length m
  * - `trans='transpose'`:    op(A) = A^T, x is length m, y is length n
@@ -51,7 +51,7 @@ export declare function sgemv(
 ): Promise<{ y: Float32Array; gpuTimeMs?: number }>;
 
 /**
- * Performs the matrix-vector operation y = alpha * op(A) * x + beta * y
+ * Performs the matrix-vector operation $$y \leftarrow \alpha \mathrm{op}(A) x + \beta y$$
  *
  * x and y are kept resident on the GPU. A must be a GpuMatrix; its own
  * `layout` (set at `GpuMatrix.from` time) determines the operation — there is

package/src/sgemv/sgemv.mjs

@@ -12,26 +12,37 @@ import { getPipeline } from "../util/pipeline.mjs";
 import { requireWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
-import { requireSameDevice } from "../util/device.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
-export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, layout = "row-major") {
+export async function sgemv(
+  device,
+  trans,
+  m,
+  n,
+  alpha,
+  A,
+  lda,
+  x,
+  incx,
+  beta,
+  y,
+  incy,
+  layout = "row-major",
+) {
   const AIsGpu = A instanceof GpuMatrix;
   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, "sgemv", { A, x, y });
   if (trans !== "no-transpose" && trans !== "transpose")
     throw new Error("trans must be 'no-transpose' or 'transpose'.");
   if (layout !== "row-major" && layout !== "column-major")
     throw new Error("layout must be 'row-major' or 'column-major'.");
-  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 (typeof beta !== "number")
-    throw new Error("beta must be a number.");
+  if (typeof beta !== "number") throw new Error("beta must be a number.");
   if (Number.isNaN(beta)) throw new Error("beta must not be NaN.");
   if (!Number.isFinite(beta)) throw new Error("beta must be finite.");
   if (
@@ -55,15 +66,13 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
       "x and y must be the same type (both Float32Array or both GpuVector).",
     );
   if (xIsGpu && !AIsGpu)
-    throw new Error(
-      "A must be a GpuMatrix when x and y are GpuVectors.",
-    );
+    throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");
   if (AIsGpu && !xIsGpu)
+    throw new Error("x and y must be GpuVectors when A is a GpuMatrix.");
+  if (xIsGpu && x._buf === y._buf)
     throw new Error(
-      "x and y must be GpuVectors when A is a GpuMatrix.",
+      "x and y must not reference the same GPU buffer when both are GpuVectors.",
     );
-  if (xIsGpu && x._buf === y._buf)
-    throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");
   if (AIsGpu && yIsGpu && A._buf === y._buf)
     throw new Error("A and y must not reference the same GPU buffer.");
   if (AIsGpu && lda !== A.lda)
@@ -101,7 +110,7 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
     );
 
   const shaderName = isNoTrans ? "sgemv_n" : "sgemv_t";
-  const pipeline   = await getPipeline(device, shaderName);
+  const pipeline = await getPipeline(device, shaderName);
 
   let ABuffer = null;
   let xBuffer = null;
@@ -112,15 +121,16 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
     ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "sgemv-A", false);
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sgemv-x", false);
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "sgemv-y", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
-        { value: m,     type: "u32" },
-        { value: n,     type: "u32" },
+        { value: m, type: "u32" },
+        { value: n, type: "u32" },
         { value: alpha, type: "f32" },
-        { value: beta,  type: "f32" },
-        { value: incx,  type: "u32" },
-        { value: incy,  type: "u32" },
-        { value: lda,   type: "u32" },
+        { value: beta, type: "f32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+        { value: lda, type: "u32" },
       ],
       "sgemv-params",
     );
@@ -139,8 +149,15 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
     const wgCount = isNoTrans
       ? Math.min(m, device.limits.maxComputeWorkgroupsPerDimension)
       : requireWorkgroups(device, "sgemv", yLen);
-    const { commandEncoder, ts } = runComputePass(device, pipeline, bindGroup, wgCount);
-    const readBuffer = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
+    const { commandEncoder, ts } = runComputePass(
+      device,
+      pipeline,
+      bindGroup,
+      wgCount,
+    );
+    const readBuffer = yIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, yBuffer);
 
     submit(device, commandEncoder);
 
@@ -159,6 +176,5 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
     if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
     if (!yIsGpu && yBuffer) destroyBuffers(yBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
-
   }
 }

package/src/sger/sger.d.mts

@@ -2,7 +2,7 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
 /**
- * Performs the rank-1 update A = alpha * x * y^T + A
+ * Performs the rank-1 update $$A \leftarrow \alpha x y^{T} + A$$
  *
  * A is an m×n matrix stored in row-major order, updated in place. `lda` is
  * the leading dimension (number of floats between the start of consecutive
@@ -43,7 +43,7 @@ export declare function sger(
 ): Promise<{ A: Float32Array; gpuTimeMs?: number }>;
 
 /**
- * Performs the rank-1 update A = alpha * x * y^T + A
+ * Performs the rank-1 update $$A \leftarrow \alpha x y^{T} + A$$
  *
  * x, y, and A are all kept resident on the GPU. `A`'s own `layout` (set at
  * `GpuMatrix.from` time) determines the operation — there is no separate