wgblas 2.2.1 → 2.3.0

package/index.d.mts

@@ -36,8 +36,15 @@ export { ssymv } from "./src/ssymv/ssymv.mjs";
 export { strmv } from "./src/strmv/strmv.mjs";
 export { strsv } from "./src/strsv/strsv.mjs";
 export { sger } from "./src/sger/sger.mjs";
+export { dger } from "./src/dger/dger.mjs";
 export { ssyr } from "./src/ssyr/ssyr.mjs";
+export { dsyr } from "./src/dsyr/dsyr.mjs";
 export { ssyr2 } from "./src/ssyr2/ssyr2.mjs";
+export { dsyr2 } from "./src/dsyr2/dsyr2.mjs";
+export { dgemv } from "./src/dgemv/dgemv.mjs";
+export { dsymv } from "./src/dsymv/dsymv.mjs";
+export { dtrmv } from "./src/dtrmv/dtrmv.mjs";
+export { dtrsv } from "./src/dtrsv/dtrsv.mjs";
 export { sgemm } from "./src/sgemm/sgemm.mjs";
 export { sgemmtr } from "./src/sgemmtr/sgemmtr.mjs";
 export { ssyrk } from "./src/ssyrk/ssyrk.mjs";

package/index.mjs

@@ -34,8 +34,15 @@ export { ssymv } from "./src/ssymv/ssymv.mjs";
 export { strmv } from "./src/strmv/strmv.mjs";
 export { strsv } from "./src/strsv/strsv.mjs";
 export { sger } from "./src/sger/sger.mjs";
+export { dger } from "./src/dger/dger.mjs";
 export { ssyr } from "./src/ssyr/ssyr.mjs";
+export { dsyr } from "./src/dsyr/dsyr.mjs";
 export { ssyr2 } from "./src/ssyr2/ssyr2.mjs";
+export { dsyr2 } from "./src/dsyr2/dsyr2.mjs";
+export { dgemv } from "./src/dgemv/dgemv.mjs";
+export { dsymv } from "./src/dsymv/dsymv.mjs";
+export { dtrmv } from "./src/dtrmv/dtrmv.mjs";
+export { dtrsv } from "./src/dtrsv/dtrsv.mjs";
 export { sgemm } from "./src/sgemm/sgemm.mjs";
 export { sgemmtr } from "./src/sgemmtr/sgemmtr.mjs";
 export { ssyrk } from "./src/ssyrk/ssyrk.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgblas",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "BLAS on WebGPU",
   "type": "module",
   "main": "index.mjs",
@@ -135,14 +135,42 @@
       "types": "./src/sger/sger.d.mts",
       "import": "./src/sger/sger.mjs"
     },
+    "./dger": {
+      "types": "./src/dger/dger.d.mts",
+      "import": "./src/dger/dger.mjs"
+    },
     "./ssyr": {
       "types": "./src/ssyr/ssyr.d.mts",
       "import": "./src/ssyr/ssyr.mjs"
     },
+    "./dsyr": {
+      "types": "./src/dsyr/dsyr.d.mts",
+      "import": "./src/dsyr/dsyr.mjs"
+    },
     "./ssyr2": {
       "types": "./src/ssyr2/ssyr2.d.mts",
       "import": "./src/ssyr2/ssyr2.mjs"
     },
