BLAS Level 3: matrix-matrix operations, O(n^3) work

Matrix-matrix operations that perform \(O(n^3)\) work on \(O(n^2)\) data. More...

Functions
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	tlapack::gemm (Op transA, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	General matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::gemm (Op transA, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	General matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	tlapack::hemm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Hermitian matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::hemm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Hermitian matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_REAL beta_t, enable_if_t<(is_real< beta_t >), int > = 0, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, real_type< T > > > = 0>
void	tlapack::her2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::her2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_REAL alpha_t, TLAPACK_REAL beta_t, enable_if_t<(is_real< alpha_t > &&is_real< beta_t >), int > = 0, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixC_t, T >, pair< alpha_t, real_type< T > >, pair< beta_t, real_type< T > > > = 0>
void	tlapack::herk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const beta_t &beta, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::herk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	tlapack::symm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Symmetric matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::symm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Symmetric matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	tlapack::syr2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::syr2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	tlapack::syrk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const beta_t &beta, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	tlapack::syrk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixB_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< alpha_t, T > > = 0>
void	tlapack::trmm (Side side, Uplo uplo, Op trans, Diag diag, const alpha_t &alpha, const matrixA_t &A, matrixB_t &B)
	Triangular matrix-matrix multiply:
template<TLAPACK_SIDE side_t, TLAPACK_UPLO uplo_t, TLAPACK_OP op_t, TLAPACK_DIAG diag_t, TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t, TLAPACK_WORKSPACE work_t>
void	tlapack::trmm_blocked_mixed (side_t side, uplo_t uplo, op_t trans, diag_t diag, const scalar_type< type_t< matrixA_t >, type_t< matrixB_t > > &alpha, const matrixA_t &A, matrixB_t &B, work_t &work, const TrmmBlockedOpts &opts={})
	Triangular matrix-matrix multiply using a blocked algorithm.
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixB_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< alpha_t, T > > = 0>
void	tlapack::trsm (Side side, Uplo uplo, Op trans, Diag diag, const alpha_t &alpha, const matrixA_t &A, matrixB_t &B)
	Solve the triangular matrix-vector equation.

Detailed Description

Matrix-matrix operations that perform \(O(n^3)\) work on \(O(n^2)\) data.

These benefit from cache reuse, since many operations can be performed for every read from main memory.

---

Function Documentation

gemm() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>

void tlapack::gemm	(	Op	transA,
		Op	transB,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		const beta_t &	beta,
		matrixC_t &	C
	)

General matrix-matrix multiply:

\[ C := \alpha op(A) \times op(B) + \beta C, \]

where \(op(X)\) is one of \(op(X) = X\), \(op(X) = X^T\), or \(op(X) = X^H\), alpha and beta are scalars, and A, B, and C are matrices, with \(op(A)\) an m-by-k matrix, \(op(B)\) a k-by-n matrix, and C an m-by-n matrix.

Parameters

[in]	transA	The operation \(op(A)\) to be used: Op::NoTrans: \(op(A) = A\). Op::Trans: \(op(A) = A^T\). Op::ConjTrans: \(op(A) = A^H\).
[in]	transB	The operation \(op(B)\) to be used: Op::NoTrans: \(op(B) = B\). Op::Trans: \(op(B) = B^T\). Op::ConjTrans: \(op(B) = B^H\).
[in]	alpha	Scalar.
[in]	A	\(op(A)\) is an m-by-k matrix.
[in]	B	\(op(B)\) is an k-by-n matrix.
[in]	beta	Scalar.
[in,out]	C	A m-by-n matrix.

gemm() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::gemm	(	Op	transA,
		Op	transB,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		matrixC_t &	C
	)

General matrix-matrix multiply:

\[ C := \alpha op(A) \times op(B), \]

where \(op(X)\) is one of \(op(X) = X\), \(op(X) = X^T\), or \(op(X) = X^H\), alpha and beta are scalars, and A, B, and C are matrices, with \(op(A)\) an m-by-k matrix, \(op(B)\) a k-by-n matrix, and C an m-by-n matrix.

Parameters

[in]	transA	The operation \(op(A)\) to be used: Op::NoTrans: \(op(A) = A\). Op::Trans: \(op(A) = A^T\). Op::ConjTrans: \(op(A) = A^H\).
[in]	transB	The operation \(op(B)\) to be used: Op::NoTrans: \(op(B) = B\). Op::Trans: \(op(B) = B^T\). Op::ConjTrans: \(op(B) = B^H\).
[in]	alpha	Scalar.
[in]	A	\(op(A)\) is an m-by-k matrix.
[in]	B	\(op(B)\) is an k-by-n matrix.
[out]	C	A m-by-n matrix.

hemm() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>

void tlapack::hemm	(	Side	side,
		Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		const beta_t &	beta,
		matrixC_t &	C
	)

Hermitian matrix-matrix multiply:

\[ C := \alpha A B + \beta C, \]

or

\[ C := \alpha B A + \beta C, \]

where alpha and beta are scalars, A is an m-by-m or n-by-n Hermitian matrix, and B and C are m-by-n matrices.

Parameters

[in]	side	The side the matrix A appears on: Side::Left: \(C = \alpha A B + \beta C\), Side::Right: \(C = \alpha B A + \beta C\).
[in]	uplo	What part of the matrix A is referenced: Uplo::Lower: only the lower triangular part of A is referenced. Uplo::Upper: only the upper triangular part of A is referenced.
[in]	alpha	Scalar.
[in]	A	If side = Left: A m-by-m Hermitian matrix. If side = Right: A n-by-n Hermitian matrix. Imaginary parts of the diagonal elements need not be set, are assumed to be zero on entry, and are set to zero on exit.
[in]	B	A m-by-n matrix.
[in]	beta	Scalar.
[in,out]	C	A m-by-n matrix.

hemm() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::hemm	(	Side	side,
		Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		matrixC_t &	C
	)

Hermitian matrix-matrix multiply:

\[ C := \alpha A B, \]

or

\[ C := \alpha B A, \]

where alpha and beta are scalars, A is an m-by-m or n-by-n Hermitian matrix, and B and C are m-by-n matrices.

Parameters

[in]	side	The side the matrix A appears on: Side::Left: \(C = \alpha A B\), Side::Right: \(C = \alpha B A\).
[in]	uplo	What part of the matrix A is referenced: Uplo::Lower: only the lower triangular part of A is referenced. Uplo::Upper: only the upper triangular part of A is referenced.
[in]	alpha	Scalar.
[in]	A	If side = Left: A m-by-m Hermitian matrix. If side = Right: A n-by-n Hermitian matrix. Imaginary parts of the diagonal elements need not be set, are assumed to be zero on entry, and are set to zero on exit.
[in]	B	A m-by-n matrix.
[out]	C	A m-by-n matrix.

her2k() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_REAL beta_t, enable_if_t<(is_real< beta_t >), int > = 0, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, real_type< T > > > = 0>

void tlapack::her2k	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		const beta_t &	beta,
		matrixC_t &	C
	)

Hermitian rank-k update:

\[ C := \alpha A B^H + conj(\alpha) B A^H + \beta C, \]

or

\[ C := \alpha A^H B + conj(\alpha) B^H A + \beta C, \]

where alpha and beta are scalars, C is an n-by-n Hermitian matrix, and A and B are n-by-k or k-by-n matrices.

Mind that if beta is complex, the output matrix C is no longer Hermitian.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A B^H + conj(\alpha) A^H B + \beta C\). Op::ConjTrans: \(C = \alpha A^H B + conj(\alpha) B A^H + \beta C\).
[in]	alpha	Real scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	B	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	beta	Real scalar.
[in,out]	C	A n-by-n Hermitian matrix. Imaginary parts of the diagonal elements need not be set, are assumed to be zero on entry, and are set to zero on exit.

