wgblas 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgblas",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "BLAS on WebGPU",
   "type": "module",
   "main": "index.mjs",
@@ -82,6 +82,18 @@
     "./strsv": {
       "import": "./src/strsv/strsv.mjs",
       "types": "./src/strsv/strsv.d.mts"
+    },
+    "./sger": {
+      "import": "./src/sger/sger.mjs",
+      "types": "./src/sger/sger.d.mts"
+    },
+    "./ssyr": {
+      "import": "./src/ssyr/ssyr.mjs",
+      "types": "./src/ssyr/ssyr.d.mts"
+    },
+    "./ssyr2": {
+      "import": "./src/ssyr2/ssyr2.mjs",
+      "types": "./src/ssyr2/ssyr2.d.mts"
     }
   },
   "files": [
@@ -123,12 +135,15 @@
     "@stdlib/blas-base-scopy": "^0.3.1",
     "@stdlib/blas-base-sdot": "^0.3.1",
     "@stdlib/blas-base-sgemv": "^0.1.1",
+    "@stdlib/blas-base-sger": "^0.1.1",
     "@stdlib/blas-base-snrm2": "^0.3.1",
     "@stdlib/blas-base-srot": "^0.2.1",
     "@stdlib/blas-base-srotm": "^0.2.1",
     "@stdlib/blas-base-sscal": "^0.3.1",
     "@stdlib/blas-base-sswap": "^0.3.1",
     "@stdlib/blas-base-ssymv": "^0.1.1",
+    "@stdlib/blas-base-ssyr": "^0.1.1",
+    "@stdlib/blas-base-ssyr2": "^0.1.1",
     "@stdlib/blas-base-strmv": "^0.1.0",
     "@stdlib/blas-base-strsv": "^0.1.1",
     "@stdlib/random-array-uniform": "^0.2.2",

package/src/classes/GpuMatrix.d.mts

@@ -1,9 +1,12 @@
 /**
- * Represents a row-major Float32Array matrix stored in GPU memory.
+ * Represents a Float32Array (or Float64Array) matrix stored in GPU memory,
+ * row-major or column-major.
  *
- * The buffer holds `rows * lda` elements. `lda` (leading dimension) is the
- * number of floats between the start of consecutive rows — must be >= `cols`.
- * When `lda === cols` the matrix is dense with no padding.
+ * `rows`/`cols` always describe the logical shape regardless of layout.
+ * `lda` (leading dimension) is the stride between consecutive rows
+ * (row-major) or columns (column-major) — must be >= `cols` (row-major) or
+ * >= `rows` (column-major). When `lda` equals that minimum the matrix is
+ * dense with no padding.
  *
  * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/classes/GpuMatrix.mjs#L7">Source code: GpuMatrix.mjs (L7)</a>
  * @see [MDN: GPUBuffer](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer)
@@ -15,28 +18,34 @@ export declare class GpuMatrix {
   /** @internal */
   readonly _buf: GPUBuffer;
 
-  /** Number of rows. */
+  /** Number of rows (logical shape, independent of layout). */
   readonly rows: number;
 
-  /** Number of columns. */
+  /** Number of columns (logical shape, independent of layout). */
   readonly cols: number;
 
-  /** Leading dimension — stride between row starts (>= cols). */
+  /** Leading dimension — stride between row starts (row-major) or column starts (column-major). */
   readonly lda: number;
 
+  /** Storage layout this matrix was created with — every routine that accepts a GpuMatrix reads this automatically. */
+  readonly layout: 'row-major' | 'column-major';
+
   /**
-   * Uploads a row-major Float32Array or Float64Array matrix to GPU memory. A
-   * Float64Array is packed as two f32s per element (WGSL has no f64 type)
-   * and stored across two GPU buffers internally; `read()` reassembles the
-   * original doubles.
+   * Uploads a Float32Array or Float64Array matrix to GPU memory, row-major
+   * or column-major. A Float64Array is packed as two f32s per element (WGSL
+   * has no f64 type) and stored across two GPU buffers internally; `read()`
+   * reassembles the original doubles.
    *
-   * `lda` defaults to `cols` (dense, no padding between rows).
-   * `data` must have at least `rows * lda` elements.
+   * `rows`/`cols` always describe the logical shape regardless of layout.
+   * `lda` defaults to `cols` (row-major) or `rows` (column-major) — dense, no
+   * padding. `data` must have at least `rows * lda` (row-major) or
+   * `cols * lda` (column-major) elements.
    *
-   * @param data - matrix data in row-major order
-   * @param rows - number of rows
-   * @param cols - number of columns
-   * @param lda  - leading dimension (default: cols)
+   * @param data   - matrix data, in the order matching `layout`
+   * @param rows   - number of rows
+   * @param cols   - number of columns
+   * @param lda    - leading dimension (default: `cols` for row-major, `rows` for column-major)
+   * @param layout - storage layout (default: `'row-major'`)
    *
    * @example
    * ```js
@@ -46,15 +55,19 @@ export declare class GpuMatrix {
    * // 2×3 matrix: [[1,2,3],[4,5,6]]
    * const mat = GpuMatrix.from(new Float32Array([1,2,3,4,5,6]), 2, 3);
    * console.log(mat.rows, mat.cols, mat.lda); // 2 3 3
+   *
+   * // Same logical matrix, column-major storage
+   * const matCol = GpuMatrix.from(new Float32Array([1,4,2,5,3,6]), 2, 3, undefined, "column-major");
    * ```
    */
-  static from(data: Float32Array | Float64Array, rows: number, cols: number, lda?: number): GpuMatrix;
+  static from(data: Float32Array | Float64Array, rows: number, cols: number, lda?: number, layout?: 'row-major' | 'column-major'): GpuMatrix;
 
   /**
-   * Downloads the matrix from GPU memory and returns a dense row-major
-   * array of shape `rows × cols` — a `Float32Array`, or a `Float64Array` if
-   * this matrix was created from one. If `lda > cols`, the leading-dimension
-   * padding is stripped so the returned array is always tightly packed.
+   * Downloads the matrix from GPU memory and returns a dense array of shape
+   * `rows × cols`, in the same layout it was created with — a `Float32Array`,
+   * or a `Float64Array` if this matrix was created from one. If `lda` exceeds
+   * the dense minimum, the leading-dimension padding is stripped so the
+   * returned array is always tightly packed.
    *
    * @example
    * ```js

package/src/classes/GpuMatrix.mjs

@@ -4,7 +4,7 @@ import { extractResult } from "../util/result.mjs";
 import { packF64, unpackF64 } from "../util/f64pack.mjs";
 
 export class GpuMatrix {
-  constructor(buffer, rows, cols, lda, auxBuffer = null) {
+  constructor(buffer, rows, cols, lda, auxBuffer = null, layout = "row-major") {
     this._buf = buffer;
     // Non-null only for Float64Array-backed matrices — see GpuVector for why
     // (packF64 splits each element into a "main"/_buf f32 and "aux"/_auxBuf
@@ -13,29 +13,43 @@ export class GpuMatrix {
     this.rows = rows;
     this.cols = cols;
     this.lda  = lda;
+    this.layout = layout;
   }
 
   /**
-   * Uploads a row-major Float32Array or Float64Array matrix to GPU memory.
-   * lda defaults to cols (dense, no padding between rows).
-   * data must have at least rows * lda elements.
+   * Uploads a Float32Array or Float64Array matrix to GPU memory, row-major or
+   * column-major. `rows`/`cols` always describe the logical shape regardless
+   * of layout. `lda` is the stride between consecutive rows (row-major) or
+   * columns (column-major) — defaults to `cols`/`rows` respectively (dense,
+   * no padding). `data` must have at least `rows * lda` (row-major) or
+   * `cols * lda` (column-major) elements.
    */
-  static from(data, rows, cols, lda = cols) {
+  static from(data, rows, cols, lda, layout = "row-major") {
+    if (layout !== "row-major" && layout !== "column-major")
+      throw new Error("layout must be 'row-major' or 'column-major'.");
+    const isRowMajor = layout === "row-major";
+    if (lda === undefined) lda = isRowMajor ? cols : rows;
+
     if (!(data instanceof Float32Array) && !(data instanceof Float64Array))
       throw new Error("GpuMatrix.from expects a Float32Array or Float64Array.");
     if (!Number.isInteger(rows) || rows <= 0)
       throw new Error("rows must be a positive integer.");
     if (!Number.isInteger(cols) || cols <= 0)
       throw new Error("cols must be a positive integer.");
-    if (!Number.isInteger(lda) || lda < cols)
-      throw new Error("lda must be an integer >= cols.");
-    if (data.length < rows * lda)
+    const minLda = isRowMajor ? cols : rows;
+    if (!Number.isInteger(lda) || lda < minLda)
+      throw new Error(`lda must be an integer >= ${isRowMajor ? "cols" : "rows"}.`);
+
+    // Row-major: `rows` chunks of length `lda` (only the first `cols` of each used).
+    // Column-major: `cols` chunks of length `lda` (only the first `rows` of each used).
+    const outerCount = isRowMajor ? rows : cols;
+    if (data.length < outerCount * lda)
       throw new Error(
-        "data does not have enough elements for the given rows and lda.",
+        "data does not have enough elements for the given rows, cols, and lda.",
       );
 
     if (data instanceof Float64Array) {
-      const n = rows * lda;
+      const n = outerCount * lda;
       const main = new Float32Array(n);
       const aux = new Uint32Array(n);
       for (let i = 0; i < n; i++) {
@@ -45,11 +59,11 @@ export class GpuMatrix {
       }
       const mainBuf = uploadBuffer(main, "gpu-matrix-f64-main", true);
       const auxBuf = uploadBuffer(aux, "gpu-matrix-f64-aux", true);
-      return new GpuMatrix(mainBuf, rows, cols, lda, auxBuf);
+      return new GpuMatrix(mainBuf, rows, cols, lda, auxBuf, layout);
     }
 
-    const buf = uploadBuffer(data.subarray(0, rows * lda), "gpu-matrix", true);
-    return new GpuMatrix(buf, rows, cols, lda);
+    const buf = uploadBuffer(data.subarray(0, outerCount * lda), "gpu-matrix", true);
+    return new GpuMatrix(buf, rows, cols, lda, null, layout);
   }
 
   async read() {
@@ -58,6 +72,10 @@ export class GpuMatrix {
     const rb = stageReadback(enc, this._buf);
     device.queue.submit([enc.finish()]);
 
+    const isRowMajor = this.layout !== "column-major";
+    const outerCount = isRowMajor ? this.rows : this.cols;
+    const innerLen   = isRowMajor ? this.cols : this.rows;
+
     if (this._auxBuf) {
       const encAux = device.createCommandEncoder();
       const rbAux = stageReadback(encAux, this._auxBuf);
@@ -67,20 +85,20 @@ export class GpuMatrix {
         extractResult(rb, Float32Array),
         extractResult(rbAux, Uint32Array),
       ]);
-      const raw = new Float64Array(this.rows * this.lda);
+      const raw = new Float64Array(outerCount * this.lda);
       for (let i = 0; i < raw.length; i++) raw[i] = unpackF64(main[i], aux[i]);
-      if (this.lda === this.cols) return raw;
-      const out = new Float64Array(this.rows * this.cols);
-      for (let r = 0; r < this.rows; r++)
-        out.set(raw.subarray(r * this.lda, r * this.lda + this.cols), r * this.cols);
+      if (this.lda === innerLen) return raw;
+      const out = new Float64Array(outerCount * innerLen);
+      for (let r = 0; r < outerCount; r++)
+        out.set(raw.subarray(r * this.lda, r * this.lda + innerLen), r * innerLen);
       return out;
     }
 
     const raw = await extractResult(rb, Float32Array);
-    if (this.lda === this.cols) return raw;
-    const out = new Float32Array(this.rows * this.cols);
-    for (let r = 0; r < this.rows; r++)
-      out.set(raw.subarray(r * this.lda, r * this.lda + this.cols), r * this.cols);
+    if (this.lda === innerLen) return raw;
+    const out = new Float32Array(outerCount * innerLen);
+    for (let r = 0; r < outerCount; r++)
+      out.set(raw.subarray(r * this.lda, r * this.lda + innerLen), r * innerLen);
     return out;
   }
 

package/src/sgemv/sgemv.d.mts

@@ -20,13 +20,17 @@ import { GpuMatrix } from "../classes/GpuMatrix.mjs";
  * @param m      - number of rows in A
  * @param n      - number of columns in A
  * @param alpha  - scalar multiplier for op(A)*x
- * @param A      - Float32Array or GpuMatrix, row-major, at least (m-1)*lda+n elements
- * @param lda    - leading dimension of A (>= n)
+ * @param A      - Float32Array, row-major or column-major (see `layout`), at least
+ *   (m-1)*lda+n elements for row-major or (n-1)*lda+m elements for column-major
+ * @param lda    - leading dimension of A (>= n for row-major, >= m for column-major)
  * @param x      - Float32Array input vector
  * @param incx   - stride for x (must be a positive integer)
  * @param beta   - scalar multiplier for y
  * @param y      - Float32Array input/output vector
  * @param incy   - stride for y (must be a positive integer)
+ * @param layout - storage layout of `A` (default: `'row-major'`); column-major
+ *   swaps the effective `m`/`n` and flips `trans` internally (op(A) stays
+ *   what you asked for either way — x/y keep their original lengths)
  * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sgemv/sgemv.mjs#L16">Source code: sgemv.mjs (L16)</a>
  * @category BLAS Level 2
  */
@@ -36,26 +40,29 @@ export declare function sgemv(
   m: number,
   n: number,
   alpha: number,
-  A: Float32Array | GpuMatrix,
+  A: Float32Array,
   lda: number,
   x: Float32Array,
   incx: number,
   beta: number,
   y: Float32Array,
   incy: number,
+  layout?: 'row-major' | 'column-major',
 ): Promise<{ y: Float32Array; gpuTimeMs?: number }>;
 
 /**
  * Performs the matrix-vector operation y = alpha * op(A) * x + beta * y
  *
- * A is kept GPU-resident; x and y are CPU Float32Arrays.
+ * A is kept GPU-resident; x and y are CPU Float32Arrays. `A`'s own `layout`
+ * (set at `GpuMatrix.from` time) determines the operation — there is no
+ * separate `layout` argument here.
  *
  * @param device - GPUDevice from `init()`
  * @param trans  - `'no-transpose'` for A, `'transpose'` for A^T
  * @param m      - number of rows in A
  * @param n      - number of columns in A
  * @param alpha  - scalar multiplier for op(A)*x
- * @param A      - GpuMatrix, row-major, GPU-resident
+ * @param A      - GpuMatrix, GPU-resident
  * @param lda    - leading dimension of A (must equal A.lda)
  * @param x      - Float32Array input vector
  * @param incx   - stride for x (must be a positive integer)
@@ -83,7 +90,9 @@ export declare function sgemv(
 /**
  * Performs the matrix-vector operation y = alpha * op(A) * x + beta * y
  *
- * x and y are kept resident on the GPU. A must be a GpuMatrix.
+ * 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
+ * no separate `layout` argument here.
  *
  * {@includeCode ../../examples/sgemv/gpuvec.sgemv.js}
  *
@@ -92,8 +101,8 @@ export declare function sgemv(
  * @param m      - number of rows in A
  * @param n      - number of columns in A
  * @param alpha  - scalar multiplier for op(A)*x
- * @param A      - GpuMatrix, row-major
- * @param lda    - leading dimension of A (>= n)
+ * @param A      - GpuMatrix
+ * @param lda    - leading dimension of A (must equal A.lda)
  * @param x      - GpuVector input vector (not mutated)
  * @param incx   - stride for x (must be a positive integer)
  * @param beta   - scalar multiplier for y

package/src/sgemv/sgemv.mjs

@@ -13,24 +13,17 @@ import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
-export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) {
+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;
-  const AIsGpu = A instanceof GpuMatrix;
-  const isNoTrans = trans === "no-transpose";
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
-  if (!isNoTrans && trans !== "transpose")
+  if (trans !== "no-transpose" && trans !== "transpose")
     throw new Error("trans must be 'no-transpose' or 'transpose'.");
-  if (
-    !Number.isInteger(m) ||
-    !Number.isInteger(n) ||
-    !Number.isInteger(incx) ||
-    !Number.isInteger(incy) ||
-    !Number.isInteger(lda)
-  )
-    throw new Error("m, n, incx, incy, and lda must be integers.");
+  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 (Number.isNaN(alpha)) throw new Error("alpha must not be NaN.");
@@ -39,9 +32,16 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
     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 (
+    !Number.isInteger(m) ||
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy) ||
+    !Number.isInteger(lda)
+  )
+    throw new Error("m, n, incx, incy, and lda must be integers.");
   if (incx <= 0 || incy <= 0)
     throw new Error("incx and incy must be positive.");
-  if (lda < n) throw new Error("lda must be >= n.");
   if (!AIsGpu && !(A instanceof Float32Array))
     throw new Error("A must be a Float32Array or GpuMatrix.");
   if (!xIsGpu && !(x instanceof Float32Array))
@@ -65,11 +65,20 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
   if (m < 0 || n < 0) throw new Error("m and n must be non-negative.");
   if (m === 0 || n === 0) return yIsGpu ? {} : { y };
 
-  // NoTrans: x has n elements, y has m elements
-  // Trans:   x has m elements, y has n elements
+  // Column-major A reinterpreted row-major is A^T — swap to the kernel's
+  // view of m/n/trans now that the shape checks above are done.
+  const effLayout = AIsGpu ? A.layout : layout;
+  if (effLayout === "column-major") {
+    [m, n] = [n, m];
+    trans = trans === "no-transpose" ? "transpose" : "no-transpose";
+  }
+  const isNoTrans = trans === "no-transpose";
+
+  // NoTrans: x has n elements, y has m elements; Trans: x has m elements, y has n elements.
   const xLen = isNoTrans ? n : m;
   const yLen = isNoTrans ? m : n;
 
+  if (lda < n) throw new Error("lda must be >= n.");
   if (!AIsGpu && A.length < (m - 1) * lda + n)
     throw new Error(
       "A does not have enough elements for the given m, n, and lda.",
@@ -110,9 +119,7 @@ export async function sgemv(device, trans, m, n, alpha, A, lda, x, incx, beta, y
       paramsBuffer,
     ]);
 
-    // NoTrans: one workgroup per row; clamped to device limit — the shader's
-    // grid-stride loop handles remaining rows when m > dispatch count.
-    // Trans:   one thread per output column → dispatch ceil(n/64)
+    // NoTrans: one workgroup per row (grid-stride handles overflow); Trans: one thread per output column.
     const wgCount = isNoTrans
       ? Math.min(m, device.limits.maxComputeWorkgroupsPerDimension)
       : calcWorkgroups(yLen);

package/src/sger/sger.d.mts

@@ -0,0 +1,111 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+/**
+ * Performs the rank-1 update A = 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
+ * rows — must be >= n).
+ *
+ * {@includeCode ../../examples/sger/sger.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/sger/web/sger.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param m      - number of rows in A (length of x)
+ * @param n      - number of columns in A (length of y)
+ * @param alpha  - scalar multiplier for x*y^T
+ * @param x      - Float32Array input vector, length at least (m-1)*incx+1
+ * @param incx   - stride for x (must be a positive integer)
+ * @param y      - Float32Array input vector, length at least (n-1)*incy+1
+ * @param incy   - stride for y (must be a positive integer)
+ * @param A      - Float32Array, row-major or column-major (see `layout`), at least
+ *   (m-1)*lda+n elements for row-major or (n-1)*lda+m elements for column-major
+ * @param lda    - leading dimension of A (>= n for row-major, >= m for column-major)
+ * @param layout - storage layout of `A` (default: `'row-major'`)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sger/sger.mjs#L15">Source code: sger.mjs (L15)</a>
+ * @category BLAS Level 2
+ */
+export declare function sger(
+  device: GPUDevice,
+  m: number,
+  n: number,
+  alpha: number,
+  x: Float32Array,
+  incx: number,
+  y: Float32Array,
+  incy: number,
+  A: Float32Array,
+  lda: number,
+  layout?: 'row-major' | 'column-major',
+): Promise<{ A: Float32Array; gpuTimeMs?: number }>;
+
+/**
+ * Performs the rank-1 update A = alpha * x * y^T + A
+ *
+ * A is kept GPU-resident; x and y are CPU Float32Arrays. `A`'s own `layout`
+ * (set at `GpuMatrix.from` time) determines the operation — there is no
+ * separate `layout` argument here.
+ *
+ * @param device - GPUDevice from `init()`
+ * @param m      - number of rows in A
+ * @param n      - number of columns in A
+ * @param alpha  - scalar multiplier for x*y^T
+ * @param x      - Float32Array input vector
+ * @param incx   - stride for x (must be a positive integer)
+ * @param y      - Float32Array input vector
+ * @param incy   - stride for y (must be a positive integer)
+ * @param A      - GpuMatrix, GPU-resident
+ * @param lda    - leading dimension of A (must equal A.lda)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sger/sger.mjs#L15">Source code: sger.mjs (L15)</a>
+ * @category BLAS Level 2
+ */
+export declare function sger(
+  device: GPUDevice,
+  m: number,
+  n: number,
+  alpha: number,
+  x: Float32Array,
+  incx: number,
+  y: Float32Array,
+  incy: number,
+  A: GpuMatrix,
+  lda: number,
+): Promise<{ gpuTimeMs?: number }>;
+
+/**
+ * Performs the rank-1 update A = 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
+ * `layout` argument here.
+ *
+ * {@includeCode ../../examples/sger/gpuvec.sger.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param m      - number of rows in A
+ * @param n      - number of columns in A
+ * @param alpha  - scalar multiplier for x*y^T
+ * @param x      - GpuVector input vector (not mutated)
+ * @param incx   - stride for x (must be a positive integer)
+ * @param y      - GpuVector input vector (not mutated)
+ * @param incy   - stride for y (must be a positive integer)
+ * @param A      - GpuMatrix, mutated in place
+ * @param lda    - leading dimension of A (must equal A.lda)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sger/sger.mjs#L15">Source code: sger.mjs (L15)</a>
+ * @category BLAS Level 2
+ */
+export declare function sger(
+  device: GPUDevice,
+  m: number,
+  n: number,
+  alpha: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+  A: GpuMatrix,
+  lda: number,
+): Promise<{ gpuTimeMs?: number }>;

package/src/sger/sger.mjs

@@ -0,0 +1,136 @@
+import {
+  uploadBuffer,
+  createParamsBuffer,
+  stageReadback,
+  destroyBuffers,
+} from "../util/buffer.mjs";
+import { createBindGroup } from "../util/bindgroup.mjs";
+import { runComputePass, submit } from "../util/compute.mjs";
+import { extractResult } from "../util/result.mjs";
+import { extractTimestamp } from "../util/benchmark.mjs";
+import { getPipeline } from "../util/pipeline.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+export async function sger(device, m, n, alpha, x, incx, y, incy, A, lda, layout = "row-major") {
+  const AIsGpu = A instanceof GpuMatrix;
+
+  if (!(device instanceof GPUDevice))
+    throw new Error("device must be a GPUDevice.");
+  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 (Number.isNaN(alpha)) throw new Error("alpha must not be NaN.");
+  if (!Number.isFinite(alpha)) throw new Error("alpha must be finite.");
+  if (
+    !Number.isInteger(m) ||
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy) ||
+    !Number.isInteger(lda)
+  )
+    throw new Error("m, n, incx, incy, and lda must be integers.");
+  if (incx <= 0 || incy <= 0)
+    throw new Error("incx and incy must be positive.");
+  if (!AIsGpu && !(A instanceof Float32Array))
+    throw new Error("A must be a Float32Array or GpuMatrix.");
+  if (AIsGpu && lda !== A.lda)
+    throw new Error("lda must match A.lda when A is a GpuMatrix.");
+  // A.rows/A.cols are fixed regardless of layout — check against original m/n before the swap below.
+  if (AIsGpu && (A.rows < m || A.cols < n))
+    throw new Error("A is too small for the given m and n.");
+
+  // GpuMatrix's own layout wins over the argument; column-major A reinterpreted row-major is A^T, so swap x/y and m/n to reproduce it (transpose of a rank-1 update swaps its two vectors).
+  const effLayout = AIsGpu ? A.layout : layout;
+  if (effLayout === "column-major") {
+    [m, n] = [n, m];
+    [x, y] = [y, x];
+    [incx, incy] = [incy, incx];
+  }
+
+  const xIsGpu = x instanceof GpuVector;
+  const yIsGpu = y instanceof GpuVector;
+
+  if (lda < n) throw new Error("lda must be >= n.");
+  if (!xIsGpu && !(x instanceof Float32Array))
+    throw new Error("x must be a Float32Array or GpuVector.");
+  if (!yIsGpu && !(y instanceof Float32Array))
+    throw new Error("y must be a Float32Array or GpuVector.");
+  if (xIsGpu !== yIsGpu)
+    throw new Error(
+      "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.");
+  if (AIsGpu && xIsGpu && A._buf === x._buf)
+    throw new Error("A and x must not reference the same GPU buffer.");
+  if (AIsGpu && yIsGpu && A._buf === y._buf)
+    throw new Error("A and y must not reference the same GPU buffer.");
+  if (m < 0 || n < 0) throw new Error("m and n must be non-negative.");
+  if (m === 0 || n === 0) return AIsGpu ? {} : { A };
+
+  if (!AIsGpu && A.length < (m - 1) * lda + n)
+    throw new Error(
+      "A does not have enough elements for the given m, n, and lda.",
+    );
+  if (x.length < (m - 1) * incx + 1)
+    throw new Error("x does not have enough elements for the given m and incx.");
+  if (y.length < (n - 1) * incy + 1)
+    throw new Error("y does not have enough elements for the given n and incy.");
+
+  const pipeline = await getPipeline(device, "sger");
+
+  let xBuffer = null;
+  let yBuffer = null;
+  let ABuffer = null;
+  let paramsBuffer = null;
+
+  try {
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sger-x", false);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "sger-y", false);
+    ABuffer = AIsGpu ? A._buf : uploadBuffer(A, "sger-A", true);
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: m,     type: "u32" },
+        { value: n,     type: "u32" },
+        { value: alpha, type: "f32" },
+        { value: incx,  type: "u32" },
+        { value: incy,  type: "u32" },
+        { value: lda,   type: "u32" },
+      ],
+      "sger-params",
+    );
+
+    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+      xBuffer,
+      yBuffer,
+      ABuffer,
+      paramsBuffer,
+    ]);
+
+    // One workgroup per row of A; clamped to device limit — the shader's
+    // grid-stride loop handles remaining rows when m > dispatch count.
+    const wgCount = Math.min(m, device.limits.maxComputeWorkgroupsPerDimension);
+    const { commandEncoder, ts } = runComputePass(pipeline, bindGroup, wgCount);
+    const readBuffer = AIsGpu ? null : stageReadback(commandEncoder, ABuffer);
+
+    submit(commandEncoder);
+
+    const gpuTimeMs = await extractTimestamp(ts);
+
+    if (AIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
+
+    const result = await extractResult(readBuffer, Float32Array);
+    if (gpuTimeMs !== undefined) return { A: result, gpuTimeMs };
+    return { A: result };
+  } finally {
+    if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
+    if (!yIsGpu && yBuffer) destroyBuffers(yBuffer);
+    if (!AIsGpu && ABuffer) destroyBuffers(ABuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+  }
+}