Function ssyr2

ssyr2(
    device: GPUDevice,
    uplo: "lower" | "upper",
    n: number,
    alpha: number,
    x: Float32Array,
    incx: number,
    y: Float32Array,
    incy: number,
    A: Float32Array,
    lda: number,
    layout?: "column-major" | "row-major",
): Promise<{ A: Float32Array; gpuTimeMs?: number }>

Performs the symmetric rank-2 update A = alpha * x * y^T + alpha * y * x^T + A

A is an n×n symmetric matrix stored in row-major order, updated in place. Only the triangle specified by uplo is referenced and updated; the other triangle is left untouched (implied by symmetry).

import { init, cleanup } from "wgblas";
import { ssyr2 } from "wgblas/ssyr2";
import { randomFloat32Array } from "wgblas/random";

// Reshapes a flat row-major array into rows for console.table's 2D grid view.
function toMatrix(A, rows, cols, lda = cols) {
  const out = [];
  for (let r = 0; r < rows; r++)
    out.push(Array.from(A.subarray(r * lda, r * lda + cols), (v) => +v.toFixed(4)));
  return out;
}

const device = await init();

// 4×4 symmetric rank-2 update, lower triangle stored; lda = n
const n = 4, lda = n;
const alpha = 1.0;
const x = randomFloat32Array(n, -10, 10);
const y = randomFloat32Array(n, -10, 10);
const A = randomFloat32Array(n * lda, -10, 10); // only lower triangle is read/updated

console.log("x:", x);
console.log("y:", y);
console.log("A (lower triangle, before):");
console.table(toMatrix(A, n, n, lda));
const { A: result } = await ssyr2(device, "lower", n, alpha, x, 1, y, 1, A, lda, "row-major");
console.log("A (lower triangle, after):");
console.table(toMatrix(result, n, n, lda));
if (typeof process !== "undefined") cleanup();

Browser (standalone HTML):

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>ssyr2 — wgblas browser example</title>
    <script src="https://unpkg.com/wgblas/dist/wgblas.browser.js"></script>
  </head>
  <body>
    <pre id="out">Running…</pre>
    <script>
      const { init, ssyr2, randomFloat32Array, cleanup } = window.wgblas;

      // Reshapes a flat row-major array into a newline-per-row grid for display.
      function matrixText(A, rows, cols, lda) {
        const lines = [];
        for (let r = 0; r < rows; r++) {
          const row = [];
          for (let c = 0; c < cols; c++) row.push(A[r * lda + c].toFixed(4));
          lines.push(row.join(", "));
        }
        return lines.join("\n");
      }

      (async () => {
        const device = await init();

        const n = 4, lda = n;
        const alpha = 1.0;
        const x = randomFloat32Array(n, -10, 10);
        const y = randomFloat32Array(n, -10, 10);
        const A = randomFloat32Array(n * lda, -10, 10); // only lower triangle is read/updated

        const { A: result } = await ssyr2(device, "lower", n, alpha, x, 1, y, 1, A, lda, "row-major");

        document.getElementById("out").textContent =
          "x: " + Array.from(x).map(v => v.toFixed(4)).join(", ") +
          "\ny: " + Array.from(y).map(v => v.toFixed(4)).join(", ") +
          "\nA (lower triangle, before):\n" + matrixText(A, n, n, lda) +
          "\nA (lower triangle, after):\n" + matrixText(result, n, n, lda);

        cleanup();
      })();
    </script>
  </body>
</html>

Parameters

device: GPUDevice
GPUDevice from init()
uplo: "lower" | "upper"
'lower' to use the lower triangle, 'upper' to use the upper triangle
n: number
order of the matrix A (number of rows and columns)
alpha: number
scalar multiplier for xy^T + yx^T
x: Float32Array
Float32Array input vector, length at least (n-1)*incx+1
incx: number
stride for x (must be a positive integer)
y: Float32Array
Float32Array input vector, length at least (n-1)*incy+1
incy: number
stride for y (must be a positive integer)
A: Float32Array
Float32Array, row-major or column-major (see layout), at least (n-1)*lda+n elements
lda: number
leading dimension of A (>= n either way — A is square)
Optionallayout: "column-major" | "row-major"
storage layout of A (default: 'row-major'); for a symmetric matrix, column-major storage just means the other triangle is the one physically referenced for a given uplo

Returns Promise<{ A: Float32Array; gpuTimeMs?: number }>

See