her2k() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::her2k	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		matrixC_t &	C
	)

Hermitian rank-k update:

\[ C := \alpha A B^H + conj(\alpha) B A^H, \]

or

\[ C := \alpha A^H B + conj(\alpha) B^H A, \]

where alpha and beta are scalars, C is an n-by-n Hermitian matrix, and A and B are n-by-k or k-by-n matrices.

Mind that if beta is complex, the output matrix C is no longer Hermitian.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A B^H + conj(\alpha) A^H B\). Op::ConjTrans: \(C = \alpha A^H B + conj(\alpha) B A^H\).
[in]	alpha	Real scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	B	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[out]	C	A n-by-n Hermitian matrix.

herk() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_REAL alpha_t, TLAPACK_REAL beta_t, enable_if_t<(is_real< alpha_t > &&is_real< beta_t >), int > = 0, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixC_t, T >, pair< alpha_t, real_type< T > >, pair< beta_t, real_type< T > > > = 0>

void tlapack::herk	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const beta_t &	beta,
		matrixC_t &	C
	)

Hermitian rank-k update:

\[ C := \alpha A A^H + \beta C, \]

or

\[ C := \alpha A^H A + \beta C, \]

where alpha and beta are real scalars, C is an n-by-n Hermitian matrix, and A is an n-by-k or k-by-n matrix.

