[linalg.algs.blas3] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp67horqxc/{from.md → to.md} +720 -0

tmp/tmp67horqxc/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,720 @@

+### BLAS 3 algorithms <a id="linalg.algs.blas3">[[linalg.algs.blas3]]</a>
+#### General matrix-matrix product <a id="linalg.algs.blas3.gemm">[[linalg.algs.blas3.gemm]]</a>
+[*Note 1*: These functions correspond to the BLAS function
+`xGEMM`. — *end note*]
+The following elements apply to all functions in
+[[linalg.algs.blas3.gemm]] in addition to function-specific elements.
+*Mandates:*
+`possibly-multipliable<decltype(A), decltype(B), decltype(C)>()` is
+`true`.
+*Preconditions:* `multipliable(A, B, C)` is `true`.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `B.extent(1)`).
+``` cpp
+template<in-matrix InMat1, in-matrix InMat2, out-matrix OutMat>
+    void matrix_product(InMat1 A, InMat2 B, OutMat C);
+  template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, out-matrix OutMat>
+    void matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C);
+```
+*Effects:* Computes C = A B.
+``` cpp
+template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat>
+  void matrix_product(InMat1 A, InMat2 B, InMat3 E, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat>
+  void matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C);
+```
+*Mandates:* *`possibly-addable`*`<InMat3, InMat3, OutMat>()` is `true`.
+*Preconditions:* *`addable`*`(E, E, C)` is `true`.
+*Effects:* Computes C = E + A B.
+*Remarks:* `C` may alias `E`.
+#### Symmetric, Hermitian, and triangular matrix-matrix product <a id="linalg.algs.blas3.xxmm">[[linalg.algs.blas3.xxmm]]</a>
+[*Note 1*: These functions correspond to the BLAS functions `xSYMM`,
+`xHEMM`, and `xTRMM`. — *end note*]
+The following elements apply to all functions in
+[[linalg.algs.blas3.xxmm]] in addition to function-specific elements.
+*Mandates:*
+- `possibly-multipliable<decltype(A), decltype(B), decltype(C)>()` is
+  `true`, and
+- `possibly-addable<decltype(E), decltype(E), decltype(C)>()` is `true`
+  for those overloads that take an `E` parameter.
+*Preconditions:*
+- `multipliable(A, B, C)` is `true`, and
+- `addable(E, E, C)` is `true` for those overloads that take an `E`
+  parameter.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `B.extent(1)`).
+``` cpp
+template<in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat>
+  void symmetric_matrix_product(InMat1 A, Triangle t, InMat2 B, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat>
+  void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, OutMat C);
+template<in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat>
+  void hermitian_matrix_product(InMat1 A, Triangle t, InMat2 B, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat>
+  void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, OutMat C);
+template<in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat>
+  void triangular_matrix_product(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat C);
+template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat>
+  void triangular_matrix_product(ExecutionPolicy&& exec,
+                                 InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat C);
+```
+These functions perform a matrix-matrix multiply, taking into account
+the `Triangle` and `DiagonalStorage` (if applicable) parameters that
+apply to the symmetric, Hermitian, or triangular (respectively) matrix
+`A` [[linalg.general]].
+*Mandates:*
+- If `InMat1` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument; and
+- *`compatible-static-extents`*`<InMat1, InMat1>(0, 1)` is `true`.
+*Preconditions:* `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes C = A B.
+``` cpp
+template<in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat>
+    void symmetric_matrix_product(InMat1 A, InMat2 B, Triangle t, OutMat C);
+  template<class ExecutionPolicy,
+           in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat>
+    void symmetric_matrix_product(ExecutionPolicy&& exec,
+                                  InMat1 A, InMat2 B, Triangle t, OutMat C);
+  template<in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat>
+    void hermitian_matrix_product(InMat1 A, InMat2 B, Triangle t, OutMat C);
+  template<class ExecutionPolicy,
+           in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat>
+    void hermitian_matrix_product(ExecutionPolicy&& exec,
+                                  InMat1 A, InMat2 B, Triangle t, OutMat C);
+  template<in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage,
+           out-matrix OutMat>
+    void triangular_matrix_product(InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, OutMat C);
+  template<class ExecutionPolicy,
+           in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage,
+           out-matrix OutMat>
+    void triangular_matrix_product(ExecutionPolicy&& exec,
+                                   InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, OutMat C);
+```
+These functions perform a matrix-matrix multiply, taking into account
+the `Triangle` and `DiagonalStorage` (if applicable) parameters that
+apply to the symmetric, Hermitian, or triangular (respectively) matrix
+`B` [[linalg.general]].
+*Mandates:*
+- If `InMat2` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument; and
+- *`compatible-static-extents`*`<InMat2, InMat2>(0, 1)` is `true`.
+*Preconditions:* `B.extent(0) == B.extent(1)` is `true`.
+*Effects:* Computes C = A B.
+``` cpp
+template<in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3,
+         out-matrix OutMat>
+  void symmetric_matrix_product(InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3,
+         out-matrix OutMat>
+  void symmetric_matrix_product(ExecutionPolicy&& exec,
+                                InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C);
+template<in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3,
+         out-matrix OutMat>
+  void hermitian_matrix_product(InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3,
+         out-matrix OutMat>
+  void hermitian_matrix_product(ExecutionPolicy&& exec,
+                                InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C);
+template<in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, in-matrix InMat3, out-matrix OutMat>
+  void triangular_matrix_product(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, InMat3 E,
+                                 OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, in-matrix InMat3, out-matrix OutMat>
+  void triangular_matrix_product(ExecutionPolicy&& exec,
+                                 InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, InMat3 E,
+                                 OutMat C);
+```
+These functions perform a potentially overwriting matrix-matrix
+multiply-add, taking into account the `Triangle` and `DiagonalStorage`
+(if applicable) parameters that apply to the symmetric, Hermitian, or
+triangular (respectively) matrix `A` [[linalg.general]].
+*Mandates:*
+- If `InMat1` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument; and
+- *`compatible-static-extents`*`<InMat1, InMat1>(0, 1)` is `true`.
+*Preconditions:* `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes C = E + A B.
+*Remarks:* `C` may alias `E`.
+``` cpp
+template<in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3,
+         out-matrix OutMat>
+  void symmetric_matrix_product(InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3,
+         out-matrix OutMat>
+  void symmetric_matrix_product(ExecutionPolicy&& exec,
+                                InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C);
+template<in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3,
+         out-matrix OutMat>
+  void hermitian_matrix_product(InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3,
+         out-matrix OutMat>
+  void hermitian_matrix_product(ExecutionPolicy&& exec,
+                                InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C);
+template<in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage,
+         in-matrix InMat3, out-matrix OutMat>
+  void triangular_matrix_product(InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, InMat3 E,
+                                 OutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage,
+         in-matrix InMat3, out-matrix OutMat>
+  void triangular_matrix_product(ExecutionPolicy&& exec,
+                                 InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, InMat3 E,
+                                 OutMat C);
+```
+These functions perform a potentially overwriting matrix-matrix
+multiply-add, taking into account the `Triangle` and `DiagonalStorage`
+(if applicable) parameters that apply to the symmetric, Hermitian, or
+triangular (respectively) matrix `B` [[linalg.general]].
+*Mandates:*
+- If `InMat2` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument; and
+- *`compatible-static-extents`*`<InMat2, InMat2>(0, 1)` is `true`.
+*Preconditions:* `B.extent(0) == B.extent(1)` is `true`.
+*Effects:* Computes C = E + A B.
+*Remarks:* `C` may alias `E`.
+#### In-place triangular matrix-matrix product <a id="linalg.algs.blas3.trmm">[[linalg.algs.blas3.trmm]]</a>
+These functions perform an in-place matrix-matrix multiply, taking into
+account the `Triangle` and `DiagonalStorage` parameters that apply to
+the triangular matrix `A` [[linalg.general]].
+[*Note 1*: These functions correspond to the BLAS function
+`xTRMM`. — *end note*]
+``` cpp
+template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_left_product(InMat A, Triangle t, DiagonalStorage d, InOutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_left_product(ExecutionPolicy&& exec,
+                                      InMat A, Triangle t, DiagonalStorage d, InOutMat C);
+```
+*Mandates:*
+- If `InMat` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- *`possibly-multipliable`*`<InMat, InOutMat, InOutMat>()` is `true`;
+  and
+- *`compatible-static-extents`*`<InMat, InMat>(0, 1)` is `true`.
+*Preconditions:*
+- *`multipliable`*`(A, C, C)` is `true`, and
+- `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes a matrix C' such that C' = A C and assigns each
+element of C' to the corresponding element of C.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `C.extent(0)`).
+``` cpp
+template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_right_product(InMat A, Triangle t, DiagonalStorage d, InOutMat C);
+template<class ExecutionPolicy,
+         in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_right_product(ExecutionPolicy&& exec,
+                                       InMat A, Triangle t, DiagonalStorage d, InOutMat C);
+```
+*Mandates:*
+- If `InMat` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- *`possibly-multipliable`*`<InOutMat, InMat, InOutMat>()` is `true`;
+  and
+- *`compatible-static-extents`*`<InMat, InMat>(0, 1)` is `true`.
+*Preconditions:*
+- *`multipliable`*`(C, A, C)` is `true`, and
+- `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes a matrix C' such that C' = C A and assigns each
+element of C' to the corresponding element of C.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `C.extent(0)`).
+#### Rank-k update of a symmetric or Hermitian matrix <a id="linalg.algs.blas3.rankk">[[linalg.algs.blas3.rankk]]</a>
+[*Note 1*: These functions correspond to the BLAS functions `xSYRK` and
+`xHERK`. — *end note*]
+The following elements apply to all functions in
+[[linalg.algs.blas3.rankk]].
+*Mandates:*
+- If `InOutMat` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- `compatible-static-extents<decltype(A), decltype(A)>(0, 1)` is `true`;
+- `compatible-static-extents<decltype(C), decltype(C)>(0, 1)` is `true`;
+  and
+- `compatible-static-extents<decltype(A), decltype(C)>(0, 0)` is `true`.
+*Preconditions:*
+- `A.extent(0)` equals `A.extent(1)`,
+- `C.extent(0)` equals `C.extent(1)`, and
+- `A.extent(0)` equals `C.extent(0)`.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `C.extent(0)`).
+``` cpp
+template<class Scalar, in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_k_update(Scalar alpha, InMat A, InOutMat C, Triangle t);
+  template<class ExecutionPolicy, class Scalar,
+           in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec,
+                                        Scalar alpha, InMat A, InOutMat C, Triangle t);
+```
+*Effects:* Computes a matrix C' such that $C' = C + \alpha A A^T$, where
+the scalar α is `alpha`, and assigns each element of C' to the
+corresponding element of C.
+``` cpp
+template<in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+  void symmetric_matrix_rank_k_update(InMat A, InOutMat C, Triangle t);
+template<class ExecutionPolicy,
+         in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+  void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec,
+                                      InMat A, InOutMat C, Triangle t);
+```
+*Effects:* Computes a matrix C' such that $C' = C + A A^T$, and assigns
+each element of C' to the corresponding element of C.
+``` cpp
+template<class Scalar, in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+  void hermitian_matrix_rank_k_update(Scalar alpha, InMat A, InOutMat C, Triangle t);
+template<class ExecutionPolicy,
+         class Scalar, in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+  void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec,
+                                      Scalar alpha, InMat A, InOutMat C, Triangle t);
+```
+*Effects:* Computes a matrix C' such that $C' = C + \alpha A A^H$, where
+the scalar α is `alpha`, and assigns each element of C' to the
+corresponding element of C.
+``` cpp
+template<in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+  void hermitian_matrix_rank_k_update(InMat A, InOutMat C, Triangle t);
+template<class ExecutionPolicy,
+         in-matrix InMat, possibly-packed-inout-matrix InOutMat, class Triangle>
+  void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec,
+                                      InMat A, InOutMat C, Triangle t);
+```
+*Effects:* Computes a matrix C' such that $C' = C + A A^H$, and assigns
+each element of C' to the corresponding element of C.
+#### Rank-2k update of a symmetric or Hermitian matrix <a id="linalg.algs.blas3.rank2k">[[linalg.algs.blas3.rank2k]]</a>
+[*Note 1*: These functions correspond to the BLAS functions `xSYR2K`
+and `xHER2K`. — *end note*]
+The following elements apply to all functions in
+[[linalg.algs.blas3.rank2k]].
+*Mandates:*
+- If `InOutMat` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- `possibly-addable<decltype(A), decltype(B), decltype(C)>()` is `true`;
+  and
+- `compatible-static-extents<decltype(A), decltype(A)>(0, 1)` is `true`.
+*Preconditions:*
+- `addable(A, B, C)` is `true`, and
+- `A.extent(0)` equals `A.extent(1)`.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `C.extent(0)`).
+``` cpp
+template<in-matrix InMat1, in-matrix InMat2,
+         possibly-packed-inout-matrix InOutMat, class Triangle>
+  void symmetric_matrix_rank_2k_update(InMat1 A, InMat2 B, InOutMat C, Triangle t);
+template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2,
+         possibly-packed-inout-matrix InOutMat, class Triangle>
+  void symmetric_matrix_rank_2k_update(ExecutionPolicy&& exec,
+                                       InMat1 A, InMat2 B, InOutMat C, Triangle t);
+```
+*Effects:* Computes a matrix C' such that $C' = C + A B^T + B A^T$, and
+assigns each element of C' to the corresponding element of C.
+``` cpp
+template<in-matrix InMat1, in-matrix InMat2,
+         possibly-packed-inout-matrix InOutMat, class Triangle>
+  void hermitian_matrix_rank_2k_update(InMat1 A, InMat2 B, InOutMat C, Triangle t);
+template<class ExecutionPolicy,
+         in-matrix InMat1, in-matrix InMat2,
+         possibly-packed-inout-matrix InOutMat, class Triangle>
+  void hermitian_matrix_rank_2k_update(ExecutionPolicy&& exec,
+                                       InMat1 A, InMat2 B, InOutMat C, Triangle t);
+```
+*Effects:* Computes a matrix C' such that $C' = C + A B^H + B A^H$, and
+assigns each element of C' to the corresponding element of C.
+#### Solve multiple triangular linear systems <a id="linalg.algs.blas3.trsm">[[linalg.algs.blas3.trsm]]</a>
+[*Note 1*: These functions correspond to the BLAS function
+`xTRSM`. — *end note*]
+``` cpp
+template<in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d,
+                                           InMat2 B, OutMat X, BinaryDivideOp divide);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec,
+                                           InMat1 A, Triangle t, DiagonalStorage d,
+                                           InMat2 B, OutMat X, BinaryDivideOp divide);
+```
+These functions perform multiple matrix solves, taking into account the
+`Triangle` and `DiagonalStorage` parameters that apply to the triangular
+matrix `A` [[linalg.general]].
+*Mandates:*
+- If `InMat1` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- *`possibly-multipliable`*`<InMat1, OutMat, InMat2>()` is `true`; and
+- *`compatible-static-extents`*`<InMat1, InMat1>(0, 1)` is `true`.
+*Preconditions:*
+- *`multipliable`*`(A, X, B)` is `true`, and
+- `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes X' such that AX' = B, and assigns each element of X'
+to the corresponding element of X. If no such X' exists, then the
+elements of `X` are valid but unspecified.
+*Complexity:* 𝑂(`A.extent(0)` × `X.extent(1)` × `X.extent(1)`).
+[*Note 2*: Since the triangular matrix is on the left, the desired
+`divide` implementation in the case of noncommutative multiplication is
+mathematically equivalent to $y^{-1} x$, where x is the first argument
+and y is the second argument, and $y^{-1}$ denotes the multiplicative
+inverse of y. — *end note*]
+``` cpp
+template<in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat>
+  void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d,
+                                           InMat2 B, OutMat X);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_left_solve(A, t, d, B, X, divides<void>{});
+```
+``` cpp
+template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat>
+  void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec,
+                                           InMat1 A, Triangle t, DiagonalStorage d,
+                                           InMat2 B, OutMat X);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_left_solve(std::forward<ExecutionPolicy>(exec),
+                                    A, t, d, B, X, divides<void>{});
+```
+``` cpp
+template<in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d,
+                                            InMat2 B, OutMat X, BinaryDivideOp divide);
+template<class ExecutionPolicy,
+         in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec,
+                                            InMat1 A, Triangle t, DiagonalStorage d,
+                                            InMat2 B, OutMat X, BinaryDivideOp divide);
+```
+These functions perform multiple matrix solves, taking into account the
+`Triangle` and `DiagonalStorage` parameters that apply to the triangular
+matrix `A` [[linalg.general]].
+*Mandates:*
+- If `InMat1` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- *`possibly-multipliable`*`<OutMat, InMat1, InMat2>()` is `true`; and
+- *`compatible-static-extents`*`<InMat1, InMat1>(0,1)` is `true`.
+*Preconditions:*
+- *`multipliable`*`(X, A, B)` is `true`, and
+- `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes X' such that X'A = B, and assigns each element of X'
+to the corresponding element of X. If no such X' exists, then the
+elements of `X` are valid but unspecified.
+*Complexity:* O( `B.extent(0)` ⋅ `B.extent(1)` ⋅ `A.extent(1)` )
+[*Note 1*: Since the triangular matrix is on the right, the desired
+`divide` implementation in the case of noncommutative multiplication is
+mathematically equivalent to $x y^{-1}$, where x is the first argument
+and y is the second argument, and $y^{-1}$ denotes the multiplicative
+inverse of y. — *end note*]
+``` cpp
+template<in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat>
+  void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d,
+                                            InMat2 B, OutMat X);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_right_solve(A, t, d, B, X, divides<void>{});
+```
+``` cpp
+template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage,
+         in-matrix InMat2, out-matrix OutMat>
+  void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec,
+                                            InMat1 A, Triangle t, DiagonalStorage d,
+                                            InMat2 B, OutMat X);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_right_solve(std::forward<ExecutionPolicy>(exec),
+                                     A, t, d, B, X, divides<void>{});
+```
+#### Solve multiple triangular linear systems in-place <a id="linalg.algs.blas3.inplacetrsm">[[linalg.algs.blas3.inplacetrsm]]</a>
+[*Note 1*: These functions correspond to the BLAS function
+`xTRSM`. — *end note*]
+``` cpp
+template<in-matrix InMat, class Triangle, class DiagonalStorage,
+         inout-matrix InOutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_left_solve(InMat A, Triangle t, DiagonalStorage d,
+                                           InOutMat B, BinaryDivideOp divide);
+template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage,
+         inout-matrix InOutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec,
+                                           InMat A, Triangle t, DiagonalStorage d,
+                                           InOutMat B, BinaryDivideOp divide);
+```
+These functions perform multiple in-place matrix solves, taking into
+account the `Triangle` and `DiagonalStorage` parameters that apply to
+the triangular matrix `A` [[linalg.general]].
+[*Note 1*: This algorithm makes it possible to compute factorizations
+like Cholesky and LU in place. Performing triangular solve in place
+hinders parallelization. However, other `ExecutionPolicy` specific
+optimizations, such as vectorization, are still possible. — *end note*]
+*Mandates:*
+- If `InMat` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- *`possibly-multipliable`*`<InMat, InOutMat, InOutMat>()` is `true`;
+  and
+- *`compatible-static-extents`*`<InMat, InMat>(0, 1)` is `true`.
+*Preconditions:*
+- *`multipliable`*`(A, B, B)` is `true`, and
+- `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes X' such that AX' = B, and assigns each element of X'
+to the corresponding element of B. If so such X' exists, then the
+elements of `B` are valid but unspecified.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `B.extent(1)`).
+``` cpp
+template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_matrix_left_solve(InMat A, Triangle t, DiagonalStorage d,
+                                           InOutMat B);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_left_solve(A, t, d, B, divides<void>{});
+```
+``` cpp
+template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+    void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec,
+                                             InMat A, Triangle t, DiagonalStorage d,
+                                             InOutMat B);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_left_solve(std::forward<ExecutionPolicy>(exec),
+                                    A, t, d, B, divides<void>{});
+```
+``` cpp
+template<in-matrix InMat, class Triangle, class DiagonalStorage,
+         inout-matrix InOutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_right_solve(InMat A, Triangle t, DiagonalStorage d,
+                                            InOutMat B, BinaryDivideOp divide);
+template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage,
+         inout-matrix InOutMat, class BinaryDivideOp>
+  void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec,
+                                            InMat A, Triangle t, DiagonalStorage d,
+                                            InOutMat B, BinaryDivideOp divide);
+```
+These functions perform multiple in-place matrix solves, taking into
+account the `Triangle` and `DiagonalStorage` parameters that apply to
+the triangular matrix `A` [[linalg.general]].
+[*Note 2*: This algorithm makes it possible to compute factorizations
+like Cholesky and LU in place. Performing triangular solve in place
+hinders parallelization. However, other `ExecutionPolicy` specific
+optimizations, such as vectorization, are still possible. — *end note*]
+*Mandates:*
+- If `InMat` has `layout_blas_packed` layout, then the layout’s
+  `Triangle` template argument has the same type as the function’s
+  `Triangle` template argument;
+- *`possibly-multipliable`*`<InOutMat, InMat, InOutMat>()` is `true`;
+  and
+- *`compatible-static-extents`*`<InMat, InMat>(0, 1)` is `true`.
+*Preconditions:*
+- *`multipliable`*`(B, A, B)` is `true`, and
+- `A.extent(0) == A.extent(1)` is `true`.
+*Effects:* Computes X' such that X'A = B, and assigns each element of X'
+to the corresponding element of B. If so such X' exists, then the
+elements of `B` are valid but unspecified.
+*Complexity:* 𝑂(`A.extent(0)` × `A.extent(1)` × `B.extent(1)`).
+``` cpp
+template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_matrix_right_solve(InMat A, Triangle t, DiagonalStorage d, InOutMat B);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_right_solve(A, t, d, B, divides<void>{});
+```
+``` cpp
+template<class ExecutionPolicy,
+         in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat>
+  void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec,
+                                            InMat A, Triangle t, DiagonalStorage d,
+                                            InOutMat B);
+```
+*Effects:* Equivalent to:
+``` cpp
+triangular_matrix_matrix_right_solve(std::forward<ExecutionPolicy>(exec),
+                                     A, t, d, B, divides<void>{});
+```

Diff to HTML by rtfpessoa