+    "./dsyr2": {
+      "types": "./src/dsyr2/dsyr2.d.mts",
+      "import": "./src/dsyr2/dsyr2.mjs"
+    },
+    "./dgemv": {
+      "types": "./src/dgemv/dgemv.d.mts",
+      "import": "./src/dgemv/dgemv.mjs"
+    },
+    "./dsymv": {
+      "types": "./src/dsymv/dsymv.d.mts",
+      "import": "./src/dsymv/dsymv.mjs"
+    },
+    "./dtrmv": {
+      "types": "./src/dtrmv/dtrmv.d.mts",
+      "import": "./src/dtrmv/dtrmv.mjs"
+    },
+    "./dtrsv": {
+      "types": "./src/dtrsv/dtrsv.d.mts",
+      "import": "./src/dtrsv/dtrsv.mjs"
+    },
     "./sgemm": {
       "types": "./src/sgemm/sgemm.d.mts",
       "import": "./src/sgemm/sgemm.mjs"
@@ -230,11 +258,18 @@
     "@stdlib/blas-base-daxpy": "^0.4.1",
     "@stdlib/blas-base-dcopy": "^0.4.1",
     "@stdlib/blas-base-ddot": "^0.4.1",
+    "@stdlib/blas-base-dgemv": "^0.1.1",
+    "@stdlib/blas-base-dger": "^0.1.1",
     "@stdlib/blas-base-dnrm2": "^0.4.1",
     "@stdlib/blas-base-drot": "^0.1.1",
     "@stdlib/blas-base-drotm": "^0.2.1",
     "@stdlib/blas-base-dscal": "^0.4.1",
     "@stdlib/blas-base-dswap": "^0.4.1",
+    "@stdlib/blas-base-dsymv": "^0.1.1",
+    "@stdlib/blas-base-dsyr": "^0.1.1",
+    "@stdlib/blas-base-dsyr2": "^0.1.1",
+    "@stdlib/blas-base-dtrmv": "^0.1.1",
+    "@stdlib/blas-base-dtrsv": "^0.1.1",
     "@stdlib/blas-base-idamax": "^0.1.1",
     "@stdlib/blas-base-isamax": "^0.1.1",
     "@stdlib/blas-base-sasum": "^0.3.1",
@@ -263,6 +298,7 @@
     "fast-check": "^4.8.0",
     "globals": "^17.7.0",
     "husky": "^9.1.7",
+    "jscpd": "^5.3.0",
     "lint-staged": "^17.0.8",
     "prettier": "^3.9.4",
     "publint": "^0.3.24",
@@ -275,10 +311,10 @@
   "scripts": {
     "prepare": "husky",
     "build:browser": "node scripts/build-browser.mjs",
-    "docs": "npx typedoc && npm run build:browser",
+    "docs": "npx typedoc && node scripts/gen-sitemap.mjs && npm run build:browser",
     "prepublishOnly": "npm run build:browser",
-    "coverage": "c8 --reporter=text --reporter=html node --test $(find tests \\( -name 'test.*.js' -o -name 'gpustorage.*.js' \\))",
-    "cpd": "jscpd src",
+    "coverage": "c8 --reporter=text --reporter=html --reporter=lcov node --test $(find tests \\( -name 'test.*.js' -o -name 'gpustorage.*.js' \\))",
+    "cpd": "jscpd src -r html -o jscpd/",
     "size": "npm run build:browser && size-limit"
   },
   "lint-staged": {

package/src/dgemv/dgemv.d.mts

@@ -0,0 +1,92 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+/**
+ * Performs the matrix-vector operation $$y \leftarrow \alpha \mathrm{op}(A) x + \beta y$$
+ * in double precision (double-double emulation — WGSL has no native f64 type).
+ *
+ * - `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
+ *
+ * A is an m×n matrix stored in row-major order. `lda` is the leading dimension
+ * (number of doubles between the start of consecutive rows — must be >= n).
+ *
+ * {@includeCode ../../examples/dgemv/dgemv.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/dgemv/web/dgemv.html}
+ *
+ * @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      - Float64Array, 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      - Float64Array input vector
+ * @param incx   - stride for x (must be a positive integer)
+ * @param beta   - scalar multiplier for y
+ * @param y      - Float64Array 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/dgemv/dgemv.mjs#L20">Source code: dgemv.mjs (L20)</a>
+ * @category BLAS Level 2
+ */
+export declare function dgemv(
+  device: GPUDevice,
+  trans: 'no-transpose' | 'transpose',
+  m: number,
+  n: number,
+  alpha: number,
+  A: Float64Array,
+  lda: number,
+  x: Float64Array,
+  incx: number,
+  beta: number,
+  y: Float64Array,
+  incy: number,
+  layout?: 'row-major' | 'column-major',
+): Promise<{ y: Float64Array; gpuTimeMs?: number }>;
+
+/**
+ * Performs the matrix-vector operation $$y \leftarrow \alpha \mathrm{op}(A) x + \beta y$$
+ * in double precision (double-double emulation).
+ *
+ * x and y are kept resident on the GPU. A must be a GpuMatrix (Float64Array-
+ * backed); its own `layout` (set at `GpuMatrix.from` time) determines the
+ * operation — there is no separate `layout` argument here.
+ *
+ * {@includeCode ../../examples/dgemv/gpu.dgemv.js}
+ *
+ * @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 (Float64Array-backed)
+ * @param lda    - leading dimension of A (must equal A.lda)
+ * @param x      - GpuVector input vector (Float64Array-backed, not mutated)
+ * @param incx   - stride for x (must be a positive integer)
+ * @param beta   - scalar multiplier for y
+ * @param y      - GpuVector input/output vector (Float64Array-backed, mutated in place)
+ * @param incy   - stride for y (must be a positive integer)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dgemv/dgemv.mjs#L20">Source code: dgemv.mjs (L20)</a>
+ * @category BLAS Level 2
+ */
+export declare function dgemv(
+  device: GPUDevice,
+  trans: 'no-transpose' | 'transpose',
+  m: number,
+  n: number,
+  alpha: number,
+  A: GpuMatrix,
+  lda: number,
+  x: GpuVector,
+  incx: number,
+  beta: number,
+  y: GpuVector,
+  incy: number,
+): Promise<{ gpuTimeMs?: number }>;

package/src/dgemv/dgemv.mjs

@@ -0,0 +1,247 @@
+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 { requireWorkgroups } from "../util/workgroup.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
+
+// dgemv: y := alpha * op(A) * x + beta * y, double-double (Dekker) f64
+// emulation of sgemv — A, x, y, alpha, and beta are each split into an f32
+// (hi, lo) pair; WGSL has no f64 type.
+export async function dgemv(
+  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;
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "dgemv", { 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 (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 (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 (!AIsGpu && !(A instanceof Float64Array))
+    throw new Error("A must be a Float64Array or GpuMatrix.");
+  if (AIsGpu && A.dtype !== Float64Array)
+    throw new Error("A must be a Float64Array-backed GpuMatrix.");
+  if (!xIsGpu && !(x instanceof Float64Array))
+    throw new Error("x must be a Float64Array or GpuVector.");
+  if (!yIsGpu && !(y instanceof Float64Array))
+    throw new Error("y must be a Float64Array or GpuVector.");
+  if (xIsGpu && x.dtype !== Float64Array)
+    throw new Error("x must be a Float64Array-backed GpuVector.");
+  if (yIsGpu && y.dtype !== Float64Array)
+    throw new Error("y must be a Float64Array-backed GpuVector.");
+  if (xIsGpu !== yIsGpu)
+    throw new Error(
+      "x and y must be the same type (both Float64Array or both GpuVector).",
+    );
+  if (xIsGpu && !AIsGpu)
+    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 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)
+    throw new Error("lda must match A.lda when A is a GpuMatrix.");
+  if (AIsGpu && (A.rows < m || A.cols < n))
+    throw new Error("A is too small for the given m and n.");
+  if (m < 0 || n < 0) throw new Error("m and n must be non-negative.");
+  if (m === 0 || n === 0) return yIsGpu ? {} : { y };
+
+  // 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.",
+    );
+  if (x.length < (xLen - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given dimensions and incx.",
+    );
+  if (y.length < (yLen - 1) * incy + 1)
+    throw new Error(
+      "y does not have enough elements for the given dimensions and incy.",
+    );
+
+  const f64Deps = ["f64/dekker", "f64/utils/add", "f64/utils/multiply"];
+  const shaderName = isNoTrans ? "dgemv_n" : "dgemv_t";
+  const entryPoint = isNoTrans ? "dgemv_n_main" : "dgemv_t_main";
+  const pipeline = await getPipeline(
+    device,
+    [...f64Deps, shaderName],
+    entryPoint,
+  );
+
+  const { hi: alphaHi, lo: alphaLo } = splitDoubleDouble(
+    new Float64Array([alpha]),
+  );
+  const { hi: betaHi, lo: betaLo } = splitDoubleDouble(
+    new Float64Array([beta]),
+  );
+
+  let AHiBuffer = null;
+  let ALoBuffer = null;
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let yHiBuffer = null;
+  let yLoBuffer = null;
+  let paramsBuffer = null;
+  let readHiBuffer = null;
+  let readLoBuffer = null;
+
+  try {
+    if (AIsGpu) {
+      AHiBuffer = A._buf;
+      ALoBuffer = A._loBuf;
+    } else {
+      const ASplit = splitDoubleDouble(A);
+      AHiBuffer = uploadBuffer(device, ASplit.hi, "dgemv-AHi", false);
+      ALoBuffer = uploadBuffer(device, ASplit.lo, "dgemv-ALo", false);
+    }
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+    } else {
+      const xSplit = splitDoubleDouble(x);
+      xHiBuffer = uploadBuffer(device, xSplit.hi, "dgemv-xHi", false);
+      xLoBuffer = uploadBuffer(device, xSplit.lo, "dgemv-xLo", false);
+    }
+    if (yIsGpu) {
+      yHiBuffer = y._buf;
+      yLoBuffer = y._loBuf;
+    } else {
+      const ySplit = splitDoubleDouble(y);
+      yHiBuffer = uploadBuffer(device, ySplit.hi, "dgemv-yHi", true);
+      yLoBuffer = uploadBuffer(device, ySplit.lo, "dgemv-yLo", true);
+    }
+    paramsBuffer = createParamsBuffer(
+      device,
+      [
+        { value: m, type: "u32" },
+        { value: n, type: "u32" },
+        { value: alphaHi[0], type: "f32" },
+        { value: alphaLo[0], type: "f32" },
+        { value: betaHi[0], type: "f32" },
+        { value: betaLo[0], type: "f32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+        { value: lda, type: "u32" },
+      ],
+      "dgemv-params",
+    );
+
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
+      AHiBuffer,
+      ALoBuffer,
+      xHiBuffer,
+      xLoBuffer,
+      yHiBuffer,
+      yLoBuffer,
+      paramsBuffer,
+    ]);
+
+    // NoTrans: one workgroup per row — dgemv_n.wgsl is a grid-stride loop, so
+    // clamping here only costs parallelism. Trans: one thread per output
+    // column, and dgemv_t.wgsl indexes straight off global_invocation_id
+    // (masked, not skipped, for out-of-range columns), so an over-limit
+    // dispatch must be refused, not truncated.
+    const wgCount = isNoTrans
+      ? Math.min(m, device.limits.maxComputeWorkgroupsPerDimension)
+      : requireWorkgroups(device, "dgemv", yLen);
+    const { commandEncoder, ts } = runComputePass(
+      device,
+      pipeline,
+      bindGroup,
+      wgCount,
+    );
+    readHiBuffer = yIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, yHiBuffer);
+    readLoBuffer = yIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, yLoBuffer);
+
+    submit(device, commandEncoder);
+
+    const gpuTimeMs = await extractTimestamp(ts);
+
+    if (yIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
+
+    const hi = await extractResult(readHiBuffer, Float32Array);
+    readHiBuffer = null;
+    const lo = await extractResult(readLoBuffer, Float32Array);
+    readLoBuffer = null;
+    const result = mergeDoubleDouble(hi, lo);
+    if (gpuTimeMs !== undefined) return { y: result, gpuTimeMs };
+    return { y: result };
+  } finally {
+    if (!AIsGpu && AHiBuffer) destroyBuffers(AHiBuffer);
+    if (!AIsGpu && ALoBuffer) destroyBuffers(ALoBuffer);
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (!yIsGpu && yHiBuffer) destroyBuffers(yHiBuffer);
+    if (!yIsGpu && yLoBuffer) destroyBuffers(yLoBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    if (readHiBuffer) destroyBuffers(readHiBuffer);
+    if (readLoBuffer) destroyBuffers(readLoBuffer);
+  }
+}

package/src/dger/dger.d.mts

@@ -0,0 +1,80 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+/**
+ * Performs the rank-1 update $$A \leftarrow \alpha x y^{T} + A$$ in double
+ * precision (double-double emulation — WGSL has no native f64 type).
+ *
+ * A is an m×n matrix stored in row-major order, updated in place. `lda` is
+ * the leading dimension (number of doubles between the start of consecutive
+ * rows — must be >= n).
+ *
+ * {@includeCode ../../examples/dger/dger.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/dger/web/dger.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      - Float64Array input vector, length at least (m-1)*incx+1
+ * @param incx   - stride for x (must be a positive integer)
+ * @param y      - Float64Array input vector, length at least (n-1)*incy+1
+ * @param incy   - stride for y (must be a positive integer)
+ * @param A      - Float64Array, 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/dger/dger.mjs#L18">Source code: dger.mjs (L18)</a>
+ * @category BLAS Level 2
+ */
+export declare function dger(
+  device: GPUDevice,
+  m: number,
+  n: number,
+  alpha: number,
+  x: Float64Array,
+  incx: number,
+  y: Float64Array,
+  incy: number,
+  A: Float64Array,
+  lda: number,
+  layout?: 'row-major' | 'column-major',
+): Promise<{ A: Float64Array; gpuTimeMs?: number }>;
+
+/**
+ * Performs the rank-1 update $$A \leftarrow \alpha x y^{T} + A$$ in double
+ * precision (double-double emulation).
+ *
+ * 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/dger/gpu.dger.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 (Float64Array-backed, not mutated)
+ * @param incx   - stride for x (must be a positive integer)
+ * @param y      - GpuVector input vector (Float64Array-backed, not mutated)
+ * @param incy   - stride for y (must be a positive integer)
+ * @param A      - GpuMatrix (Float64Array-backed), mutated in place
+ * @param lda    - leading dimension of A (must equal A.lda)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dger/dger.mjs#L18">Source code: dger.mjs (L18)</a>
+ * @category BLAS Level 2
+ */
+export declare function dger(
+  device: GPUDevice,
+  m: number,
+  n: number,
+  alpha: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+  A: GpuMatrix,
+  lda: number,
+): Promise<{ gpuTimeMs?: number }>;