Mind that if alpha or beta are complex, the output matrix C may no longer Hermitian.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A A^H + \beta C\). Op::ConjTrans: \(C = \alpha A^H A + \beta C\).
[in]	alpha	Real scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	beta	Real scalar.
[in,out]	C	A n-by-n Hermitian matrix. Imaginary parts of the diagonal elements need not be set, are assumed to be zero on entry, and are set to zero on exit.

herk() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::herk	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		matrixC_t &	C
	)

Hermitian rank-k update:

\[ C := \alpha A A^H, \]

or

\[ C := \alpha A^H A, \]

where alpha and beta are real scalars, C is an n-by-n Hermitian matrix, and A is an n-by-k or k-by-n matrix.

Mind that if alpha or beta are complex, the output matrix C may no longer Hermitian.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A A^H\). Op::ConjTrans: \(C = \alpha A^H A\).
[in]	alpha	Real scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[out]	C	A n-by-n Hermitian matrix.

symm() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>

void tlapack::symm	(	Side	side,
		Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		const beta_t &	beta,
		matrixC_t &	C
	)

Symmetric matrix-matrix multiply:

\[ C := \alpha A B + \beta C, \]

or

\[ C := \alpha B A + \beta C, \]

where alpha and beta are scalars, A is an m-by-m or n-by-n symmetric matrix, and B and C are m-by-n matrices.

Parameters

[in]	side	The side the matrix A appears on: Side::Left: \(C = \alpha A B + \beta C\), Side::Right: \(C = \alpha B A + \beta C\).
[in]	uplo	What part of the matrix A is referenced: Uplo::Lower: only the lower triangular part of A is referenced. Uplo::Upper: only the upper triangular part of A is referenced.
[in]	alpha	Scalar.
[in]	A	If side = Left: A m-by-m symmetric matrix. If side = Right: A n-by-n symmetric matrix.
[in]	B	A m-by-n matrix.
[in]	beta	Scalar.
[in,out]	C	A m-by-n matrix.

symm() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::symm	(	Side	side,
		Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		matrixC_t &	C
	)

Symmetric matrix-matrix multiply:

\[ C := \alpha A B, \]

or

\[ C := \alpha B A, \]

where alpha and beta are scalars, A is an m-by-m or n-by-n symmetric matrix, and B and C are m-by-n matrices.

Parameters

[in]	side	The side the matrix A appears on: Side::Left: \(C = \alpha A B\), Side::Right: \(C = \alpha B A\).
[in]	uplo	What part of the matrix A is referenced: Uplo::Lower: only the lower triangular part of A is referenced. Uplo::Upper: only the upper triangular part of A is referenced.
[in]	alpha	Scalar.
[in]	A	If side = Left: A m-by-m symmetric matrix. If side = Right: A n-by-n symmetric matrix.
[in]	B	A m-by-n matrix.
[out]	C	A m-by-n matrix.

