Loading...
Searching...
No Matches
gemm: General matrix multiply: C = AB + C
Batched LA » MAGMA BLAS and Auxiliary » Level 3: matrix-matrix operations, O(n^3) work

\(C = \alpha \;op(A) \;op(B) + \beta C\) More...

## Functions

void | magmablas_cgemm_batched (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex alpha, magmaFloatComplex const *const *dA_array, magma_int_t ldda, magmaFloatComplex const *const *dB_array, magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| CGEMM performs one of the matrix-matrix operations.

void

magmablas_cgemm_batched_core (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex alpha, magmaFloatComplex const *const *dA_array, magma_int_t Ai, magma_int_t Aj, magma_int_t ldda, magmaFloatComplex const *const *dB_array, magma_int_t Bi, magma_int_t Bj, magma_int_t lddb, magmaFloatComplex beta, magmaFloatComplex **dC_array, magma_int_t Ci, magma_int_t Cj, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)

| CGEMM performs one of the matrix-matrix operations.
void | magmablas_cgemm_vbatched (magma_trans_t transA, magma_trans_t transB, magma_int_t *m, magma_int_t *n, magma_int_t *k, magmaFloatComplex alpha, magmaFloatComplex const *const *dA_array, magma_int_t *ldda, magmaFloatComplex const *const *dB_array, magma_int_t *lddb, magmaFloatComplex beta, magmaFloatComplex **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| CGEMM performs one of the matrix-matrix operations.
void | magmablas_dgemm_batched (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, double alpha, double const *const *dA_array, magma_int_t ldda, double const *const *dB_array, magma_int_t lddb, double beta, double **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| DGEMM performs one of the matrix-matrix operations.

void

magmablas_dgemm_batched_core (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, double alpha, double const *const *dA_array, magma_int_t Ai, magma_int_t Aj, magma_int_t ldda, double const *const *dB_array, magma_int_t Bi, magma_int_t Bj, magma_int_t lddb, double beta, double **dC_array, magma_int_t Ci, magma_int_t Cj, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)

| DGEMM performs one of the matrix-matrix operations.
void | magmablas_dgemm_vbatched (magma_trans_t transA, magma_trans_t transB, magma_int_t *m, magma_int_t *n, magma_int_t *k, double alpha, double const *const *dA_array, magma_int_t *ldda, double const *const *dB_array, magma_int_t *lddb, double beta, double **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| DGEMM performs one of the matrix-matrix operations.
void | magmablas_sgemm_batched (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, float alpha, float const *const *dA_array, magma_int_t ldda, float const *const *dB_array, magma_int_t lddb, float beta, float **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| SGEMM performs one of the matrix-matrix operations.

void

magmablas_sgemm_batched_core (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, float alpha, float const *const *dA_array, magma_int_t Ai, magma_int_t Aj, magma_int_t ldda, float const *const *dB_array, magma_int_t Bi, magma_int_t Bj, magma_int_t lddb, float beta, float **dC_array, magma_int_t Ci, magma_int_t Cj, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)

| SGEMM performs one of the matrix-matrix operations.
void | magmablas_sgemm_vbatched (magma_trans_t transA, magma_trans_t transB, magma_int_t *m, magma_int_t *n, magma_int_t *k, float alpha, float const *const *dA_array, magma_int_t *ldda, float const *const *dB_array, magma_int_t *lddb, float beta, float **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| SGEMM performs one of the matrix-matrix operations.
void | magmablas_zgemm_batched (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex alpha, magmaDoubleComplex const *const *dA_array, magma_int_t ldda, magmaDoubleComplex const *const *dB_array, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex **dC_array, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)
| ZGEMM performs one of the matrix-matrix operations.

void

magmablas_zgemm_batched_core (magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex alpha, magmaDoubleComplex const *const *dA_array, magma_int_t Ai, magma_int_t Aj, magma_int_t ldda, magmaDoubleComplex const *const *dB_array, magma_int_t Bi, magma_int_t Bj, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex **dC_array, magma_int_t Ci, magma_int_t Cj, magma_int_t lddc, magma_int_t batchCount, magma_queue_t queue)

| ZGEMM performs one of the matrix-matrix operations.
void | magmablas_zgemm_vbatched (magma_trans_t transA, magma_trans_t transB, magma_int_t *m, magma_int_t *n, magma_int_t *k, magmaDoubleComplex alpha, magmaDoubleComplex const *const *dA_array, magma_int_t *ldda, magmaDoubleComplex const *const *dB_array, magma_int_t *lddb, magmaDoubleComplex beta, magmaDoubleComplex **dC_array, magma_int_t *lddc, magma_int_t batchCount, magma_queue_t queue)
| ZGEMM performs one of the matrix-matrix operations.

## Detailed Description

\(C = \alpha \;op(A) \;op(B) + \beta C\)

## Function Documentation

## magmablas_cgemm_batched()

void magmablas_cgemm_batched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex const *const * | dA_array,
|  | magma_int_t | ldda,
|  | magmaFloatComplex const *const * | dB_array,
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_cgemm_batched_core()

void magmablas_cgemm_batched_core | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex const *const * | dA_array,
|  | magma_int_t | Ai,
|  | magma_int_t | Aj,
|  | magma_int_t | ldda,
|  | magmaFloatComplex const *const * | dB_array,
|  | magma_int_t | Bi,
|  | magma_int_t | Bj,
|  | magma_int_t | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dC_array,
|  | magma_int_t | Ci,
|  | magma_int_t | Cj,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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, each array C is overwritten by the m by n matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | Ai | INTEGER Row offset for all 'A' matrices.
  [in] | Aj | INTEGER Column offset for all 'A' matrices.
  [in] | Bi | INTEGER Row offset for all 'B' matrices.
  [in] | Bj | INTEGER Column offset for all 'B' matrices.
  [in] | Ci | INTEGER Row offset for all 'C' matrices.
  [in] | Cj | INTEGER Column offset for all 'C' matrices.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_cgemm_vbatched()

void magmablas_cgemm_vbatched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magma_int_t * | k,
|  | magmaFloatComplex | alpha,
|  | magmaFloatComplex const *const * | dA_array,
|  | magma_int_t * | ldda,
|  | magmaFloatComplex const *const * | dB_array,
|  | magma_int_t * | lddb,
|  | magmaFloatComplex | beta,
|  | magmaFloatComplex ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | Array of integers, dimension (batchCount + 1) On entry, each INTEGER M specifies the number of rows of the corresponding matrices op( A ) and C. M must be at least zero. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of the corresponding matrix op( B ) and the number of columns of the corresponding matrix C. N must be at least zero. The last element of the array is used internally by the routine.
  [in] | k | Array of integers, dimension (batchCount + 1). On entry, each INTEGER K specifies the number of columns of the corresponding matrix op( A ) and the number of rows of the corresponding matrix op( B ). K must be at least zero. The last element of the array is used internally by the routine.
  [in] | alpha | COMPLEX On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array A of DIMENSION ( LDDA, ka ), where ka is K when transA = MagmaNoTrans, and is M otherwise. Before entry with transA = MagmaNoTrans, the leading M by K part of the array A must contain the matrix A, otherwise the leading K by M part of the array A must contain the matrix A.
  [in] | ldda | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDA specifies the first dimension of the corresponding matrix A as declared in the calling (sub) program. When transA = MagmaNoTrans then LDDA must be at least max( 1, M ), otherwise ldda must be at least max( 1, K ). The last element of the array is used internally by the routine.
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a COMPLEX array B of DIMENSION ( LDDB, kb ), where kb is N when transB = MagmaNoTrans, and is K otherwise. Before entry with transB = MagmaNoTrans, the leading K by N part of the array B must contain the matrix B, otherwise the leading N by K part of the array B must contain the matrix B.
  [in] | lddb | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDB specifies the first dimension of the corresponding matrix B as declared in the calling (sub) program. When transB = MagmaNoTrans then LDDB must be at least max( 1, K ), otherwise LDDB must be at least max( 1, N ). The last element of the array is used internally by the routine.
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDC specifies the first dimension of the corresponding matrix C as declared in the calling (sub) program. LDDC must be at least max( 1, M ). The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgemm_batched()

void magmablas_dgemm_batched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | double | alpha,
|  | double const *const * | dA_array,
|  | magma_int_t | ldda,
|  | double const *const * | dB_array,
|  | magma_int_t | lddb,
|  | double | beta,
|  | double ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgemm_batched_core()

void magmablas_dgemm_batched_core | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | double | alpha,
|  | double const *const * | dA_array,
|  | magma_int_t | Ai,
|  | magma_int_t | Aj,
|  | magma_int_t | ldda,
|  | double const *const * | dB_array,
|  | magma_int_t | Bi,
|  | magma_int_t | Bj,
|  | magma_int_t | lddb,
|  | double | beta,
|  | double ** | dC_array,
|  | magma_int_t | Ci,
|  | magma_int_t | Cj,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array B of DIMENSION ( LDB, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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, each array C is overwritten by the m by n matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | Ai | INTEGER Row offset for all 'A' matrices.
  [in] | Aj | INTEGER Column offset for all 'A' matrices.
  [in] | Bi | INTEGER Row offset for all 'B' matrices.
  [in] | Bj | INTEGER Column offset for all 'B' matrices.
  [in] | Ci | INTEGER Row offset for all 'C' matrices.
  [in] | Cj | INTEGER Column offset for all 'C' matrices.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_dgemm_vbatched()

void magmablas_dgemm_vbatched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magma_int_t * | k,
|  | double | alpha,
|  | double const *const * | dA_array,
|  | magma_int_t * | ldda,
|  | double const *const * | dB_array,
|  | magma_int_t * | lddb,
|  | double | beta,
|  | double ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | Array of integers, dimension (batchCount + 1) On entry, each INTEGER M specifies the number of rows of the corresponding matrices op( A ) and C. M must be at least zero. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of the corresponding matrix op( B ) and the number of columns of the corresponding matrix C. N must be at least zero. The last element of the array is used internally by the routine.
  [in] | k | Array of integers, dimension (batchCount + 1). On entry, each INTEGER K specifies the number of columns of the corresponding matrix op( A ) and the number of rows of the corresponding matrix op( B ). K must be at least zero. The last element of the array is used internally by the routine.
  [in] | alpha | DOUBLE PRECISION On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array A of DIMENSION ( LDDA, ka ), where ka is K when transA = MagmaNoTrans, and is M otherwise. Before entry with transA = MagmaNoTrans, the leading M by K part of the array A must contain the matrix A, otherwise the leading K by M part of the array A must contain the matrix A.
  [in] | ldda | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDA specifies the first dimension of the corresponding matrix A as declared in the calling (sub) program. When transA = MagmaNoTrans then LDDA must be at least max( 1, M ), otherwise ldda must be at least max( 1, K ). The last element of the array is used internally by the routine.
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array B of DIMENSION ( LDDB, kb ), where kb is N when transB = MagmaNoTrans, and is K otherwise. Before entry with transB = MagmaNoTrans, the leading K by N part of the array B must contain the matrix B, otherwise the leading N by K part of the array B must contain the matrix B.
  [in] | lddb | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDB specifies the first dimension of the corresponding matrix B as declared in the calling (sub) program. When transB = MagmaNoTrans then LDDB must be at least max( 1, K ), otherwise LDDB must be at least max( 1, N ). The last element of the array is used internally by the routine.
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDC specifies the first dimension of the corresponding matrix C as declared in the calling (sub) program. LDDC must be at least max( 1, M ). The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgemm_batched()

void magmablas_sgemm_batched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | float | alpha,
|  | float const *const * | dA_array,
|  | magma_int_t | ldda,
|  | float const *const * | dB_array,
|  | magma_int_t | lddb,
|  | float | beta,
|  | float ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a REAL array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgemm_batched_core()

void magmablas_sgemm_batched_core | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | float | alpha,
|  | float const *const * | dA_array,
|  | magma_int_t | Ai,
|  | magma_int_t | Aj,
|  | magma_int_t | ldda,
|  | float const *const * | dB_array,
|  | magma_int_t | Bi,
|  | magma_int_t | Bj,
|  | magma_int_t | lddb,
|  | float | beta,
|  | float ** | dC_array,
|  | magma_int_t | Ci,
|  | magma_int_t | Cj,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a REAL array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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). 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, each array C is overwritten by the m by n matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | Ai | INTEGER Row offset for all 'A' matrices.
  [in] | Aj | INTEGER Column offset for all 'A' matrices.
  [in] | Bi | INTEGER Row offset for all 'B' matrices.
  [in] | Bj | INTEGER Column offset for all 'B' matrices.
  [in] | Ci | INTEGER Row offset for all 'C' matrices.
  [in] | Cj | INTEGER Column offset for all 'C' matrices.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_sgemm_vbatched()

void magmablas_sgemm_vbatched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magma_int_t * | k,
|  | float | alpha,
|  | float const *const * | dA_array,
|  | magma_int_t * | ldda,
|  | float const *const * | dB_array,
|  | magma_int_t * | lddb,
|  | float | beta,
|  | float ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | Array of integers, dimension (batchCount + 1) On entry, each INTEGER M specifies the number of rows of the corresponding matrices op( A ) and C. M must be at least zero. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of the corresponding matrix op( B ) and the number of columns of the corresponding matrix C. N must be at least zero. The last element of the array is used internally by the routine.
  [in] | k | Array of integers, dimension (batchCount + 1). On entry, each INTEGER K specifies the number of columns of the corresponding matrix op( A ) and the number of rows of the corresponding matrix op( B ). K must be at least zero. The last element of the array is used internally by the routine.
  [in] | alpha | REAL On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a REAL array A of DIMENSION ( LDDA, ka ), where ka is K when transA = MagmaNoTrans, and is M otherwise. Before entry with transA = MagmaNoTrans, the leading M by K part of the array A must contain the matrix A, otherwise the leading K by M part of the array A must contain the matrix A.
  [in] | ldda | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDA specifies the first dimension of the corresponding matrix A as declared in the calling (sub) program. When transA = MagmaNoTrans then LDDA must be at least max( 1, M ), otherwise ldda must be at least max( 1, K ). The last element of the array is used internally by the routine.
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a REAL array B of DIMENSION ( LDDB, kb ), where kb is N when transB = MagmaNoTrans, and is K otherwise. Before entry with transB = MagmaNoTrans, the leading K by N part of the array B must contain the matrix B, otherwise the leading N by K part of the array B must contain the matrix B.
  [in] | lddb | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDB specifies the first dimension of the corresponding matrix B as declared in the calling (sub) program. When transB = MagmaNoTrans then LDDB must be at least max( 1, K ), otherwise LDDB must be at least max( 1, N ). The last element of the array is used internally by the routine.
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDC specifies the first dimension of the corresponding matrix C as declared in the calling (sub) program. LDDC must be at least max( 1, M ). The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgemm_batched()

void magmablas_zgemm_batched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex const *const * | dA_array,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex const *const * | dB_array,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dC_array,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgemm_batched_core()

void magmablas_zgemm_batched_core | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | k,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex const *const * | dA_array,
|  | magma_int_t | Ai,
|  | magma_int_t | Aj,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex const *const * | dB_array,
|  | magma_int_t | Bi,
|  | magma_int_t | Bj,
|  | magma_int_t | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dC_array,
|  | magma_int_t | Ci,
|  | magma_int_t | Cj,
|  | magma_int_t | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero.
  [in] | n | INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero.
  [in] | k | INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K 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, ka ), where ka is k when transA = MagmaNoTrans, and is m otherwise. Before entry with transA = MagmaNoTrans, the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A.
  [in] | ldda | INTEGER. On entry, ldda specifies the first dimension of each array A as declared in the calling (sub) program. When transA = MagmaNoTrans then ldda must be at least max( 1, m ), otherwise ldda must be at least max( 1, k ).
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array B of DIMENSION ( lddb, kb ), where kb is n when transB = MagmaNoTrans, and is k otherwise. Before entry with transB = MagmaNoTrans, the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B.
  [in] | lddb | INTEGER. On entry, lddb specifies the first dimension of each array B as declared in the calling (sub) program. When transB = MagmaNoTrans then lddb must be at least max( 1, k ), otherwise lddb must be at least max( 1, n ).
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | INTEGER. On entry, lddc specifies the first dimension of each array C as declared in the calling (sub) program. lddc must be at least max( 1, m ).
  [in] | Ai | INTEGER Row offset for all 'A' matrices.
  [in] | Aj | INTEGER Column offset for all 'A' matrices.
  [in] | Bi | INTEGER Row offset for all 'B' matrices.
  [in] | Bj | INTEGER Column offset for all 'B' matrices.
  [in] | Ci | INTEGER Row offset for all 'C' matrices.
  [in] | Cj | INTEGER Column offset for all 'C' matrices.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magmablas_zgemm_vbatched()

void magmablas_zgemm_vbatched | ( | magma_trans_t | transA,
|  | magma_trans_t | transB,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | magma_int_t * | k,
|  | magmaDoubleComplex | alpha,
|  | magmaDoubleComplex const *const * | dA_array,
|  | magma_int_t * | ldda,
|  | magmaDoubleComplex const *const * | dB_array,
|  | magma_int_t * | lddb,
|  | magmaDoubleComplex | beta,
|  | magmaDoubleComplex ** | dC_array,
|  | magma_int_t * | lddc,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZGEMM performs one of the matrix-matrix operations.

    C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

    op( X ) = X      or
    op( X ) = X**T   or
    op( X ) = X**H,

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

## Parameters

Parameters

  [in]

  transA

  magma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( A ) = A.
  - = MagmaTrans: op( A ) = A**T.
  - = MagmaConjTrans: op( A ) = A**H.

  [in]

  transB

  magma_trans_t. On entry, transB specifies the form of op( B ) to be used in the matrix multiplication as follows:
  - = MagmaNoTrans: op( B ) = B.
  - = MagmaTrans: op( B ) = B**T.
  - = MagmaConjTrans: op( B ) = B**H.

  [in] | m | Array of integers, dimension (batchCount + 1) On entry, each INTEGER M specifies the number of rows of the corresponding matrices op( A ) and C. M must be at least zero. The last element of the array is used internally by the routine.
  [in] | n | Array of integers, dimension (batchCount + 1). On entry, each INTEGER N specifies the number of columns of the corresponding matrix op( B ) and the number of columns of the corresponding matrix C. N must be at least zero. The last element of the array is used internally by the routine.
  [in] | k | Array of integers, dimension (batchCount + 1). On entry, each INTEGER K specifies the number of columns of the corresponding matrix op( A ) and the number of rows of the corresponding matrix op( B ). K must be at least zero. The last element of the array is used internally by the routine.
  [in] | alpha | COMPLEX_16 On entry, ALPHA specifies the scalar alpha.
  [in] | dA_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array A of DIMENSION ( LDDA, ka ), where ka is K when transA = MagmaNoTrans, and is M otherwise. Before entry with transA = MagmaNoTrans, the leading M by K part of the array A must contain the matrix A, otherwise the leading K by M part of the array A must contain the matrix A.
  [in] | ldda | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDA specifies the first dimension of the corresponding matrix A as declared in the calling (sub) program. When transA = MagmaNoTrans then LDDA must be at least max( 1, M ), otherwise ldda must be at least max( 1, K ). The last element of the array is used internally by the routine.
  [in] | dB_array | Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array B of DIMENSION ( LDDB, kb ), where kb is N when transB = MagmaNoTrans, and is K otherwise. Before entry with transB = MagmaNoTrans, the leading K by N part of the array B must contain the matrix B, otherwise the leading N by K part of the array B must contain the matrix B.
  [in] | lddb | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDB specifies the first dimension of the corresponding matrix B as declared in the calling (sub) program. When transB = MagmaNoTrans then LDDB must be at least max( 1, K ), otherwise LDDB must be at least max( 1, N ). The last element of the array is used internally by the routine.
  [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 matrix ( alpha*op( A )*op( B ) + beta*C ).
  [in] | lddc | Array of integers, dimension (batchCount + 1). On entry, each INTEGER LDDC specifies the first dimension of the corresponding matrix C as declared in the calling (sub) program. LDDC must be at least max( 1, M ). The last element of the array is used internally by the routine.
  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.