Loading...
Searching...
No Matches
hemm: Hermitian matrix multiply
Dense 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 | magma_chemm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dB, magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| Perform Hermitian matrix-matrix product.
void | magma_zhemm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dB, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| Perform Hermitian matrix-matrix product.
void | magmablas_chemm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dB, magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| CHEMM performs one of the matrix-matrix operations.

void

magmablas_chemm_mgpu (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_ptr dA[], magma_int_t ldda, magma_int_t offset, magmaFloatComplex_ptr dB[], magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex_ptr dC[], magma_int_t lddc, magmaFloatComplex_ptr dwork[], magma_int_t dworksiz, magma_int_t ngpu, magma_int_t nb, magma_queue_t queues[][20], magma_int_t nqueue, magma_event_t events[][MagmaMaxGPUs *MagmaMaxGPUs+10], magma_int_t nevents, magma_int_t gnode[MagmaMaxGPUs][MagmaMaxGPUs+2], magma_int_t ncmplx)

| CHEMM performs one of the matrix-matrix operations.
void | magmablas_csymm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dB, magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| CSYMM performs one of the matrix-matrix operations.
void | magmablas_dsymm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, double alpha, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_const_ptr dB, magma_int_t lddb, double beta, magmaDouble_ptr dC, magma_int_t lddc, magma_queue_t queue)
| DSYMM performs one of the matrix-matrix operations.

void

magmablas_dsymm_mgpu (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, double alpha, magmaDouble_ptr dA[], magma_int_t ldda, magma_int_t offset, magmaDouble_ptr dB[], magma_int_t lddb, double beta, magmaDouble_ptr dC[], magma_int_t lddc, magmaDouble_ptr dwork[], magma_int_t dworksiz, magma_int_t ngpu, magma_int_t nb, magma_queue_t queues[][20], magma_int_t nqueue, magma_event_t events[][MagmaMaxGPUs *MagmaMaxGPUs+10], magma_int_t nevents, magma_int_t gnode[MagmaMaxGPUs][MagmaMaxGPUs+2], magma_int_t ncmplx)

| DSYMM performs one of the matrix-matrix operations.
void | magmablas_ssymm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_const_ptr dB, magma_int_t lddb, float beta, magmaFloat_ptr dC, magma_int_t lddc, magma_queue_t queue)
| SSYMM performs one of the matrix-matrix operations.

void

magmablas_ssymm_mgpu (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, float alpha, magmaFloat_ptr dA[], magma_int_t ldda, magma_int_t offset, magmaFloat_ptr dB[], magma_int_t lddb, float beta, magmaFloat_ptr dC[], magma_int_t lddc, magmaFloat_ptr dwork[], magma_int_t dworksiz, magma_int_t ngpu, magma_int_t nb, magma_queue_t queues[][20], magma_int_t nqueue, magma_event_t events[][MagmaMaxGPUs *MagmaMaxGPUs+10], magma_int_t nevents, magma_int_t gnode[MagmaMaxGPUs][MagmaMaxGPUs+2], magma_int_t ncmplx)

| SSYMM performs one of the matrix-matrix operations.
void | magmablas_zhemm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dB, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| ZHEMM performs one of the matrix-matrix operations.

void

magmablas_zhemm_mgpu (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_ptr dA[], magma_int_t ldda, magma_int_t offset, magmaDoubleComplex_ptr dB[], magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex_ptr dC[], magma_int_t lddc, magmaDoubleComplex_ptr dwork[], magma_int_t dworksiz, magma_int_t ngpu, magma_int_t nb, magma_queue_t queues[][20], magma_int_t nqueue, magma_event_t events[][MagmaMaxGPUs *MagmaMaxGPUs+10], magma_int_t nevents, magma_int_t gnode[MagmaMaxGPUs][MagmaMaxGPUs+2], magma_int_t ncmplx)

| ZHEMM performs one of the matrix-matrix operations.
void | magmablas_zsymm (magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dB, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex_ptr dC, magma_int_t lddc, magma_queue_t queue)
| ZSYMM 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

## magma_chemm()

void magma_chemm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

Perform Hermitian matrix-matrix product.