syr2k() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>

void tlapack::syr2k	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		const beta_t &	beta,
		matrixC_t &	C
	)

Symmetric rank-k update:

\[ C := \alpha A B^T + \alpha B A^T + \beta C, \]

or

\[ C := \alpha A^T B + \alpha B^T A + \beta C, \]

where alpha and beta are scalars, C is an n-by-n symmetric matrix, and A and B are n-by-k or k-by-n matrices.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A B^T + \alpha B A^T + \beta C\). Op::Trans: \(C = \alpha A^T B + \alpha B^T A + \beta C\).
[in]	alpha	Scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	B	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	beta	Scalar.
[in,out]	C	A n-by-n symmetric matrix.

syr2k() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::syr2k	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const matrixB_t &	B,
		matrixC_t &	C
	)

Symmetric rank-k update:

\[ C := \alpha A B^T + \alpha B A^T, \]

or

\[ C := \alpha A^T B + \alpha B^T A, \]

where alpha and beta are scalars, C is an n-by-n symmetric matrix, and A and B are n-by-k or k-by-n matrices.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A B^T + \alpha B A^T\). Op::Trans: \(C = \alpha A^T B + \alpha B^T A\).
[in]	alpha	Scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	B	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[out]	C	A n-by-n symmetric matrix.

syrk() [1/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>

void tlapack::syrk	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const beta_t &	beta,
		matrixC_t &	C
	)

Symmetric rank-k update:

\[ C := \alpha A A^T + \beta C, \]

or

\[ C := \alpha A^T A + \beta C, \]

where alpha and beta are scalars, C is an n-by-n symmetric matrix, and A is an n-by-k or k-by-n matrix.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A A^T + \beta C\). Op::Trans: \(C = \alpha A^T A + \beta C\).
[in]	alpha	Scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[in]	beta	Scalar.
[in,out]	C	A n-by-n symmetric matrix.

syrk() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>

void tlapack::syrk	(	Uplo	uplo,
		Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		matrixC_t &	C
	)

Symmetric rank-k update:

\[ C := \alpha A A^T, \]

or

\[ C := \alpha A^T A, \]

where alpha and beta are scalars, C is an n-by-n symmetric matrix, and A is an n-by-k or k-by-n matrix.

Parameters

[in]	uplo	What part of the matrix C is referenced, the opposite triangle being assumed from symmetry: Uplo::Lower: only the lower triangular part of C is referenced. Uplo::Upper: only the upper triangular part of C is referenced.
[in]	trans	The operation to be performed: Op::NoTrans: \(C = \alpha A A^T\). Op::Trans: \(C = \alpha A^T A\).
[in]	alpha	Scalar.
[in]	A	A n-by-k matrix. If trans = NoTrans: a n-by-k matrix. Otherwise: a k-by-n matrix.
[out]	C	A n-by-n symmetric matrix.

trmm()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixB_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< alpha_t, T > > = 0>

void tlapack::trmm	(	Side	side,
		Uplo	uplo,
		Op	trans,
		Diag	diag,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		matrixB_t &	B
	)

Triangular matrix-matrix multiply:

\[ B := \alpha op(A) B, \]

or

\[ B := \alpha B op(A), \]

where \(op(A)\) is one of \(op(A) = A\), \(op(A) = A^T\), or \(op(A) = A^H\), B is an m-by-n matrix, and A is an m-by-m or n-by-n, unit or non-unit, upper or lower triangular matrix.

Parameters

