wgblas 2.0.0 → 2.2.0

package/src/ddot/ddot.d.mts

@@ -0,0 +1,62 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Computes the dot product of two vectors of doubles in extended precision:
+ * $$\text{result} = \sum_{i} x_i y_i$$
+ * Each element of `x` and `y` is split into a (hi, lo) double-double f32 pair
+ * (see `splitDoubleDouble`/`f64.mjs`) since WGSL has no f64 type; the
+ * elementwise products and their accumulation both use 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.
+ *
+ * {@includeCode ../../examples/ddot/ddot.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/ddot/web/ddot.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)
+ * @param y - Float64Array input vector
+ * @param incy - stride for y (must be a positive integer)
+ * @returns dot product scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ddot/ddot.mjs#L20">Source code: ddot.mjs (L20)</a>
+ * @category BLAS Level 1
+ */
+export declare function ddot(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+  y: Float64Array,
+  incy: number,
+): Promise<{ dot: number } | { dot: number; gpuTimeMs: number }>;
+
+/**
+ * Computes the dot product of two vectors of doubles in extended precision:
+ * $$\text{result} = \sum_{i} x_i y_i$$
+ * Accumulation uses Dekker's double-double algorithm (see `shaders/f64/`),
+ * giving ~48 bits of mantissa.
+ *
+ * {@includeCode ../../examples/ddot/gpu.ddot.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)
+ * @param y - Float64Array-backed GpuVector input vector
+ * @param incy - stride for y (must be a positive integer)
+ * @returns dot product scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ddot/ddot.mjs#L20">Source code: ddot.mjs (L20)</a>
+ * @category BLAS Level 1
+ */
+export declare function ddot(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+): Promise<{ dot: number } | { dot: number; gpuTimeMs: number }>;

package/src/ddot/ddot.mjs

