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

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

## Functions

void | magmablas_cgemv_batched (magma_trans_t trans, magma_int_t m, magma_int_t n, const magmaFloatComplex alpha, magmaFloatComplex const *const *dA_array, magma_int_t ldda, magmaFloatComplex const *const *dx_array, magma_int_t incx, const magmaFloatComplex beta, magmaFloatComplex **dy_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| CGEMV performs one of the matrix-vector operations.
void | magmablas_cgemv_batched_strided (magma_trans_t trans, magma_int_t m, magma_int_t n, const magmaFloatComplex alpha, const magmaFloatComplex *dA, magma_int_t ldda, magma_int_t strideA, const magmaFloatComplex *dx, magma_int_t incx, magma_int_t stridex, const magmaFloatComplex beta, magmaFloatComplex *dy, magma_int_t incy, magma_int_t stridey, magma_int_t batchCount, magma_queue_t queue)
| CGEMV performs one of the matrix-vector operations.
void | magmablas_cgemv_vbatched (magma_trans_t trans, magma_int_t *m, magma_int_t *n, magmaFloatComplex alpha, magmaFloatComplex_ptr dA_array[], magma_int_t *ldda, magmaFloatComplex_ptr dx_array[], magma_int_t *incx, magmaFloatComplex beta, magmaFloatComplex_ptr dy_array[], magma_int_t *incy, magma_int_t batchCount, magma_queue_t queue)
| CGEMV performs one of the matrix-vector operations.
void | magmablas_dgemv_batched (magma_trans_t trans, magma_int_t m, magma_int_t n, const double alpha, double const *const *dA_array, magma_int_t ldda, double const *const *dx_array, magma_int_t incx, const double beta, double **dy_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| DGEMV performs one of the matrix-vector operations.
void | magmablas_dgemv_batched_strided (magma_trans_t trans, magma_int_t m, magma_int_t n, const double alpha, const double *dA, magma_int_t ldda, magma_int_t strideA, const double *dx, magma_int_t incx, magma_int_t stridex, const double beta, double *dy, magma_int_t incy, magma_int_t stridey, magma_int_t batchCount, magma_queue_t queue)
| DGEMV performs one of the matrix-vector operations.
void | magmablas_dgemv_vbatched (magma_trans_t trans, magma_int_t *m, magma_int_t *n, double alpha, magmaDouble_ptr dA_array[], magma_int_t *ldda, magmaDouble_ptr dx_array[], magma_int_t *incx, double beta, magmaDouble_ptr dy_array[], magma_int_t *incy, magma_int_t batchCount, magma_queue_t queue)
| DGEMV performs one of the matrix-vector operations.
void | magmablas_sgemv_batched (magma_trans_t trans, magma_int_t m, magma_int_t n, const float alpha, float const *const *dA_array, magma_int_t ldda, float const *const *dx_array, magma_int_t incx, const float beta, float **dy_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| SGEMV performs one of the matrix-vector operations.
void | magmablas_sgemv_batched_strided (magma_trans_t trans, magma_int_t m, magma_int_t n, const float alpha, const float *dA, magma_int_t ldda, magma_int_t strideA, const float *dx, magma_int_t incx, magma_int_t stridex, const float beta, float *dy, magma_int_t incy, magma_int_t stridey, magma_int_t batchCount, magma_queue_t queue)
| SGEMV performs one of the matrix-vector operations.
void | magmablas_sgemv_vbatched (magma_trans_t trans, magma_int_t *m, magma_int_t *n, float alpha, magmaFloat_ptr dA_array[], magma_int_t *ldda, magmaFloat_ptr dx_array[], magma_int_t *incx, float beta, magmaFloat_ptr dy_array[], magma_int_t *incy, magma_int_t batchCount, magma_queue_t queue)
| SGEMV performs one of the matrix-vector operations.
void | magmablas_zgemv_batched (magma_trans_t trans, magma_int_t m, magma_int_t n, const magmaDoubleComplex alpha, magmaDoubleComplex const *const *dA_array, magma_int_t ldda, magmaDoubleComplex const *const *dx_array, magma_int_t incx, const magmaDoubleComplex beta, magmaDoubleComplex **dy_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| ZGEMV performs one of the matrix-vector operations.
void | magmablas_zgemv_batched_strided (magma_trans_t trans, magma_int_t m, magma_int_t n, const magmaDoubleComplex alpha, const magmaDoubleComplex *dA, magma_int_t ldda, magma_int_t strideA, const magmaDoubleComplex *dx, magma_int_t incx, magma_int_t stridex, const magmaDoubleComplex beta, magmaDoubleComplex *dy, magma_int_t incy, magma_int_t stridey, magma_int_t batchCount, magma_queue_t queue)
| ZGEMV performs one of the matrix-vector operations.
void | magmablas_zgemv_vbatched (magma_trans_t trans, magma_int_t *m, magma_int_t *n, magmaDoubleComplex alpha, magmaDoubleComplex_ptr dA_array[], magma_int_t *ldda, magmaDoubleComplex_ptr dx_array[], magma_int_t *incx, magmaDoubleComplex beta, magmaDoubleComplex_ptr dy_array[], magma_int_t *incy, magma_int_t batchCount, magma_queue_t queue)
| ZGEMV performs one of the matrix-vector operations.

## Detailed Description

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

## Function Documentation

## magmablas_cgemv_batched()

void magmablas_cgemv_batched | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const magmaFloatComplex | alpha,
|  | magmaFloatComplex const *const * | dA_array,
|  | magma_int_t | ldda,
|  | magmaFloatComplex const *const * | dx_array,
|  | magma_int_t | incx,
|  | const magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dy_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using pointer-to-pointer (P2P) interface. All matrices and vectors must have the same dimension(s).

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_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array A of DIMENSION ( ldda, n ) on the GPU
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a 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, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a 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] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_cgemv_batched_strided()

void magmablas_cgemv_batched_strided | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const magmaFloatComplex | alpha,
|  | const magmaFloatComplex * | dA,
|  | magma_int_t | ldda,
|  | magma_int_t | strideA,
|  | const magmaFloatComplex * | dx,
|  | magma_int_t | incx,
|  | magma_int_t | stridex,
|  | const magmaFloatComplex | beta,
|  | magmaFloatComplex * | dy,
|  | magma_int_t | incy,
|  | magma_int_t | stridey,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using "pointer + stride" interface. All matrices and vectors must have the same dimension(s).

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 | Pointer to the first COMPLEX array 'A' of DIMENSION ( ldda, n ) in the batch
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | strideA | INTEGER specifies the distance between two consecutive matrices in the batch.
  [in] | dx | Pointer to the first COMPLEX array 'x' in the batch, 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] | stridex | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | beta | COMPLEX On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy | Pointer to the first COMPLEX array 'y' in the batch, 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] | stridey | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_cgemv_vbatched()

void magmablas_cgemv_vbatched | ( | magma_trans_t | trans,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex_ptr | dA_array[],
|  | magma_int_t * | ldda,
|  | magmaFloatComplex_ptr | dx_array[],
|  | magma_int_t * | incx,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex_ptr | dy_array[],
|  | magma_int_t * | incy,
|  | magma_int_t | batchCount,
|  | 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 | Array of integers, dimension (batchCount + 1). On entry, each INTEGER M specifies the number of rows of each matrix A. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of each matrix A The last element of the array is used internally by the routine.
  [in] | alpha | COMPLEX On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array A of DIMENSION ( LDDA, N ) on the GPU
  [in] | ldda | Array of integers, dimension (batchCount + 1). Each INTEGER LDDA specifies the leading dimension of each matrix A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array of dimension N if trans == MagmaNoTrans M if trans == MagmaTrans or MagmaConjTrans
  [in] | incx | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector X. INCX must not be zero. The last element of the array is used internally by the routine.
  [in] | beta | COMPLEX On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array of dimension M if trans == MagmaNoTrans N if trans == MagmaTrans or MagmaConjTrans
  [in] | incy | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector Y. INCY must not be zero. The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgemv_batched()

void magmablas_dgemv_batched | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const double | alpha,
|  | double const *const * | dA_array,
|  | magma_int_t | ldda,
|  | double const *const * | dx_array,
|  | magma_int_t | incx,
|  | const double | beta,
|  | double ** | dy_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using pointer-to-pointer (P2P) interface. All matrices and vectors must have the same dimension(s).

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_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array A of DIMENSION ( ldda, n ) on the GPU
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a 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, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a 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] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgemv_batched_strided()

void magmablas_dgemv_batched_strided | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const double | alpha,
|  | const double * | dA,
|  | magma_int_t | ldda,
|  | magma_int_t | strideA,
|  | const double * | dx,
|  | magma_int_t | incx,
|  | magma_int_t | stridex,
|  | const double | beta,
|  | double * | dy,
|  | magma_int_t | incy,
|  | magma_int_t | stridey,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using "pointer + stride" interface. All matrices and vectors must have the same dimension(s).

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 | Pointer to the first DOUBLE PRECISION array 'A' of DIMENSION ( ldda, n ) in the batch
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | strideA | INTEGER specifies the distance between two consecutive matrices in the batch.
  [in] | dx | Pointer to the first DOUBLE PRECISION array 'x' in the batch, 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] | stridex | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | beta | DOUBLE PRECISION On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy | Pointer to the first DOUBLE PRECISION array 'y' in the batch, 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] | stridey | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgemv_vbatched()

