Detailed Description

Batched linear algebra operations.

Topics
	FLOP counts
	Theoretical floating point operation counts for linear algebra operations.

Compression of masks containing zeros
template<index_t N = 8, simdifiable VA, simdifiable VS, simdifiable VAo, simdifiable VSo>
index_t	batmat::linalg::compress_masks (VA &&Ain, VS &&Sin, VAo &&Aout, VSo &&Sout)
template<index_t N = 8, simdifiable VS>
index_t	batmat::linalg::compress_masks_count (VS &&Sin)
template<index_t N = 8, simdifiable VA, simdifiable VS, simdifiable VAo>
index_t	batmat::linalg::compress_masks_sqrt (VA &&Ain, VS &&Sin, VAo &&Aout)
template<index_t N = 8, simdifiable VA, simdifiable VS, simdifiable VAo, simdifiable VSo>
index_t	batmat::linalg::compress_masks_sqrt (VA &&Ain, VS &&Sin, VAo &&Aout, VSo &&Sout)

Copying and filling batches of matrices
template<simdifiable VA, simdifiable VB, rotate_opt... Opts>
void	batmat::linalg::copy (VA &&A, VB &&B, Opts... opts)
	B = A.
template<MatrixStructure S, simdifiable VA, simdifiable VB, rotate_opt... Opts>
void	batmat::linalg::copy (Structured< VA, S > A, Structured< VB, S > B, Opts... opts)
	B = A.
template<simdifiable VB>
void	batmat::linalg::fill (simdified_value_t< VB > a, VB &&B)
	B = a.
template<MatrixStructure S, simdifiable VB>
void	batmat::linalg::fill (simdified_value_t< VB > a, Structured< VB, S > B)
	B = a.

Multiplication of batches of matrices with diagonal scaling
template<simdifiable VA, simdifiable VB, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::gemm_diag (VA &&A, VB &&B, VD &&D, Vd &&d, Opts... opts)
	D = A diag(d) B.
template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::gemm_diag_add (VA &&A, VB &&B, VC &&C, VD &&D, Vd &&d, Opts... opts)
	D = C + A diag(d) B.
template<simdifiable VA, simdifiable VB, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::gemm_diag_add (VA &&A, VB &&B, VD &&D, Vd &&d, Opts... opts)
	D += A diag(d) B.
template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::gemm_diag_sub (VA &&A, VB &&B, VC &&C, VD &&D, Vd &&d, Opts... opts)
	D = C - A diag(d) B.
template<simdifiable VA, simdifiable VB, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::gemm_diag_sub (VA &&A, VB &&B, VD &&D, Vd &&d, Opts... opts)
	D -= A diag(d) B.
template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::syrk_diag (VA &&A, Structured< VD, SC > D, Vd &&d, Opts... opts)
	D = A diag(d) Aᵀ with D symmetric.
template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::syrk_diag_add (VA &&A, Structured< VC, SC > C, Structured< VD, SC > D, Vd &&d, Opts... opts)
	D = C + A diag(d) Aᵀ with C, D symmetric.
template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::syrk_diag_add (VA &&A, Structured< VD, SC > D, Vd &&d, Opts... opts)
	D += A diag(d) Aᵀ with D symmetric.
template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::syrk_diag_sub (VA &&A, Structured< VC, SC > C, Structured< VD, SC > D, Vd &&d, Opts... opts)
	D = C - A diag(d) Aᵀ with C, D symmetric.
template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>
void	batmat::linalg::syrk_diag_sub (VA &&A, Structured< VD, SC > D, Vd &&d, Opts... opts)
	D -= A diag(d) Aᵀ with D symmetric.

Multiplication of batches of general matrices
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemm (VA &&A, VB &&B, VD &&D, TilingOptions packing={}, Opts... opts)
	D = A B.
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemm_neg (VA &&A, VB &&B, VD &&D, TilingOptions packing={}, Opts... opts)
	D = -A B.
template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemm_add (VA &&A, VB &&B, VC &&C, VD &&D, TilingOptions packing={}, Opts... opts)
	D = C + A B.
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemm_add (VA &&A, VB &&B, VD &&D, TilingOptions packing={}, Opts... opts)
	D += A B.
template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemm_sub (VA &&A, VB &&B, VC &&C, VD &&D, TilingOptions packing={}, Opts... opts)
	D = C - A B.
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemm_sub (VA &&A, VB &&B, VD &&D, TilingOptions packing={}, Opts... opts)
	D -= A B.

Multiplication of batches of matrices with symmetric results
template<MatrixStructure SA, MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk (Structured< VA, SA > A, Structured< VD, SD > D, Opts... opts)
	D = A Aᵀ with D symmetric.
template<MatrixStructure SD, class TA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk (TA &&A, Structured< VD, SD > D, Opts... opts)
	D = A Aᵀ with D symmetric.
template<MatrixStructure SD, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk (Structured< VD, SD > D, Opts... opts)
	D = D Dᵀ with D triangular on input and symmetric on output.
template<MatrixStructure SA, MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_neg (Structured< VA, SA > A, Structured< VD, SD > D, Opts... opts)
	D = -A Aᵀ with D symmetric.
template<MatrixStructure SD, class TA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_neg (TA &&A, Structured< VD, SD > D, Opts... opts)
	D = A Aᵀ with D symmetric.
template<MatrixStructure SD, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_neg (Structured< VD, SD > D, Opts... opts)
	D = -D Dᵀ with D triangular on input and symmetric on output.
template<MatrixStructure SD, simdifiable VA, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_add (VA &&A, Structured< VC, SD > C, Structured< VD, SD > D, Opts... opts)
	D = C + A Aᵀ with C, D symmetric.
template<MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_add (VA &&A, Structured< VD, SD > D, Opts... opts)
	D += A Aᵀ with D symmetric.
template<MatrixStructure SD, simdifiable VA, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_sub (VA &&A, Structured< VC, SD > C, Structured< VD, SD > D, Opts... opts)
	D = C - A Aᵀ with C, D symmetric.
template<MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::syrk_sub (VA &&A, Structured< VD, SD > D, Opts... opts)
	D -= A Aᵀ with D symmetric.

Multiplication of batches of triangular matrices
template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::trmm (Structured< VA, SA > A, Structured< VB, SB > B, Structured< VD, SD > D, Opts... opts)
	D = A B with A and/or B triangular.
template<class TA, class TB, class TD, shift_opt... Opts>
void	batmat::linalg::trmm (TA &&A, TB &&B, TD &&D, Opts... opts)
	D = A B with A and/or B triangular.