[in]	side	Whether \(op(A)\) is on the left or right of B: Side::Left: \(B = \alpha op(A) B\). Side::Right: \(B = \alpha B op(A)\).
[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed to be zero: Uplo::Lower: A is lower triangular. Uplo::Upper: A is upper triangular. Uplo::General is illegal (see gemm() instead).
[in]	trans	The form of \(op(A)\): Op::NoTrans: \(op(A) = A\). Op::Trans: \(op(A) = A^T\). Op::ConjTrans: \(op(A) = A^H\).
[in]	diag	Whether A has a unit or non-unit diagonal: Diag::Unit: A is assumed to be unit triangular. Diag::NonUnit: A is not assumed to be unit triangular.
[in]	alpha	Scalar.
[in]	A	If side = Left: a m-by-m matrix. If side = Right: a n-by-n matrix.
[in,out]	B	A m-by-n matrix.

trmm_blocked_mixed()

template<TLAPACK_SIDE side_t, TLAPACK_UPLO uplo_t, TLAPACK_OP op_t, TLAPACK_DIAG diag_t, TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t, TLAPACK_WORKSPACE work_t>

void tlapack::trmm_blocked_mixed	(	side_t	side,
		uplo_t	uplo,
		op_t	trans,
		diag_t	diag,
		const scalar_type< type_t< matrixA_t >, type_t< matrixB_t > > &	alpha,
		const matrixA_t &	A,
		matrixB_t &	B,
		work_t &	work,
		const TrmmBlockedOpts &	opts = {}
	)

Triangular matrix-matrix multiply using a blocked algorithm.

In iteration i, the algorithm computes \(B_{0i} += \alpha A_{0i,i} B_i\) and then \(B_i := \alpha A_{i,i} B_i\), where i is the block index. See details in the implementation. \(B_i\) is cast to the precision type of work, enabling mixed precision.

Todo:

Implement the algorithm for the remaining cases. See what is missing below.

Parameters

[in]	side	Whether \(op(A)\) is on the left or right of B: Side::Left: \(B = \alpha op(A) B\). Side::Right: \(B = \alpha B op(A)\).
[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed to be zero: Uplo::Lower: A is lower triangular. Uplo::Upper: A is upper triangular. Uplo::General is illegal (see gemm() instead).
[in]	trans	The form of \(op(A)\): Op::NoTrans: \(op(A) = A\). Op::Trans: \(op(A) = A^T\). Op::ConjTrans: \(op(A) = A^H\).
[in]	diag	Whether A has a unit or non-unit diagonal: Diag::Unit: A is assumed to be unit triangular. Diag::NonUnit: A is not assumed to be unit triangular.
[in]	alpha	Scalar.
[in]	A	If side = Left: a m-by-m matrix. If side = Right: a n-by-n matrix.
[in,out]	B	A m-by-n matrix.
	work	nb-by-n workspace that also informs the precision type to case B.
[in]	opts	Options.

trsm()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixB_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< alpha_t, T > > = 0>

void tlapack::trsm	(	Side	side,
		Uplo	uplo,
		Op	trans,
		Diag	diag,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		matrixB_t &	B
	)

Solve the triangular matrix-vector equation.

\[ op(A) X = \alpha B, \]

or

\[ X op(A) = \alpha B, \]

where \(op(A)\) is one of \(op(A) = A\), \(op(A) = A^T\), or \(op(A) = A^H\), X and B are m-by-n matrices, and A is an m-by-m or n-by-n, unit or non-unit, upper or lower triangular matrix.

No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

Parameters

[in]	side	Whether \(op(A)\) is on the left or right of X: Side::Left: \(op(A) X = B\). Side::Right: \(X op(A) = B\).
[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed to be zero: Uplo::Lower: A is lower triangular. Uplo::Upper: A is upper triangular.
[in]	trans	The form of \(op(A)\): Op::NoTrans: \(op(A) = A\). Op::Trans: \(op(A) = A^T\). Op::ConjTrans: \(op(A) = A^H\).
[in]	diag	Whether A has a unit or non-unit diagonal: Diag::Unit: A is assumed to be unit triangular. Diag::NonUnit: A is not assumed to be unit triangular.
[in]	alpha	Scalar.
[in]	A	If side = Left: a m-by-m matrix. If side = Right: a n-by-n matrix.
[in,out]	B	On entry, the m-by-n matrix B. On exit, the m-by-n matrix X.