void magmablas_dgemv_vbatched | ( | magma_trans_t | trans,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | double | alpha,
|  | magmaDouble_ptr | dA_array[],
|  | magma_int_t * | ldda,
|  | magmaDouble_ptr | dx_array[],
|  | magma_int_t * | incx,
|  | double | beta,
|  | magmaDouble_ptr | dy_array[],
|  | magma_int_t * | incy,
|  | magma_int_t | batchCount,
|  | 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 | Array of integers, dimension (batchCount + 1). On entry, each INTEGER M specifies the number of rows of each matrix A. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of each matrix A The last element of the array is used internally by the routine.
  [in] | alpha | DOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array A of DIMENSION ( LDDA, N ) on the GPU
  [in] | ldda | Array of integers, dimension (batchCount + 1). Each INTEGER LDDA specifies the leading dimension of each matrix A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array of dimension N if trans == MagmaNoTrans M if trans == MagmaTrans or MagmaConjTrans
  [in] | incx | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector X. INCX must not be zero. The last element of the array is used internally by the routine.
  [in] | beta | DOUBLE PRECISION On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array of dimension M if trans == MagmaNoTrans N if trans == MagmaTrans or MagmaConjTrans
  [in] | incy | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector Y. INCY must not be zero. The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgemv_batched()

void magmablas_sgemv_batched | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const float | alpha,
|  | float const *const * | dA_array,
|  | magma_int_t | ldda,
|  | float const *const * | dx_array,
|  | magma_int_t | incx,
|  | const float | beta,
|  | float ** | dy_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using pointer-to-pointer (P2P) interface. All matrices and vectors must have the same dimension(s).

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_array | Array of pointers, dimension (batchCount). Each is a REAL array A of DIMENSION ( ldda, n ) on the GPU
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a 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, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a 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] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgemv_batched_strided()

