wgblas 1.2.0 → 2.0.0

package/index.d.mts

@@ -17,6 +17,7 @@ export { sasum } from "./src/sasum/sasum.mjs";
 export { dasum } from "./src/dasum/dasum.mjs";
 export { snrm2 } from "./src/snrm2/snrm2.mjs";
 export { isamax } from "./src/isamax/isamax.mjs";
+export { idamax } from "./src/idamax/idamax.mjs";
 export { srot } from "./src/srot/srot.mjs";
 export { srotm } from "./src/srotm/srotm.mjs";
 export { sgemv } from "./src/sgemv/sgemv.mjs";
@@ -26,6 +27,13 @@ export { strsv } from "./src/strsv/strsv.mjs";
 export { sger } from "./src/sger/sger.mjs";
 export { ssyr } from "./src/ssyr/ssyr.mjs";
 export { ssyr2 } from "./src/ssyr2/ssyr2.mjs";
+export { sgemm } from "./src/sgemm/sgemm.mjs";
+export { sgemmtr } from "./src/sgemmtr/sgemmtr.mjs";
+export { ssyrk } from "./src/ssyrk/ssyrk.mjs";
+export { ssyr2k } from "./src/ssyr2k/ssyr2k.mjs";
+export { ssymm } from "./src/ssymm/ssymm.mjs";
+export { strmm } from "./src/strmm/strmm.mjs";
+export { strsm } from "./src/strsm/strsm.mjs";
 
 /**
  * Initializes the WebGPU device.
@@ -35,6 +43,10 @@ export { ssyr2 } from "./src/ssyr2/ssyr2.mjs";
  *   and `"low-power"` favors the integrated one.
  *   See [MDN: GPU.requestAdapter()](https://developer.mozilla.org/en-US/docs/Web/API/GPU/requestAdapter).
  * @param options.benchmark - enable GPU timestamp queries; BLAS functions return `{ result, gpuTimeMs }` (default: `false`)
+ * @param options.dumpShaders - Node-only. Forwards Dawn's `dump_shaders` debug toggle, printing
+ *   each pipeline's WGSL and compiled backend IR (SPIR-V/Vulkan, MSL/Metal, or HLSL/D3D12,
+ *   whichever Dawn picked) to stderr as it compiles. A Dawn passthrough, not a wgblas format —
+ *   no effect in the browser, which gives pages no API to request compiled shader IR (default: `false`)
  *
  * @example Default (high-performance GPU)
  * ```js
@@ -69,6 +81,7 @@ export { ssyr2 } from "./src/ssyr2/ssyr2.mjs";
 export declare function init(options?: {
   powerPreference?: GPUPowerPreference;
   benchmark?: boolean;
+  dumpShaders?: boolean;
 }): Promise<GPUDevice>;
 
 /**

package/index.mjs

@@ -15,6 +15,7 @@ export { sasum } from "./src/sasum/sasum.mjs";
 export { dasum } from "./src/dasum/dasum.mjs";
 export { snrm2 } from "./src/snrm2/snrm2.mjs";
 export { isamax } from "./src/isamax/isamax.mjs";
+export { idamax } from "./src/idamax/idamax.mjs";
 export { srot } from "./src/srot/srot.mjs";
 export { srotm } from "./src/srotm/srotm.mjs";
 export { sgemv } from "./src/sgemv/sgemv.mjs";
@@ -24,3 +25,10 @@ export { strsv } from "./src/strsv/strsv.mjs";
 export { sger } from "./src/sger/sger.mjs";
 export { ssyr } from "./src/ssyr/ssyr.mjs";
 export { ssyr2 } from "./src/ssyr2/ssyr2.mjs";
+export { sgemm } from "./src/sgemm/sgemm.mjs";
+export { sgemmtr } from "./src/sgemmtr/sgemmtr.mjs";
+export { ssyrk } from "./src/ssyrk/ssyrk.mjs";
+export { ssyr2k } from "./src/ssyr2k/ssyr2k.mjs";
+export { ssymm } from "./src/ssymm/ssymm.mjs";
+export { strmm } from "./src/strmm/strmm.mjs";
+export { strsm } from "./src/strsm/strsm.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgblas",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "BLAS on WebGPU",
   "type": "module",
   "main": "index.mjs",
@@ -59,6 +59,10 @@
       "import": "./src/isamax/isamax.mjs",
       "types": "./src/isamax/isamax.d.mts"
     },
+    "./idamax": {
+      "import": "./src/idamax/idamax.mjs",
+      "types": "./src/idamax/idamax.d.mts"
+    },
     "./srot": {
       "import": "./src/srot/srot.mjs",
       "types": "./src/srot/srot.d.mts"
@@ -94,6 +98,34 @@
     "./ssyr2": {
       "import": "./src/ssyr2/ssyr2.mjs",
       "types": "./src/ssyr2/ssyr2.d.mts"
+    },
+    "./sgemm": {
+      "import": "./src/sgemm/sgemm.mjs",
+      "types": "./src/sgemm/sgemm.d.mts"
+    },
+    "./sgemmtr": {
+      "import": "./src/sgemmtr/sgemmtr.mjs",
+      "types": "./src/sgemmtr/sgemmtr.d.mts"
+    },
+    "./ssyrk": {
+      "import": "./src/ssyrk/ssyrk.mjs",
+      "types": "./src/ssyrk/ssyrk.d.mts"
+    },
+    "./ssyr2k": {
+      "import": "./src/ssyr2k/ssyr2k.mjs",
+      "types": "./src/ssyr2k/ssyr2k.d.mts"
+    },
+    "./ssymm": {
+      "import": "./src/ssymm/ssymm.mjs",
+      "types": "./src/ssymm/ssymm.d.mts"
+    },
+    "./strmm": {
+      "import": "./src/strmm/strmm.mjs",
+      "types": "./src/strmm/strmm.d.mts"
+    },
+    "./strsm": {
+      "import": "./src/strsm/strsm.mjs",
+      "types": "./src/strsm/strsm.d.mts"
     }
   },
   "files": [
@@ -110,7 +142,26 @@
   },
   "keywords": [
     "BLAS",
-    "WebGPU"
+    "WebGPU",
+    "linear-algebra",
+    "linear",
+    "algebra",
+    "subroutines",
+    "level 1",
+    "level 2",
+    "level 3",
+    "gpu",
+    "gpgpu",
+    "wgsl",
+    "compute-shader",
+    "matrix",
+    "vector",
+    "matmul",
+    "dot product",
+    "float32",
+    "float64",
+    "numerical-computing",
+    "scientific-computing"
   ],
   "author": "Manit Roy",
   "license": "Apache-2.0",
@@ -120,7 +171,7 @@
   "bugs": {
     "url": "https://github.com/manit2004/wgblas/issues"
   },
-  "homepage": "https://github.com/manit2004/wgblas#readme",
+  "homepage": "https://manit2004.github.io/wgblas/",
   "dependencies": {
     "webgpu": "^0.4.0"
   },
@@ -129,11 +180,13 @@
     "@commitlint/config-conventional": "^21.2.0",
     "@eslint/js": "^10.0.1",
     "@stdlib/blas-base-dasum": "^0.4.1",
+    "@stdlib/blas-base-idamax": "^0.1.1",
     "@stdlib/blas-base-isamax": "^0.1.1",
     "@stdlib/blas-base-sasum": "^0.3.1",
     "@stdlib/blas-base-saxpy": "^0.3.1",
     "@stdlib/blas-base-scopy": "^0.3.1",
     "@stdlib/blas-base-sdot": "^0.3.1",
+    "@stdlib/blas-base-sgemm": "^0.1.1",
     "@stdlib/blas-base-sgemv": "^0.1.1",
     "@stdlib/blas-base-sger": "^0.1.1",
     "@stdlib/blas-base-snrm2": "^0.3.1",

package/src/dasum/dasum.d.mts

@@ -5,7 +5,7 @@ import { GpuVector } from "../classes/GpuVector.mjs";
  * precision: result = sum(|x[i]|). Each element of `x` has abs() applied,
  * then is split into a (hi, lo) double-double f32 pair (see
  * `splitDoubleDouble`/`f64.mjs`) since WGSL has no f64 type; accumulation
- * uses Dekker's double-double algorithm (see `shaders/f64/dekker.wgsl`), giving ~48 bits
+ * uses Dekker's double-double algorithm (see `shaders/f64/`), giving ~48 bits
  * of mantissa — more than a single f32 (24 bits) but less than true f64
  * (52 bits), so results are not bit-exact with a CPU double.
  *
@@ -33,7 +33,7 @@ export declare function dasum(
  * Computes the sum of absolute values of a vector of doubles in double
  * precision: result = sum(|x[i]|).
  *
- * {@includeCode ../../examples/dasum/gpuvec.dasum.js}
+ * {@includeCode ../../examples/dasum/gpu.dasum.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/dasum/dasum.mjs

@@ -34,10 +34,12 @@ export async function dasum(device, n, x, incx) {
       "x does not have enough elements for the given n and incx.",
     );
 
-  // Concatenated with f64/dekker.wgsl for its DD struct/ddAdd helpers (WGSL
-  // has no #include); entryPoint omitted since each module has only one @compute.
-  const pipelineMain = await getPipeline(device, ["f64/dekker", "dasum"]);
-  const pipelineReduce = await getPipeline(device, ["f64/dekker", "reduction/sumF64"]);
+  // Concatenated with f64/dekker.wgsl (DD struct), f64/utils/abs.wgsl
+  // (ddAbs), and f64/utils/add.wgsl (ddAddProtected) — WGSL has no
+  // #include; entryPoint omitted since each module has only one @compute.
+  const f64Deps = ["f64/dekker", "f64/utils/abs", "f64/utils/add"];
+  const pipelineMain = await getPipeline(device, [...f64Deps, "dasum"]);
+  const pipelineReduce = await getPipeline(device, [...f64Deps, "reduction/sumF64"]);
 
   let xHiBuffer = null;
   let xLoBuffer = null;

package/src/idamax/idamax.d.mts

@@ -0,0 +1,51 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Returns the 0-based index of the element with the largest absolute value,
+ * for a vector of doubles. Each element of `x` is split into a (hi, lo)
+ * double-double f32 pair (see `splitDoubleDouble`/`f64.mjs`) since WGSL has
+ * no f64 type; comparisons use the double-double pair directly (hi, falling
+ * back to lo on an exact tie), giving ~48 bits of discriminating precision —
+ * more than a single f32 (24 bits) but less than true f64 (52 bits). Ties
+ * are broken in favour of the lower index, matching CBLAS behaviour.
+ *
+ * {@includeCode ../../examples/idamax/idamax.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/idamax/web/idamax.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array input vector
+ * @param incx - stride for x (must be a positive integer)
+ * @returns 0-based index of max |x[i]|
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/idamax/idamax.mjs#L19">Source code: idamax.mjs (L19)</a>
+ * @category BLAS Level 1
+ */
+export declare function idamax(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+): Promise<{ index: number } | { index: number; gpuTimeMs: number }>;
+
+/**
+ * Returns the 0-based index of the element with the largest absolute value.
+ * Ties are broken in favour of the lower index, matching CBLAS behaviour.
+ *
+ * {@includeCode ../../examples/idamax/gpu.idamax.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array-backed GpuVector input vector
+ * @param incx - stride for x (must be a positive integer)
+ * @returns 0-based index of max |x[i]|
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/idamax/idamax.mjs#L19">Source code: idamax.mjs (L19)</a>
+ * @category BLAS Level 1
+ */
+export declare function idamax(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+): Promise<{ index: number } | { index: number; gpuTimeMs: number }>;

