Loading...
Searching...
No Matches
hemm: Hermitian matrix multiply
Batched LA » MAGMA BLAS and Auxiliary » Level 3: matrix-matrix operations, O(n^3) work

\(C = \alpha A B + \beta C\) or \(C = \alpha B A + \beta C\) where \(A\) is Hermitian More...

## Functions

void | magmablas_chemm_batched (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex **dA_array, magma_int_t ldda, magmaFloatComplex **dB_array, magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| CHEMM performs one of the matrix-matrix operations.
void | magmablas_chemm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_int_t *m, magma_int_t *n, magmaFloatComplex alpha, magmaFloatComplex **dA_array, magma_int_t *ldda, magmaFloatComplex **dB_array, magma_int_t *lddb, magmaFloatComplex beta, magmaFloatComplex **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| CHEMM performs one of the matrix-matrix operations.
void | magmablas_dsymm_batched (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, double alpha, double **dA_array, magma_int_t ldda, double **dB_array, magma_int_t lddb, double beta, double **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| DSYMM performs one of the matrix-matrix operations.
void | magmablas_dsymm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_int_t *m, magma_int_t *n, double alpha, double **dA_array, magma_int_t *ldda, double **dB_array, magma_int_t *lddb, double beta, double **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| DSYMM performs one of the matrix-matrix operations.
void | magmablas_ssymm_batched (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, float alpha, float **dA_array, magma_int_t ldda, float **dB_array, magma_int_t lddb, float beta, float **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| SSYMM performs one of the matrix-matrix operations.
void | magmablas_ssymm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_int_t *m, magma_int_t *n, float alpha, float **dA_array, magma_int_t *ldda, float **dB_array, magma_int_t *lddb, float beta, float **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| SSYMM performs one of the matrix-matrix operations.
void | magmablas_zhemm_batched (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex **dA_array, magma_int_t ldda, magmaDoubleComplex **dB_array, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| ZHEMM performs one of the matrix-matrix operations.
void | magmablas_zhemm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_int_t *m, magma_int_t *n, magmaDoubleComplex alpha, magmaDoubleComplex **dA_array, magma_int_t *ldda, magmaDoubleComplex **dB_array, magma_int_t *lddb, magmaDoubleComplex beta, magmaDoubleComplex **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| ZHEMM performs one of the matrix-matrix operations.

## Detailed Description

\(C = \alpha A B + \beta C\) or \(C = \alpha B A + \beta C\) where \(A\) is Hermitian

## Function Documentation

## magmablas_chemm_batched()

void magmablas_chemm_batched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex ** | dA_array,
|  | magma_int_t | ldda,
|  | magmaFloatComplex ** | dB_array,
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CHEMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a Hermitian matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each Hermitian matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each Hermitian matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the Hermitian matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the Hermitian matrix is to be referenced.

Parameters

  [in] | m | INTEGER On entry, m specifies the number of rows of each matrix C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of each matrix C. n >= 0.
  [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, ka ), where ka is m when side = MagmaLower and is n otherwise. Before entry with side = MagmaLeft, the m by m part of the array A must contain the Hermitian matrix, such that when uplo = MagmaUpper, the leading m by m 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, and when uplo = MagmaLower, the leading m by m 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. Before entry with side = MagmaRight, the n by n part of the array A must contain the Hermitian matrix, such that when 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, and when 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, they 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. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array B of DIMENSION ( lddb, n ). Before entry, the leading m by n part of the array B must contain the matrix B.
  [in] | lddb | INTEGER On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, m ).
  [in] | beta | COMPLEX On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array C of DIMENSION ( lddc, n ). Before entry, the leading m by n part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the m by n updated matrix.
  [in] | lddc | INTEGER On entry, lddc specifies the first dimension of C as declared in the calling (sub) program. lddc >= max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_chemm_vbatched()

void magmablas_chemm_vbatched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex ** | dA_array,
|  | magma_int_t * | ldda,
|  | magmaFloatComplex ** | dB_array,
|  | magma_int_t * | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CHEMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a Hermitian matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each Hermitian matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each Hermitian matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the Hermitian matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the Hermitian matrix is to be referenced.

Parameters

  [in] | m | INTEGER array, dimension(batchCount + 1). On entry, each element M specifies the number of rows of each matrix C. M >= 0.
  [in] | n | INTEGER array, dimension(batchCount + 1). On entry, each element N specifies the number of columns of each matrix C. N >= 0.
  [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, ka ), where ka is M when side = MagmaLower and is N otherwise. Before entry with side = MagmaLeft, the M by M part of the array A must contain the Hermitian matrix, such that when uplo = MagmaUpper, the leading M by M 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, and when uplo = MagmaLower, the leading M by M 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. Before entry with side = MagmaRight, the N by N part of the array A must contain the Hermitian matrix, such that when 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, and when 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, they 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. When side = MagmaLower then LDDA >= max( 1, M ), otherwise LDDA >= max( 1, N ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array B of DIMENSION ( LDDB, N ). Before entry, the leading M by N part of the array B must contain the matrix B.
  [in] | lddb | INTEGER array, dimension(batchCount + 1). On entry, each element LDDB specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, M ).
  [in] | beta | COMPLEX On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a COMPLEX array C of DIMENSION ( LDDC, N ). Before entry, the leading M by N part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the M by N updated matrix.
  [in] | lddc | INTEGER array, dimension(batchCount + 1). On entry, each element LDDC specifies the first dimension of C as declared in the calling (sub) program. LDDC >= max( 1, M ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dsymm_batched()

void magmablas_dsymm_batched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | double | alpha,
|  | double ** | dA_array,
|  | magma_int_t | ldda,
|  | double ** | dB_array,
|  | magma_int_t | lddb,
|  | double | beta,
|  | double ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DSYMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a symmetric matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each symmetric matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each symmetric matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the symmetric matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the symmetric matrix is to be referenced.

Parameters

  [in] | m | INTEGER On entry, m specifies the number of rows of each matrix C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of each matrix C. n >= 0.
  [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, ka ), where ka is m when side = MagmaLower and is n otherwise. Before entry with side = MagmaLeft, the m by m part of the array A must contain the symmetric matrix, such that when uplo = MagmaUpper, the leading m by m 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, and when uplo = MagmaLower, the leading m by m 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. Before entry with side = MagmaRight, the n by n part of the array A must contain the symmetric matrix, such that when 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, and when 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, they 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. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array B of DIMENSION ( lddb, n ). Before entry, the leading m by n part of the array B must contain the matrix B.
  [in] | lddb | INTEGER On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, m ).
  [in] | beta | DOUBLE PRECISION On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array C of DIMENSION ( lddc, n ). Before entry, the leading m by n part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the m by n updated matrix.
  [in] | lddc | INTEGER On entry, lddc specifies the first dimension of C as declared in the calling (sub) program. lddc >= max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dsymm_vbatched()

void magmablas_dsymm_vbatched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | double | alpha,
|  | double ** | dA_array,
|  | magma_int_t * | ldda,
|  | double ** | dB_array,
|  | magma_int_t * | lddb,
|  | double | beta,
|  | double ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DSYMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a symmetric matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each symmetric matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each symmetric matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the symmetric matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the symmetric matrix is to be referenced.

Parameters

  [in] | m | INTEGER array, dimension(batchCount + 1). On entry, each element M specifies the number of rows of each matrix C. M >= 0.
  [in] | n | INTEGER array, dimension(batchCount + 1). On entry, each element N specifies the number of columns of each matrix C. N >= 0.
  [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, ka ), where ka is M when side = MagmaLower and is N otherwise. Before entry with side = MagmaLeft, the M by M part of the array A must contain the symmetric matrix, such that when uplo = MagmaUpper, the leading M by M 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, and when uplo = MagmaLower, the leading M by M 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. Before entry with side = MagmaRight, the N by N part of the array A must contain the symmetric matrix, such that when 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, and when 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, they 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. When side = MagmaLower then LDDA >= max( 1, M ), otherwise LDDA >= max( 1, N ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array B of DIMENSION ( LDDB, N ). Before entry, the leading M by N part of the array B must contain the matrix B.
  [in] | lddb | INTEGER array, dimension(batchCount + 1). On entry, each element LDDB specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, M ).
  [in] | beta | DOUBLE PRECISION On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a DOUBLE PRECISION array C of DIMENSION ( LDDC, N ). Before entry, the leading M by N part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the M by N updated matrix.
  [in] | lddc | INTEGER array, dimension(batchCount + 1). On entry, each element LDDC specifies the first dimension of C as declared in the calling (sub) program. LDDC >= max( 1, M ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ssymm_batched()

void magmablas_ssymm_batched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | float | alpha,
|  | float ** | dA_array,
|  | magma_int_t | ldda,
|  | float ** | dB_array,
|  | magma_int_t | lddb,
|  | float | beta,
|  | float ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SSYMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a symmetric matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each symmetric matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each symmetric matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the symmetric matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the symmetric matrix is to be referenced.

Parameters

  [in] | m | INTEGER On entry, m specifies the number of rows of each matrix C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of each matrix C. n >= 0.
  [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, ka ), where ka is m when side = MagmaLower and is n otherwise. Before entry with side = MagmaLeft, the m by m part of the array A must contain the symmetric matrix, such that when uplo = MagmaUpper, the leading m by m 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, and when uplo = MagmaLower, the leading m by m 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. Before entry with side = MagmaRight, the n by n part of the array A must contain the symmetric matrix, such that when 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, and when 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, they 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. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a REAL array B of DIMENSION ( lddb, n ). Before entry, the leading m by n part of the array B must contain the matrix B.
  [in] | lddb | INTEGER On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, m ).
  [in] | beta | REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a REAL array C of DIMENSION ( lddc, n ). Before entry, the leading m by n part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the m by n updated matrix.
  [in] | lddc | INTEGER On entry, lddc specifies the first dimension of C as declared in the calling (sub) program. lddc >= max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_ssymm_vbatched()

void magmablas_ssymm_vbatched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | float | alpha,
|  | float ** | dA_array,
|  | magma_int_t * | ldda,
|  | float ** | dB_array,
|  | magma_int_t * | lddb,
|  | float | beta,
|  | float ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SSYMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a symmetric matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each symmetric matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each symmetric matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the symmetric matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the symmetric matrix is to be referenced.

Parameters

  [in] | m | INTEGER array, dimension(batchCount + 1). On entry, each element M specifies the number of rows of each matrix C. M >= 0.
  [in] | n | INTEGER array, dimension(batchCount + 1). On entry, each element N specifies the number of columns of each matrix C. N >= 0.
  [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, ka ), where ka is M when side = MagmaLower and is N otherwise. Before entry with side = MagmaLeft, the M by M part of the array A must contain the symmetric matrix, such that when uplo = MagmaUpper, the leading M by M 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, and when uplo = MagmaLower, the leading M by M 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. Before entry with side = MagmaRight, the N by N part of the array A must contain the symmetric matrix, such that when 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, and when 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, they 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. When side = MagmaLower then LDDA >= max( 1, M ), otherwise LDDA >= max( 1, N ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a REAL array B of DIMENSION ( LDDB, N ). Before entry, the leading M by N part of the array B must contain the matrix B.
  [in] | lddb | INTEGER array, dimension(batchCount + 1). On entry, each element LDDB specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, M ).
  [in] | beta | REAL On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a REAL array C of DIMENSION ( LDDC, N ). Before entry, the leading M by N part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the M by N updated matrix.
  [in] | lddc | INTEGER array, dimension(batchCount + 1). On entry, each element LDDC specifies the first dimension of C as declared in the calling (sub) program. LDDC >= max( 1, M ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zhemm_batched()

void magmablas_zhemm_batched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex ** | dA_array,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex ** | dB_array,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZHEMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a Hermitian matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each Hermitian matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each Hermitian matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the Hermitian matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the Hermitian matrix is to be referenced.

Parameters

  [in] | m | INTEGER On entry, m specifies the number of rows of each matrix C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of each matrix C. n >= 0.
  [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, ka ), where ka is m when side = MagmaLower and is n otherwise. Before entry with side = MagmaLeft, the m by m part of the array A must contain the Hermitian matrix, such that when uplo = MagmaUpper, the leading m by m 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, and when uplo = MagmaLower, the leading m by m 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. Before entry with side = MagmaRight, the n by n part of the array A must contain the Hermitian matrix, such that when 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, and when 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, they 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. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a COMPLEX*16 array B of DIMENSION ( lddb, n ). Before entry, the leading m by n part of the array B must contain the matrix B.
  [in] | lddb | INTEGER On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, m ).
  [in] | beta | COMPLEX*16 On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a COMPLEX*16 array C of DIMENSION ( lddc, n ). Before entry, the leading m by n part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the m by n updated matrix.
  [in] | lddc | INTEGER On entry, lddc specifies the first dimension of C as declared in the calling (sub) program. lddc >= max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zhemm_vbatched()

void magmablas_zhemm_vbatched | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex ** | dA_array,
|  | magma_int_t * | ldda,
|  | magmaDoubleComplex ** | dB_array,
|  | magma_int_t * | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZHEMM performs one of the matrix-matrix operations.

    C := alpha*A*B + beta*C,

or C := alpha*B*A + beta*C,

where alpha and beta are scalars, A is a Hermitian matrix, and B and C are m by n matrices.

Parameters

  [in] | side | magma_side_t On entry, side specifies whether each Hermitian matrix A appears on the left or right in the operation as follows:

SIDE = MagmaLeft C := alpha*A*B + beta*C, SIDE = MagmaRight C := alpha*B*A + beta*C.

Parameters

  [in] | uplo | magma_uplo_t On entry, uplo specifies whether the upper or lower triangular part of each Hermitian matrix A is to be referenced as follows:

uplo = MagmaUpper Only the upper triangular part of the Hermitian matrix is to be referenced. uplo = MagmaLower Only the lower triangular part of the Hermitian matrix is to be referenced.

Parameters

  [in] | m | INTEGER array, dimension(batchCount + 1). On entry, each element M specifies the number of rows of each matrix C. M >= 0.
  [in] | n | INTEGER array, dimension(batchCount + 1). On entry, each element N specifies the number of columns of each matrix C. N >= 0.
  [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, ka ), where ka is M when side = MagmaLower and is N otherwise. Before entry with side = MagmaLeft, the M by M part of the array A must contain the Hermitian matrix, such that when uplo = MagmaUpper, the leading M by M 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, and when uplo = MagmaLower, the leading M by M 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. Before entry with side = MagmaRight, the N by N part of the array A must contain the Hermitian matrix, such that when 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, and when 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, they 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. When side = MagmaLower then LDDA >= max( 1, M ), otherwise LDDA >= max( 1, N ).
  [in] | dB_array | Array of pointers, dimension(batchCount). Each is a COMPLEX*16 array B of DIMENSION ( LDDB, N ). Before entry, the leading M by N part of the array B must contain the matrix B.
  [in] | lddb | INTEGER array, dimension(batchCount + 1). On entry, each element LDDB specifies the first dimension of B as declared in the calling (sub) program. LDDB >= max( 1, M ).
  [in] | beta | COMPLEX*16 On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input.
  [in,out] | dC_array | Array of pointers, dimension(batchCount). Each is a COMPLEX*16 array C of DIMENSION ( LDDC, N ). Before entry, the leading M by N part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the M by N updated matrix.
  [in] | lddc | INTEGER array, dimension(batchCount + 1). On entry, each element LDDC specifies the first dimension of C as declared in the calling (sub) program. LDDC >= max( 1, M ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.