wgblas 0.1.2 → 1.1.0

package/src/sgemv/sgemv.d.mts

@@ -0,0 +1,127 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+/**
+ * Performs the matrix-vector operation y = alpha * op(A) * x + beta * y
+ *
+ * - `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 floats between the start of consecutive rows — must be >= n).
+ *
+ * {@includeCode ../../examples/sgemv/sgemv.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/sgemv/web/sgemv.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      - 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
+ */
+export declare function sgemv(
+  device: GPUDevice,
+  trans: 'no-transpose' | 'transpose',
+  m: number,
+  n: number,
+  alpha: number,
+  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`'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, 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)
+ * @param beta   - scalar multiplier for y
+ * @param y      - Float32Array input/output vector
+ * @param incy   - stride for y (must be a positive integer)
+ * @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
+ */
+export declare function sgemv(
+  device: GPUDevice,
+  trans: 'no-transpose' | 'transpose',
+  m: number,
+  n: number,
+  alpha: number,
+  A: GpuMatrix,
+  lda: number,
+  x: Float32Array,
+  incx: number,
+  beta: number,
+  y: Float32Array,
+  incy: number,
+): Promise<{ y: Float32Array; gpuTimeMs?: number }>;
+
+/**
+ * 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; its own
+ * `layout` (set at `GpuMatrix.from` time) determines the operation — there is
+ * no separate `layout` argument here.
+ *
+ * {@includeCode ../../examples/sgemv/gpuvec.sgemv.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
+ * @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
+ * @param y      - GpuVector 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/sgemv/sgemv.mjs#L16">Source code: sgemv.mjs (L16)</a>
+ * @category BLAS Level 2
+ */
+export declare function sgemv(
+  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/sgemv/sgemv.mjs

@@ -0,0 +1,148 @@
+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";
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+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;
+
+  if (!(device instanceof GPUDevice))
+    throw new Error("device must be a GPUDevice.");
+  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 Float32Array))
+    throw new Error("A must be a Float32Array or GpuMatrix.");
+  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 (xIsGpu && x._buf === y._buf)
+    throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");
+  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 shaderName = isNoTrans ? "sgemv_n" : "sgemv_t";
+  const pipeline   = await getPipeline(device, shaderName);
+
+  const ABuffer = AIsGpu ? A._buf : uploadBuffer(A, "sgemv-A", false);
+  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sgemv-x", false);
+  const yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "sgemv-y", true);
+  const paramsBuffer = createParamsBuffer(
+    [
+      { value: m,     type: "u32" },
+      { value: n,     type: "u32" },
+      { value: alpha, type: "f32" },
+      { value: beta,  type: "f32" },
+      { value: incx,  type: "u32" },
+      { value: incy,  type: "u32" },
+      { value: lda,   type: "u32" },
+    ],
+    "sgemv-params",
+  );
+
+  try {
+    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+      ABuffer,
+      xBuffer,
+      yBuffer,
+      paramsBuffer,
+    ]);
+
+    // 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);
+    const { commandEncoder, ts } = runComputePass(pipeline, bindGroup, wgCount);
+    const readBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+
+    submit(commandEncoder);
+
+    const gpuTimeMs = await extractTimestamp(ts);
+
+    if (yIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
+
+    const result = await extractResult(readBuffer, Float32Array);
+    if (gpuTimeMs !== undefined) return { y: result, gpuTimeMs };
+    return { y: result };
+  } finally {
+    if (!AIsGpu) destroyBuffers(ABuffer);
+    if (!xIsGpu) destroyBuffers(xBuffer);
+    if (!yIsGpu) destroyBuffers(yBuffer);
+    destroyBuffers(paramsBuffer);
+
+  }
+}

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);
+  }
+}

package/src/shaders/browser-shaders.mjs

@@ -1,5 +1,6 @@
 import argmax from "./reduction/argmax.wgsl";
 import sum from "./reduction/sum.wgsl";
+import sumF64 from "./reduction/sumF64.wgsl";
 import sscal from "./sscal.wgsl";
 import sswap from "./sswap.wgsl";
 import saxpy from "./saxpy.wgsl";
@@ -10,10 +11,23 @@ import snrm2 from "./snrm2.wgsl";
 import srot from "./srot.wgsl";
 import srotm from "./srotm.wgsl";
 import isamax from "./isamax.wgsl";
+import sgemv_n from "./sgemv_n.wgsl";
+import sgemv_t from "./sgemv_t.wgsl";
+import ssymv from "./ssymv.wgsl";
+import strmv from "./strmv.wgsl";
+import sger from "./sger.wgsl";
+import ssyr from "./ssyr.wgsl";
+import ssyr2 from "./ssyr2.wgsl";
+import f64add from "./f64add.wgsl";
+import dasum from "./dasum.wgsl";
+import strsv_invert_block from "./strsv_invert_block.wgsl";
+import strsv_apply_inverse from "./strsv_apply_inverse.wgsl";
+import strsv_update from "./strsv_update.wgsl";
 
 export const shaderSources = {
   "reduction/argmax": argmax,
   "reduction/sum": sum,
+  "reduction/sumF64": sumF64,
   sscal,
   sswap,
   saxpy,
@@ -24,4 +38,16 @@ export const shaderSources = {
   srot,
   srotm,
   isamax,
+  sgemv_n,
+  sgemv_t,
+  ssymv,
+  strmv,
+  sger,
+  ssyr,
+  ssyr2,
+  f64add,
+  dasum,
+  strsv_invert_block,
+  strsv_apply_inverse,
+  strsv_update,
 };

package/src/shaders/dasum.wgsl

@@ -0,0 +1,98 @@
+// dasum: result = sum(|x[i]|)
+// pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/sumF64.wgsl.
+// Same structure as sasum.wgsl — every value is now a [main, aux] pair
+// (see src/util/f64pack.mjs) and every `+`/`+=` is computeSum via addPair
+// instead of plain f32 addition. Concatenated after f64add.wgsl by
+// getPipeline (WGSL has no #include), reusing its decode/encode/computeSum/
+// addFields and Packed struct — f64add.wgsl declares no bindings and no entry
+// point of its own (just helper functions), so bindings here start at 0 and
+// the entry point is simply `dasum_main`.
+//
+// xAux/partialsAux are array<u32>, not array<f32> — aux's bits must never
+// pass through an f32-typed storage slot (NaN-bit-pattern corruption risk,
+// see f64pack.mjs and the Packed struct comment above decode()/encode() in
+// f64add.wgsl); Packed (from f64add.wgsl) keeps aux as u32 in registers/
+// workgroup memory too.
+//
+// Per-thread accumulation (acc0..acc3) stays in DECODED Fields form for the
+// entire strided loop below, via addFields — not re-encoded to Packed and
+// re-decoded on every single element like a naive version would. Only the
+// freshly-loaded x[idx] needs decoding each iteration (unavoidable, it's new
+// data every time); the running total never leaves Fields form until the
+// four accumulators are combined and encoded exactly once, right before
+// writing into workgroup-shared `tile`. The cross-thread reduction tree
+// after that still goes through Packed per level (unavoidable — each level
+// combines values that live in different threads' registers via shared
+// memory), but that's a fixed 6 levels regardless of n, unlike the strided
+// loop above whose iteration count scales with n.
+
+@group(0) @binding(0) var<storage, read>       xMain:        array<f32>;
+@group(0) @binding(1) var<storage, read>       xAux:         array<u32>;
+@group(0) @binding(2) var<storage, read_write> partialsMain: array<f32>;
+@group(0) @binding(3) var<storage, read_write> partialsAux:  array<u32>;
+@group(0) @binding(4) var<uniform>             params:       Params;
+
+struct Params {
+  n:     u32,
+  x_inc: u32,
+}
+
+const WGS: u32 = 64;
+
+var<workgroup> tile: array<Packed, 64>;
+
+// a + b, where a/b are [main, aux] pairs — computeSum takes decoded Fields.
+// Only used for the cross-thread reduction tree below; the per-thread
+// strided loop uses addFields directly instead (see module comment).
+fn addPair(a: Packed, b: Packed) -> Packed {
+  return computeSum(decode(bitcast<u32>(a.main), a.aux), decode(bitcast<u32>(b.main), b.aux));
+}
+
+// |x| for a packed double is abs(main) with aux untouched — only main's
+// sign bit carries the double's sign (see fieldsToPacked() in f64pack.mjs).
+// Returns decoded Fields directly (not Packed) for the per-thread loop.
+fn absFields(idx: u32) -> Fields {
+  return decode(bitcast<u32>(abs(xMain[idx])), xAux[idx]);
+}
+
+@compute @workgroup_size(64)
+fn dasum_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  var acc0: Fields = Fields(0u, 0u, 0u, 0u);
+  var acc1: Fields = Fields(0u, 0u, 0u, 0u);
+  var acc2: Fields = Fields(0u, 0u, 0u, 0u);
+  var acc3: Fields = Fields(0u, 0u, 0u, 0u);
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    acc0 = addFields(acc0, absFields( id                * params.x_inc));
+    acc1 = addFields(acc1, absFields((id +      stride) * params.x_inc));
+    acc2 = addFields(acc2, absFields((id + 2u * stride) * params.x_inc));
+    acc3 = addFields(acc3, absFields((id + 3u * stride) * params.x_inc));
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    acc0 = addFields(acc0, absFields(id * params.x_inc));
+  }
+
+  // Combine the 4 per-thread accumulators in Fields form too — still no
+  // encode/decode needed, since none of them have touched Packed yet.
+  let combined = addFields(addFields(acc0, acc1), addFields(acc2, acc3));
+  tile[lid.x] = encode(combined.sign, combined.rawExp, combined.mantissaHi, combined.lo);
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (lid.x < s) { tile[lid.x] = addPair(tile[lid.x], tile[lid.x + s]); }
+    workgroupBarrier();
+  }
+
+  if (lid.x == 0u) {
+    partialsMain[wgid.x] = tile[0].main;
+    partialsAux[wgid.x] = tile[0].aux;
+  }
+}