wgblas 0.1.0

package/src/snrm2/snrm2.d.mts

@@ -0,0 +1,44 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Computes the Euclidean norm of a vector: result = sqrt(sum(x[i] * x[i]))
+ *
+ * {@includeCode ../../examples/snrm2/snrm2.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/snrm2/web/snrm2.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float32Array 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/snrm2/snrm2.mjs#L18">Source code: snrm2.mjs (L18)</a>
+ * @category BLAS Level 1
+ */
+export declare function snrm2(
+  device: GPUDevice,
+  n: number,
+  x: Float32Array,
+  incx: number,
+): Promise<{ nrm2: number } | { nrm2: number; gpuTimeMs: number }>;
+
+/**
+ * Computes the Euclidean norm of a vector: result = sqrt(sum(x[i] * x[i]))
+ *
+ * {@includeCode ../../examples/snrm2/gpuvec.snrm2.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector 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/snrm2/snrm2.mjs#L18">Source code: snrm2.mjs (L18)</a>
+ * @category BLAS Level 1
+ */
+export declare function snrm2(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+): Promise<{ nrm2: number } | { nrm2: number; gpuTimeMs: number }>;

package/src/snrm2/snrm2.mjs

@@ -0,0 +1,100 @@
+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";
+
+const WGS = 64; // workgroup size
+
+export async function snrm2(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 Float32Array))
+    throw new Error("x must be a Float32Array or 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.",
+    );
+
+  const pipelineMain = await getPipeline(device, "snrm2");
+  const pipelineReduce = await getPipeline(device, "reduction/sum");
+
+  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "snrm2-x", false);
+  const partialsBuffer = createStorageBuffer(2 * WGS * 4, "snrm2-partials"); // 2*WGS partial sums of f32
+  const resultBuffer = createResultBuffer(4, "snrm2-result"); // final f32 scalar
+  const paramsBuffer = createParamsBuffer(
+    [
+      { value: n, type: "u32" },
+      { value: incx, type: "u32" },
+    ],
+    "snrm2-params",
+  );
+
+  const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+    xBuffer,
+    partialsBuffer,
+    paramsBuffer,
+  ]);
+  const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+    pipelineMain,
+    bgMain,
+    2 * WGS,
+  ); // dispatch 2*WGS workgroups
+
+  submit(enc1);
+
+  const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
+    partialsBuffer,
+    resultBuffer,
+  ]);
+  const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+    pipelineReduce,
+    bgReduce,
+    1,
+  ); // reduce partials to single result
+  const readBuffer = stageReadback(enc2, resultBuffer);
+
+  submit(enc2);
+
+  const [gpuTime1, gpuTime2, sqsumArr] = await Promise.all([
+    extractTimestamp(ts1),
+    extractTimestamp(ts2),
+    extractResult(readBuffer, Float32Array),
+  ]);
+
+  // sqrt is taken on CPU after the GPU sum-of-squares reduction
+  const nrm2 = Math.sqrt(sqsumArr[0]);
+
+  if (xIsGpu) {
+    destroyBuffers(partialsBuffer, resultBuffer, paramsBuffer, readBuffer);
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { nrm2 };
+  }
+
+  destroyBuffers(
+    xBuffer,
+    partialsBuffer,
+    resultBuffer,
+    paramsBuffer,
+    readBuffer,
+  );
+  if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+    return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
+  return { nrm2 };
+}

package/src/srot/srot.d.mts