@@ -0,0 +1,184 @@
+import {
+  createStorageBuffer,
+  createParamsBuffer,
+  createResultBuffer,
+  stageReadback,
+  destroyBuffers,
+  uploadBuffer,
+} 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, mergeDoubleDouble } from "../util/f64.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
+
+export async function ddot(device, n, x, incx, y, incy) {
+  const xIsGpu = x instanceof GpuVector;
+  const yIsGpu = y instanceof GpuVector;
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "ddot", { x, y });
+  if (
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy)
+  )
+    throw new Error("n, incx, and incy must be integers.");
+  if (incx <= 0 || incy <= 0)
+    throw new Error("incx and incy must be positive.");
+  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 (n <= 0) return { dot: 0 };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+  if (y.length < (n - 1) * incy + 1)
+    throw new Error(
+      "y does not have enough elements for the given n and incy.",
+    );
+
+  // Concatenated with f64/dekker.wgsl (DD struct) and f64/utils/add.wgsl
+  // (ddAddProtected) — WGSL has no #include; entryPoint omitted since each
+  // module has only one @compute. Only the first pass multiplies, so
+  // f64/utils/multiply.wgsl is left out of the reduction's module.
+  const ddCore = ["f64/dekker", "f64/utils/add"];
+  const pipelineMain = await getPipeline(device, [
+    ...ddCore,
+    "f64/utils/multiply",
+    "ddot",
+  ]);
+  const pipelineReduce = await getPipeline(device, [
+    ...ddCore,
+    "reduction/sumF64",
+  ]);
+
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let yHiBuffer = null;
+  let yLoBuffer = null;
+  let partialsHiBuffer = null;
+  let partialsLoBuffer = null;
+  let resultHiBuffer = null;
+  let resultLoBuffer = null;
+  let paramsBuffer = null;
+  let readHiBuffer = null;
+  let readLoBuffer = null;
+
+  try {
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+      yHiBuffer = y._buf;
+      yLoBuffer = y._loBuf;
+    } else {
+      // No abs here (unlike dasum) — the product carries its own sign.
+      const xSplit = splitDoubleDouble(x);
+      const ySplit = splitDoubleDouble(y);
+      xHiBuffer = uploadBuffer(device, xSplit.hi, "ddot-xHi", false);
+      xLoBuffer = uploadBuffer(device, xSplit.lo, "ddot-xLo", false);
+      yHiBuffer = uploadBuffer(device, ySplit.hi, "ddot-yHi", false);
+      yLoBuffer = uploadBuffer(device, ySplit.lo, "ddot-yLo", false);
+    }
+    partialsHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "ddot-partialsHi",
+    );
+    partialsLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "ddot-partialsLo",
+    );
+    resultHiBuffer = createResultBuffer(device, 4, "ddot-result-hi");
+    resultLoBuffer = createResultBuffer(device, 4, "ddot-result-lo");
+    paramsBuffer = createParamsBuffer(
+      device,
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+      ],
+      "ddot-params",
+    );
+
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
+      xHiBuffer,
+      xLoBuffer,
+      yHiBuffer,
+      yLoBuffer,
+      partialsHiBuffer,
+      partialsLoBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups — one partial per workgroup
+
+    submit(device, enc1);
+
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [partialsHiBuffer, partialsLoBuffer, resultHiBuffer, resultLoBuffer],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // dispatch 1 workgroup to reduce the partial sums to a single result
+    readHiBuffer = stageReadback(device, enc2, resultHiBuffer);
+    readLoBuffer = stageReadback(device, enc2, resultLoBuffer);
+
+    submit(device, enc2);
+
+    const hiPromise = extractResult(readHiBuffer, Float32Array);
+    const loPromise = extractResult(readLoBuffer, Float32Array);
+    readHiBuffer = null; // ownership transferred — extractResult's own finally destroys it
+    readLoBuffer = null;
+
+    const [gpuTime1, gpuTime2, hiArr, loArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      hiPromise,
+      loPromise,
+    ]);
+
+    // dot is always a scalar readback — both paths return { dot }
+    const dot = mergeDoubleDouble(hiArr, loArr)[0];
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { dot, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { dot };
+  } finally {
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (!yIsGpu && yHiBuffer) destroyBuffers(yHiBuffer);
+    if (!yIsGpu && yLoBuffer) destroyBuffers(yLoBuffer);
+    if (partialsHiBuffer) destroyBuffers(partialsHiBuffer);
+    if (partialsLoBuffer) destroyBuffers(partialsLoBuffer);
+    if (resultHiBuffer) destroyBuffers(resultHiBuffer);
+    if (resultLoBuffer) destroyBuffers(resultLoBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
+    if (readHiBuffer) destroyBuffers(readHiBuffer);
+    if (readLoBuffer) destroyBuffers(readLoBuffer);
+  }
+}

package/src/devdocs.mjs

@@ -4,6 +4,19 @@
  * repository and explains the reasoning behind it — not just what the code
  * does, but why it is shaped the way it is.
  *
+ * ## How These Docs Are Organized
+ *
+ * The sidebar's top-level modules mirror the repository's top-level folders.
+ * `devdocs` stands in for `src/` — the module you're reading right now is a
+ * narrated walkthrough of it, with `devdocs/blas-routines` and
+ * `devdocs/shaders` covering `src/index.mjs` and `src/shaders/`
+ * respectively. Its siblings — `assets`, `benchmarks`, `examples`, `scripts`,
+ * `tests` — each document the identically-named top-level folder.
+ *
+ * `docs` is the one exception: it's the public API reference generated from
+ * `index.d.mts`, not a tour of the top-level `docs/` folder. That folder is
+ * this site's own generated output — the two just happen to share a name.
+ *
  * ## What is BLAS?
  *
  * BLAS (Basic Linear Algebra Subprograms) is a standard API for vector and

package/src/dnrm2/dnrm2.d.mts

