\(C = \alpha A B + \beta C\) or \(C = \alpha B A + \beta C\) where \(A\) is symmetric More...

Functions
template<typename TA , typename TB , typename TC >
void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, scalar_type< TA, TB, TC > alpha, TA const A, int64_t lda, TB const B, int64_t ldb, scalar_type< TA, TB, TC > beta, TC *C, int64_t ldc)
	Symmetric matrix-matrix multiply:

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< float > const &alpha, std::vector< float * > const &Aarray, std::vector< int64_t > const &lda, std::vector< float * > const &Barray, std::vector< int64_t > const &ldb, std::vector< float > const &beta, std::vector< float * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info)
	CPU, variable-size batched, float version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< double > const &alpha, std::vector< double * > const &Aarray, std::vector< int64_t > const &lda, std::vector< double * > const &Barray, std::vector< int64_t > const &ldb, std::vector< double > const &beta, std::vector< double * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info)
	CPU, variable-size batched, double version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< std::complex< float > > const &alpha, std::vector< std::complex< float > * > const &Aarray, std::vector< int64_t > const &lda, std::vector< std::complex< float > * > const &Barray, std::vector< int64_t > const &ldb, std::vector< std::complex< float > > const &beta, std::vector< std::complex< float > * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info)
	CPU, variable-size batched, complex<float> version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< std::complex< double > > const &alpha, std::vector< std::complex< double > * > const &Aarray, std::vector< int64_t > const &lda, std::vector< std::complex< double > * > const &Barray, std::vector< int64_t > const &ldb, std::vector< std::complex< double > > const &beta, std::vector< std::complex< double > * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info)
	CPU, variable-size batched, complex<double> version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< float > const &alpha, std::vector< float * > const &Aarray, std::vector< int64_t > const &lda, std::vector< float * > const &Barray, std::vector< int64_t > const &ldb, std::vector< float > const &beta, std::vector< float * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info, blas::Queue &queue)
	GPU device, variable-size batched, float version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< double > const &alpha, std::vector< double * > const &Aarray, std::vector< int64_t > const &lda, std::vector< double * > const &Barray, std::vector< int64_t > const &ldb, std::vector< double > const &beta, std::vector< double * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info, blas::Queue &queue)
	GPU device, variable-size batched, double version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< std::complex< float > > const &alpha, std::vector< std::complex< float > * > const &Aarray, std::vector< int64_t > const &lda, std::vector< std::complex< float > * > const &Barray, std::vector< int64_t > const &ldb, std::vector< std::complex< float > > const &beta, std::vector< std::complex< float > * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info, blas::Queue &queue)
	GPU device, variable-size batched, complex<float> version.

void	blas::batch::symm (blas::Layout layout, std::vector< blas::Side > const &side, std::vector< blas::Uplo > const &uplo, std::vector< int64_t > const &m, std::vector< int64_t > const &n, std::vector< std::complex< double > > const &alpha, std::vector< std::complex< double > * > const &Aarray, std::vector< int64_t > const &lda, std::vector< std::complex< double > * > const &Barray, std::vector< int64_t > const &ldb, std::vector< std::complex< double > > const &beta, std::vector< std::complex< double > * > const &Carray, std::vector< int64_t > const &ldc, size_t batch_size, std::vector< int64_t > &info, blas::Queue &queue)
	GPU device, variable-size batched, complex<double> version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, float alpha, float const A, int64_t lda, float const B, int64_t ldb, float beta, float *C, int64_t ldc, blas::Queue &queue)
	GPU device, float version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, double alpha, double const A, int64_t lda, double const B, int64_t ldb, double beta, double *C, int64_t ldc, blas::Queue &queue)
	GPU device, double version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, std::complex< float > alpha, std::complex< float > const A, int64_t lda, std::complex< float > const B, int64_t ldb, std::complex< float > beta, std::complex< float > *C, int64_t ldc, blas::Queue &queue)
	GPU device, complex<float> version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, std::complex< double > alpha, std::complex< double > const A, int64_t lda, std::complex< double > const B, int64_t ldb, std::complex< double > beta, std::complex< double > *C, int64_t ldc, blas::Queue &queue)
	GPU device, complex<double> version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, float alpha, float const A, int64_t lda, float const B, int64_t ldb, float beta, float *C, int64_t ldc)
	CPU, float version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, double alpha, double const A, int64_t lda, double const B, int64_t ldb, double beta, double *C, int64_t ldc)
	CPU, double version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, std::complex< float > alpha, std::complex< float > const A, int64_t lda, std::complex< float > const B, int64_t ldb, std::complex< float > beta, std::complex< float > *C, int64_t ldc)
	CPU, complex<float> version.

void	blas::symm (blas::Layout layout, blas::Side side, blas::Uplo uplo, int64_t m, int64_t n, std::complex< double > alpha, std::complex< double > const A, int64_t lda, std::complex< double > const B, int64_t ldb, std::complex< double > beta, std::complex< double > *C, int64_t ldc)
	CPU, complex<double> version.

Detailed Description

\(C = \alpha A B + \beta C\) or \(C = \alpha B A + \beta C\) where \(A\) is symmetric

Function Documentation

◆ symm()

template<typename TA , typename TB , typename TC >

void blas::symm	(	blas::Layout	layout,
		blas::Side	side,
		blas::Uplo	uplo,
		int64_t	m,
		int64_t	n,
		scalar_type< TA, TB, TC >	alpha,
		TA const *	A,
		int64_t	lda,
		TB const *	B,
		int64_t	ldb,
		scalar_type< TA, TB, TC >	beta,
		TC *	C,
		int64_t	ldc
	)

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.

Generic implementation for arbitrary data types.

Parameters

[in]	layout	Matrix storage, Layout::ColMajor or Layout::RowMajor.
[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]	m	Number of rows of the matrices B and C.
[in]	n	Number of columns of the matrices B and C.
[in]	alpha	Scalar alpha. If alpha is zero, A and B are not accessed.
[in]	A	If side = Left: The m-by-m matrix A, stored in an lda-by-m array. If side = Right: The n-by-n matrix A, stored in an lda-by-n array.
[in]	lda	Leading dimension of A. If side = Left: lda >= max(1, m). If side = Right: lda >= max(1, n).
[in]	B	The m-by-n matrix B, stored in an ldb-by-n array.
[in]	ldb	Leading dimension of B. ldb >= max(1, n).
[in]	beta	Scalar beta. If beta is zero, C need not be set on input.
[in]	C	The m-by-n matrix C, stored in an lda-by-n array.
[in]	ldc	Leading dimension of C. ldc >= max(1, n).

Functions

Detailed Description

Function Documentation

◆ symm()