template<MatrixStructure SA, simdifiable VA, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::trmm (Structured< VA, SA > A, VD &&D, Opts... opts)
	D = A D with A triangular.
template<MatrixStructure SB, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::trmm (VD &&D, Structured< VB, SB > B, Opts... opts)
	D = D B with B triangular.
template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::trmm_neg (Structured< VA, SA > A, Structured< VB, SB > B, Structured< VD, SD > D, Opts... opts)
	D = -A B with A and/or B triangular.
template<class TA, class TB, class TD, shift_opt... Opts>
void	batmat::linalg::trmm_neg (TA &&A, TB &&B, TD &&D, Opts... opts)
	D = -A B with A and/or B triangular.
template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::trmm_add (Structured< VA, SA > A, Structured< VB, SB > B, Structured< VC, SD > C, Structured< VD, SD > D, Opts... opts)
	D = C + A B with A and/or B triangular.
template<class TA, class TB, class TC, class TD, shift_opt... Opts>
void	batmat::linalg::trmm_add (TA &&A, TB &&B, TC &&C, TD &&D, Opts... opts)
	D = C + A B with A and/or B triangular.
template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::trmm_sub (Structured< VA, SA > A, Structured< VB, SB > B, Structured< VC, SD > C, Structured< VD, SD > D, Opts... opts)
	D = C - A B with A and/or B triangular.
template<class TA, class TB, class TC, class TD, shift_opt... Opts>
void	batmat::linalg::trmm_sub (TA &&A, TB &&B, TC &&C, TD &&D, Opts... opts)
	D = C - A B with A and/or B triangular.

Matrix-vector multiplication of batches of matrices
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemv (VA &&A, VB &&B, VD &&D, Opts... opts)
	d = A b
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemv_neg (VA &&A, VB &&B, VD &&D, Opts... opts)
	d = -A b
template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemv_add (VA &&A, VB &&B, VC &&C, VD &&D, Opts... opts)
	d = c + A b
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemv_add (VA &&A, VB &&B, VD &&D, Opts... opts)
	d = d + A b
template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemv_sub (VA &&A, VB &&B, VC &&C, VD &&D, Opts... opts)
	d = c - A b
template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>
void	batmat::linalg::gemv_sub (VA &&A, VB &&B, VD &&D, Opts... opts)
	d = d - A b

Cholesky factorization updates
template<MatrixStructure SL, simdifiable VL, simdifiable VA, simdifiable Vd>
void	batmat::linalg::hyhound_diag (Structured< VL, SL > L, VA &&A, Vd &&d)
	Update Cholesky factor L using low-rank term A diag(d) Aᵀ.
template<MatrixStructure SL, simdifiable VL, simdifiable VA, simdifiable Vd, simdifiable VW>
void	batmat::linalg::hyhound_diag (Structured< VL, SL > L, VA &&A, Vd &&d, VW &&W)
	Update Cholesky factor L using low-rank term A diag(d) Aᵀ, with full Householder representation.
template<MatrixStructure SL, simdifiable VL>
auto	batmat::linalg::hyhound_size_W (Structured< VL, SL > L)
	Get the size of the storage for the matrix W returned by hyhound_diag(Structured<VL,SL>, VA&&, Vd&&, VW&&).
template<simdifiable VL, simdifiable VA, simdifiable VD, simdifiable VB, simdifiable Vd, simdifiable VW>
void	batmat::linalg::hyhound_diag_apply (VL &&L, VA &&A, VD &&D, VB &&B, Vd &&d, VW &&W, index_t kA_in_offset=0)
	Apply Householder transformation generated by hyhound_diag, computing (L̃, D) = (L, A) Q̆.
template<simdifiable VL, simdifiable VA, simdifiable VB, simdifiable Vd, simdifiable VW>
void	batmat::linalg::hyhound_diag_apply (VL &&L, VA &&A, VB &&B, Vd &&d, VW &&W)
	Apply Householder transformation generated by hyhound_diag, computing (L̃, Ã) = (L, A) Q̆.
template<MatrixStructure SL, simdifiable VL, simdifiable VA, simdifiable Vd>
void	batmat::linalg::hyhound_sign (Structured< VL, SL > L, VA &&A, Vd &&d)
	Update Cholesky factor L using low-rank term A diag(copysign(1, d)) Aᵀ, where d contains only ±0 values.
template<MatrixStructure SL, simdifiable VL1, simdifiable VA1, simdifiable VL2, simdifiable VA2, simdifiable Vd>
void	batmat::linalg::hyhound_diag_2 (Structured< VL1, SL > L1, VA1 &&A1, VL2 &&L2, VA2 &&A2, Vd &&d)
	Update Cholesky factor L using low-rank term A diag(d) Aᵀ, where L and A are stored as two separate block rows.
template<MatrixStructure SL, simdifiable VL11, simdifiable VA1, simdifiable VL21, simdifiable VA2, simdifiable VA2o, simdifiable VU, simdifiable VA3, simdifiable VA3o, simdifiable Vd>
void	batmat::linalg::hyhound_diag_cyclic (Structured< VL11, SL > L11, VA1 &&A1, VL21 &&L21, VA2 &&A22, VA2o &&A2_out, VU &&L31, VA3 &&A31, VA3o &&A3_out, Vd &&d)
	Update structured Cholesky factor L using structured low-rank term A diag(d) Aᵀ,.
template<MatrixStructure SL, simdifiable VL11, simdifiable VA1, simdifiable VL21, simdifiable VA2, simdifiable VA2o, simdifiable VLu1, simdifiable VAuo, simdifiable Vd>
void	batmat::linalg::hyhound_diag_riccati (Structured< VL11, SL > L11, VA1 &&A1, VL21 &&L21, VA2 &&A2, VA2o &&A2_out, VLu1 &&Lu1, VAuo &&Au_out, Vd &&d, bool shift_A_out=false)
	Update structured Cholesky factor L using structured low-rank term A diag(d) Aᵀ,.

Cholesky factorization of batches of matrices
template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD>
void	batmat::linalg::syrk_add_potrf (VA &&A, Structured< VC, SC > C, Structured< VD, SC > D, simdified_value_t< VA > regularization=0)
	D = chol(C + AAᵀ) with C symmetric, D triangular.
template<MatrixStructure SC, simdifiable VA, simdifiable VD>
void	batmat::linalg::syrk_add_potrf (VA &&A, Structured< VD, SC > D)
	D = chol(D + AAᵀ) with D symmetric/triangular.
template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD>
void	batmat::linalg::syrk_sub_potrf (VA &&A, Structured< VC, SC > C, Structured< VD, SC > D, simdified_value_t< VA > regularization=0)
	D = chol(C - AAᵀ) with C symmetric, D triangular.