Source code: ssyr2.mjs (L15)

ssyr2(
    device: GPUDevice,
    uplo: "lower" | "upper",
    n: number,
    alpha: number,
    x: Float32Array,
    incx: number,
    y: Float32Array,
    incy: number,
    A: GpuMatrix,
    lda: number,
): Promise<{ gpuTimeMs?: number }>
Performs the symmetric rank-2 update A = alpha * x * y^T + alpha * y * x^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.
Parameters
- device: GPUDevice
  GPUDevice from init()
- uplo: "lower" | "upper"
  'lower' to use the lower triangle, 'upper' to use the upper triangle
- n: number
  order of the matrix A
- alpha: number
  scalar multiplier for xy^T + yx^T
- x: Float32Array
  Float32Array input vector
- incx: number
  stride for x (must be a positive integer)
- y: Float32Array
  Float32Array input vector
- incy: number
  stride for y (must be a positive integer)
- A: GpuMatrix
  GpuMatrix, row-major, GPU-resident, Float32-backed
- lda: number
  leading dimension of A (must equal A.lda)
Returns Promise<{ gpuTimeMs?: number }>
See
Source code: ssyr2.mjs (L15)
- Defined in src/ssyr2/ssyr2.d.mts:66

ssyr2(
    device: GPUDevice,
    uplo: "lower" | "upper",
    n: number,
    alpha: number,
    x: GpuVector,
    incx: number,
    y: GpuVector,
    incy: number,
    A: GpuMatrix,
    lda: number,
): Promise<{ gpuTimeMs?: number }>

Performs the symmetric rank-2 update A = alpha * x * y^T + alpha * y * x^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.

import { init, cleanup } from "wgblas";
import { ssyr2 } from "wgblas/ssyr2";
import { GpuVector } from "wgblas/classes/GpuVector";
import { GpuMatrix } from "wgblas/classes/GpuMatrix";
import { randomFloat32Array } from "wgblas/random";

// Reshapes a flat row-major array into rows for console.table's 2D grid view.
function toMatrix(A, rows, cols, lda = cols) {
  const out = [];
  for (let r = 0; r < rows; r++)
    out.push(Array.from(A.subarray(r * lda, r * lda + cols), (v) => +v.toFixed(4)));
  return out;
}

const device = await init();

const n = 4;
const x = randomFloat32Array(n, -10, 10);
const y = randomFloat32Array(n, -10, 10);
const A = randomFloat32Array(n * n, -10, 10);

const xGpu = GpuVector.from(x);
const yGpu = GpuVector.from(y);
const AGpu = GpuMatrix.from(A, n, n, n, "row-major");

console.log("x:", x);
console.log("y:", y);
console.log("A (before):");
console.table(toMatrix(A, n, n));

// results stay on the GPU between steps
await ssyr2(device, "lower", n, 1.0, xGpu, 1, yGpu, 1, AGpu, AGpu.lda); // A += x*y^T + y*x^T
await ssyr2(device, "lower", n, 1.0, xGpu, 1, yGpu, 1, AGpu, AGpu.lda); // A += x*y^T + y*x^T again

// single readback (GpuMatrix.read() is already dense — no lda padding to strip)
const result = await AGpu.read();
console.log("A (lower triangle, after two rank-2 updates):");
console.table(toMatrix(result, n, n));

xGpu.destroy();
yGpu.destroy();
AGpu.destroy();

if (typeof process !== "undefined") cleanup();

Parameters

device: GPUDevice
GPUDevice from init()
uplo: "lower" | "upper"
'lower' to use the lower triangle, 'upper' to use the upper triangle
n: number
order of the matrix A
alpha: number
scalar multiplier for xy^T + yx^T
x: GpuVector
GpuVector input vector (not mutated), Float32-backed
incx: number
stride for x (must be a positive integer)
y: GpuVector
GpuVector input vector (not mutated), Float32-backed
incy: number
stride for y (must be a positive integer)
A: GpuMatrix
GpuMatrix, row-major, mutated in place, Float32-backed
lda: number
leading dimension of A (must equal A.lda)

Returns Promise<{ gpuTimeMs?: number }>

See

Source code: ssyr2.mjs (L15)

Function ssyr2

Parameters

Returns Promise<{ A: Float32Array; gpuTimeMs?: number }>

See

Parameters

Returns Promise<{ gpuTimeMs?: number }>

See

Parameters

Returns Promise<{ gpuTimeMs?: number }>

See

Settings