\( C = \alpha A B + \beta C \) (side == MagmaLeft), or
\( C = \alpha B A + \beta C \) (side == MagmaRight),
where \( A \) is Hermitian.

Parameters

  [in] | side | Whether A is on the left or right.
  [in] | uplo | Whether the upper or lower triangle of A is referenced.
  [in] | m | Number of rows of C. m >= 0.
  [in] | n | Number of columns of C. n >= 0.
  [in] | alpha | Scalar \( \alpha \)
  [in] | dA | COMPLEX array on GPU device. If side == MagmaLeft, the m-by-m Hermitian matrix A of dimension (ldda,m), ldda >= max(1,m); otherwise, the n-by-n Hermitian matrix A of dimension (ldda,n), ldda >= max(1,n).
  [in] | ldda | Leading dimension of dA.
  [in] | dB | COMPLEX array on GPU device. The m-by-n matrix B of dimension (lddb,n), lddb >= max(1,m).
  [in] | lddb | Leading dimension of dB.
  [in] | beta | Scalar \( \beta \)
  [in,out] | dC | COMPLEX array on GPU device. The m-by-n matrix C of dimension (lddc,n), lddc >= max(1,m).
  [in] | lddc | Leading dimension of dC.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_zhemm()

void magma_zhemm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

Perform Hermitian matrix-matrix product.

\( C = \alpha A B + \beta C \) (side == MagmaLeft), or
\( C = \alpha B A + \beta C \) (side == MagmaRight),
where \( A \) is Hermitian.

Parameters

  [in] | side | Whether A is on the left or right.
  [in] | uplo | Whether the upper or lower triangle of A is referenced.
  [in] | m | Number of rows of C. m >= 0.
  [in] | n | Number of columns of C. n >= 0.
  [in] | alpha | Scalar \( \alpha \)
  [in] | dA | COMPLEX_16 array on GPU device. If side == MagmaLeft, the m-by-m Hermitian matrix A of dimension (ldda,m), ldda >= max(1,m); otherwise, the n-by-n Hermitian matrix A of dimension (ldda,n), ldda >= max(1,n).
  [in] | ldda | Leading dimension of dA.
  [in] | dB | COMPLEX_16 array on GPU device. The m-by-n matrix B of dimension (lddb,n), lddb >= max(1,m).
  [in] | lddb | Leading dimension of dB.
  [in] | beta | Scalar \( \beta \)
  [in,out] | dC | COMPLEX_16 array on GPU device. The m-by-n matrix C of dimension (lddc,n), lddc >= max(1,m).
  [in] | lddc | Leading dimension of dC.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_chemm()

void magmablas_chemm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | 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 the 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 the 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 C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of C. n >= 0.
  [in] | alpha | COMPLEX On entry, alpha specifies the scalar alpha.

  [in]

  dA

  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 A as declared in the calling (sub) program. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB | 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 | 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] | queue | magma_queue_t Queue to execute in.

## magmablas_chemm_mgpu()

void magmablas_chemm_mgpu | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex_ptr | dA[],
|  | magma_int_t | ldda,
|  | magma_int_t | offset,
|  | magmaFloatComplex_ptr | dB[],
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex_ptr | dC[],
|  | magma_int_t | lddc,
|  | magmaFloatComplex_ptr | dwork[],
|  | magma_int_t | dworksiz,
|  | magma_int_t | ngpu,
|  | magma_int_t | nb,
|  | magma_queue_t | queues[][20],
|  | magma_int_t | nqueue,
|  | magma_event_t | events[][MagmaMaxGPUs *MagmaMaxGPUs+10],
|  | magma_int_t | nevents,
|  | magma_int_t | gnode[MagmaMaxGPUs][MagmaMaxGPUs+2],
|  | magma_int_t | ncmplx )

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 the 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.

    Currently, only MagmaLeft is implemented ***

Parameters

  [in] | uplo | magma_uplo_t On entry, UPLO specifies whether the upper or lower triangular part of the 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.

Currently, only MagmaLower is implemented ***

