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

Functions
void	magma_cgemv (magma_trans_t transA, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dx, magma_int_t incx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_int_t incy, magma_queue_t queue)
	Perform matrix-vector product.

void	magma_dgemv (magma_trans_t transA, magma_int_t m, magma_int_t n, double alpha, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_const_ptr dx, magma_int_t incx, double beta, magmaDouble_ptr dy, magma_int_t incy, magma_queue_t queue)
	Perform matrix-vector product.

void	magma_sgemv (magma_trans_t transA, magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_const_ptr dx, magma_int_t incx, float beta, magmaFloat_ptr dy, magma_int_t incy, magma_queue_t queue)
	Perform matrix-vector product.

void	magma_zgemv (magma_trans_t transA, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dx, magma_int_t incx, magmaDoubleComplex beta, magmaDoubleComplex_ptr dy, magma_int_t incy, magma_queue_t queue)
	Perform matrix-vector product.

void	magmablas_cgemv_conj (magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dx, magma_int_t incx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_int_t incy, magma_queue_t queue)
	CGEMV_CONJ performs the matrix-vector operation.

void	magmablas_cgemv (magma_trans_t trans, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dx, magma_int_t incx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_int_t incy, magma_queue_t queue)
	CGEMV performs one of the matrix-vector operations.

void	magmablas_dgemv_conj (magma_int_t m, magma_int_t n, double alpha, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_const_ptr dx, magma_int_t incx, double beta, magmaDouble_ptr dy, magma_int_t incy, magma_queue_t queue)
	DGEMV_CONJ performs the matrix-vector operation.

void	magmablas_dgemv (magma_trans_t trans, magma_int_t m, magma_int_t n, double alpha, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_const_ptr dx, magma_int_t incx, double beta, magmaDouble_ptr dy, magma_int_t incy, magma_queue_t queue)
	DGEMV performs one of the matrix-vector operations.

void	magmablas_sgemv_conj (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_const_ptr dx, magma_int_t incx, float beta, magmaFloat_ptr dy, magma_int_t incy, magma_queue_t queue)
	SGEMV_CONJ performs the matrix-vector operation.

void	magmablas_sgemv (magma_trans_t trans, magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_const_ptr dx, magma_int_t incx, float beta, magmaFloat_ptr dy, magma_int_t incy, magma_queue_t queue)
	SGEMV performs one of the matrix-vector operations.

void	magmablas_zgemv_conj (magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dx, magma_int_t incx, magmaDoubleComplex beta, magmaDoubleComplex_ptr dy, magma_int_t incy, magma_queue_t queue)
	ZGEMV_CONJ performs the matrix-vector operation.

void	magmablas_zgemv (magma_trans_t trans, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dx, magma_int_t incx, magmaDoubleComplex beta, magmaDoubleComplex_ptr dy, magma_int_t incy, magma_queue_t queue)
	ZGEMV performs one of the matrix-vector operations.

Detailed Description

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

Function Documentation

◆ magma_cgemv()

void magma_cgemv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloatComplex_const_ptr	dx,
		magma_int_t	incx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

Perform matrix-vector product.

\( y = \alpha A x + \beta y \) (transA == MagmaNoTrans), or
\( y = \alpha A^T x + \beta y \) (transA == MagmaTrans), or
\( y = \alpha A^H x + \beta y \) (transA == MagmaConjTrans).

Parameters

[in]	transA	Operation to perform on A.
[in]	m	Number of rows of A. m >= 0.
[in]	n	Number of columns of A. n >= 0.
[in]	alpha	Scalar \( \alpha \)
[in]	dA	COMPLEX array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]	ldda	Leading dimension of dA.
[in]	dx	COMPLEX array on GPU device. If transA == MagmaNoTrans, the n element vector x of dimension (1 + (n-1)incx); otherwise, the m element vector x of dimension (1 + (m-1)incx).
[in]	incx	Stride between consecutive elements of dx. incx != 0.
[in]	beta	Scalar \( \beta \)
[in,out]	dy	COMPLEX array on GPU device. If transA == MagmaNoTrans, the m element vector y of dimension (1 + (m-1)incy); otherwise, the n element vector y of dimension (1 + (n-1)incy).
[in]	incy	Stride between consecutive elements of dy. incy != 0.
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_dgemv()