template<MatrixStructure SC, simdifiable VA, simdifiable VD>
void	batmat::linalg::syrk_sub_potrf (VA &&A, Structured< VD, SC > D, simdified_value_t< VA > regularization=0)
	D = chol(D - AAᵀ) with D symmetric/triangular.
template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD, simdifiable Vd>
void	batmat::linalg::syrk_diag_add_potrf (VA &&A, Structured< VC, SC > C, Structured< VD, SC > D, Vd &&d, simdified_value_t< VA > regularization=0)
	D = chol(C + A diag(d) Aᵀ) with C symmetric, D triangular.
template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd>
void	batmat::linalg::syrk_diag_add_potrf (VA &&A, Structured< VD, SC > D, Vd &&d)
	D = chol(D + A diag(d) Aᵀ) with D symmetric/triangular.
template<MatrixStructure SC, simdifiable VC, simdifiable VD>
void	batmat::linalg::potrf (Structured< VC, SC > C, Structured< VD, SC > D, simdified_value_t< VC > regularization=0)
	D = chol(C) with C symmetric, D triangular.
template<MatrixStructure SD, simdifiable VD>
void	batmat::linalg::potrf (Structured< VD, SD > D, simdified_value_t< VD > regularization=0)
	D = chol(D) with D symmetric/triangular.

Symmetric multiplication of batches of matrices
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD>
void	batmat::linalg::symm_add (Structured< VA, SA > A, VB &&B, VC &&C, VD &&D)
	D = C + A B with A symmetric.
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::symm_add (Structured< VA, SA > A, VB &&B, VD &&D)
	D = D + A B with A symmetric.

Symmetric matrix-vector multiplication of batches of matrices
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::symv (Structured< VA, SA > A, VB &&B, VD &&D)
	d = A b where A is symmetric
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::symv_neg (Structured< VA, SA > A, VB &&B, VD &&D)
	d = -A b where A is symmetric
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD>
void	batmat::linalg::symv_add (Structured< VA, SA > A, VB &&B, VC &&C, VD &&D)
	d = c + A b where A is symmetric
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::symv_add (Structured< VA, SA > A, VB &&B, VD &&D)
	d = d + A b where A is symmetric
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD>
void	batmat::linalg::symv_sub (Structured< VA, SA > A, VB &&B, VC &&C, VD &&D)
	d = c - A b where A is symmetric
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::symv_sub (Structured< VA, SA > A, VB &&B, VD &&D)
	d = d - A b where A is symmetric

Symmetric matrix-vector multiplication of a block tridiagonal matrix
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::syomv (Structured< VA, SA > A, VB &&B, VD &&D)
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>
void	batmat::linalg::syomv_neg (Structured< VA, SA > A, VB &&B, VD &&D)

Triangular views of batches of matrices
template<class M>
constexpr auto	batmat::linalg::tril (M &&m)
	Lower-triangular view.
template<class M>
constexpr auto	batmat::linalg::triu (M &&m)
	Upper-triangular view.
template<MatrixStructure S, class M>
constexpr auto	batmat::linalg::make_structured (M &&m)
	View with the given structure.

Triangular solve of batches of matrices
template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD, int RotB = 0>
void	batmat::linalg::trsm (Structured< VA, SA > A, VB &&B, VD &&D, with_rotate_B_t< RotB >={})
	D = A⁻¹ B with A triangular.
template<MatrixStructure SA, simdifiable VA, simdifiable VD, int RotB = 0>
void	batmat::linalg::trsm (Structured< VA, SA > A, VD &&D, with_rotate_B_t< RotB > shift={})
	D = A⁻¹ D with A triangular.
template<MatrixStructure SB, simdifiable VA, simdifiable VB, simdifiable VD, int RotA = 0>
void	batmat::linalg::trsm (VA &&A, Structured< VB, SB > B, VD &&D, with_rotate_A_t< RotA >={})
	D = A B⁻¹ with B triangular.
template<MatrixStructure SB, simdifiable VB, simdifiable VD, int RotA = 0>
void	batmat::linalg::trsm (VD &&D, Structured< VB, SB > B, with_rotate_A_t< RotA > shift={})
	D = D B⁻¹ with B triangular.

Triangular inversion of batches of matrices
template<simdifiable VA, simdifiable VD>
void	batmat::linalg::trtri (Structured< VA, MatrixStructure::LowerTriangular > A, Structured< VD, MatrixStructure::LowerTriangular > D)
	D = A⁻¹ with A, D lower triangular.
template<simdifiable VA, simdifiable VD>
void	batmat::linalg::trtri (Structured< VA, MatrixStructure::UpperTriangular > A, Structured< VD, MatrixStructure::UpperTriangular > D)
	D = A⁻¹ with A, D upper triangular.
template<simdifiable VD>
void	batmat::linalg::trtri (Structured< VD, MatrixStructure::LowerTriangular > D)
	D = D⁻¹ with D lower triangular.
template<simdifiable VD>
void	batmat::linalg::trtri (Structured< VD, MatrixStructure::UpperTriangular > D)
	D = D⁻¹ with D upper triangular.

Classes
struct	batmat::linalg::TilingOptions
	Packing and tiling options for matrix-matrix multiplication. More...
struct	batmat::linalg::Structured< M, S >
	Light-weight wrapper class used for overload resolution of triangular and symmetric matrices. More...

Enumerations
enum class	batmat::linalg::PackingSelector : int8_t { batmat::linalg::PackingSelector::Never , batmat::linalg::PackingSelector::Always , batmat::linalg::PackingSelector::Transpose }
	Decides which matrices to pack during large matrix-matrix multiplication. More...
enum class	batmat::linalg::MatrixStructure : int8_t { batmat::linalg::MatrixStructure::General , batmat::linalg::MatrixStructure::LowerTriangular , batmat::linalg::MatrixStructure::UpperTriangular }

Functions
constexpr MatrixStructure	batmat::linalg::transpose (MatrixStructure s)
template<class M>
	batmat::linalg::Structured (M &&) -> Structured< M >

Class Documentation

◆ batmat::linalg::TilingOptions

struct batmat::linalg::TilingOptions

Class Members
bool	no_tiling = false	Don't use cache tiling.
PackingSelector	pack_A = PackingSelector::Transpose	When to pack matrix A.
PackingSelector	pack_B = PackingSelector::Always	When to pack matrix B.
index_t	n_c = 0	Cache block size in the N dimension (columns of B, C and D).
index_t	k_c = 0	Cache block size in the K dimension (columns of A, rows of B).
index_t	m_c = 0	Cache block size in the M dimension (rows of A, C and D).

