MAGMA
2.7.1
Matrix Algebra for GPU and Multicore Architectures
|
\( 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... | |
\( y = \alpha Ax + \beta y \)
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).
[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. |
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).
[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. |
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).
[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. |
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).
[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. |
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.
[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. |
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.
[in] | trans | magma_trans_t On entry, TRANS specifies the operation to be performed as follows:
|
[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. |
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.
[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. |
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.
[in] | trans | magma_trans_t On entry, TRANS specifies the operation to be performed as follows:
|
[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. |
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.
[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. |
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.
[in] | trans | magma_trans_t On entry, TRANS specifies the operation to be performed as follows:
|
[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. |
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.
[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. |
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.
[in] | trans | magma_trans_t On entry, TRANS specifies the operation to be performed as follows:
|
[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. |