void magma_dgemv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		double	alpha,
		magmaDouble_const_ptr	dA,
		magma_int_t	ldda,
		magmaDouble_const_ptr	dx,
		magma_int_t	incx,
		double	beta,
		magmaDouble_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

Perform matrix-vector product.

\( y = \alpha A x + \beta y \) (transA == MagmaNoTrans), or
\( y = \alpha A^T x + \beta y \) (transA == MagmaTrans), or
\( y = \alpha A^H x + \beta y \) (transA == MagmaConjTrans).

Parameters

[in]	transA	Operation to perform on A.
[in]	m	Number of rows of A. m >= 0.
[in]	n	Number of columns of A. n >= 0.
[in]	alpha	Scalar \( \alpha \)
[in]	dA	DOUBLE PRECISION array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]	ldda	Leading dimension of dA.
[in]	dx	DOUBLE PRECISION array on GPU device. If transA == MagmaNoTrans, the n element vector x of dimension (1 + (n-1)incx); otherwise, the m element vector x of dimension (1 + (m-1)incx).
[in]	incx	Stride between consecutive elements of dx. incx != 0.
[in]	beta	Scalar \( \beta \)
[in,out]	dy	DOUBLE PRECISION array on GPU device. If transA == MagmaNoTrans, the m element vector y of dimension (1 + (m-1)incy); otherwise, the n element vector y of dimension (1 + (n-1)incy).
[in]	incy	Stride between consecutive elements of dy. incy != 0.
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_sgemv()

void magma_sgemv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		float	alpha,
		magmaFloat_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloat_const_ptr	dx,
		magma_int_t	incx,
		float	beta,
		magmaFloat_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

Perform matrix-vector product.

\( y = \alpha A x + \beta y \) (transA == MagmaNoTrans), or
\( y = \alpha A^T x + \beta y \) (transA == MagmaTrans), or
\( y = \alpha A^H x + \beta y \) (transA == MagmaConjTrans).

Parameters

[in]	transA	Operation to perform on A.
[in]	m	Number of rows of A. m >= 0.
[in]	n	Number of columns of A. n >= 0.
[in]	alpha	Scalar \( \alpha \)
[in]	dA	REAL array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]	ldda	Leading dimension of dA.
[in]	dx	REAL array on GPU device. If transA == MagmaNoTrans, the n element vector x of dimension (1 + (n-1)incx); otherwise, the m element vector x of dimension (1 + (m-1)incx).
[in]	incx	Stride between consecutive elements of dx. incx != 0.
[in]	beta	Scalar \( \beta \)
[in,out]	dy	REAL array on GPU device. If transA == MagmaNoTrans, the m element vector y of dimension (1 + (m-1)incy); otherwise, the n element vector y of dimension (1 + (n-1)incy).
[in]	incy	Stride between consecutive elements of dy. incy != 0.
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_zgemv()

void magma_zgemv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magmaDoubleComplex	alpha,
		magmaDoubleComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaDoubleComplex_const_ptr	dx,
		magma_int_t	incx,
		magmaDoubleComplex	beta,
		magmaDoubleComplex_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

Perform matrix-vector product.

\( y = \alpha A x + \beta y \) (transA == MagmaNoTrans), or
\( y = \alpha A^T x + \beta y \) (transA == MagmaTrans), or
\( y = \alpha A^H x + \beta y \) (transA == MagmaConjTrans).

Parameters