package/src/idamax/idamax.mjs

@@ -0,0 +1,128 @@
+import {
+  uploadBuffer,
+  createStorageBuffer,
+  createParamsBuffer,
+  createResultBuffer,
+  stageReadback,
+  destroyBuffers,
+} from "../util/buffer.mjs";
+import { createBindGroup } from "../util/bindgroup.mjs";
+import { runComputePass, submit } from "../util/compute.mjs";
+import { extractTimestamp } from "../util/benchmark.mjs";
+import { extractResult } from "../util/result.mjs";
+import { getPipeline } from "../util/pipeline.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { splitDoubleDouble } from "../util/f64.mjs";
+
+const WGS = 64;
+
+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.");
+  if (!Number.isInteger(n) || !Number.isInteger(incx))
+    throw new Error("n and incx must be integers.");
+  if (incx <= 0) throw new Error("incx must be positive.");
+  if (!xIsGpu && !(x instanceof Float64Array))
+    throw new Error("x must be a Float64Array or GpuVector.");
+  if (xIsGpu && x.dtype !== Float64Array)
+    throw new Error("x must be a Float64Array-backed GpuVector.");
+  if (n <= 0) return { index: 0 };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and 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");
+
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let partialsValHiBuffer = null;
+  let partialsValLoBuffer = null;
+  let partialsIdxBuffer = null;
+  let resultBuffer = null;
+  let paramsBuffer = null;
+  let readBuffer = null;
+
+  try {
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+    } else {
+      const { hi, lo } = splitDoubleDouble(x);
+      xHiBuffer = uploadBuffer(hi, "idamax-xHi", false);
+      xLoBuffer = uploadBuffer(lo, "idamax-xLo", false);
+    }
+    partialsValHiBuffer = createStorageBuffer(2 * WGS * 4, "idamax-partials-val-hi");
+    partialsValLoBuffer = createStorageBuffer(2 * WGS * 4, "idamax-partials-val-lo");
+    partialsIdxBuffer = createStorageBuffer(2 * WGS * 4, "idamax-partials-idx");
+    resultBuffer = createResultBuffer(4, "idamax-result"); // u32 index
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+      ],
+      "idamax-params",
+    );
+
+    const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+      xHiBuffer,
+      xLoBuffer,
+      partialsValHiBuffer,
+      partialsValLoBuffer,
+      partialsIdxBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups
+
+    submit(enc1);
+
+    const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
+      partialsValHiBuffer,
+      partialsValLoBuffer,
+      partialsIdxBuffer,
+      resultBuffer,
+    ]);
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // dispatch 1 workgroup to reduce the partials to a single index
+    readBuffer = stageReadback(enc2, resultBuffer);
+
+    submit(enc2);
+
+    const resultPromise = extractResult(readBuffer, Uint32Array);
+    readBuffer = null; // ownership transferred — extractResult's own finally destroys it
+
+    const [gpuTime1, gpuTime2, idxArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      resultPromise,
+    ]);
+
+    const index = idxArr[0];
+
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { index, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { index };
+  } finally {
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (partialsValHiBuffer) destroyBuffers(partialsValHiBuffer);
+    if (partialsValLoBuffer) destroyBuffers(partialsValLoBuffer);
+    if (partialsIdxBuffer) destroyBuffers(partialsIdxBuffer);
+    if (resultBuffer) destroyBuffers(resultBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(enc2) threw before ownership was transferred above.
+    if (readBuffer) destroyBuffers(readBuffer);
+  }
+}

