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

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

Functions
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T >, pair< beta_t, T > > = 0>
void	tlapack::gemv (Op trans, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, const beta_t &beta, vectorY_t &y)
	General matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>
void	tlapack::gemv (Op trans, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, vectorY_t &y)
	General matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	tlapack::ger (const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	General matrix rank-1 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	tlapack::geru (const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	General matrix rank-1 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T >, pair< beta_t, T > > = 0>
void	tlapack::hemv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, const beta_t &beta, vectorY_t &y)
	Hermitian matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>
void	tlapack::hemv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, vectorY_t &y)
	Hermitian matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_REAL alpha_t, enable_if_t<(is_real< alpha_t >), int > = 0, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, real_type< T > >, pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	tlapack::her (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, matrixA_t &A)
	Hermitian matrix rank-1 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	tlapack::her2 (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	Hermitian matrix rank-2 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T >, pair< beta_t, T > > = 0>
void	tlapack::symv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, const beta_t &beta, vectorY_t &y)
	Symmetric matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>
void	tlapack::symv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, vectorY_t &y)
	Symmetric matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	tlapack::syr (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, matrixA_t &A)
	Symmetric matrix rank-1 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	tlapack::syr2 (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	Symmetric matrix rank-2 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	tlapack::trmv (Uplo uplo, Op trans, Diag diag, const matrixA_t &A, vectorX_t &x)
	Triangular matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	tlapack::trsv (Uplo uplo, Op trans, Diag diag, const matrixA_t &A, vectorX_t &x)
	Solve the triangular matrix-vector equation.

Detailed Description

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

These are memory bound, since every operation requires a memory read or write.

---

Function Documentation

gemv() [1/2]

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

void tlapack::gemv	(	Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const vectorX_t &	x,
		const beta_t &	beta,
		vectorY_t &	y
	)

General matrix-vector multiply:

\[ y := \alpha op(A) x + \beta y, \]

where \(op(A)\) is one of \(op(A) = A\), \(op(A) = A^T\), \(op(A) = A^H\), or \(op(A) = conj(A)\), alpha and beta are scalars, x and y are vectors, and A is a matrix.

Parameters

[in]	trans	The operation to be performed: Op::NoTrans: \(y = \alpha A x + \beta y\), Op::Trans: \(y = \alpha A^T x + \beta y\), Op::ConjTrans: \(y = \alpha A^H x + \beta y\), Op::Conj: \(y = \alpha conj(A) x + \beta y\).
[in]	alpha	Scalar.
[in]	A	\(op(A)\) is an m-by-n matrix.
[in]	x	A n-element vector.
[in]	beta	Scalar.
[in,out]	y	A m-element vector.

gemv() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>

void tlapack::gemv	(	Op	trans,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const vectorX_t &	x,
		vectorY_t &	y
	)

General matrix-vector multiply:

\[ y := \alpha op(A) x, \]

where \(op(A)\) is one of \(op(A) = A\), \(op(A) = A^T\), \(op(A) = A^H\), or \(op(A) = conj(A)\), alpha and beta are scalars, x and y are vectors, and A is a matrix.

Parameters

[in]	trans	The operation to be performed: Op::NoTrans: \(y = \alpha A x\), Op::Trans: \(y = \alpha A^T x\), Op::ConjTrans: \(y = \alpha A^H x\), Op::Conj: \(y = \alpha conj(A) x\).
[in]	alpha	Scalar.
[in]	A	\(op(A)\) is an m-by-n matrix.
[in]	x	A n-element vector.
[in,out]	y	A m-element vector.

ger()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>

void tlapack::ger	(	const alpha_t &	alpha,
		const vectorX_t &	x,
		const vectorY_t &	y,
		matrixA_t &	A
	)

General matrix rank-1 update:

\[ A := \alpha x y^H + A, \]

where alpha is a scalar, x and y are vectors, and A is an m-by-n matrix.

Parameters

[in]	alpha	Scalar.
[in]	x	A m-element vector.
[in]	y	A n-element vector.
[in]	A	A m-by-n matrix.

geru()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>

void tlapack::geru	(	const alpha_t &	alpha,
		const vectorX_t &	x,
		const vectorY_t &	y,
		matrixA_t &	A
	)

General matrix rank-1 update:

\[ A := \alpha x y^T + A, \]

where alpha is a scalar, x and y are vectors, and A is an m-by-n matrix.

Parameters

[in]	alpha	Scalar.
[in]	x	A m-element vector.
[in]	y	A n-element vector.
[in]	A	A m-by-n matrix.

hemv() [1/2]

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

void tlapack::hemv	(	Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const vectorX_t &	x,
		const beta_t &	beta,
		vectorY_t &	y
	)

Hermitian matrix-vector multiply:

\[ y := \alpha A x + \beta y, \]

where alpha and beta are scalars, x and y are vectors, and A is an n-by-n Hermitian matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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	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]	x	A n-element vector.
[in]	beta	Scalar.
[in,out]	y	A n-element vector.

hemv() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>

void tlapack::hemv	(	Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const vectorX_t &	x,
		vectorY_t &	y
	)