Parameters

  [in] | m | INTEGER On entry, M specifies the number of rows of the matrix dC. M >= 0.
  [in] | n | INTEGER On entry, N specifies the number of columns of the matrix dC. N >= 0.
  [in] | alpha | COMPLEX On entry, ALPHA specifies the scalar alpha.

  [in]

  dA

  COMPLEX array 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 A as declared in the calling (sub) program. When SIDE = MagmaLower then LDDA >= max( 1, m ), otherwise LDDA >= max( 1, n ).
  [in] | dB | COMPLEX array 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 | COMPLEX array 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 ).

## magmablas_csymm()

void magmablas_csymm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

CSYMM 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 the 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 the 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 C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of C. n >= 0.
  [in] | alpha | COMPLEX On entry, alpha specifies the scalar alpha.

  [in]

  dA

  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 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 A as declared in the calling (sub) program. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB | 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 | 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] | queue | magma_queue_t Queue to execute in.

## magmablas_dsymm()

void magmablas_dsymm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | double | alpha,
|  | magmaDouble_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDouble_const_ptr | dB,
|  | magma_int_t | lddb,
|  | double | beta,
|  | magmaDouble_ptr | dC,
|  | magma_int_t | lddc,
|  | 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 the 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 the 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 C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of C. n >= 0.
  [in] | alpha | DOUBLE PRECISION On entry, alpha specifies the scalar alpha.

  [in]

  dA

  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 A as declared in the calling (sub) program. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB | 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 | 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] | queue | magma_queue_t Queue to execute in.

## magmablas_dsymm_mgpu()

void magmablas_dsymm_mgpu | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | double | alpha,
|  | magmaDouble_ptr | dA[],
|  | magma_int_t | ldda,
|  | magma_int_t | offset,
|  | magmaDouble_ptr | dB[],
|  | magma_int_t | lddb,
|  | double | beta,
|  | magmaDouble_ptr | dC[],
|  | magma_int_t | lddc,
|  | magmaDouble_ptr | dwork[],
|  | magma_int_t | dworksiz,
|  | magma_int_t | ngpu,
|  | magma_int_t | nb,
|  | magma_queue_t | queues[][20],
|  | magma_int_t | nqueue,
|  | magma_event_t | events[][MagmaMaxGPUs *MagmaMaxGPUs+10],
|  | magma_int_t | nevents,
|  | magma_int_t | gnode[MagmaMaxGPUs][MagmaMaxGPUs+2],
|  | magma_int_t | ncmplx )

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 the 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.

    Currently, only MagmaLeft is implemented ***

Parameters

  [in] | uplo | magma_uplo_t On entry, UPLO specifies whether the upper or lower triangular part of the 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.

Currently, only MagmaLower is implemented ***

Parameters

  [in] | m | INTEGER On entry, M specifies the number of rows of the matrix dC. M >= 0.
  [in] | n | INTEGER On entry, N specifies the number of columns of the matrix dC. N >= 0.
  [in] | alpha | DOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.

  [in]

  dA

  DOUBLE PRECISION array 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 A as declared in the calling (sub) program. When SIDE = MagmaLower then LDDA >= max( 1, m ), otherwise LDDA >= max( 1, n ).
  [in] | dB | DOUBLE PRECISION array 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 | DOUBLE PRECISION array 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 ).

## magmablas_ssymm()

void magmablas_ssymm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | float | alpha,
|  | magmaFloat_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloat_const_ptr | dB,
|  | magma_int_t | lddb,
|  | float | beta,
|  | magmaFloat_ptr | dC,
|  | magma_int_t | lddc,
|  | 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 the 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 the 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 C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of C. n >= 0.
  [in] | alpha | REAL On entry, alpha specifies the scalar alpha.

  [in]

  dA

  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 A as declared in the calling (sub) program. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB | 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 | 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] | queue | magma_queue_t Queue to execute in.

## magmablas_ssymm_mgpu()

