MAGMA  2.3.0
Matrix Algebra for GPU and Multicore Architectures
 All Classes Files Functions Friends Groups Pages
gemv: General matrix-vector multiply

\( 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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

Detailed Description

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

Function Documentation

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]transAOperation to perform on A.
[in]mNumber of rows of A. m >= 0.
[in]nNumber of columns of A. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dACOMPLEX array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]lddaLeading dimension of dA.
[in]dxCOMPLEX 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]incxStride between consecutive elements of dx. incx != 0.
[in]betaScalar \( \beta \)
[in,out]dyCOMPLEX 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]incyStride between consecutive elements of dy. incy != 0.
[in]queuemagma_queue_t Queue to execute in.
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]transAOperation to perform on A.
[in]mNumber of rows of A. m >= 0.
[in]nNumber of columns of A. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dADOUBLE PRECISION array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]lddaLeading dimension of dA.
[in]dxDOUBLE 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]incxStride between consecutive elements of dx. incx != 0.
[in]betaScalar \( \beta \)
[in,out]dyDOUBLE 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]incyStride between consecutive elements of dy. incy != 0.
[in]queuemagma_queue_t Queue to execute in.
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]transAOperation to perform on A.
[in]mNumber of rows of A. m >= 0.
[in]nNumber of columns of A. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dAREAL array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]lddaLeading dimension of dA.
[in]dxREAL 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]incxStride between consecutive elements of dx. incx != 0.
[in]betaScalar \( \beta \)
[in,out]dyREAL 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]incyStride between consecutive elements of dy. incy != 0.
[in]queuemagma_queue_t Queue to execute in.
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]transAOperation to perform on A.
[in]mNumber of rows of A. m >= 0.
[in]nNumber of columns of A. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dACOMPLEX_16 array of dimension (ldda,n), ldda >= max(1,m). The m-by-n matrix A, on GPU device.
[in]lddaLeading dimension of dA.
[in]dxCOMPLEX_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]incxStride between consecutive elements of dx. incx != 0.
[in]betaScalar \( \beta \)
[in,out]dyCOMPLEX_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]incyStride between consecutive elements of dy. incy != 0.
[in]queuemagma_queue_t Queue to execute in.
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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaCOMPLEX On entry, ALPHA specifies the scalar alpha.
[in]dACOMPLEX array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxCOMPLEX array of dimension n
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaDOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyREAL array of dimension m
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]transmagma_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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaCOMPLEX On entry, ALPHA specifies the scalar alpha.
[in]dACOMPLEX array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxCOMPLEX array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaCOMPLEX On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyCOMPLEX array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaDOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
[in]dADOUBLE PRECISION array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxDOUBLE PRECISION array of dimension n
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaDOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyDOUBLE PRECISION array of dimension m
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]transmagma_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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaDOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
[in]dADOUBLE PRECISION array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxDOUBLE PRECISION array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaDOUBLE PRECISION On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyDOUBLE PRECISION array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaREAL On entry, ALPHA specifies the scalar alpha.
[in]dAREAL array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxREAL array of dimension n
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaDOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyREAL array of dimension m
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]transmagma_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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaREAL On entry, ALPHA specifies the scalar alpha.
[in]dAREAL array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxREAL array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaREAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyREAL array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaCOMPLEX_16 On entry, ALPHA specifies the scalar alpha.
[in]dACOMPLEX_16 array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxCOMPLEX_16 array of dimension n
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaDOUBLE REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyDOUBLE PRECISION array of dimension m
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.
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]transmagma_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]mINTEGER On entry, m specifies the number of rows of the matrix A.
[in]nINTEGER On entry, n specifies the number of columns of the matrix A
[in]alphaCOMPLEX_16 On entry, ALPHA specifies the scalar alpha.
[in]dACOMPLEX_16 array of dimension ( LDDA, n ) on the GPU.
[in]lddaINTEGER LDDA specifies the leading dimension of A.
[in]dxCOMPLEX_16 array of dimension n if trans == MagmaNoTrans m if trans == MagmaTrans or MagmaConjTrans
[in]incxSpecifies the increment for the elements of X. INCX must not be zero.
[in]betaCOMPLEX_16 On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
[out]dyCOMPLEX_16 array of dimension m if trans == MagmaNoTrans n if trans == MagmaTrans or MagmaConjTrans
[in]incySpecifies the increment for the elements of Y. INCY must not be zero.
[in]queuemagma_queue_t Queue to execute in.