Hermitian matrix-vector multiply:

\[ y := \alpha A x, \]

where alpha and beta are scalars, x and y are vectors, and A is an n-by-n Hermitian matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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	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]	x	A n-element vector.
[in,out]	y	A n-element vector.

her()

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

void tlapack::her	(	Uplo	uplo,
		const alpha_t &	alpha,
		const vectorX_t &	x,
		matrixA_t &	A
	)

Hermitian matrix rank-1 update:

\[ A := \alpha x x^H + A, \]

where alpha is a real scalar, x is a vector, and A is an n-by-n Hermitian matrix.

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

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. Uplo::Lower: only the lower triangular part of A is referenced. Uplo::Upper: only the upper triangular part of A is referenced.
[in]	alpha	Real scalar.
[in]	x	A n-element vector.
[in,out]	A	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.

her2()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>

void tlapack::her2	(	Uplo	uplo,
		const alpha_t &	alpha,
		const vectorX_t &	x,
		const vectorY_t &	y,
		matrixA_t &	A
	)

Hermitian matrix rank-2 update:

\[ A := \alpha x y^H + \text{conj}(\alpha) y x^H + A, \]

where alpha is a scalar, x and y are vectors, and A is an n-by-n Hermitian matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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]	x	A n-element vector.
[in]	y	A n-element vector.
[in,out]	A	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.

symv() [1/2]

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

void tlapack::symv	(	Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const vectorX_t &	x,
		const beta_t &	beta,
		vectorY_t &	y
	)

Symmetric matrix-vector multiply:

\[ y := \alpha A x + \beta y, \]

where alpha and beta are scalars, x and y are vectors, and A is an n-by-n symmetric matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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	A n-by-n symmetric matrix.
[in]	x	A n-element vector.
[in]	beta	Scalar.
[in,out]	y	A n-element vector.

symv() [2/2]

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>

void tlapack::symv	(	Uplo	uplo,
		const alpha_t &	alpha,
		const matrixA_t &	A,
		const vectorX_t &	x,
		vectorY_t &	y
	)

Symmetric matrix-vector multiply:

\[ y := \alpha A x, \]

where alpha and beta are scalars, x and y are vectors, and A is an n-by-n symmetric matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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	A n-by-n symmetric matrix.
[in]	x	A n-element vector.
[in,out]	y	A n-element vector.

syr()

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

void tlapack::syr	(	Uplo	uplo,
		const alpha_t &	alpha,
		const vectorX_t &	x,
		matrixA_t &	A
	)

Symmetric matrix rank-1 update:

\[ A := \alpha x x^T + A, \]

where alpha is a scalar, x is a vector, and A is an n-by-n symmetric matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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]	x	A n-element vector.
[in,out]	A	A n-by-n symmetric matrix.

syr2()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>

void tlapack::syr2	(	Uplo	uplo,
		const alpha_t &	alpha,
		const vectorX_t &	x,
		const vectorY_t &	y,
		matrixA_t &	A
	)

Symmetric matrix rank-2 update:

\[ A := \alpha x y^T + \alpha y x^T + A, \]

where alpha is a scalar, x and y are vectors, and A is an n-by-n symmetric matrix.

Parameters

[in]	uplo	What part of the matrix A is referenced, the opposite triangle being assumed from symmetry. 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]	x	A n-element vector.
[in]	y	A n-element vector.
[in,out]	A	A n-by-n symmetric matrix.

trmv()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>

void tlapack::trmv	(	Uplo	uplo,
		Op	trans,
		Diag	diag,
		const matrixA_t &	A,
		vectorX_t &	x
	)

Triangular matrix-vector multiply:

\[ x := op(A) x, \]

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

Parameters

[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 operation to be performed: Op::NoTrans: \(x = A x\), Op::Trans: \(x = A^T x\), Op::ConjTrans: \(x = A^H x\).
[in]	diag	Whether A has a unit or non-unit diagonal: Diag::Unit: A is assumed to be unit triangular. The diagonal elements of A are not referenced. Diag::NonUnit: A is not assumed to be unit triangular.
[in]	A	A n-by-n matrix.
[in,out]	x	A n-element vector.

trsv()

template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>

void tlapack::trsv	(	Uplo	uplo,
		Op	trans,
		Diag	diag,
		const matrixA_t &	A,
		vectorX_t &	x
	)

Solve the triangular matrix-vector equation.

\[ op(A) x = b, \]

where \(op(A)\) is one of \(op(A) = A\), \(op(A) = A^T\), or \(op(A) = A^H\), x and b are vectors, and A is an 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]	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 equation to be solved: Op::NoTrans: \(A x = b\), Op::Trans: \(A^T x = b\), Op::ConjTrans: \(A^H x = b\).
[in]	diag	Whether A has a unit or non-unit diagonal: Diag::Unit: A is assumed to be unit triangular. The diagonal elements of A are not referenced. Diag::NonUnit: A is not assumed to be unit triangular.
[in]	A	A n-by-n matrix.
[in,out]	x	On entry, the n-element vector b. On exit, the n-element vector x.