[linalg.syn] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpok3t6qy_/{from.md → to.md} +700 -0

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

	@@ -0,0 +1,700 @@

+### Header `<linalg>` synopsis <a id="linalg.syn">[[linalg.syn]]</a>
+``` cpp
+namespace std::linalg {
+  // [linalg.tags.order], storage order tags
+  struct column_major_t;
+  inline constexpr column_major_t column_major;
+  struct row_major_t;
+  inline constexpr row_major_t row_major;
+  // [linalg.tags.triangle], triangle tags
+  struct upper_triangle_t;
+  inline constexpr upper_triangle_t upper_triangle;
+  struct lower_triangle_t;
+  inline constexpr lower_triangle_t lower_triangle;
+  // [linalg.tags.diagonal], diagonal tags
+  struct implicit_unit_diagonal_t;
+  inline constexpr implicit_unit_diagonal_t implicit_unit_diagonal;
+  struct explicit_diagonal_t;
+  inline constexpr explicit_diagonal_t explicit_diagonal;
+  // [linalg.layout.packed], class template layout_blas_packed
+  template<class Triangle, class StorageOrder>
+    class layout_blas_packed;
+  // [linalg.helpers], exposition-only helpers
+  // [linalg.helpers.concepts], linear algebra argument concepts
+  template<class T>
+    constexpr bool is-mdspan = see below;               // exposition only
+  template<class T>
+    concept in-vector = see below;                      // exposition only
+  template<class T>
+    concept out-vector = see below;                     // exposition only
+  template<class T>
+    concept inout-vector = see below;                   // exposition only
+  template<class T>
+    concept in-matrix = see below;                      // exposition only
+  template<class T>
+    concept out-matrix = see below;                     // exposition only
+  template<class T>
+    concept inout-matrix = see below;                   // exposition only
+  template<class T>
+    concept possibly-packed-inout-matrix = see below;   // exposition only
+  template<class T>
+    concept in-object = see below;                      // exposition only
+  template<class T>
+    concept out-object = see below;                     // exposition only
+  template<class T>
+    concept inout-object = see below;                   // exposition only
+  // [linalg.scaled], scaled in-place transformation
+  // [linalg.scaled.scaledaccessor], class template scaled_accessor
+  template<class ScalingFactor, class NestedAccessor>
+    class scaled_accessor;
+  // [linalg.scaled.scaled], function template scaled
+  template<class ScalingFactor,
+           class ElementType, class Extents, class Layout, class Accessor>
+    constexpr auto scaled(ScalingFactor alpha, mdspan<ElementType, Extents, Layout, Accessor> x);
+  // [linalg.conj], conjugated in-place transformation
+  // [linalg.conj.conjugatedaccessor], class template conjugated_accessor
+  template<class NestedAccessor>
+    class conjugated_accessor;
+  // [linalg.conj.conjugated], function template conjugated
+  template<class ElementType, class Extents, class Layout, class Accessor>
+    constexpr auto conjugated(mdspan<ElementType, Extents, Layout, Accessor> a);
+  // [linalg.transp], transpose in-place transformation
+  // [linalg.transp.layout.transpose], class template layout_transpose
+  template<class Layout>
+    class layout_transpose;
+  // [linalg.transp.transposed], function template transposed
+  template<class ElementType, class Extents, class Layout, class Accessor>
+    constexpr auto transposed(mdspan<ElementType, Extents, Layout, Accessor> a);
+  // [linalg.conjtransposed], conjugated transpose in-place transformation
+  template<class ElementType, class Extents, class Layout, class Accessor>
+    constexpr auto conjugate_transposed(mdspan<ElementType, Extents, Layout, Accessor> a);
+  // [linalg.algs.blas1], BLAS 1 algorithms
+  // [linalg.algs.blas1.givens], Givens rotations
+  // [linalg.algs.blas1.givens.lartg], compute Givens rotation
+  template<class Real>
+    struct setup_givens_rotation_result {
+      Real c;
+      Real s;
+      Real r;
+    };
+  template<class Real>
+    struct setup_givens_rotation_result<complex<Real>> {
+      Real c;
+      complex<Real> s;
+      complex<Real> r;
+    };
+  template<class Real>
+    setup_givens_rotation_result<Real> setup_givens_rotation(Real a, Real b) noexcept;
+  template<class Real>
+    setup_givens_rotation_result<complex<Real>>
+      setup_givens_rotation(complex<Real> a, complex<Real> b) noexcept;
+  // [linalg.algs.blas1.givens.rot], apply computed Givens rotation
+  template<inout-vector InOutVec1, inout-vector InOutVec2, class Real>
+    void apply_givens_rotation(InOutVec1 x, InOutVec2 y, Real c, Real s);
+  template<class ExecutionPolicy, inout-vector InOutVec1, inout-vector InOutVec2, class Real>
+    void apply_givens_rotation(ExecutionPolicy&& exec,
+                               InOutVec1 x, InOutVec2 y, Real c, Real s);
+  template<inout-vector InOutVec1, inout-vector InOutVec2, class Real>
+    void apply_givens_rotation(InOutVec1 x, InOutVec2 y, Real c, complex<Real> s);
+  template<class ExecutionPolicy, inout-vector InOutVec1, inout-vector InOutVec2, class Real>
+    void apply_givens_rotation(ExecutionPolicy&& exec,
+                               InOutVec1 x, InOutVec2 y, Real c, complex<Real> s);
+  // [linalg.algs.blas1.swap], swap elements
+  template<inout-object InOutObj1, inout-object InOutObj2>
+    void swap_elements(InOutObj1 x, InOutObj2 y);
+  template<class ExecutionPolicy, inout-object InOutObj1, inout-object InOutObj2>
+    void swap_elements(ExecutionPolicy&& exec, InOutObj1 x, InOutObj2 y);
+  // [linalg.algs.blas1.scal], multiply elements by scalar
+  template<class Scalar, inout-object InOutObj>
+    void scale(Scalar alpha, InOutObj x);
+  template<class ExecutionPolicy, class Scalar, inout-object InOutObj>
+    void scale(ExecutionPolicy&& exec, Scalar alpha, InOutObj x);
+  // [linalg.algs.blas1.copy], copy elements
+  template<in-object InObj, out-object OutObj>
+    void copy(InObj x, OutObj y);
+  template<class ExecutionPolicy, in-object InObj, out-object OutObj>
+    void copy(ExecutionPolicy&& exec, InObj x, OutObj y);
+  // [linalg.algs.blas1.add], add elementwise
+  template<in-object InObj1, in-object InObj2, out-object OutObj>
+    void add(InObj1 x, InObj2 y, OutObj z);
+  template<class ExecutionPolicy, in-object InObj1, in-object InObj2, out-object OutObj>
+    void add(ExecutionPolicy&& exec, InObj1 x, InObj2 y, OutObj z);
+  // [linalg.algs.blas1.dot], dot product of two vectors
+  template<in-vector InVec1, in-vector InVec2, class Scalar>
+    Scalar dot(InVec1 v1, InVec2 v2, Scalar init);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, class Scalar>
+    Scalar dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init);
+  template<in-vector InVec1, in-vector InVec2>
+    auto dot(InVec1 v1, InVec2 v2);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2>
+    auto dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2);
+  template<in-vector InVec1, in-vector InVec2, class Scalar>
+    Scalar dotc(InVec1 v1, InVec2 v2, Scalar init);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, class Scalar>
+    Scalar dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init);
+  template<in-vector InVec1, in-vector InVec2>
+    auto dotc(InVec1 v1, InVec2 v2);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2>
+    auto dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2);
+  // [linalg.algs.blas1.ssq], scaled sum of squares of a vector's elements
+  template<class Scalar>
+    struct sum_of_squares_result {
+      Scalar scaling_factor;
+      Scalar scaled_sum_of_squares;
+    };
+  template<in-vector InVec, class Scalar>
+    sum_of_squares_result<Scalar>
+      vector_sum_of_squares(InVec v, sum_of_squares_result<Scalar> init);
+  template<class ExecutionPolicy, in-vector InVec, class Scalar>
+    sum_of_squares_result<Scalar>
+      vector_sum_of_squares(ExecutionPolicy&& exec,
+                            InVec v, sum_of_squares_result<Scalar> init);
+  // [linalg.algs.blas1.nrm2], Euclidean norm of a vector
+  template<in-vector InVec, class Scalar>
+    Scalar vector_two_norm(InVec v, Scalar init);
+  template<class ExecutionPolicy, in-vector InVec, class Scalar>
+    Scalar vector_two_norm(ExecutionPolicy&& exec, InVec v, Scalar init);
+  template<in-vector InVec>
+    auto vector_two_norm(InVec v);
+  template<class ExecutionPolicy, in-vector InVec>
+    auto vector_two_norm(ExecutionPolicy&& exec, InVec v);
+  // [linalg.algs.blas1.asum], sum of absolute values of vector elements
+  template<in-vector InVec, class Scalar>
+    Scalar vector_abs_sum(InVec v, Scalar init);
+  template<class ExecutionPolicy, in-vector InVec, class Scalar>
+    Scalar vector_abs_sum(ExecutionPolicy&& exec, InVec v, Scalar init);
+  template<in-vector InVec>
+    auto vector_abs_sum(InVec v);
+  template<class ExecutionPolicy, in-vector InVec>
+    auto vector_abs_sum(ExecutionPolicy&& exec, InVec v);
+  // [linalg.algs.blas1.iamax], index of maximum absolute value of vector elements
+  template<in-vector InVec>
+    typename InVec::extents_type vector_idx_abs_max(InVec v);
+  template<class ExecutionPolicy, in-vector InVec>
+    typename InVec::extents_type vector_idx_abs_max(ExecutionPolicy&& exec, InVec v);
+  // [linalg.algs.blas1.matfrobnorm], Frobenius norm of a matrix
+  template<in-matrix InMat, class Scalar>
+    Scalar matrix_frob_norm(InMat A, Scalar init);
+  template<class ExecutionPolicy, in-matrix InMat, class Scalar>
+    Scalar matrix_frob_norm(ExecutionPolicy&& exec, InMat A, Scalar init);
+  template<in-matrix InMat>
+    auto matrix_frob_norm(InMat A);
+  template<class ExecutionPolicy, in-matrix InMat>
+    auto matrix_frob_norm(ExecutionPolicy&& exec, InMat A);
+  // [linalg.algs.blas1.matonenorm], one norm of a matrix
+  template<in-matrix InMat, class Scalar>
+    Scalar matrix_one_norm(InMat A, Scalar init);
+  template<class ExecutionPolicy, in-matrix InMat, class Scalar>
+    Scalar matrix_one_norm(ExecutionPolicy&& exec, InMat A, Scalar init);
+  template<in-matrix InMat>
+    auto matrix_one_norm(InMat A);
+  template<class ExecutionPolicy, in-matrix InMat>
+    auto matrix_one_norm(ExecutionPolicy&& exec, InMat A);
+  // [linalg.algs.blas1.matinfnorm], infinity norm of a matrix
+  template<in-matrix InMat, class Scalar>
+    Scalar matrix_inf_norm(InMat A, Scalar init);
+  template<class ExecutionPolicy, in-matrix InMat, class Scalar>
+    Scalar matrix_inf_norm(ExecutionPolicy&& exec, InMat A, Scalar init);
+  template<in-matrix InMat>
+    auto matrix_inf_norm(InMat A);
+  template<class ExecutionPolicy, in-matrix InMat>
+    auto matrix_inf_norm(ExecutionPolicy&& exec, InMat A);
+  // [linalg.algs.blas2], BLAS 2 algorithms
+  // [linalg.algs.blas2.gemv], general matrix-vector product
+  template<in-matrix InMat, in-vector InVec, out-vector OutVec>
+    void matrix_vector_product(InMat A, InVec x, OutVec y);
+  template<class ExecutionPolicy, in-matrix InMat, in-vector InVec, out-vector OutVec>
+    void matrix_vector_product(ExecutionPolicy&& exec, InMat A, InVec x, OutVec y);
+  template<in-matrix InMat, in-vector InVec1, in-vector InVec2, out-vector OutVec>
+    void matrix_vector_product(InMat A, InVec1 x, InVec2 y, OutVec z);
+  template<class ExecutionPolicy,
+           in-matrix InMat, in-vector InVec1, in-vector InVec2, out-vector OutVec>
+    void matrix_vector_product(ExecutionPolicy&& exec, InMat A, InVec1 x, InVec2 y, OutVec z);
+  // [linalg.algs.blas2.symv], symmetric matrix-vector product
+  template<in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec>
+    void symmetric_matrix_vector_product(InMat A, Triangle t, InVec x, OutVec y);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec>
+    void symmetric_matrix_vector_product(ExecutionPolicy&& exec,
+                                         InMat A, Triangle t, InVec x, OutVec y);
+  template<in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2,
+           out-vector OutVec>
+    void symmetric_matrix_vector_product(InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2,
+           out-vector OutVec>
+    void symmetric_matrix_vector_product(ExecutionPolicy&& exec,
+                                         InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z);
+  // [linalg.algs.blas2.hemv], Hermitian matrix-vector product
+  template<in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec>
+    void hermitian_matrix_vector_product(InMat A, Triangle t, InVec x, OutVec y);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec>
+    void hermitian_matrix_vector_product(ExecutionPolicy&& exec,
+                                         InMat A, Triangle t, InVec x, OutVec y);
+  template<in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2,
+           out-vector OutVec>
+    void hermitian_matrix_vector_product(InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2,
+           out-vector OutVec>
+    void hermitian_matrix_vector_product(ExecutionPolicy&& exec,
+                                         InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z);
+  // [linalg.algs.blas2.trmv], triangular matrix-vector product
+  // Overwriting triangular matrix-vector product
+  template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec,
+           out-vector OutVec>
+    void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d,
+                                          InVec x, OutVec y);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec,
+           out-vector OutVec>
+    void triangular_matrix_vector_product(ExecutionPolicy&& exec,
+                                          InMat A, Triangle t, DiagonalStorage d,
+                                          InVec x, OutVec y);
+  // In-place triangular matrix-vector product
+  template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec>
+    void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InOutVec y);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec>
+    void triangular_matrix_vector_product(ExecutionPolicy&& exec,
+                                          InMat A, Triangle t, DiagonalStorage d, InOutVec y);
+  // Updating triangular matrix-vector product
+  template<in-matrix InMat, class Triangle, class DiagonalStorage,
+           in-vector InVec1, in-vector InVec2, out-vector OutVec>
+    void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d,
+                                          InVec1 x, InVec2 y, OutVec z);
+  template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage,
+           in-vector InVec1, in-vector InVec2, out-vector OutVec>
+    void triangular_matrix_vector_product(ExecutionPolicy&& exec,
+                                          InMat A, Triangle t, DiagonalStorage d,
+                                          InVec1 x, InVec2 y, OutVec z);
+  // [linalg.algs.blas2.trsv], solve a triangular linear system
+  // Solve a triangular linear system, not in place
+  template<in-matrix InMat, class Triangle, class DiagonalStorage,
+           in-vector InVec, out-vector OutVec, class BinaryDivideOp>
+    void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d,
+                                        InVec b, OutVec x, BinaryDivideOp divide);
+  template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage,
+           in-vector InVec, out-vector OutVec, class BinaryDivideOp>
+    void triangular_matrix_vector_solve(ExecutionPolicy&& exec,
+                                        InMat A, Triangle t, DiagonalStorage d,
+                                        InVec b, OutVec x, BinaryDivideOp divide);
+  template<in-matrix InMat, class Triangle, class DiagonalStorage,
+           in-vector InVec, out-vector OutVec>
+    void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d,
+                                        InVec b, OutVec x);
+  template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage,
+           in-vector InVec, out-vector OutVec>
+    void triangular_matrix_vector_solve(ExecutionPolicy&& exec,
+                                        InMat A, Triangle t, DiagonalStorage d,
+                                        InVec b, OutVec x);
+  // Solve a triangular linear system, in place
+  template<in-matrix InMat, class Triangle, class DiagonalStorage,
+           inout-vector InOutVec, class BinaryDivideOp>
+    void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d,
+                                        InOutVec b, BinaryDivideOp divide);
+  template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage,
+           inout-vector InOutVec, class BinaryDivideOp>
+    void triangular_matrix_vector_solve(ExecutionPolicy&& exec,
+                                        InMat A, Triangle t, DiagonalStorage d,
+                                        InOutVec b, BinaryDivideOp divide);
+  template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec>
+    void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InOutVec b);
+  template<class ExecutionPolicy,
+           in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec>
+    void triangular_matrix_vector_solve(ExecutionPolicy&& exec,
+                                        InMat A, Triangle t, DiagonalStorage d, InOutVec b);
+  // [linalg.algs.blas2.rank1], nonsymmetric rank-1 matrix update
+  template<in-vector InVec1, in-vector InVec2, inout-matrix InOutMat>
+    void matrix_rank_1_update(InVec1 x, InVec2 y, InOutMat A);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, inout-matrix InOutMat>
+    void matrix_rank_1_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InOutMat A);
+  template<in-vector InVec1, in-vector InVec2, inout-matrix InOutMat>
+    void matrix_rank_1_update_c(InVec1 x, InVec2 y, InOutMat A);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, inout-matrix InOutMat>
+    void matrix_rank_1_update_c(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InOutMat A);
+  // [linalg.algs.blas2.symherrank1], symmetric or Hermitian rank-1 matrix update
+  template<class Scalar, in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_1_update(Scalar alpha, InVec x, InOutMat A, Triangle t);
+  template<class ExecutionPolicy,
+           class Scalar, in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec,
+                                        Scalar alpha, InVec x, InOutMat A, Triangle t);
+  template<in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_1_update(InVec x, InOutMat A, Triangle t);
+  template<class ExecutionPolicy,
+           in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec, InVec x, InOutMat A, Triangle t);
+  template<class Scalar, in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void hermitian_matrix_rank_1_update(Scalar alpha, InVec x, InOutMat A, Triangle t);
+  template<class ExecutionPolicy,
+           class Scalar, in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec,
+                                        Scalar alpha, InVec x, InOutMat A, Triangle t);
+  template<in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void hermitian_matrix_rank_1_update(InVec x, InOutMat A, Triangle t);
+  template<class ExecutionPolicy,
+           in-vector InVec, possibly-packed-inout-matrix InOutMat, class Triangle>
+    void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec, InVec x, InOutMat A, Triangle t);
+  // [linalg.algs.blas2.rank2], symmetric and Hermitian rank-2 matrix updates
+  // symmetric rank-2 matrix update
+  template<in-vector InVec1, in-vector InVec2,
+           possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_2_update(InVec1 x, InVec2 y, InOutMat A, Triangle t);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2,
+           possibly-packed-inout-matrix InOutMat, class Triangle>
+    void symmetric_matrix_rank_2_update(ExecutionPolicy&& exec,
+                                        InVec1 x, InVec2 y, InOutMat A, Triangle t);
+  // Hermitian rank-2 matrix update
+  template<in-vector InVec1, in-vector InVec2,
+           possibly-packed-inout-matrix InOutMat, class Triangle>
+    void hermitian_matrix_rank_2_update(InVec1 x, InVec2 y, InOutMat A, Triangle t);
+  template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2,
+           possibly-packed-inout-matrix InOutMat, class Triangle>
+    void hermitian_matrix_rank_2_update(ExecutionPolicy&& exec,
+                                        InVec1 x, InVec2 y, InOutMat A, Triangle t);
+  // [linalg.algs.blas3], BLAS 3 algorithms
+  // [linalg.algs.blas3.gemm], general matrix-matrix product
+  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);
+  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);
+  // [linalg.algs.blas3.xxmm], symmetric, Hermitian, and triangular matrix-matrix product
+  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);
+  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);
+  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);
+  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);
+  // [linalg.algs.blas3.trmm], in-place triangular matrix-matrix product
+  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);
+  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);
+  // [linalg.algs.blas3.rankk], rank-k update of a symmetric or Hermitian matrix
+  // rank-k symmetric matrix update
+  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);
+  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);
+  // rank-k Hermitian matrix update
+  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);
+  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);
+  // [linalg.algs.blas3.rank2k], rank-2k update of a symmetric or Hermitian matrix
+  // rank-2k symmetric matrix update
+  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);
+  // rank-2k Hermitian matrix update
+  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);
+  // [linalg.algs.blas3.trsm], solve multiple triangular linear systems
+  // solve multiple triangular systems on the left, not-in-place
+  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);
+  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);
+  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);
+  // solve multiple triangular systems on the right, not-in-place
+  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);
+  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);
+  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);
+  // solve multiple triangular systems on the left, in-place
+  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);
+  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);
+  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);
+  // solve multiple triangular systems on the right, in-place
+  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);
+  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);
+  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);
+}
+```

Diff to HTML by rtfpessoa