@@ -0,0 +1,62 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Applies a Givens plane rotation to vectors x and y:
+ *   x = c*x + s*y
+ *   y = -s*x + c*y
+ *
+ * {@includeCode ../../examples/srot/srot.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/srot/web/srot.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float32Array input/output vector
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - Float32Array 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/srot/srot.mjs#L15">Source code: srot.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function srot(
+  device: GPUDevice,
+  n: number,
+  x: Float32Array,
+  incx: number,
+  y: Float32Array,
+  incy: number,
+  c: number,
+  s: number,
+): Promise<{ x: Float32Array; y: Float32Array } | { x: Float32Array; y: Float32Array; gpuTimeMs: number }>;
+
+/**
+ * Applies a Givens plane rotation to vectors x and y:
+ *   x = c*x + s*y
+ *   y = -s*x + c*y
+ *
+ * {@includeCode ../../examples/srot/gpuvec.srot.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector input/output vector (mutated in place)
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - GpuVector input/output vector (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/srot/srot.mjs#L15">Source code: srot.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function srot(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+  c: number,
+  s: number,
+): Promise<{} | { gpuTimeMs: number }>;

package/src/srot/srot.mjs

@@ -0,0 +1,95 @@
+import {
+  uploadBuffer,
+  createParamsBuffer,
+  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 { calcWorkgroups } from "../util/workgroup.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+export async function srot(device, n, x, incx, y, incy, c, s) {
+  const xIsGpu = x instanceof GpuVector;
+  const yIsGpu = y instanceof GpuVector;
+
+  if (!(device instanceof GPUDevice))
+    throw new Error("device must be a GPUDevice.");
+  if (
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy)
+  )
+    throw new Error("n, incx, and incy must be integers.");
+  if (isNaN(c) || isNaN(s)) throw new Error("c and s must not be NaN.");
+  if (!isFinite(c)) throw new Error("c must be finite.");
+  if (!isFinite(s)) throw new Error("s must be finite.");
+  if (incx <= 0 || incy <= 0)
+    throw new Error("incx and incy must be positive.");
+  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 (n <= 0) return xIsGpu ? {} : { x, y };
+  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.",
+    );
+
+  const pipeline = await getPipeline(device, "srot");
+
+  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srot-x", true);
+  const yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srot-y", true);
+  const paramsBuffer = createParamsBuffer(
+    [
+      { value: n, type: "u32" },
+      { value: c, type: "f32" },
+      { value: s, type: "f32" },
+      { value: incx, type: "u32" },
+      { value: incy, type: "u32" },
+    ],
+    "srot-params",
+  );
+
+  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    xBuffer,
+    yBuffer,
+    paramsBuffer,
+  ]);
+  const { commandEncoder, ts } = runComputePass(
+    pipeline,
+    bindGroup,
+    calcWorkgroups(n),
+  );
+  const readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+  const readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+  submit(commandEncoder);
+
+  const gpuTimeMs = await extractTimestamp(ts);
+
+  if (xIsGpu && yIsGpu) {
+    destroyBuffers(paramsBuffer);
+    if (gpuTimeMs !== undefined) return { gpuTimeMs };
+    return {};
+  }
+
+  const [xResult, yResult] = await Promise.all([
+    extractResult(readX, Float32Array),
+    extractResult(readY, Float32Array),
+  ]);
+  destroyBuffers(xBuffer, yBuffer, paramsBuffer, readX, readY);
+
+  if (gpuTimeMs !== undefined) return { x: xResult, y: yResult, gpuTimeMs };
+  return { x: xResult, y: yResult };
+}

package/src/srotm/srotm.d.mts

@@ -0,0 +1,60 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Applies a modified Givens plane rotation H to vectors x and y:
+ *   x = H[0][0]*x + H[0][1]*y
+ *   y = H[1][0]*x + H[1][1]*y
+ *
+ * {@includeCode ../../examples/srotm/srotm.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/srotm/web/srotm.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float32Array input/output vector
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - Float32Array input/output vector
+ * @param incy - stride for y (must be a positive integer)
+ * @param param - 5-element Float32Array: [flag, h11, h21, h12, h22]
+ *   flag = -2: identity (no-op), -1: full H, 0: unit diagonal, 1: unit off-diagonal
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/srotm/srotm.mjs#L15">Source code: srotm.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function srotm(
+  device: GPUDevice,
+  n: number,
+  x: Float32Array,
+  incx: number,
+  y: Float32Array,
+  incy: number,
+  param: Float32Array,
+): Promise<{ x: Float32Array; y: Float32Array } | { x: Float32Array; y: Float32Array; gpuTimeMs: number }>;
+
+/**
+ * Applies a modified Givens plane rotation H to vectors x and y:
+ *   x = H[0][0]*x + H[0][1]*y
+ *   y = H[1][0]*x + H[1][1]*y
+ *
+ * {@includeCode ../../examples/srotm/gpuvec.srotm.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector input/output vector (mutated in place)
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - GpuVector input/output vector (mutated in place)
+ * @param incy - stride for y (must be a positive integer)
+ * @param param - 5-element Float32Array: [flag, h11, h21, h12, h22]
+ *   flag = -2: identity (no-op), -1: full H, 0: unit diagonal, 1: unit off-diagonal
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/srotm/srotm.mjs#L15">Source code: srotm.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function srotm(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+  param: Float32Array,
+): Promise<{} | { gpuTimeMs: number }>;

package/src/srotm/srotm.mjs

@@ -0,0 +1,94 @@
+import {
+  uploadBuffer,
+  createParamsBuffer,
+  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 { calcWorkgroups } from "../util/workgroup.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+export async function srotm(device, n, x, incx, y, incy, param) {
+  const xIsGpu = x instanceof GpuVector;
+  const yIsGpu = y instanceof GpuVector;
+
+  if (!(device instanceof GPUDevice))
+    throw new Error("device must be a GPUDevice.");
+  if (
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy)
+  )
+    throw new Error("n, incx, and incy must be integers.");
+  if (!(param instanceof Float32Array) || param.length !== 5)
+    throw new Error("param must be a Float32Array of length 5.");
+  if (incx <= 0 || incy <= 0)
+    throw new Error("incx and incy must be positive.");
+  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 (n <= 0 || param[0] === -2.0) return xIsGpu ? {} : { x, y };
+  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.",
+    );
+
+  const pipeline = await getPipeline(device, "srotm");
+
+  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srotm-x", true);
+  const yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srotm-y", true);
+  const paramBuffer = uploadBuffer(param, "srotm-param", false);
+  const paramsBuffer = createParamsBuffer(
+    [
+      { value: n, type: "u32" },
+      { value: incx, type: "u32" },
+      { value: incy, type: "u32" },
+    ],
+    "srotm-params",
+  );
+
+  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    xBuffer,
+    yBuffer,
+    paramBuffer,
+    paramsBuffer,
+  ]);
+  const { commandEncoder, ts } = runComputePass(
+    pipeline,
+    bindGroup,
+    calcWorkgroups(n),
+  );
+  const readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+  const readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+  submit(commandEncoder);
+
+  const gpuTimeMs = await extractTimestamp(ts);
+
+  if (xIsGpu && yIsGpu) {
+    destroyBuffers(paramBuffer, paramsBuffer);
+    if (gpuTimeMs !== undefined) return { gpuTimeMs };
+    return {};
+  }
+
+  const [xResult, yResult] = await Promise.all([
+    extractResult(readX, Float32Array),
+    extractResult(readY, Float32Array),
+  ]);
+  destroyBuffers(xBuffer, yBuffer, paramBuffer, paramsBuffer, readX, readY);
+
+  if (gpuTimeMs !== undefined) return { x: xResult, y: yResult, gpuTimeMs };
+  return { x: xResult, y: yResult };
+}

package/src/sscal/sscal.d.mts

@@ -0,0 +1,46 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Scales a single-precision vector by a constant: x = alpha * x
+ *
+ * {@includeCode ../../examples/sscal/sscal.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/sscal/web/sscal.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements to scale (must be a positive integer)
+ * @param alpha - scalar multiplier
+ * @param x - Float32Array input/output vector
+ * @param incx - stride for x (must be a positive integer)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sscal/sscal.mjs#L15">Source code: sscal.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function sscal(
+  device: GPUDevice,
+  n: number,
+  alpha: number,
+  x: Float32Array,
+  incx: number,
+): Promise<Float32Array | { result: Float32Array; gpuTimeMs: number }>;
+
+/**
+ * Scales a single-precision vector by a constant: x = alpha * x
+ *
+ * {@includeCode ../../examples/sscal/gpuvec.sscal.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements to scale (must be a positive integer)
+ * @param alpha - scalar multiplier
+ * @param x - GpuVector input/output vector (mutated in place)
+ * @param incx - stride for x (must be a positive integer)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sscal/sscal.mjs#L15">Source code: sscal.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function sscal(
+  device: GPUDevice,
+  n: number,
+  alpha: number,
+  x: GpuVector,
+  incx: number,
+): Promise<{} | { gpuTimeMs: number }>;

package/src/sscal/sscal.mjs

@@ -0,0 +1,71 @@
+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 { calcWorkgroups } from "../util/workgroup.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+export async function sscal(device, n, alpha, 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 (isNaN(alpha)) throw new Error("alpha must not be NaN.");
+  if (!isFinite(alpha)) throw new Error("alpha must be finite.");
+  if (incx <= 0) throw new Error("incx must be positive.");
+  if (!(x instanceof Float32Array) && !(x instanceof GpuVector))
+    throw new Error("x must be a Float32Array or GpuVector.");
+  if (n <= 0) return xIsGpu ? {} : x;
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+
+  const pipeline = await getPipeline(device, "sscal");
+
+  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sscal-x", true);
+  const paramsBuffer = createParamsBuffer(
+    [
+      { value: n, type: "u32" },
+      { value: alpha, type: "f32" },
+      { value: incx, type: "u32" },
+    ],
+    "sscal-params",
+  );
+
+  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    xBuffer,
+    paramsBuffer,
+  ]);
+  const { commandEncoder, ts } = runComputePass(
+    pipeline,
+    bindGroup,
+    calcWorkgroups(n),
+  );
+  const readBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+
+  submit(commandEncoder);
+
+  const gpuTimeMs = await extractTimestamp(ts);
+
+  if (xIsGpu) {
+    destroyBuffers(paramsBuffer);
+    if (gpuTimeMs !== undefined) return { gpuTimeMs };
+    return {};
+  }
+
+  const result = await extractResult(readBuffer, Float32Array);
+  destroyBuffers(xBuffer, paramsBuffer, readBuffer);
+
+  if (gpuTimeMs !== undefined) return { result, gpuTimeMs };
+  return result;
+}

package/src/sswap/sswap.d.mts

@@ -0,0 +1,50 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Swaps the elements of two single-precision vectors: x <-> y
+ *
+ * {@includeCode ../../examples/sswap/sswap.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/sswap/web/sswap.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements to swap (must be a positive integer)
+ * @param x - Float32Array first input/output vector
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - Float32Array second input/output vector
+ * @param incy - stride for y (must be a positive integer)
+ * @see [Source code: sswap.mjs (L15)](https://github.com/manit2004/wgblas/blob/main/src/sswap/sswap.mjs#L15)
+ * @category BLAS Level 1
+ */
+export declare function sswap(
+  device: GPUDevice,
+  n: number,
+  x: Float32Array,
+  incx: number,
+  y: Float32Array,
+  incy: number,
+): Promise<{ x: Float32Array; y: Float32Array } | { x: Float32Array; y: Float32Array; gpuTimeMs: number }>;
+
+/**
+ * Swaps the elements of two single-precision vectors: x <-> y
+ *
+ * {@includeCode ../../examples/sswap/gpuvec.sswap.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements to swap (must be a positive integer)
+ * @param x - GpuVector first input/output vector (mutated in place)
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - GpuVector second input/output vector (mutated in place)
+ * @param incy - stride for y (must be a positive integer)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/sswap/sswap.mjs#L15">Source code: sswap.mjs (L15)</a>
+ * @category BLAS Level 1
+ */
+export declare function sswap(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+): Promise<{} | { gpuTimeMs: number }>;