wgblas
    Preparing search index...

    Function strsm

    • Solves the triangular matrix equation $$\mathrm{op}(A) X = \alpha B \quad (\texttt{side='left'})$$ $$X \mathrm{op}(A) = \alpha B \quad (\texttt{side='right'})$$ overwriting B with the solution X — A is triangular, only its uplo triangle stored; B is a general m×n matrix.

      • side='left': A is m×m — solves op(A)*X = alpha*B
      • side='right': A is n×n — solves X*op(A) = alpha*B

      Blocked substitution (strsv's own technique, generalized to a matrix RHS): strsv_invert_block + sgemm, both unmodified. A near-zero diagonal entry amplifies error, same as any triangular solve.

      import { init, cleanup } from "wgblas";
      import { strsm } from "wgblas/strsm";

      const device = await init();

      // Solves A*X = alpha*B for X, overwriting B. Passing B = A recovers the
      // identity, undoing what the strmm example does.
      const n = 3,
        lda = n;
      const A = new Float32Array([2, 0, 0, 3, 4, 0, 5, 6, 8]);
      const B = new Float32Array([2, 0, 0, 3, 4, 0, 5, 6, 8]);

      console.log("A (lower triangular) = B =");
      console.table([A.slice(0, 3), A.slice(3, 6), A.slice(6, 9)]);

      const { B: result } = await strsm(
        device,
        "left",
        "lower",
        "no-transpose",
        "non-unit",
        n,
        n,
        1,
        A,
        lda,
        B,
        lda,
      );
      console.log("X solving A*X = B, i.e. the identity =");
      console.table([result.slice(0, 3), result.slice(3, 6), result.slice(6, 9)]);

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

      Browser (standalone HTML):

      <!doctype html>
      <html lang="en">
        <head>
          <meta charset="UTF-8" />
          <title>strsm — 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, strsm, cleanup } = window.wgblas;

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

              // Solves A*X = B, overwriting B. Passing B = A recovers the identity,
              // undoing what the strmm example does.
              const n = 3, lda = n;
              const A = new Float32Array([2, 0, 0,
                                          3, 4, 0,
                                          5, 6, 8]);
              const B = new Float32Array([2, 0, 0,
                                          3, 4, 0,
                                          5, 6, 8]);

              const { B: result } = await strsm(device, "left", "lower", "no-transpose", "non-unit", n, n, 1, A, lda, B, lda);

              document.getElementById("out").textContent = [
                "A (lower triangular) = B =",
                "  [" + A.slice(0, 3).join(", ") + "]",
                "  [" + A.slice(3, 6).join(", ") + "]",
                "  [" + A.slice(6, 9).join(", ") + "]",
                "X solving A*X = B, i.e. the identity =",
                "  [" + result.slice(0, 3).join(", ") + "]",
                "  [" + result.slice(3, 6).join(", ") + "]",
                "  [" + result.slice(6, 9).join(", ") + "]",
              ].join("\n");

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

      Parameters

      • device: GPUDevice

        GPUDevice from init()

      • side: "right" | "left"

        'left' to solve op(A)X=alphaB, 'right' to solve Xop(A)=alphaB

      • uplo: "lower" | "upper"

        'lower' if only A's lower triangle is stored, 'upper' for upper

      • transA: "no-transpose" | "transpose"

        'no-transpose' for A, 'transpose' for A^T

      • diag: "unit" | "non-unit"

        'unit' to treat A's diagonal as all-ones (A's diagonal is not read), 'non-unit' to read it

      • m: number

        rows of B

      • n: number

        columns of B

      • alpha: number

        scalar multiplier for B

      • A: Float32Array

        Float32Array, triangular, row-major or column-major (see layout)

      • lda: number

        leading dimension of A as stored

      • B: Float32Array

        Float32Array input/output matrix, overwritten with the solution, row-major or column-major

      • ldb: number

        leading dimension of B as stored

      • Optionallayout: "column-major" | "row-major"

        storage layout shared by A/B when they're Float32Array (default: 'row-major') — column-major A is a genuine transpose (A isn't symmetric like ssymm's), so both transA and uplo are adjusted internally to compensate

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

      the solution X, written into B, as a Float32Array

      Source code: strsm.mjs (L25)

    • Solves the triangular matrix equation $$\mathrm{op}(A) X = \alpha B \quad (\texttt{side='left'})$$ $$X \mathrm{op}(A) = \alpha B \quad (\texttt{side='right'})$$ overwriting B in place with X.

      A and B are both kept GPU-resident. Each matrix's own layout (set at GpuMatrix.from time) determines the operation — there is no separate layout argument here. A and B must both be GpuMatrix or both be Float32Array — mixing is not supported.

      import { init, cleanup } from "wgblas";
      import { strsm } from "wgblas/strsm";
      import { GpuMatrix } from "wgblas/classes/GpuMatrix";

      const device = await init();

      // Solves A*X = B in place on the GPU. Passing B = A recovers the identity,
      // undoing what the strmm example does.
      const n = 3;
      const A = new Float32Array([2, 0, 0, 3, 4, 0, 5, 6, 8]);

      const AGpu = GpuMatrix.from(A, n, n, n, "row-major");
      const BGpu = GpuMatrix.from(A.slice(), n, n, n, "row-major");

      console.log("A (lower triangular) = B =");
      console.table([A.slice(0, 3), A.slice(3, 6), A.slice(6, 9)]);

      await strsm(
        device,
        "left",
        "lower",
        "no-transpose",
        "non-unit",
        n,
        n,
        1,
        AGpu,
        AGpu.lda,
        BGpu,
        BGpu.lda,
      );

      const result = await BGpu.read();
      console.log("X solving A*X = B, i.e. the identity =");
      console.table([result.slice(0, 3), result.slice(3, 6), result.slice(6, 9)]);

      AGpu.destroy();
      BGpu.destroy();
      if (typeof process !== "undefined") cleanup();

      Parameters

      • device: GPUDevice

        GPUDevice from init()

      • side: "right" | "left"

        'left' to solve op(A)X=alphaB, 'right' to solve Xop(A)=alphaB

      • uplo: "lower" | "upper"

        'lower' if only A's lower triangle is stored, 'upper' for upper

      • transA: "no-transpose" | "transpose"

        'no-transpose' for A, 'transpose' for A^T

      • diag: "unit" | "non-unit"

        'unit' to treat A's diagonal as all-ones (A's diagonal is not read), 'non-unit' to read it

      • m: number

        rows of B

      • n: number

        columns of B

      • alpha: number

        scalar multiplier for B

      • A: GpuMatrix

        GpuMatrix, triangular

      • lda: number

        leading dimension of A (must equal A.lda)

      • B: GpuMatrix

        GpuMatrix (overwritten in place with the solution)

      • ldb: number

        leading dimension of B (must equal B.lda)

      Returns Promise<{ gpuTimeMs?: number }>

      no B — it stays GPU-resident; call B.read() yourself for a CPU readback (see the example)

      Source code: strsm.mjs (L25)

    Settings
    Member Visibility