Loading...
Searching...
No Matches
gemv: General matrix-vector multiply
Dense LA » MAGMA BLAS and Auxiliary » Level 2: matrix-vector operations, O(n^2) work

\(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 := alpha*A *x + beta*y
  - = MagmaTrans: y := alpha*A^T*x + beta*y
  - = MagmaConjTrans: y := alpha*A^H*x + 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 := alpha*A *x + beta*y
  - = MagmaTrans: y := alpha*A^T*x + beta*y
  - = MagmaConjTrans: y := alpha*A^H*x + 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 := alpha*A *x + beta*y
  - = MagmaTrans: y := alpha*A^T*x + beta*y
  - = MagmaConjTrans: y := alpha*A^H*x + 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 := alpha*A *x + beta*y
  - = MagmaTrans: y := alpha*A^T*x + beta*y
  - = MagmaConjTrans: y := alpha*A^H*x + 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.