@@ -0,0 +1,50 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Computes the Euclidean norm of a double-precision vector:
+ * $$\text{result} = \sqrt{\sum_{i} x_i^2}$$
+ * — double-double (Dekker) f64 emulation of {@link snrm2}, since WGSL has
+ * no native f64 type.
+ *
+ * {@includeCode ../../examples/dnrm2/dnrm2.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/dnrm2/web/dnrm2.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 Euclidean norm scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dnrm2/dnrm2.mjs#L21">Source code: dnrm2.mjs (L21)</a>
+ * @category BLAS Level 1
+ */
+export declare function dnrm2(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+): Promise<{ nrm2: number } | { nrm2: number; gpuTimeMs: number }>;
+
+/**
+ * Computes the Euclidean norm of a double-precision vector:
+ * $$\text{result} = \sqrt{\sum_{i} x_i^2}$$
+ * — GPU-resident overload; see the Float64Array overload above for the
+ * routine itself.
+ *
+ * {@includeCode ../../examples/dnrm2/gpu.dnrm2.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector input vector (must be Float64Array-backed)
+ * @param incx - stride for x (must be a positive integer)
+ * @returns Euclidean norm scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dnrm2/dnrm2.mjs#L21">Source code: dnrm2.mjs (L21)</a>
+ * @category BLAS Level 1
+ */
+export declare function dnrm2(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+): Promise<{ nrm2: number } | { nrm2: number; gpuTimeMs: number }>;

package/src/dnrm2/dnrm2.mjs

@@ -0,0 +1,189 @@
+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, mergeDoubleDouble } from "../util/f64.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
+
+// dnrm2: sqrt(sum(x[i]*x[i])), double-double (Dekker) f64 emulation of
+// snrm2 — same scaled accumulation (Blue's algorithm) snrm2 uses to avoid
+// overflow, with (scale, ssq) as double-double pairs instead of plain f32.
+// See dnrm2.wgsl for why the per-element branch that algorithm needs had to
+// become branch-free (select()-based) here.
+export async function dnrm2(device, n, x, incx) {
+  const xIsGpu = x instanceof GpuVector;
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "dnrm2", { x });
+  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 { nrm2: 0 };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+
+  // Concatenated with f64/dekker.wgsl (DD struct), f64/utils/abs.wgsl
+  // (ddAbs), f64/utils/greater.wgsl (ddGreater), f64/utils/add.wgsl
+  // (ddAddProtected), f64/utils/multiply.wgsl (ddMulProtected),
+  // f64/utils/divide.wgsl (ddDivProtected), and f64/utils/sqrt.wgsl
+  // (ddSqrtProtected) — WGSL has no #include.
+  const f64Deps = [
+    "f64/dekker",
+    "f64/utils/abs",
+    "f64/utils/greater",
+    "f64/utils/add",
+    "f64/utils/multiply",
+    "f64/utils/divide",
+    "f64/utils/sqrt",
+  ];
+  const pipelineMain = await getPipeline(device, [...f64Deps, "dnrm2"]);
+  const pipelineReduce = await getPipeline(device, [
+    ...f64Deps,
+    "reduction/scaledSumF64",
+  ]);
+
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let partialsScaleHiBuffer = null;
+  let partialsScaleLoBuffer = null;
+  let partialsSsqHiBuffer = null;
+  let partialsSsqLoBuffer = null;
+  let resultHiBuffer = null;
+  let resultLoBuffer = null;
+  let paramsBuffer = null;
+  let readHiBuffer = null;
+  let readLoBuffer = null;
+
+  try {
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+    } else {
+      const { hi, lo } = splitDoubleDouble(x);
+      xHiBuffer = uploadBuffer(device, hi, "dnrm2-xHi", false);
+      xLoBuffer = uploadBuffer(device, lo, "dnrm2-xLo", false);
+    }
+    // 2*WGS partial (scale, ssq) DD pairs — see dnrm2.wgsl for what they represent.
+    partialsScaleHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-scaleHi",
+    );
+    partialsScaleLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-scaleLo",
+    );
+    partialsSsqHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-ssqHi",
+    );
+    partialsSsqLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-ssqLo",
+    );
+    resultHiBuffer = createResultBuffer(device, 4, "dnrm2-result-hi");
+    resultLoBuffer = createResultBuffer(device, 4, "dnrm2-result-lo");
+    paramsBuffer = createParamsBuffer(
+      device,
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+      ],
+      "dnrm2-params",
+    );
+
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
+      xHiBuffer,
+      xLoBuffer,
+      partialsScaleHiBuffer,
+      partialsScaleLoBuffer,
+      partialsSsqHiBuffer,
+      partialsSsqLoBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups
+
+    submit(device, enc1);
+
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [
+        partialsScaleHiBuffer,
+        partialsScaleLoBuffer,
+        partialsSsqHiBuffer,
+        partialsSsqLoBuffer,
+        resultHiBuffer,
+        resultLoBuffer,
+      ],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // reduce partials to a single result
+    readHiBuffer = stageReadback(device, enc2, resultHiBuffer);
+    readLoBuffer = stageReadback(device, enc2, resultLoBuffer);
+
+    submit(device, enc2);
+
+    const hiPromise = extractResult(readHiBuffer, Float32Array);
+    const loPromise = extractResult(readLoBuffer, Float32Array);
+    readHiBuffer = null; // ownership transferred — extractResult's own finally destroys it
+    readLoBuffer = null;
+
+    const [gpuTime1, gpuTime2, hiArr, loArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      hiPromise,
+      loPromise,
+    ]);
+
+    // reduction/scaledSumF64.wgsl already computes scale·sqrt(ssq) on the
+    // GPU — no separate sqrt step here.
+    const nrm2 = mergeDoubleDouble(hiArr, loArr)[0];
+
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { nrm2 };
+  } finally {
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (partialsScaleHiBuffer) destroyBuffers(partialsScaleHiBuffer);
+    if (partialsScaleLoBuffer) destroyBuffers(partialsScaleLoBuffer);
+    if (partialsSsqHiBuffer) destroyBuffers(partialsSsqHiBuffer);
+    if (partialsSsqLoBuffer) destroyBuffers(partialsSsqLoBuffer);
+    if (resultHiBuffer) destroyBuffers(resultHiBuffer);
+    if (resultLoBuffer) destroyBuffers(resultLoBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
+    if (readHiBuffer) destroyBuffers(readHiBuffer);
+    if (readLoBuffer) destroyBuffers(readLoBuffer);
+  }
+}