[in]	transA	Operation to perform on A.
[in]	m	Number of rows of A. m >= 0.
[in]	n	Number of columns of A. n >= 0.
[in]	alpha	Scalar \( \alpha \)
[in]	dA	COMPLEX_16 array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]	ldda	Leading dimension of dA.
[in]	dx	COMPLEX_16 array on GPU device. If transA == MagmaNoTrans, the n element vector x of dimension (1 + (n-1)incx); otherwise, the m element vector x of dimension (1 + (m-1)incx).
[in]	incx	Stride between consecutive elements of dx. incx != 0.
[in]	beta	Scalar \( \beta \)
[in,out]	dy	COMPLEX_16 array on GPU device. If transA == MagmaNoTrans, the m element vector y of dimension (1 + (m-1)incy); otherwise, the n element vector y of dimension (1 + (n-1)incy).
[in]	incy	Stride between consecutive elements of dy. incy != 0.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_cgemv_conj()

void magmablas_cgemv_conj	(	magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloatComplex_const_ptr	dx,
		magma_int_t	incx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

CGEMV_CONJ performs the matrix-vector operation.

y := alpha*A*conj(x)    + beta*y,

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

Parameters

[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	COMPLEX On entry, ALPHA specifies the scalar alpha.
[in]	dA	COMPLEX array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	COMPLEX array of dimension n
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	DOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	REAL array of dimension m
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_cgemv()

void magmablas_cgemv	(	magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloatComplex_const_ptr	dx,
		magma_int_t	incx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

CGEMV performs one of the matrix-vector operations.

y := alpha*A*x    + beta*y,   or
y := alpha*A**T*x + beta*y,   or
y := alpha*A**H*x + beta*y,

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

Parameters

[in]	trans	magma_trans_t On entry, TRANS specifies the operation to be performed as follows: = MagmaNoTrans: y := alphaA x + betay = MagmaTrans: y := alphaA^Tx + betay = MagmaConjTrans: y := alphaA^Hx + beta*y
[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	COMPLEX On entry, ALPHA specifies the scalar alpha.
[in]	dA	COMPLEX array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	COMPLEX array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	COMPLEX On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	COMPLEX array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_dgemv_conj()

void magmablas_dgemv_conj	(	magma_int_t	m,
		magma_int_t	n,
		double	alpha,
		magmaDouble_const_ptr	dA,
		magma_int_t	ldda,
		magmaDouble_const_ptr	dx,
		magma_int_t	incx,
		double	beta,
		magmaDouble_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

DGEMV_CONJ performs the matrix-vector operation.

y := alpha*A*conj(x)    + beta*y,

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

Parameters

[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	DOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
[in]	dA	DOUBLE PRECISION array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	DOUBLE PRECISION array of dimension n
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	DOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	DOUBLE PRECISION array of dimension m
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_dgemv()

void magmablas_dgemv	(	magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		double	alpha,
		magmaDouble_const_ptr	dA,
		magma_int_t	ldda,
		magmaDouble_const_ptr	dx,
		magma_int_t	incx,
		double	beta,
		magmaDouble_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

DGEMV performs one of the matrix-vector operations.

y := alpha*A*x    + beta*y,   or
y := alpha*A**T*x + beta*y,   or
y := alpha*A**H*x + beta*y,

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

Parameters

[in]	trans	magma_trans_t On entry, TRANS specifies the operation to be performed as follows: = MagmaNoTrans: y := alphaA x + betay = MagmaTrans: y := alphaA^Tx + betay = MagmaConjTrans: y := alphaA^Hx + beta*y
[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	DOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
[in]	dA	DOUBLE PRECISION array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	DOUBLE PRECISION array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	DOUBLE PRECISION On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	DOUBLE PRECISION array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_sgemv_conj()

void magmablas_sgemv_conj	(	magma_int_t	m,
		magma_int_t	n,
		float	alpha,
		magmaFloat_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloat_const_ptr	dx,
		magma_int_t	incx,
		float	beta,
		magmaFloat_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

SGEMV_CONJ performs the matrix-vector operation.

y := alpha*A*conj(x)    + beta*y,

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

Parameters

[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	REAL On entry, ALPHA specifies the scalar alpha.
[in]	dA	REAL array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	REAL array of dimension n
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	DOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	REAL array of dimension m
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_sgemv()

void magmablas_sgemv	(	magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		float	alpha,
		magmaFloat_const_ptr	dA,
		magma_int_t	ldda,
		magmaFloat_const_ptr	dx,
		magma_int_t	incx,
		float	beta,
		magmaFloat_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

SGEMV performs one of the matrix-vector operations.

y := alpha*A*x    + beta*y,   or
y := alpha*A**T*x + beta*y,   or
y := alpha*A**H*x + beta*y,

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

Parameters

[in]	trans	magma_trans_t On entry, TRANS specifies the operation to be performed as follows: = MagmaNoTrans: y := alphaA x + betay = MagmaTrans: y := alphaA^Tx + betay = MagmaConjTrans: y := alphaA^Hx + beta*y
[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	REAL On entry, ALPHA specifies the scalar alpha.
[in]	dA	REAL array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	REAL array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	REAL array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_zgemv_conj()

void magmablas_zgemv_conj	(	magma_int_t	m,
		magma_int_t	n,
		magmaDoubleComplex	alpha,
		magmaDoubleComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaDoubleComplex_const_ptr	dx,
		magma_int_t	incx,
		magmaDoubleComplex	beta,
		magmaDoubleComplex_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

ZGEMV_CONJ performs the matrix-vector operation.

y := alpha*A*conj(x)    + beta*y,

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

Parameters

[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	COMPLEX_16 On entry, ALPHA specifies the scalar alpha.
[in]	dA	COMPLEX_16 array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	COMPLEX_16 array of dimension n
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	DOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	DOUBLE PRECISION array of dimension m
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

◆ magmablas_zgemv()

void magmablas_zgemv	(	magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		magmaDoubleComplex	alpha,
		magmaDoubleComplex_const_ptr	dA,
		magma_int_t	ldda,
		magmaDoubleComplex_const_ptr	dx,
		magma_int_t	incx,
		magmaDoubleComplex	beta,
		magmaDoubleComplex_ptr	dy,
		magma_int_t	incy,
		magma_queue_t	queue
	)

ZGEMV performs one of the matrix-vector operations.

y := alpha*A*x    + beta*y,   or
y := alpha*A**T*x + beta*y,   or
y := alpha*A**H*x + beta*y,

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

Parameters

[in]	trans	magma_trans_t On entry, TRANS specifies the operation to be performed as follows: = MagmaNoTrans: y := alphaA x + betay = MagmaTrans: y := alphaA^Tx + betay = MagmaConjTrans: y := alphaA^Hx + beta*y
[in]	m	INTEGER On entry, m specifies the number of rows of the matrix A.
[in]	n	INTEGER On entry, n specifies the number of columns of the matrix A
[in]	alpha	COMPLEX_16 On entry, ALPHA specifies the scalar alpha.
[in]	dA	COMPLEX_16 array of dimension ( LDDA, n ) on the GPU.
[in]	ldda	INTEGER LDDA specifies the leading dimension of A.
[in]	dx	COMPLEX_16 array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]	incx	Specifies the increment for the elements of X. INCX must not be zero.
[in]	beta	COMPLEX_16 On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]	dy	COMPLEX_16 array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]	incy	Specifies the increment for the elements of Y. INCY must not be zero.
[in]	queue	magma_queue_t Queue to execute in.

Functions

Detailed Description

Function Documentation

◆ magma_cgemv()

◆ magma_dgemv()

◆ magma_sgemv()

◆ magma_zgemv()

◆ magmablas_cgemv_conj()

◆ magmablas_cgemv()

◆ magmablas_dgemv_conj()

◆ magmablas_dgemv()

◆ magmablas_sgemv_conj()

◆ magmablas_sgemv()

◆ magmablas_zgemv_conj()

◆ magmablas_zgemv()