void magmablas_sgemv_batched_strided | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const float | alpha,
|  | const float * | dA,
|  | magma_int_t | ldda,
|  | magma_int_t | strideA,
|  | const float * | dx,
|  | magma_int_t | incx,
|  | magma_int_t | stridex,
|  | const float | beta,
|  | float * | dy,
|  | magma_int_t | incy,
|  | magma_int_t | stridey,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using "pointer + stride" interface. All matrices and vectors must have the same dimension(s).

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 | Pointer to the first REAL array 'A' of DIMENSION ( ldda, n ) in the batch
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | strideA | INTEGER specifies the distance between two consecutive matrices in the batch.
  [in] | dx | Pointer to the first REAL array 'x' in the batch, 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] | stridex | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | beta | REAL On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy | Pointer to the first REAL array 'y' in the batch, 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] | stridey | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgemv_vbatched()

void magmablas_sgemv_vbatched | ( | magma_trans_t | trans,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | float | alpha,
|  | magmaFloat_ptr | dA_array[],
|  | magma_int_t * | ldda,
|  | magmaFloat_ptr | dx_array[],
|  | magma_int_t * | incx,
|  | float | beta,
|  | magmaFloat_ptr | dy_array[],
|  | magma_int_t * | incy,
|  | magma_int_t | batchCount,
|  | 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 | Array of integers, dimension (batchCount + 1). On entry, each INTEGER M specifies the number of rows of each matrix A. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of each matrix A The last element of the array is used internally by the routine.
  [in] | alpha | REAL On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a REAL array A of DIMENSION ( LDDA, N ) on the GPU
  [in] | ldda | Array of integers, dimension (batchCount + 1). Each INTEGER LDDA specifies the leading dimension of each matrix A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a REAL array of dimension N if trans == MagmaNoTrans M if trans == MagmaTrans or MagmaConjTrans
  [in] | incx | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector X. INCX must not be zero. The last element of the array is used internally by the routine.
  [in] | beta | REAL On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a REAL array of dimension M if trans == MagmaNoTrans N if trans == MagmaTrans or MagmaConjTrans
  [in] | incy | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector Y. INCY must not be zero. The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgemv_batched()

void magmablas_zgemv_batched | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const magmaDoubleComplex | alpha,
|  | magmaDoubleComplex const *const * | dA_array,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex const *const * | dx_array,
|  | magma_int_t | incx,
|  | const magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dy_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using pointer-to-pointer (P2P) interface. All matrices and vectors must have the same dimension(s).

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_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array A of DIMENSION ( ldda, n ) on the GPU
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a 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, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a 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] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgemv_batched_strided()

