Loading...
Searching...
No Matches
hemv: Hermitian 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_chemv_batched (magma_uplo_t uplo, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex **dA_array, magma_int_t ldda, magmaFloatComplex **dX_array, magma_int_t incx, magmaFloatComplex beta, magmaFloatComplex **dY_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| CHEMV performs the matrix-vector operation:
void | magmablas_chemv_vbatched (magma_uplo_t uplo, 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)
| CHEMV performs the matrix-vector operation:
void | magmablas_dsymv_batched (magma_uplo_t uplo, magma_int_t n, double alpha, double **dA_array, magma_int_t ldda, double **dX_array, magma_int_t incx, double beta, double **dY_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| DSYMV performs the matrix-vector operation:
void | magmablas_dsymv_vbatched (magma_uplo_t uplo, 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)
| DSYMV performs the matrix-vector operation:
void | magmablas_ssymv_batched (magma_uplo_t uplo, magma_int_t n, float alpha, float **dA_array, magma_int_t ldda, float **dX_array, magma_int_t incx, float beta, float **dY_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| SSYMV performs the matrix-vector operation:
void | magmablas_ssymv_vbatched (magma_uplo_t uplo, 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)
| SSYMV performs the matrix-vector operation:
void | magmablas_zhemv_batched (magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex **dA_array, magma_int_t ldda, magmaDoubleComplex **dX_array, magma_int_t incx, magmaDoubleComplex beta, magmaDoubleComplex **dY_array, magma_int_t incy, magma_int_t batchCount, magma_queue_t queue)
| ZHEMV performs the matrix-vector operation:
void | magmablas_zhemv_vbatched (magma_uplo_t uplo, 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)
| ZHEMV performs the matrix-vector operation:

## Detailed Description

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

## Function Documentation

## magmablas_chemv_batched()

void magmablas_chemv_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex ** | dA_array,
|  | magma_int_t | ldda,
|  | magmaFloatComplex ** | dX_array,
|  | magma_int_t | incx,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dY_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CHEMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n Hermitian matrix. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER. On entry, N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading n by n upper triangular part of the array A must contain the upper triangular part of the Hermitian matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading n by n lower triangular part of the array A must contain the lower triangular part of the Hermitian matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER. On entry, LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that ldda is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dX_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER. On entry, 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.
  [in,out] | dY_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_chemv_vbatched()

void magmablas_chemv_vbatched | ( | magma_uplo_t | uplo,
|  | 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 )

CHEMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n Hermitian matrix. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER array, dimension(batchCoutn + 1). On entry, each element N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading N by N upper triangular part of the array A must contain the upper triangular part of the Hermitian matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading N by N lower triangular part of the array A must contain the lower triangular part of the Hermitian matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). On entry, each element LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that LDDA is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dx_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER array, dimension(batchCount + 1). On entry, each element INCX specifies the increment for the elements of each 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.
  [in,out] | dy_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER array, dimension(batchCount + 1). On entry, each element INCY specifies the increment for the elements of each Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dsymv_batched()

void magmablas_dsymv_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | double | alpha,
|  | double ** | dA_array,
|  | magma_int_t | ldda,
|  | double ** | dX_array,
|  | magma_int_t | incx,
|  | double | beta,
|  | double ** | dY_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DSYMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER. On entry, N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading n by n upper triangular part of the array A must contain the upper triangular part of the symmetric matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading n by n lower triangular part of the array A must contain the lower triangular part of the symmetric matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER. On entry, LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that ldda is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dX_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER. On entry, 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.
  [in,out] | dY_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dsymv_vbatched()

void magmablas_dsymv_vbatched | ( | magma_uplo_t | uplo,
|  | 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 )

DSYMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER array, dimension(batchCoutn + 1). On entry, each element N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading N by N upper triangular part of the array A must contain the upper triangular part of the symmetric matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading N by N lower triangular part of the array A must contain the lower triangular part of the symmetric matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). On entry, each element LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that LDDA is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dx_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER array, dimension(batchCount + 1). On entry, each element INCX specifies the increment for the elements of each 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.
  [in,out] | dy_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER array, dimension(batchCount + 1). On entry, each element INCY specifies the increment for the elements of each Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ssymv_batched()

void magmablas_ssymv_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | float | alpha,
|  | float ** | dA_array,
|  | magma_int_t | ldda,
|  | float ** | dX_array,
|  | magma_int_t | incx,
|  | float | beta,
|  | float ** | dY_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SSYMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER. On entry, N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading n by n upper triangular part of the array A must contain the upper triangular part of the symmetric matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading n by n lower triangular part of the array A must contain the lower triangular part of the symmetric matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER. On entry, LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that ldda is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dX_array | Array of pointers, dimension(batchCount). Each is a REAL array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER. On entry, 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.
  [in,out] | dY_array | Array of pointers, dimension(batchCount). Each is a REAL array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ssymv_vbatched()

void magmablas_ssymv_vbatched | ( | magma_uplo_t | uplo,
|  | 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 )

SSYMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER array, dimension(batchCoutn + 1). On entry, each element N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading N by N upper triangular part of the array A must contain the upper triangular part of the symmetric matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading N by N lower triangular part of the array A must contain the lower triangular part of the symmetric matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). On entry, each element LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that LDDA is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dx_array | Array of pointers, dimension(batchCount). Each is a REAL array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER array, dimension(batchCount + 1). On entry, each element INCX specifies the increment for the elements of each 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.
  [in,out] | dy_array | Array of pointers, dimension(batchCount). Each is a REAL array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER array, dimension(batchCount + 1). On entry, each element INCY specifies the increment for the elements of each Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zhemv_batched()