package/src/init.mjs

@@ -11,6 +11,7 @@ let _benchmarkEnabled = false;
 export async function init({
   powerPreference = "high-performance",
   benchmark = false,
+  dumpShaders = false,
 } = {}) {
   if (_device) {
     return _device;
@@ -23,9 +24,16 @@ export async function init({
   if (typeof window === "undefined") {
     const { create, globals } = await import("webgpu");
     Object.assign(globalThis, globals);
-    gpu = create([]);
+    // dumpShaders forwards Dawn's own debug toggle — prints each pipeline's
+    // WGSL and compiled backend IR to stderr. Node-only; see index.d.mts.
+    const toggles = dumpShaders
+      ? ["enable-dawn-features=dump_shaders,disable_symbol_renaming"]
+      : [];
+    gpu = create(toggles);
     _gpu = gpu;
   } else {
+    if (dumpShaders)
+      console.warn("dumpShaders has no effect in the browser — see init()'s docs.");
     gpu = navigator.gpu;
   }
 

package/src/isamax/isamax.d.mts

@@ -28,7 +28,7 @@ export declare function isamax(
  * Returns the 0-based index of the element with the largest absolute value.
  * Ties are broken in favour of the lower index, matching CBLAS behaviour.
  *
- * {@includeCode ../../examples/isamax/gpuvec.isamax.js}
+ * {@includeCode ../../examples/isamax/gpu.isamax.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/sasum/sasum.d.mts

@@ -26,7 +26,7 @@ export declare function sasum(
 /**
  * Computes the sum of absolute values of a vector: result = sum(|x[i]|)
  *
- * {@includeCode ../../examples/sasum/gpuvec.sasum.js}
+ * {@includeCode ../../examples/sasum/gpu.sasum.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/saxpy/saxpy.d.mts

@@ -31,7 +31,7 @@ export declare function saxpy(
 /**
  * Performs the operation y = alpha * x + y
  *
- * {@includeCode ../../examples/saxpy/gpuvec.saxpy.js}
+ * {@includeCode ../../examples/saxpy/gpu.saxpy.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/scopy/scopy.d.mts

@@ -29,7 +29,7 @@ export declare function scopy(
 /**
  * Performs the operation y = x
  *
- * {@includeCode ../../examples/scopy/gpuvec.scopy.js}
+ * {@includeCode ../../examples/scopy/gpu.scopy.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/sdot/sdot.d.mts

@@ -30,7 +30,7 @@ export declare function sdot(
 /**
  * Computes the dot product of two vectors: result = sum(x[i] * y[i])
  *
- * {@includeCode ../../examples/sdot/gpuvec.sdot.js}
+ * {@includeCode ../../examples/sdot/gpu.sdot.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/sgemm/sgemm.d.mts

@@ -0,0 +1,102 @@
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+/**
+ * Performs the matrix-matrix operation C = alpha * op(A) * 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
+ *
+ * A, B, C are row-major or column-major (see `layout`) — backed by one of
+ * two shared-memory-tiled, register-blocked kernels chosen by shape:
+ * `sgemm_small.wgsl` (BM=BN=32) below a 6x6 workgroup grid, `sgemm_large.wgsl`
+ * (BM=BN=64) above it.
+ *
+ * {@includeCode ../../examples/sgemm/sgemm.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/sgemm/web/sgemm.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param transA - `'no-transpose'` for A, `'transpose'` for A^T
+ * @param transB - `'no-transpose'` for B, `'transpose'` for B^T
+ * @param m      - rows of op(A) and C
+ * @param n      - columns of op(B) and C
+ * @param k      - columns of op(A), rows of op(B)
+ * @param alpha  - scalar multiplier for op(A)*op(B)
+ * @param A      - Float32Array, row-major or column-major (see `layout`)
+ * @param lda    - leading dimension of A as stored
+ * @param B      - Float32Array, row-major or column-major (see `layout`)
+ * @param ldb    - leading dimension of B as stored
+ * @param beta   - scalar multiplier for C
+ * @param C      - Float32Array input/output matrix, row-major or column-major
+ * @param ldc    - leading dimension of C as stored
+ * @param layout - storage layout shared by A/B/C when they're Float32Array
+ *   (default: `'row-major'`); column-major A/B flips the respective trans
+ *   flag internally, column-major C computes C^T = op(B)^T*op(A)^T instead
+ *   (same underlying bytes) — op(A)*op(B) stays what you asked for either way
+ * @returns updated C as a Float32Array
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sgemm/sgemm.mjs#L17">Source code: sgemm.mjs (L17)</a>
+ * @category BLAS Level 3
+ */
+export declare function sgemm(
+  device: GPUDevice,
+  transA: 'no-transpose' | 'transpose',
+  transB: 'no-transpose' | 'transpose',
+  m: number,
+  n: number,
+  k: number,
+  alpha: number,
+  A: Float32Array,
+  lda: number,
+  B: Float32Array,
+  ldb: number,
+  beta: number,
+  C: Float32Array,
+  ldc: number,
+  layout?: 'row-major' | 'column-major',
+): Promise<{ C: Float32Array; gpuTimeMs?: number }>;
+
+/**
+ * Performs the matrix-matrix operation C = alpha * op(A) * 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
+ * `layout` argument here. A and B must be GpuMatrix whenever C is, and vice
+ * versa — mixing a GpuMatrix with a plain Float32Array is not supported.
+ *
+ * {@includeCode ../../examples/sgemm/gpu.sgemm.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param transA - `'no-transpose'` for A, `'transpose'` for A^T
+ * @param transB - `'no-transpose'` for B, `'transpose'` for B^T
+ * @param m      - rows of op(A) and C
+ * @param n      - columns of op(B) and C
+ * @param k      - columns of op(A), rows of op(B)
+ * @param alpha  - scalar multiplier for op(A)*op(B)
+ * @param A      - GpuMatrix
+ * @param lda    - leading dimension of A (must equal A.lda)
+ * @param B      - GpuMatrix
+ * @param ldb    - leading dimension of B (must equal B.lda)
+ * @param beta   - scalar multiplier for C
+ * @param C      - GpuMatrix (mutated in place)
+ * @param ldc    - leading dimension of C (must equal C.lda)
+ * @returns no C — it stays GPU-resident; call `C.read()` yourself for a CPU readback (see the example)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sgemm/sgemm.mjs#L17">Source code: sgemm.mjs (L17)</a>
+ * @category BLAS Level 3
+ */
+export declare function sgemm(
+  device: GPUDevice,
+  transA: 'no-transpose' | 'transpose',
+  transB: 'no-transpose' | 'transpose',
+  m: number,
+  n: number,
+  k: number,
+  alpha: number,
+  A: GpuMatrix,
+  lda: number,
+  B: GpuMatrix,
+  ldb: number,
+  beta: number,
+  C: GpuMatrix,
+  ldc: number,
+): Promise<{ gpuTimeMs?: number }>;