void magmablas_zgemv_batched_strided | ( | magma_trans_t | trans,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | const magmaDoubleComplex | alpha,
|  | const magmaDoubleComplex * | dA,
|  | magma_int_t | ldda,
|  | magma_int_t | strideA,
|  | const magmaDoubleComplex * | dx,
|  | magma_int_t | incx,
|  | magma_int_t | stridex,
|  | const magmaDoubleComplex | beta,
|  | magmaDoubleComplex * | dy,
|  | magma_int_t | incy,
|  | magma_int_t | stridey,
|  | magma_int_t | batchCount,
|  | 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.

This is the batch version of the routine, using "pointer + stride" interface. All matrices and vectors must have the same dimension(s).

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 | Pointer to the first COMPLEX_16 array 'A' of DIMENSION ( ldda, n ) in the batch
  [in] | ldda | INTEGER LDDA specifies the leading dimension of A.
  [in] | strideA | INTEGER specifies the distance between two consecutive matrices in the batch.
  [in] | dx | Pointer to the first COMPLEX_16 array 'x' in the batch, 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] | stridex | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | beta | COMPLEX_16 On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy | Pointer to the first COMPLEX_16 array 'y' in the batch, 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] | stridey | INTEGER Specifies the distance between two consecutive vectors in the batch
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgemv_vbatched()

void magmablas_zgemv_vbatched | ( | magma_trans_t | trans,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex_ptr | dA_array[],
|  | magma_int_t * | ldda,
|  | magmaDoubleComplex_ptr | dx_array[],
|  | magma_int_t * | incx,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex_ptr | dy_array[],
|  | magma_int_t * | incy,
|  | magma_int_t | batchCount,
|  | 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 | Array of integers, dimension (batchCount + 1). On entry, each INTEGER M specifies the number of rows of each matrix A. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of each matrix A The last element of the array is used internally by the routine.
  [in] | alpha | COMPLEX_16 On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array A of DIMENSION ( LDDA, N ) on the GPU
  [in] | ldda | Array of integers, dimension (batchCount + 1). Each INTEGER LDDA specifies the leading dimension of each matrix A.
  [in] | dx_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array of dimension N if trans == MagmaNoTrans M if trans == MagmaTrans or MagmaConjTrans
  [in] | incx | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector X. INCX must not be zero. The last element of the array is used internally by the routine.
  [in] | beta | COMPLEX_16 On entry, ALPHA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
  [out] | dy_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array of dimension M if trans == MagmaNoTrans N if trans == MagmaTrans or MagmaConjTrans
  [in] | incy | Array of integers, dimension (batchCount + 1). Each integer specifies the increment for the elements of each vector Y. INCY must not be zero. The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.