void magmablas_zhemv_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex ** | dA_array,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex ** | dX_array,
|  | magma_int_t | incx,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dY_array,
|  | magma_int_t | incy,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZHEMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n Hermitian matrix. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER. On entry, N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading n by n upper triangular part of the array A must contain the upper triangular part of the Hermitian matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading n by n lower triangular part of the array A must contain the lower triangular part of the Hermitian matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER. On entry, LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that ldda is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dX_array | Array of pointers, dimension(batchCount). Each is a COMPLEX_16 array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER. On entry, 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.
  [in,out] | dY_array | Array of pointers, dimension(batchCount). Each is a COMPLEX_16 array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zhemv_vbatched()

void magmablas_zhemv_vbatched | ( | magma_uplo_t | uplo,
|  | 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 )

ZHEMV performs the matrix-vector operation:

    y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n Hermitian matrix. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t. On entry, UPLO specifies whether the upper or lower triangular part of the array A is to be referenced as follows:
  - = MagmaUpper: Only the upper triangular part of A is to be referenced.
  - = MagmaLower: Only the lower triangular part of A is to be referenced.

  [in] | n | INTEGER array, dimension(batchCoutn + 1). On entry, each element N specifies the order of each matrix A. N must be at least zero.
  [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 ). Before entry with UPLO = MagmaUpper, the leading N by N upper triangular part of the array A must contain the upper triangular part of the Hermitian matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = MagmaLower, the leading N by N lower triangular part of the array A must contain the lower triangular part of the Hermitian matrix and the strictly upper triangular part of A is not referenced. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). On entry, each element LDDA specifies the first dimension of each A as declared in the calling (sub) program. LDDA must be at least max( 1, n ). It is recommended that LDDA is multiple of 16. Otherwise performance would be deteriorated as the memory accesses would not be fully coalescent.
  [in] | dx_array | Array of pointers, dimension(batchCount). Each is a COMPLEX_16 array X of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector X.
  [in] | incx | INTEGER array, dimension(batchCount + 1). On entry, each element INCX specifies the increment for the elements of each 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.
  [in,out] | dy_array | Array of pointers, dimension(batchCount). Each is a COMPLEX_16 array Y of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector Y. On exit, Y is overwritten by the updated vector Y.
  [in] | incy | INTEGER array, dimension(batchCount + 1). On entry, each element INCY specifies the increment for the elements of each Y. INCY must not be zero.
  [in] | batchCount | INTEGER. The number of problems to operate on.
  [in] | queue | magma_queue_t Queue to execute in.