Enumeration Type Documentation

◆ PackingSelector

enum class batmat::linalg::PackingSelector : int8_t

strong

#include <batmat/linalg/gemm.hpp>

Decides which matrices to pack during large matrix-matrix multiplication.

Enumerator
Never	Access the original matrices directly in the micro-kernels.
Always	Always pack the blocks of the matrix in a contiguous workspace.
Transpose	Pack the blocks of the matrix only if it is not in the optimal storage order.

Definition at line 20 of file gemm.hpp.

◆ MatrixStructure

enum class batmat::linalg::MatrixStructure : int8_t

strong

#include <batmat/linalg/structure.hpp>

Enumerator
General
LowerTriangular
UpperTriangular

Definition at line 8 of file structure.hpp.

Function Documentation

◆ compress_masks()

template<index_t N = 8, simdifiable VA, simdifiable VS, simdifiable VAo, simdifiable VSo>

index_t batmat::linalg::compress_masks	(	VA &&	Ain,
		VS &&	Sin,
		VAo &&	Aout,
		VSo &&	Sout )

#include <batmat/linalg/compress.hpp>

Definition at line 240 of file compress.hpp.

◆ compress_masks_count()

template<index_t N = 8, simdifiable VS>

index_t batmat::linalg::compress_masks_count ( VS && Sin )

#include <batmat/linalg/compress.hpp>

Definition at line 246 of file compress.hpp.

◆ compress_masks_sqrt() [1/2]

template<index_t N = 8, simdifiable VA, simdifiable VS, simdifiable VAo>

index_t batmat::linalg::compress_masks_sqrt	(	VA &&	Ain,
		VS &&	Sin,
		VAo &&	Aout )

#include <batmat/linalg/compress.hpp>

Definition at line 252 of file compress.hpp.

◆ compress_masks_sqrt() [2/2]

template<index_t N = 8, simdifiable VA, simdifiable VS, simdifiable VAo, simdifiable VSo>

index_t batmat::linalg::compress_masks_sqrt	(	VA &&	Ain,
		VS &&	Sin,
		VAo &&	Aout,
		VSo &&	Sout )

#include <batmat/linalg/compress.hpp>

Definition at line 258 of file compress.hpp.

◆ copy() [1/2]

template<simdifiable VA, simdifiable VB, rotate_opt... Opts>

void batmat::linalg::copy	(	VA &&	A,
		VB &&	B,
		Opts...	opts )

#include <batmat/linalg/copy.hpp>

B = A.

Definition at line 187 of file copy.hpp.

◆ copy() [2/2]

template<MatrixStructure S, simdifiable VA, simdifiable VB, rotate_opt... Opts>

void batmat::linalg::copy	(	Structured< VA, S >	A,
		Structured< VB, S >	B,
		Opts...	opts )

#include <batmat/linalg/copy.hpp>

B = A.

Definition at line 196 of file copy.hpp.

◆ fill() [1/2]

template<simdifiable VB>

void batmat::linalg::fill	(	simdified_value_t< VB >	a,
		VB &&	B )

#include <batmat/linalg/copy.hpp>

B = a.

Examples: example.cpp.

Definition at line 204 of file copy.hpp.

◆ fill() [2/2]

template<MatrixStructure S, simdifiable VB>

void batmat::linalg::fill	(	simdified_value_t< VB >	a,
		Structured< VB, S >	B )

#include <batmat/linalg/copy.hpp>

B = a.

Definition at line 210 of file copy.hpp.

◆ gemm_diag()

template<simdifiable VA, simdifiable VB, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::gemm_diag	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D = A diag(d) B.

Definition at line 93 of file gemm-diag.hpp.

◆ gemm_diag_add() [1/2]

