gemv: General matrix-vector multiply

\(y = \alpha Ax + \beta y\) More...

Functions
template<typename TA , typename TX , typename TY >
void	blas::gemv (blas::Layout layout, blas::Op trans, int64_t m, int64_t n, blas::scalar_type< TA, TX, TY > alpha, TA const *A, int64_t lda, TX const *x, int64_t incx, blas::scalar_type< TA, TX, TY > beta, TY *y, int64_t incy)
	General matrix-vector multiply:
void	blas::gemv (blas::Layout layout, blas::Op trans, int64_t m, int64_t n, float alpha, float const *A, int64_t lda, float const *x, int64_t incx, float beta, float *y, int64_t incy)
	CPU, float version.
void	blas::gemv (blas::Layout layout, blas::Op trans, int64_t m, int64_t n, double alpha, double const *A, int64_t lda, double const *x, int64_t incx, double beta, double *y, int64_t incy)
	CPU, double version.
void	blas::gemv (blas::Layout layout, blas::Op trans, int64_t m, int64_t n, std::complex< float > alpha, std::complex< float > const *A, int64_t lda, std::complex< float > const *x, int64_t incx, std::complex< float > beta, std::complex< float > *y, int64_t incy)
	CPU, complex<float> version.
void	blas::gemv (blas::Layout layout, blas::Op trans, int64_t m, int64_t n, std::complex< double > alpha, std::complex< double > const *A, int64_t lda, std::complex< double > const *x, int64_t incx, std::complex< double > beta, std::complex< double > *y, int64_t incy)
	CPU, complex<double> version.

Detailed Description

\(y = \alpha Ax + \beta y\)

Function Documentation

gemv()

template<typename TA , typename TX , typename TY >

void blas::gemv	(	blas::Layout	layout,
		blas::Op	trans,
		int64_t	m,
		int64_t	n,
		blas::scalar_type< TA, TX, TY >	alpha,
		TA const *	A,
		int64_t	lda,
		TX const *	x,
		int64_t	incx,
		blas::scalar_type< TA, TX, TY >	beta,
		TY *	y,
		int64_t	incy
	)

General matrix-vector multiply:

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

where \(op(A)\) is one of \(op(A) = A\), \(op(A) = A^T\), or \(op(A) = A^H\), alpha and beta are scalars, x and y are vectors, and A is an m-by-n matrix.

Generic implementation for arbitrary data types.

Parameters

[in]	layout	Matrix storage, Layout::ColMajor or Layout::RowMajor.
[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\).
[in]	m	Number of rows of the matrix A. m >= 0.
[in]	n	Number of columns of the matrix A. n >= 0.
[in]	alpha	Scalar alpha. If alpha is zero, A and x are not accessed.
[in]	A	The m-by-n matrix A, stored in an lda-by-n array [RowMajor: m-by-lda].
[in]	lda	Leading dimension of A. lda >= max(1, m) [RowMajor: lda >= max(1, n)].
[in]	x	If trans = NoTrans: the n-element vector x, in an array of length (n-1)*abs(incx) + 1. Otherwise: the m-element vector x, in an array of length (m-1)*abs(incx) + 1.
[in]	incx	Stride between elements of x. incx must not be zero. If incx < 0, uses elements of x in reverse order: x(n-1), ..., x(0).
[in]	beta	Scalar beta. If beta is zero, y need not be set on input.
[in,out]	y	If trans = NoTrans: the m-element vector y, in an array of length (m-1)*abs(incy) + 1. Otherwise: the n-element vector y, in an array of length (n-1)*abs(incy) + 1.
[in]	incy	Stride between elements of y. incy must not be zero. If incy < 0, uses elements of y in reverse order: y(n-1), ..., y(0).