void magmablas_ssymm_mgpu | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | float | alpha,
|  | magmaFloat_ptr | dA[],
|  | magma_int_t | ldda,
|  | magma_int_t | offset,
|  | magmaFloat_ptr | dB[],
|  | magma_int_t | lddb,
|  | float | beta,
|  | magmaFloat_ptr | dC[],
|  | magma_int_t | lddc,
|  | magmaFloat_ptr | dwork[],
|  | magma_int_t | dworksiz,
|  | magma_int_t | ngpu,
|  | magma_int_t | nb,
|  | magma_queue_t | queues[][20],
|  | magma_int_t | nqueue,
|  | magma_event_t | events[][MagmaMaxGPUs *MagmaMaxGPUs+10],
|  | magma_int_t | nevents,
|  | magma_int_t | gnode[MagmaMaxGPUs][MagmaMaxGPUs+2],
|  | magma_int_t | ncmplx )

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 the 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.

    Currently, only MagmaLeft is implemented ***

Parameters

  [in] | uplo | magma_uplo_t On entry, UPLO specifies whether the upper or lower triangular part of the 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.

Currently, only MagmaLower is implemented ***

Parameters

  [in] | m | INTEGER On entry, M specifies the number of rows of the matrix dC. M >= 0.
  [in] | n | INTEGER On entry, N specifies the number of columns of the matrix dC. N >= 0.
  [in] | alpha | REAL On entry, ALPHA specifies the scalar alpha.

  [in]

  dA

  REAL array 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 A as declared in the calling (sub) program. When SIDE = MagmaLower then LDDA >= max( 1, m ), otherwise LDDA >= max( 1, n ).
  [in] | dB | REAL array 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 | REAL array 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 ).

## magmablas_zhemm()

void magmablas_zhemm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | 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 the 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 the 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 C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of C. n >= 0.
  [in] | alpha | COMPLEX*16 On entry, alpha specifies the scalar alpha.

  [in]

  dA

  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 A as declared in the calling (sub) program. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB | 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 | 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] | queue | magma_queue_t Queue to execute in.

## magmablas_zhemm_mgpu()

void magmablas_zhemm_mgpu | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex_ptr | dA[],
|  | magma_int_t | ldda,
|  | magma_int_t | offset,
|  | magmaDoubleComplex_ptr | dB[],
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex_ptr | dC[],
|  | magma_int_t | lddc,
|  | magmaDoubleComplex_ptr | dwork[],
|  | magma_int_t | dworksiz,
|  | magma_int_t | ngpu,
|  | magma_int_t | nb,
|  | magma_queue_t | queues[][20],
|  | magma_int_t | nqueue,
|  | magma_event_t | events[][MagmaMaxGPUs *MagmaMaxGPUs+10],
|  | magma_int_t | nevents,
|  | magma_int_t | gnode[MagmaMaxGPUs][MagmaMaxGPUs+2],
|  | magma_int_t | ncmplx )

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 the 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.

    Currently, only MagmaLeft is implemented ***

Parameters

  [in] | uplo | magma_uplo_t On entry, UPLO specifies whether the upper or lower triangular part of the 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.

Currently, only MagmaLower is implemented ***

Parameters

  [in] | m | INTEGER On entry, M specifies the number of rows of the matrix dC. M >= 0.
  [in] | n | INTEGER On entry, N specifies the number of columns of the matrix dC. N >= 0.
  [in] | alpha | COMPLEX*16 On entry, ALPHA specifies the scalar alpha.

  [in]

  dA

  COMPLEX*16 array 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 A as declared in the calling (sub) program. When SIDE = MagmaLower then LDDA >= max( 1, m ), otherwise LDDA >= max( 1, n ).
  [in] | dB | COMPLEX*16 array 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 | COMPLEX*16 array 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 ).

## magmablas_zsymm()

void magmablas_zsymm | ( | magma_side_t | side,
|  | magma_uplo_t | uplo,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex_const_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex_ptr | dC,
|  | magma_int_t | lddc,
|  | magma_queue_t | queue )

ZSYMM 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 the 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 the 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 C. m >= 0.
  [in] | n | INTEGER On entry, n specifies the number of columns of C. n >= 0.
  [in] | alpha | COMPLEX*16 On entry, alpha specifies the scalar alpha.

  [in]

  dA

  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 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 A as declared in the calling (sub) program. When side = MagmaLower then ldda >= max( 1, m ), otherwise ldda >= max( 1, n ).
  [in] | dB | 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 | 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] | queue | magma_queue_t Queue to execute in.