template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::gemm_diag_add	(	VA &&	A,
		VB &&	B,
		VC &&	C,
		VD &&	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D = C + A diag(d) B.

Definition at line 104 of file gemm-diag.hpp.

◆ gemm_diag_add() [2/2]

template<simdifiable VA, simdifiable VB, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::gemm_diag_add	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D += A diag(d) B.

Definition at line 114 of file gemm-diag.hpp.

◆ gemm_diag_sub() [1/2]

template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::gemm_diag_sub	(	VA &&	A,
		VB &&	B,
		VC &&	C,
		VD &&	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D = C - A diag(d) B.

Definition at line 122 of file gemm-diag.hpp.

◆ gemm_diag_sub() [2/2]

template<simdifiable VA, simdifiable VB, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::gemm_diag_sub	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D -= A diag(d) B.

Definition at line 132 of file gemm-diag.hpp.

◆ syrk_diag()

template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::syrk_diag	(	VA &&	A,
		Structured< VD, SC >	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D = A diag(d) Aᵀ with D symmetric.

Definition at line 140 of file gemm-diag.hpp.

◆ syrk_diag_add() [1/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::syrk_diag_add	(	VA &&	A,
		Structured< VC, SC >	C,
		Structured< VD, SC >	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D = C + A diag(d) Aᵀ with C, D symmetric.

Definition at line 154 of file gemm-diag.hpp.

◆ syrk_diag_add() [2/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::syrk_diag_add	(	VA &&	A,
		Structured< VD, SC >	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D += A diag(d) Aᵀ with D symmetric.

Definition at line 166 of file gemm-diag.hpp.

◆ syrk_diag_sub() [1/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::syrk_diag_sub	(	VA &&	A,
		Structured< VC, SC >	C,
		Structured< VD, SC >	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D = C - A diag(d) Aᵀ with C, D symmetric.

Definition at line 174 of file gemm-diag.hpp.

◆ syrk_diag_sub() [2/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd, detail::gemm_diag::track_zeros_opt... Opts>

void batmat::linalg::syrk_diag_sub	(	VA &&	A,
		Structured< VD, SC >	D,
		Vd &&	d,
		Opts...	opts )

#include <batmat/linalg/gemm-diag.hpp>

D -= A diag(d) Aᵀ with D symmetric.

Definition at line 186 of file gemm-diag.hpp.

◆ gemm()

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemm	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		TilingOptions	packing = {},
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A B.

Definition at line 255 of file gemm.hpp.

◆ gemm_neg()

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemm_neg	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		TilingOptions	packing = {},
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = -A B.

Definition at line 265 of file gemm.hpp.

◆ gemm_add() [1/2]

template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemm_add	(	VA &&	A,
		VB &&	B,
		VC &&	C,
		VD &&	D,
		TilingOptions	packing = {},
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C + A B.

Definition at line 275 of file gemm.hpp.

◆ gemm_add() [2/2]

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemm_add	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		TilingOptions	packing = {},
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D += A B.

Definition at line 283 of file gemm.hpp.

◆ gemm_sub() [1/2]

template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemm_sub	(	VA &&	A,
		VB &&	B,
		VC &&	C,
		VD &&	D,
		TilingOptions	packing = {},
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C - A B.

Definition at line 290 of file gemm.hpp.

◆ gemm_sub() [2/2]

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemm_sub	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		TilingOptions	packing = {},
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D -= A B.

Definition at line 298 of file gemm.hpp.

◆ syrk() [1/3]

template<MatrixStructure SA, MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk	(	Structured< VA, SA >	A,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A Aᵀ with D symmetric.

Examples: example.cpp.

Definition at line 310 of file gemm.hpp.

◆ syrk() [2/3]

template<MatrixStructure SD, class TA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk	(	TA &&	A,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A Aᵀ with D symmetric.

Definition at line 323 of file gemm.hpp.

◆ syrk() [3/3]

template<MatrixStructure SD, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk	(	Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = D Dᵀ with D triangular on input and symmetric on output.

Definition at line 329 of file gemm.hpp.

◆ syrk_neg() [1/3]

template<MatrixStructure SA, MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_neg	(	Structured< VA, SA >	A,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = -A Aᵀ with D symmetric.

Definition at line 343 of file gemm.hpp.

◆ syrk_neg() [2/3]

template<MatrixStructure SD, class TA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_neg	(	TA &&	A,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A Aᵀ with D symmetric.

Definition at line 356 of file gemm.hpp.

◆ syrk_neg() [3/3]

template<MatrixStructure SD, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_neg	(	Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = -D Dᵀ with D triangular on input and symmetric on output.

Definition at line 362 of file gemm.hpp.

◆ syrk_add() [1/2]

template<MatrixStructure SD, simdifiable VA, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_add	(	VA &&	A,
		Structured< VC, SD >	C,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C + A Aᵀ with C, D symmetric.

Definition at line 376 of file gemm.hpp.

◆ syrk_add() [2/2]

template<MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_add	(	VA &&	A,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D += A Aᵀ with D symmetric.

Definition at line 386 of file gemm.hpp.

◆ syrk_sub() [1/2]

template<MatrixStructure SD, simdifiable VA, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_sub	(	VA &&	A,
		Structured< VC, SD >	C,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C - A Aᵀ with C, D symmetric.

Definition at line 393 of file gemm.hpp.

◆ syrk_sub() [2/2]

template<MatrixStructure SD, simdifiable VA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::syrk_sub	(	VA &&	A,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D -= A Aᵀ with D symmetric.

Definition at line 403 of file gemm.hpp.

◆ trmm() [1/4]

template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::trmm	(	Structured< VA, SA >	A,
		Structured< VB, SB >	B,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A B with A and/or B triangular.

Definition at line 416 of file gemm.hpp.

◆ trmm() [2/4]

template<class TA, class TB, class TD, shift_opt... Opts>

void batmat::linalg::trmm	(	TA &&	A,
		TB &&	B,
		TD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A B with A and/or B triangular.

Definition at line 425 of file gemm.hpp.

◆ trmm() [3/4]

template<MatrixStructure SA, simdifiable VA, simdifiable VD, shift_opt... Opts>

void batmat::linalg::trmm	(	Structured< VA, SA >	A,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = A D with A triangular.

Definition at line 431 of file gemm.hpp.

◆ trmm() [4/4]

template<MatrixStructure SB, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::trmm	(	VD &&	D,
		Structured< VB, SB >	B,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = D B with B triangular.

Definition at line 436 of file gemm.hpp.

◆ trmm_neg() [1/2]

template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::trmm_neg	(	Structured< VA, SA >	A,
		Structured< VB, SB >	B,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = -A B with A and/or B triangular.

Definition at line 444 of file gemm.hpp.

◆ trmm_neg() [2/2]

template<class TA, class TB, class TD, shift_opt... Opts>

void batmat::linalg::trmm_neg	(	TA &&	A,
		TB &&	B,
		TD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = -A B with A and/or B triangular.

Definition at line 453 of file gemm.hpp.

◆ trmm_add() [1/2]

template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::trmm_add	(	Structured< VA, SA >	A,
		Structured< VB, SB >	B,
		Structured< VC, SD >	C,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C + A B with A and/or B triangular.

Definition at line 462 of file gemm.hpp.

◆ trmm_add() [2/2]

template<class TA, class TB, class TC, class TD, shift_opt... Opts>

void batmat::linalg::trmm_add	(	TA &&	A,
		TB &&	B,
		TC &&	C,
		TD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C + A B with A and/or B triangular.

Definition at line 472 of file gemm.hpp.

◆ trmm_sub() [1/2]

template<MatrixStructure SA, MatrixStructure SB, MatrixStructure SD, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::trmm_sub	(	Structured< VA, SA >	A,
		Structured< VB, SB >	B,
		Structured< VC, SD >	C,
		Structured< VD, SD >	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C - A B with A and/or B triangular.

Definition at line 481 of file gemm.hpp.

◆ trmm_sub() [2/2]

template<class TA, class TB, class TC, class TD, shift_opt... Opts>

void batmat::linalg::trmm_sub	(	TA &&	A,
		TB &&	B,
		TC &&	C,
		TD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemm.hpp>

D = C - A B with A and/or B triangular.

Definition at line 491 of file gemm.hpp.

◆ gemv()

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemv	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemv.hpp>

d = A b

Definition at line 73 of file gemv.hpp.

◆ gemv_neg()

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemv_neg	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemv.hpp>

d = -A b

Definition at line 83 of file gemv.hpp.

◆ gemv_add() [1/2]

template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemv_add	(	VA &&	A,
		VB &&	B,
		VC &&	C,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemv.hpp>

d = c + A b

Definition at line 93 of file gemv.hpp.

◆ gemv_add() [2/2]

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemv_add	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemv.hpp>

d = d + A b

Definition at line 101 of file gemv.hpp.

◆ gemv_sub() [1/2]

template<simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemv_sub	(	VA &&	A,
		VB &&	B,
		VC &&	C,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemv.hpp>

d = c - A b

Definition at line 108 of file gemv.hpp.

◆ gemv_sub() [2/2]

template<simdifiable VA, simdifiable VB, simdifiable VD, shift_opt... Opts>

void batmat::linalg::gemv_sub	(	VA &&	A,
		VB &&	B,
		VD &&	D,
		Opts...	opts )

#include <batmat/linalg/gemv.hpp>

d = d - A b

Definition at line 116 of file gemv.hpp.

◆ hyhound_diag() [1/2]

template<MatrixStructure SL, simdifiable VL, simdifiable VA, simdifiable Vd>

void batmat::linalg::hyhound_diag	(	Structured< VL, SL >	L,
		VA &&	A,
		Vd &&	d )

#include <batmat/linalg/hyhound.hpp>

Update Cholesky factor L using low-rank term A diag(d) Aᵀ.

Definition at line 152 of file hyhound.hpp.

◆ hyhound_diag() [2/2]

template<MatrixStructure SL, simdifiable VL, simdifiable VA, simdifiable Vd, simdifiable VW>

void batmat::linalg::hyhound_diag	(	Structured< VL, SL >	L,
		VA &&	A,
		Vd &&	d,
		VW &&	W )

#include <batmat/linalg/hyhound.hpp>

Update Cholesky factor L using low-rank term A diag(d) Aᵀ, with full Householder representation.

Definition at line 161 of file hyhound.hpp.

◆ hyhound_size_W()

template<MatrixStructure SL, simdifiable VL>

auto batmat::linalg::hyhound_size_W ( Structured< VL, SL > L )

#include <batmat/linalg/hyhound.hpp>

Get the size of the storage for the matrix W returned by hyhound_diag(Structured<VL,SL>, VA&&, Vd&&, VW&&).

Definition at line 170 of file hyhound.hpp.

◆ hyhound_diag_apply() [1/2]

template<simdifiable VL, simdifiable VA, simdifiable VD, simdifiable VB, simdifiable Vd, simdifiable VW>

void batmat::linalg::hyhound_diag_apply	(	VL &&	L,
		VA &&	A,
		VD &&	D,
		VB &&	B,
		Vd &&	d,
		VW &&	W,
		index_t	kA_in_offset = 0 )

#include <batmat/linalg/hyhound.hpp>

Apply Householder transformation generated by hyhound_diag, computing (L̃, D) = (L, A) Q̆.

Parameters

[in,out]	L	Part of the Cholesky factor to be updated (rectangular). Overwritten by L̃.
[in]	A	Update matrix (rectangular).
[out]	D	Updated update matrix (rectangular).
[in]	B	Householder reflector vectors returned by hyhound_diag.
[in]	d	Diagonal update matrix.
[in]	W	Householder representation returned by hyhound_diag.
[in]	kA_in_offset	If A is smaller than D, A is implicitly padded with zero columns: the offset of the nonzero part of A in the padded matrix can be specified using `kA_in_offset`.

Definition at line 188 of file hyhound.hpp.

◆ hyhound_diag_apply() [2/2]

template<simdifiable VL, simdifiable VA, simdifiable VB, simdifiable Vd, simdifiable VW>

void batmat::linalg::hyhound_diag_apply	(	VL &&	L,
		VA &&	A,
		VB &&	B,
		Vd &&	d,
		VW &&	W )

#include <batmat/linalg/hyhound.hpp>

Apply Householder transformation generated by hyhound_diag, computing (L̃, Ã) = (L, A) Q̆.

Parameters

[in,out]	L	Part of the Cholesky factor to be updated (rectangular). Overwritten by L̃.
[in,out]	A	Update matrix (rectangular). Overwritten by Ã.
[in]	B	Householder reflector vectors returned by hyhound_diag.
[in]	d	Diagonal update matrix.
[in]	W	Householder representation returned by hyhound_diag.

Definition at line 202 of file hyhound.hpp.

◆ hyhound_sign()

template<MatrixStructure SL, simdifiable VL, simdifiable VA, simdifiable Vd>

void batmat::linalg::hyhound_sign	(	Structured< VL, SL >	L,
		VA &&	A,
		Vd &&	d )

#include <batmat/linalg/hyhound.hpp>

Update Cholesky factor L using low-rank term A diag(copysign(1, d)) Aᵀ, where d contains only ±0 values.

Definition at line 212 of file hyhound.hpp.

◆ hyhound_diag_2()

template<MatrixStructure SL, simdifiable VL1, simdifiable VA1, simdifiable VL2, simdifiable VA2, simdifiable Vd>

void batmat::linalg::hyhound_diag_2	(	Structured< VL1, SL >	L1,
		VA1 &&	A1,
		VL2 &&	L2,
		VA2 &&	A2,
		Vd &&	d )

#include <batmat/linalg/hyhound.hpp>

Update Cholesky factor L using low-rank term A diag(d) Aᵀ, where L and A are stored as two separate block rows.

\[ L = \begin{pmatrix} L_{11} \\ L_{21} \end{pmatrix}, \quad A = \begin{pmatrix} A_{1} \\ A_{2} \end{pmatrix}. \]

Definition at line 226 of file hyhound.hpp.

◆ hyhound_diag_cyclic()

template<MatrixStructure SL, simdifiable VL11, simdifiable VA1, simdifiable VL21, simdifiable VA2, simdifiable VA2o, simdifiable VU, simdifiable VA3, simdifiable VA3o, simdifiable Vd>

void batmat::linalg::hyhound_diag_cyclic	(	Structured< VL11, SL >	L11,
		VA1 &&	A1,
		VL21 &&	L21,
		VA2 &&	A22,
		VA2o &&	A2_out,
		VU &&	L31,
		VA3 &&	A31,
		VA3o &&	A3_out,
		Vd &&	d )

#include <batmat/linalg/hyhound.hpp>

Update structured Cholesky factor L using structured low-rank term A diag(d) Aᵀ,.

\[ L = \begin{pmatrix} L_{11} \\ L_{21} \\ L_{31} \end{pmatrix}, \quad A = \begin{pmatrix} A_{11} & A_{12} \\ 0 & A_{22} \\ A_{31} & 0 \end{pmatrix}, \quad \tilde A = \begin{pmatrix} 0 \\ \tilde A_{2} \\ \tilde A_{3} \end{pmatrix}. \]

Definition at line 240 of file hyhound.hpp.

◆ hyhound_diag_riccati()

template<MatrixStructure SL, simdifiable VL11, simdifiable VA1, simdifiable VL21, simdifiable VA2, simdifiable VA2o, simdifiable VLu1, simdifiable VAuo, simdifiable Vd>

void batmat::linalg::hyhound_diag_riccati	(	Structured< VL11, SL >	L11,
		VA1 &&	A1,
		VL21 &&	L21,
		VA2 &&	A2,
		VA2o &&	A2_out,
		VLu1 &&	Lu1,
		VAuo &&	Au_out,
		Vd &&	d,
		bool	shift_A_out = false )

#include <batmat/linalg/hyhound.hpp>

Update structured Cholesky factor L using structured low-rank term A diag(d) Aᵀ,.

\[ L = \begin{pmatrix} L_{11} \\ L_{21} \\ L_{u} \end{pmatrix}, \quad A = \begin{pmatrix} A_{1} \\ A_{2} \\ 0 \end{pmatrix}, \quad \tilde A = \begin{pmatrix} 0 \\ \tilde A_{2} \\ \tilde A_{u} \end{pmatrix}. \]

The shift_A_out parameter indicates whether the output matrix A2_out should be shifted along the batch dimension. This is used in the Cyqlone solver.

Definition at line 258 of file hyhound.hpp.

◆ syrk_add_potrf() [1/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD>

void batmat::linalg::syrk_add_potrf	(	VA &&	A,
		Structured< VC, SC >	C,
		Structured< VD, SC >	D,
		simdified_value_t< VA >	regularization = 0 )

#include <batmat/linalg/potrf.hpp>

D = chol(C + AAᵀ) with C symmetric, D triangular.

Definition at line 49 of file potrf.hpp.

◆ syrk_add_potrf() [2/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VD>

void batmat::linalg::syrk_add_potrf	(	VA &&	A,
		Structured< VD, SC >	D )

#include <batmat/linalg/potrf.hpp>

D = chol(D + AAᵀ) with D symmetric/triangular.

Definition at line 57 of file potrf.hpp.

◆ syrk_sub_potrf() [1/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD>

void batmat::linalg::syrk_sub_potrf	(	VA &&	A,
		Structured< VC, SC >	C,
		Structured< VD, SC >	D,
		simdified_value_t< VA >	regularization = 0 )

#include <batmat/linalg/potrf.hpp>

D = chol(C - AAᵀ) with C symmetric, D triangular.

Definition at line 64 of file potrf.hpp.

◆ syrk_sub_potrf() [2/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VD>

void batmat::linalg::syrk_sub_potrf	(	VA &&	A,
		Structured< VD, SC >	D,
		simdified_value_t< VA >	regularization = 0 )

#include <batmat/linalg/potrf.hpp>

D = chol(D - AAᵀ) with D symmetric/triangular.

Definition at line 72 of file potrf.hpp.

◆ syrk_diag_add_potrf() [1/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VC, simdifiable VD, simdifiable Vd>

void batmat::linalg::syrk_diag_add_potrf	(	VA &&	A,
		Structured< VC, SC >	C,
		Structured< VD, SC >	D,
		Vd &&	d,
		simdified_value_t< VA >	regularization = 0 )

#include <batmat/linalg/potrf.hpp>

D = chol(C + A diag(d) Aᵀ) with C symmetric, D triangular.

Definition at line 79 of file potrf.hpp.

◆ syrk_diag_add_potrf() [2/2]

template<MatrixStructure SC, simdifiable VA, simdifiable VD, simdifiable Vd>

void batmat::linalg::syrk_diag_add_potrf	(	VA &&	A,
		Structured< VD, SC >	D,
		Vd &&	d )

#include <batmat/linalg/potrf.hpp>

D = chol(D + A diag(d) Aᵀ) with D symmetric/triangular.

Definition at line 90 of file potrf.hpp.

◆ potrf() [1/2]

template<MatrixStructure SC, simdifiable VC, simdifiable VD>

void batmat::linalg::potrf	(	Structured< VC, SC >	C,
		Structured< VD, SC >	D,
		simdified_value_t< VC >	regularization = 0 )

#include <batmat/linalg/potrf.hpp>

D = chol(C) with C symmetric, D triangular.

Examples: example.cpp.

Definition at line 97 of file potrf.hpp.

◆ potrf() [2/2]

template<MatrixStructure SD, simdifiable VD>

void batmat::linalg::potrf	(	Structured< VD, SD >	D,
		simdified_value_t< VD >	regularization = 0 )

#include <batmat/linalg/potrf.hpp>

D = chol(D) with D symmetric/triangular.

Definition at line 105 of file potrf.hpp.

◆ transpose()

MatrixStructure batmat::linalg::transpose ( MatrixStructure s )

constexpr

#include <batmat/linalg/structure.hpp>

Definition at line 11 of file structure.hpp.

◆ symm_add() [1/2]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD>

void batmat::linalg::symm_add	(	Structured< VA, SA >	A,
		VB &&	B,
		VC &&	C,
		VD &&	D )

#include <batmat/linalg/symm.hpp>

D = C + A B with A symmetric.

Definition at line 76 of file symm.hpp.

◆ symm_add() [2/2]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::symm_add	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/symm.hpp>

D = D + A B with A symmetric.

Definition at line 83 of file symm.hpp.

◆ symv()

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::symv	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/symv.hpp>

d = A b where A is symmetric

Definition at line 47 of file symv.hpp.

◆ symv_neg()

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::symv_neg	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/symv.hpp>

d = -A b where A is symmetric

Definition at line 57 of file symv.hpp.

◆ symv_add() [1/2]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD>

void batmat::linalg::symv_add	(	Structured< VA, SA >	A,
		VB &&	B,
		VC &&	C,
		VD &&	D )

#include <batmat/linalg/symv.hpp>

d = c + A b where A is symmetric

Definition at line 67 of file symv.hpp.

◆ symv_add() [2/2]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::symv_add	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/symv.hpp>

d = d + A b where A is symmetric

Definition at line 75 of file symv.hpp.

◆ symv_sub() [1/2]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VC, simdifiable VD>

void batmat::linalg::symv_sub	(	Structured< VA, SA >	A,
		VB &&	B,
		VC &&	C,
		VD &&	D )

#include <batmat/linalg/symv.hpp>

d = c - A b where A is symmetric

Definition at line 82 of file symv.hpp.

◆ symv_sub() [2/2]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::symv_sub	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/symv.hpp>

d = d - A b where A is symmetric

Definition at line 90 of file symv.hpp.

◆ syomv()

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::syomv	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/syomv.hpp>

Definition at line 46 of file syomv.hpp.

◆ syomv_neg()

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD>

void batmat::linalg::syomv_neg	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D )

#include <batmat/linalg/syomv.hpp>

Definition at line 55 of file syomv.hpp.

◆ Structured()

template<class M>

batmat::linalg::Structured ( M && ) -> Structured< M >

#include <batmat/linalg/triangular.hpp>

◆ tril()

template<class M>

auto batmat::linalg::tril ( M && m )

nodiscardconstexpr

#include <batmat/linalg/triangular.hpp>

Lower-triangular view.

Examples: example.cpp.

Definition at line 41 of file triangular.hpp.

◆ triu()

template<class M>

auto batmat::linalg::triu ( M && m )

nodiscardconstexpr

#include <batmat/linalg/triangular.hpp>

Upper-triangular view.

Examples: example.cpp.

Definition at line 47 of file triangular.hpp.

◆ make_structured()

template<MatrixStructure S, class M>

auto batmat::linalg::make_structured ( M && m )

nodiscardconstexpr

#include <batmat/linalg/triangular.hpp>

View with the given structure.

Definition at line 53 of file triangular.hpp.

◆ trsm() [1/4]

template<MatrixStructure SA, simdifiable VA, simdifiable VB, simdifiable VD, int RotB = 0>

void batmat::linalg::trsm	(	Structured< VA, SA >	A,
		VB &&	B,
		VD &&	D,
		with_rotate_B_t< RotB >	= {} )

#include <batmat/linalg/trsm.hpp>

D = A⁻¹ B with A triangular.

Definition at line 51 of file trsm.hpp.

◆ trsm() [2/4]

template<MatrixStructure SA, simdifiable VA, simdifiable VD, int RotB = 0>

void batmat::linalg::trsm	(	Structured< VA, SA >	A,
		VD &&	D,
		with_rotate_B_t< RotB >	shift = {} )

#include <batmat/linalg/trsm.hpp>

D = A⁻¹ D with A triangular.

Definition at line 58 of file trsm.hpp.

◆ trsm() [3/4]

template<MatrixStructure SB, simdifiable VA, simdifiable VB, simdifiable VD, int RotA = 0>

void batmat::linalg::trsm	(	VA &&	A,
		Structured< VB, SB >	B,
		VD &&	D,
		with_rotate_A_t< RotA >	= {} )

#include <batmat/linalg/trsm.hpp>

D = A B⁻¹ with B triangular.

Definition at line 65 of file trsm.hpp.

◆ trsm() [4/4]

template<MatrixStructure SB, simdifiable VB, simdifiable VD, int RotA = 0>

void batmat::linalg::trsm	(	VD &&	D,
		Structured< VB, SB >	B,
		with_rotate_A_t< RotA >	shift = {} )

#include <batmat/linalg/trsm.hpp>

D = D B⁻¹ with B triangular.

Definition at line 75 of file trsm.hpp.

◆ trtri() [1/4]

template<simdifiable VA, simdifiable VD>

void batmat::linalg::trtri	(	Structured< VA, MatrixStructure::LowerTriangular >	A,
		Structured< VD, MatrixStructure::LowerTriangular >	D )

#include <batmat/linalg/trtri.hpp>

D = A⁻¹ with A, D lower triangular.

Definition at line 41 of file trtri.hpp.

◆ trtri() [2/4]

template<simdifiable VA, simdifiable VD>

void batmat::linalg::trtri	(	Structured< VA, MatrixStructure::UpperTriangular >	A,
		Structured< VD, MatrixStructure::UpperTriangular >	D )

#include <batmat/linalg/trtri.hpp>

D = A⁻¹ with A, D upper triangular.

Definition at line 51 of file trtri.hpp.

◆ trtri() [3/4]

template<simdifiable VD>

void batmat::linalg::trtri ( Structured< VD, MatrixStructure::LowerTriangular > D )

#include <batmat/linalg/trtri.hpp>

D = D⁻¹ with D lower triangular.

Definition at line 58 of file trtri.hpp.

◆ trtri() [4/4]

template<simdifiable VD>

void batmat::linalg::trtri ( Structured< VD, MatrixStructure::UpperTriangular > D )

#include <batmat/linalg/trtri.hpp>

D = D⁻¹ with D upper triangular.

Definition at line 66 of file trtri.hpp.

Detailed Description

Topics

Compression of masks containing zeros

Copying and filling batches of matrices

Multiplication of batches of matrices with diagonal scaling

Multiplication of batches of general matrices

Multiplication of batches of matrices with symmetric results

Multiplication of batches of triangular matrices

Matrix-vector multiplication of batches of matrices

Cholesky factorization updates

Cholesky factorization of batches of matrices

Symmetric multiplication of batches of matrices

Symmetric matrix-vector multiplication of batches of matrices

Symmetric matrix-vector multiplication of a block tridiagonal matrix

Triangular views of batches of matrices

Triangular solve of batches of matrices

Triangular inversion of batches of matrices

Classes

Enumerations

Functions

Class Documentation

◆ batmat::linalg::TilingOptions

Enumeration Type Documentation

◆ PackingSelector

◆ MatrixStructure

Function Documentation

◆ compress_masks()

◆ compress_masks_count()

◆ compress_masks_sqrt() [1/2]

◆ compress_masks_sqrt() [2/2]

◆ copy() [1/2]

◆ copy() [2/2]

◆ fill() [1/2]

◆ fill() [2/2]

◆ gemm_diag()

◆ gemm_diag_add() [1/2]

◆ gemm_diag_add() [2/2]

◆ gemm_diag_sub() [1/2]

◆ gemm_diag_sub() [2/2]

◆ syrk_diag()

◆ syrk_diag_add() [1/2]

◆ syrk_diag_add() [2/2]

◆ syrk_diag_sub() [1/2]

◆ syrk_diag_sub() [2/2]

◆ gemm()

◆ gemm_neg()

◆ gemm_add() [1/2]

◆ gemm_add() [2/2]

◆ gemm_sub() [1/2]

◆ gemm_sub() [2/2]

◆ syrk() [1/3]

◆ syrk() [2/3]

◆ syrk() [3/3]

◆ syrk_neg() [1/3]

◆ syrk_neg() [2/3]

◆ syrk_neg() [3/3]

◆ syrk_add() [1/2]

◆ syrk_add() [2/2]

◆ syrk_sub() [1/2]

◆ syrk_sub() [2/2]

◆ trmm() [1/4]

◆ trmm() [2/4]

◆ trmm() [3/4]

◆ trmm() [4/4]

◆ trmm_neg() [1/2]

◆ trmm_neg() [2/2]

◆ trmm_add() [1/2]

◆ trmm_add() [2/2]

◆ trmm_sub() [1/2]

◆ trmm_sub() [2/2]

◆ gemv()

◆ gemv_neg()

◆ gemv_add() [1/2]

◆ gemv_add() [2/2]

◆ gemv_sub() [1/2]

◆ gemv_sub() [2/2]

◆ hyhound_diag() [1/2]

◆ hyhound_diag() [2/2]

◆ hyhound_size_W()

◆ hyhound_diag_apply() [1/2]