package/src/drot/drot.d.mts

@@ -0,0 +1,67 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Applies a Givens plane rotation to double-precision vectors x and y:
+ * $$\begin{aligned} x &\leftarrow cx + sy \\\\ y &\leftarrow -sx + cy \end{aligned}$$
+ * — double-double (Dekker) f64 emulation of {@link srot}, since WGSL has no
+ * native f64 type.
+ *
+ * {@includeCode ../../examples/drot/drot.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/drot/web/drot.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array input/output vector
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - Float64Array input/output vector
+ * @param incy - stride for y (must be a positive integer)
+ * @param c - cosine of rotation angle
+ * @param s - sine of rotation angle
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/drot/drot.mjs#L19">Source code: drot.mjs (L19)</a>
+ * @category BLAS Level 1
+ */
+export declare function drot(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+  y: Float64Array,
+  incy: number,
+  c: number,
+  s: number,
+): Promise<
+  | { x: Float64Array; y: Float64Array }
+  | { x: Float64Array; y: Float64Array; gpuTimeMs: number }
+>;
+
+/**
+ * Applies a Givens plane rotation to double-precision vectors x and y:
+ * $$\begin{aligned} x &\leftarrow cx + sy \\\\ y &\leftarrow -sx + cy \end{aligned}$$
+ * — GPU-resident overload; see the Float64Array overload above for the
+ * routine itself.
+ *
+ * {@includeCode ../../examples/drot/gpu.drot.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector input/output vector (must be Float64Array-backed, mutated in place)
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - GpuVector input/output vector (must be Float64Array-backed, mutated in place)
+ * @param incy - stride for y (must be a positive integer)
+ * @param c - cosine of rotation angle
+ * @param s - sine of rotation angle
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/drot/drot.mjs#L19">Source code: drot.mjs (L19)</a>
+ * @category BLAS Level 1
+ */
+export declare function drot(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+  c: number,
+  s: number,
+): Promise<{} | { gpuTimeMs: number }>;