CORE_PLASMA_Complex64_t(3)

NAME
CORE_PLASMA_Complex64_t - Kernel Interface - Double Complex

  Functions
int CORE_dlag2z (int m, int n, const double *R, int ldr, PLASMA_Complex64_t *Z, int ldz)
void CORE_dzasum (PLASMA_enum storev, PLASMA_enum uplo, int M, int N, const PLASMA_Complex64_t *A, int lda, double *work)
void CORE_zbrdalg1 (PLASMA_enum uplo, int n, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *VQ, PLASMA_Complex64_t *TAUQ, PLASMA_Complex64_t *VP, PLASMA_Complex64_t *TAUP, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, PLASMA_Complex64_t *work)
int CORE_zgbelr (PLASMA_enum uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zgblrx (PLASMA_enum uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zgbrce (PLASMA_enum uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
void CORE_zgbtype1cb (PLASMA_enum uplo, int N, int NB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *VQ, PLASMA_Complex64_t *TAUQ, PLASMA_Complex64_t *VP, PLASMA_Complex64_t *TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t *WORK)
void CORE_zgbtype2cb (PLASMA_enum uplo, int N, int NB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *VQ, PLASMA_Complex64_t *TAUQ, PLASMA_Complex64_t *VP, PLASMA_Complex64_t *TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t *WORK)
void CORE_zgbtype3cb (PLASMA_enum uplo, int N, int NB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *VQ, PLASMA_Complex64_t *TAUQ, PLASMA_Complex64_t *VP, PLASMA_Complex64_t *TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t *WORK)
int CORE_zgeadd (PLASMA_enum trans, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t *B, int LDB)
int CORE_zgelqt (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
void CORE_zgemm (PLASMA_enum transA, int transB, int M, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
void CORE_zgemv (PLASMA_enum trans, int m, int n, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int lda, const PLASMA_Complex64_t *x, int incx, PLASMA_Complex64_t beta, PLASMA_Complex64_t *y, int incy)
void CORE_zgeqp3_init (int n, int *jpvt)
void CORE_zgeqp3_larfg (PLASMA_desc A, int ii, int jj, int i, int j, PLASMA_Complex64_t *tau, PLASMA_Complex64_t *beta)
void CORE_zgeqp3_norms (PLASMA_desc A, int ioff, int joff, double *norms1, double *norms2)
void CORE_zgeqp3_pivot (PLASMA_desc A, PLASMA_Complex64_t *F, int ldf, int jj, int k, int *jpvt, double *norms1, double *norms2, int *info)
void CORE_zgeqp3_update (const PLASMA_Complex64_t *Ajj, int lda1, PLASMA_Complex64_t *Ajk, int lda2, const PLASMA_Complex64_t *Fk, int ldf, int joff, int k, int koff, int nb, double *norms1, double *norms2, int *info)
int CORE_zgeqrt (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zgessm (int M, int N, int K, int IB, const int *IPIV, const PLASMA_Complex64_t *L, int LDL, PLASMA_Complex64_t *A, int LDA)
int CORE_zgetf2_nopiv (int M, int N, PLASMA_Complex64_t *A, int LDA)
int CORE_zgetrf (int m, int n, PLASMA_Complex64_t *A, int lda, int *IPIV, int *info)
int CORE_zgetrf_incpiv (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA, int *IPIV, int *INFO)
int CORE_zgetrf_nopiv (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA)
int CORE_zgetrf_reclap (CORE_zgetrf_data_t *data, int M, int N, PLASMA_Complex64_t *A, int LDA, int *IPIV, int *info)
int CORE_zgetrf_rectil (CORE_zgetrf_data_t *data, const PLASMA_desc A, int *IPIV, int *info)
void CORE_zgetrip (int m, int n, PLASMA_Complex64_t *A, PLASMA_Complex64_t *W)
int CORE_zhbelr (PLASMA_enum uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zhblrx (PLASMA_enum uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zhbrce (PLASMA_enum uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
void CORE_zhbtype1cb (int N, int NB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t *WORK)
void CORE_zhbtype2cb (int N, int NB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t *WORK)
void CORE_zhbtype3cb (int N, int NB, PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *V, const PLASMA_Complex64_t *TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t *WORK)
void CORE_zhegst (int itype, PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, int *INFO)
void CORE_zhemm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
void CORE_zher2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *B, int LDB, double beta, PLASMA_Complex64_t *C, int LDC)
int CORE_zherfb (PLASMA_enum uplo, int n, int k, int ib, int nb, const PLASMA_Complex64_t *A, int lda, const PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *C, int ldc, PLASMA_Complex64_t *WORK, int ldwork)
void CORE_zherk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, const PLASMA_Complex64_t *A, int LDA, double beta, PLASMA_Complex64_t *C, int LDC)
void CORE_zlacpy (PLASMA_enum uplo, int M, int N, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
int CORE_zlacpy_pivot (const PLASMA_desc descA, PLASMA_enum direct, int k1, int k2, const int *ipiv, int *rankin, int *rankout, PLASMA_Complex64_t *A, int lda, int init)
void CORE_zlag2c (int m, int n, const PLASMA_Complex64_t *A, int lda, PLASMA_Complex32_t *B, int ldb, int *info)
void CORE_clag2z (int m, int n, const PLASMA_Complex32_t *A, int lda, PLASMA_Complex64_t *B, int ldb)
void CORE_zlange (int norm, int M, int N, const PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
void CORE_zlanhe (int norm, PLASMA_enum uplo, int N, const PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
void CORE_zlansy (int norm, PLASMA_enum uplo, int N, const PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
void CORE_zlantr (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
int CORE_zlarfb_gemm (PLASMA_enum side, PLASMA_enum trans, int direct, int storev, int M, int N, int K, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *C, int LDC, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zlarfx2 (PLASMA_enum side, int N, PLASMA_Complex64_t V, PLASMA_Complex64_t TAU, PLASMA_Complex64_t *C1, int LDC1, PLASMA_Complex64_t *C2, int LDC2)
int CORE_zlarfx2c (PLASMA_enum uplo, PLASMA_Complex64_t V, PLASMA_Complex64_t TAU, PLASMA_Complex64_t *C1, PLASMA_Complex64_t *C2, PLASMA_Complex64_t *C3)
int CORE_zlarfx2ce (PLASMA_enum uplo, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *C1, PLASMA_Complex64_t *C2, PLASMA_Complex64_t *C3)
void CORE_zlarfy (int N, PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *V, const PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zlascal (PLASMA_enum uplo, int m, int n, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda)
int CORE_zlascl (PLASMA_enum type, int kl, int ku, double cfrom, double cto, int m, int n, PLASMA_Complex64_t *A, int lda)
void CORE_zlaset (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t beta, PLASMA_Complex64_t *A, int LDA)
void CORE_zlaset2 (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA)
void CORE_zlaswp (int N, PLASMA_Complex64_t *A, int LDA, int I1, int I2, const int *IPIV, int INC)
int CORE_zlaswp_ontile (PLASMA_desc descA, int i1, int i2, const int *ipiv, int inc)
int CORE_zswptr_ontile (PLASMA_desc descA, int i1, int i2, const int *ipiv, int inc, const PLASMA_Complex64_t *Akk, int ldak)
int CORE_zlaswpc_ontile (PLASMA_desc descA, int i1, int i2, const int *ipiv, int inc)
int CORE_zlatro (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_zlauum (PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA)
int CORE_zpamm (int op, PLASMA_enum side, PLASMA_enum storev, int M, int N, int K, int L, const PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *W, int LDW)
int CORE_zparfb (PLASMA_enum side, PLASMA_enum trans, PLASMA_enum direct, PLASMA_enum storev, int M1, int N1, int M2, int N2, int K, int L, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zpemv (PLASMA_enum trans, int storev, int M, int N, int L, PLASMA_Complex64_t ALPHA, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *X, int INCX, PLASMA_Complex64_t BETA, PLASMA_Complex64_t *Y, int INCY, PLASMA_Complex64_t *WORK)
void CORE_zplghe (double bump, int m, int n, PLASMA_Complex64_t *A, int lda, int gM, int m0, int n0, unsigned long long int seed)
void CORE_zplgsy (PLASMA_Complex64_t bump, int m, int n, PLASMA_Complex64_t *A, int lda, int gM, int m0, int n0, unsigned long long int seed)
void CORE_zplrnt (int m, int n, PLASMA_Complex64_t *A, int lda, int gM, int m0, int n0, unsigned long long int seed)
int CORE_zpltmg (PLASMA_enum mtxtype, int M, int N, PLASMA_Complex64_t *A, int LDA, int gM, int gN, int m0, int n0, unsigned long long int seed)
int CORE_zpltmg_chebvand (int M, int N, PLASMA_Complex64_t *A, int LDA, int gN, int m0, int n0, PLASMA_Complex64_t *W)
int CORE_zpltmg_circul (int M, int N, PLASMA_Complex64_t *A, int LDA, int gM, int m0, int n0, const PLASMA_Complex64_t *V)
void CORE_zpltmg_condexq (int M, int N, PLASMA_Complex64_t *Q, int LDQ)
void CORE_zpltmg_fiedler (int M, int N, const PLASMA_Complex64_t *X, int incX, const PLASMA_Complex64_t *Y, int incY, PLASMA_Complex64_t *A, int LDA)
int CORE_zpltmg_hankel (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t *A, int LDA, int m0, int n0, int nb, const PLASMA_Complex64_t *V1, const PLASMA_Complex64_t *V2)
void CORE_zpltmg_toeppd1 (int gM, int m0, int M, PLASMA_Complex64_t *W, unsigned long long int seed)
void CORE_zpltmg_toeppd2 (int M, int N, int K, int m0, int n0, const PLASMA_Complex64_t *W, PLASMA_Complex64_t *A, int LDA)
void CORE_zpotrf (PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA, int *info)
void CORE_zsetvar (const PLASMA_Complex64_t *alpha, PLASMA_Complex64_t *x)
void CORE_zshiftw (int s, int cl, int m, int n, int L, PLASMA_Complex64_t *A, PLASMA_Complex64_t *W)
int CORE_zssssm (int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *L1, int LDL1, const PLASMA_Complex64_t *L2, int LDL2, const int *IPIV)
int CORE_zstedc (PLASMA_enum compz, int n, double *D, double *E, PLASMA_Complex64_t *Z, int LDZ, PLASMA_Complex64_t *WORK, int LWORK, double *RWORK, int LRWORK, int *IWORK, int LIWORK)
int CORE_zsteqr (PLASMA_enum compz, int n, double *D, double *E, PLASMA_Complex64_t *Z, int LDZ, double *WORK)
void CORE_zswap (int m, int n, PLASMA_Complex64_t *Q, int ldq, const PLASMA_Complex64_t *work, const int *perm, int start, int end)
void CORE_zswpab (int i, int n1, int n2, PLASMA_Complex64_t *A, PLASMA_Complex64_t *work)
void CORE_zsymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
void CORE_zsyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
void CORE_zsyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
int CORE_ztradd (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t *B, int LDB)
void CORE_ztrasm (PLASMA_enum storev, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const PLASMA_Complex64_t *A, int lda, double *work)
void CORE_ztrdalg1 (int n, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, PLASMA_Complex64_t *work)
void CORE_ztrmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_ztrsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_ztrtri (PLASMA_enum uplo, PLASMA_enum diag, int N, PLASMA_Complex64_t *A, int LDA, int *info)
int CORE_ztslqt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_ztsmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_ztsmlq_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *A3, int lda3, const PLASMA_Complex64_t *V, int ldv, const PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsmlq_hetra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, const PLASMA_Complex64_t *V, int ldv, const PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_ztsmqr_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *A3, int lda3, const PLASMA_Complex64_t *V, int ldv, const PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsmqr_hetra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, const PLASMA_Complex64_t *V, int ldv, const PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsqrt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_ztsrfb (PLASMA_enum side, PLASMA_enum trans, int direct, int storev, int M1, int N1, int M2, int N2, int K, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_ztstrf (int M, int N, int IB, int NB, PLASMA_Complex64_t *U, int LDU, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *L, int LDL, int *IPIV, PLASMA_Complex64_t *WORK, int LDWORK, int *INFO)
int CORE_zttlqt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zttmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zttmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, const PLASMA_Complex64_t *V, int LDV, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zttqrt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zunmlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *C, int LDC, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zunmqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const PLASMA_Complex64_t *A, int LDA, const PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *C, int LDC, PLASMA_Complex64_t *WORK, int LDWORK)

Detailed Description

This is the group of double complex kernels available in coreblas library.

Function Documentation

  void CORE_clag2z (int m, int n, const PLASMA_Complex32_t * A, int lda, PLASMA_Complex64_t * B, int ldb)
CORE_PLASMA_clag2z converts a PLASMA_Complex32_t matrix, A, to a PLASMA_Complex64_t matrix, B.

Parameters:
    m The number of rows of the matrices A and B. m >= 0.
    n The number of columns of the matrices A and B. n >= 0.
    A The PLASMA_Complex32_t m-by-n matrix to convert.
    lda The leading dimension of the array A. lda >= max(1,m).
    B The PLASMA_Complex64_t m-by-n matrix to convert.
    ldb The leading dimension of the array B. ldb >= max(1,m).

  int CORE_dlag2z (int m, int n, const double * R, int ldr, PLASMA_Complex64_t * Z, int ldz)
CORE_dlag2z - Copy a real matrix R into the real part of a complex matrix Z

Parameters:
    m m specifies the number of rows of the matrices R and Z.
    n n specifies the number of columns of the matrices R and Z.
    R R contains the real coefficient to be copied into the complex matrix. R is of size ldr -by- n.
    ldr ldr specifies the leading dimension of R. ldr >= max(1,m).
    Z On exit, the real part of the values of Z will be set to the ones stored in R, and the imaginary part set to 0. Z is of size ldz -by- n.
    ldz ldz specifies the leading dimension of Z. ldz >= max(1,m).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_dzasum (PLASMA_enum storev, PLASMA_enum uplo, int M, int N, const PLASMA_Complex64_t * A, int lda, double * work)
CORE_dzasum - Computes the sums of the absolute values of elements in a same row or column. This function is an auxiliary function to norm computations.

Parameters:
    storev Specifies whether the sums are made per column or row. = PlasmaColumnwise: Computes the sum on each column = PlasmaRowwise: Computes the sum on each row
    uplo Specifies whether the matrix A is upper triangular or lower triangular or general = PlasmaUpperLower: All matrix A is referenced; = PlasmaUpper: Upper triangle of A is referenced; = PlasmaLower: Lower triangle of A is referenced.
    M M specifies the number of rows of the matrix A. M >= 0.
    N N specifies the number of columns of the matrix A. N >= 0.
    A A is a M-by-N matrix.
    lda The leading dimension of the array A. lda >= max(1,M).
    work Array of dimension M if storev = PlasmaRowwise; N otherwise. On exit, contains the sums of the absolute values per column or row.

  void CORE_zbrdalg1 (PLASMA_enum uplo, int n, int nb, PLASMA_Complex64_t * A, int lda, PLASMA_Complex64_t * VQ, PLASMA_Complex64_t * TAUQ, PLASMA_Complex64_t * VP, PLASMA_Complex64_t * TAUP, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, PLASMA_Complex64_t * work)
CORE_zbrdalg1 is a part of the bidiagonal reduction algorithm (bulgechasing). It correspond to a local driver of the kernels that should be executed on a single core.

Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    n The order of the matrix A. n >= 0.
    nb The size of the Bandwidth of the matrix A, which correspond to the tile size. nb >= 0.
    A PLASMA_Complex64_t array, dimension (lda,n) On entry, the (2nb+1)-by-n lower or upper band general matrix to be reduced to bidiagonal. On exit, if uplo = PlasmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the bidiagonal matrix B. if uplo = PlasmaLower the diagonal and first subdiagonal of A are overwritten by the corresponding elements of the elements of the bidiagonal matrix B.
    lda (input) INTEGER The leading dimension of the array A. LDA >= max(1,nb+1).
    VQ PLASMA_Complex64_t array, dimension (n) if wantz=0 or ldv*Vblksiz*blkcnt if wantz>0. The scalar elementary left reflectors are written in this array.
    TAUQ PLASMA_Complex64_t array, dimension (n) if wantz=0 or Vblksiz*Vblksiz*blkcnt if wantz>0. The scalar factors of the left elementary reflectors are written in this array.
    VP PLASMA_Complex64_t array, dimension (n) if wantz=0 or ldv*Vblksiz*blkcnt if wantz>0. The scalar elementary right reflectors are written in this array.
    TAUP PLASMA_Complex64_t array, dimension (n) if wantz=0 or Vblksiz*Vblksiz*blkcnt if wantz>0. The scalar factors of the right elementary reflectors are written in this array.
    Vblksiz Local parameter to Plasma. It correspond to the local bloccking of the applyQ2 used to apply the orthogonal matrix Q2.
    wantz integer tobe 0 or 1. if wantz=0 the V and TAU are not stored on only they are kept for next step then overwritten.
    i Integer that refer to the current sweep. (outer loop).
    sweepid Integer that refer to the sweep to chase.(inner loop).
    m Integer that refer to a sweep step, to ensure order dependencies.
    grsiz Integer that refer to the size of a group. group mean the number of kernel that should be executed sequentially on the same core. group size is a trade-off between locality (cache reuse) and parallelism. a small group size increase parallelism while a large group size increase cache reuse.
    work Workspace of size nb. Used by the core_zgbtype[123]cb.

  int CORE_zgbelr (PLASMA_enum uplo, int N, PLASMA_desc * A, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int eltsize)
CORE_zgbelr is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel eliminate a column by an element-wise annihiliation, and for each annihiliation, it apply a left update, followed by an right update on the diagonal 2x2 element, where it create a new nnz, eliminate it and update V and TAU, then it continue until finishing the the whole column. When this is done, it take advantage that data are on cache and will apply the right on the remaining part of this region that has not been updated by the right yet. Note that the column to be eliminated is located at st-1.
Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    N The order of the matrix A.
    A A pointer to the descriptor of the matrix A.
    V PLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    eltsize PLASMA internal value which refer to the size of the precision.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 1-BDL Householder add -1 because of C

  int CORE_zgblrx (PLASMA_enum uplo, int N, PLASMA_desc * A, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int eltsize)
CORE_zgblrx is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply a left update, followed by an right and for each annihiliation, it apply a left update, followed by an right update on the diagonal 2x2 element, where it create a new nnz, eliminate it and update V and TAU, then it continue until finishing the the whole column. When this is done, it take advantage that data are on cache and will apply the right on the remaining part of this region that has not been updated by the right yet.
Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    N The order of the matrix A.
    A A pointer to the descriptor of the matrix A.
    V PLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    eltsize PLASMA internal value which refer to the size of the precision.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 1-BDL Householder add -1 because of C

  int CORE_zgbrce (PLASMA_enum uplo, int N, PLASMA_desc * A, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int eltsize)
CORE_zgbrce is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply a right update, create a new nnz, then it eliminate it, and move to the next right update, create a new nnz, eliminate it and so on until finishing. When this is done, it take advantage that data are on cache and will apply the left on the remaining part of this region that has not been updated by the left yet.
Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    N The order of the matrix A.
    A A pointer to the descriptor of the matrix A.
    V PLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    eltsize PLASMA internal value which refer to the size of the precision.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 1-BDL Householder add -1 because of C

  void CORE_zgbtype1cb (PLASMA_enum uplo, int N, int NB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * VQ, PLASMA_Complex64_t * TAUQ, PLASMA_Complex64_t * VP, PLASMA_Complex64_t * TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t * WORK)
CORE_zgbtype1cb is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel eliminate a column by an column-wise annihiliation, then it apply a left+right update on the hermitian triangle. Note that the column to be eliminated is located at st-1.
All detail are available on technical report or SC11 paper. Azzam Haidar, Hatem Ltaief, and Jack Dongarra. 2011. Parallel reduction to condensed forms for symmetric eigenvalue problems using aggregated fine-grained and memory-aware kernels. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). ACM, New York, NY, USA, , Article 8 , 11 pages. http://doi.acm.org/10.1145/2063384.2063394
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A.
    NB The size of the band.
    A A pointer to the matrix A of size (3*NB+1)-by-N.
    LDA The leading dimension of the matrix A. LDA >= max(1,3*NB+1)
    VP TODO: Check and fix doc PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAUP TODO: Check and fix doc PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    VQ TODO: Check and fix doc PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAUQ TODO: Check and fix doc PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    sweep The sweep number that is eliminated. it serve to calculate the pointer to the position where to store the Vs and Ts.
    Vblksiz constant which correspond to the blocking used when applying the Vs. it serve to calculate the pointer to the position where to store the Vs and Ts.
    WANTZ constant which indicate if Eigenvalue are requested or both Eigenvalue/Eigenvectors.
    WORK Workspace of size nb.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zgbtype2cb (PLASMA_enum uplo, int N, int NB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * VQ, PLASMA_Complex64_t * TAUQ, PLASMA_Complex64_t * VP, PLASMA_Complex64_t * TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t * WORK)
CORE_zgbtype2cb is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply the right update remaining from the type1 and this later will create a bulge so it eliminate the first column of the created bulge and do the corresponding Left update.
All detail are available on technical report or SC11 paper. Azzam Haidar, Hatem Ltaief, and Jack Dongarra. 2011. Parallel reduction to condensed forms for symmetric eigenvalue problems using aggregated fine-grained and memory-aware kernels. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). ACM, New York, NY, USA, , Article 8 , 11 pages. http://doi.acm.org/10.1145/2063384.2063394
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A.
    NB The size of the band.
    A A pointer to the matrix A of size (3*NB+1)-by-N.
    LDA The leading dimension of the matrix A. LDA >= max(1,3*NB+1)
    VP TODO: Check and fix doc PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors of the previous type 1 are used here to continue update then new one are generated to eliminate the bulge and stored in this array.
    TAUP TODO: Check and fix doc PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors of the previous type 1 are used here to continue update then new one are generated to eliminate the bulge and stored in this array.
    VQ TODO: Check and fix doc PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors of the previous type 1 are used here to continue update then new one are generated to eliminate the bulge and stored in this array.
    TAUQ TODO: Check and fix doc PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors of the previous type 1 are used here to continue update then new one are generated to eliminate the bulge and stored in this array.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    sweep The sweep number that is eliminated. it serve to calculate the pointer to the position where to store the Vs and Ts.
    Vblksiz constant which correspond to the blocking used when applying the Vs. it serve to calculate the pointer to the position where to store the Vs and Ts.
    WANTZ constant which indicate if Eigenvalue are requested or both Eigenvalue/Eigenvectors.
    WORK Workspace of size nb.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zgbtype3cb (PLASMA_enum uplo, int N, int NB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * VQ, PLASMA_Complex64_t * TAUQ, PLASMA_Complex64_t * VP, PLASMA_Complex64_t * TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t * WORK)
CORE_zgbtype3cb is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply a left+right update on the hermitian triangle. Note that this kernel is very similar to type1 but does not do an elimination.
All detail are available on technical report or SC11 paper. Azzam Haidar, Hatem Ltaief, and Jack Dongarra. 2011. Parallel reduction to condensed forms for symmetric eigenvalue problems using aggregated fine-grained and memory-aware kernels. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). ACM, New York, NY, USA, , Article 8 , 11 pages. http://doi.acm.org/10.1145/2063384.2063394
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A.
    NB The size of the band.
    A A pointer to the matrix A of size (3*NB+1)-by-N.
    LDA The leading dimension of the matrix A. LDA >= max(1,3*NB+1)
    VP TODO: Check and fix doc PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAUP TODO: Check and fix doc PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    VQ TODO: Check and fix doc PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAUQ TODO: Check and fix doc PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    sweep The sweep number that is eliminated. it serve to calculate the pointer to the position where to store the Vs and Ts.
    Vblksiz constant which correspond to the blocking used when applying the Vs. it serve to calculate the pointer to the position where to store the Vs and Ts.
    WANTZ constant which indicate if Eigenvalue are requested or both Eigenvalue/Eigenvectors.
    WORK Workspace of size nb.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zgeadd (PLASMA_enum trans, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t * B, int LDB)
CORE_zgeadd adds two matrices together as in PBLAS pzgeadd.
 B <- alpha * op(A)  + beta * B,
where op(X) = X, X', or conj(X')
Parameters:
    trans Specifies whether the matrix A is non-transposed, transposed, or conjugate transposed = PlasmaNoTrans: op(A) = A = PlasmaTrans: op(A) = A' = PlasmaConjTrans: op(A) = conj(A')
    M Number of rows of the matrices op(A) and B.
    N Number of columns of the matrices op(A) and B.
    alpha Scalar factor of A.
    A Matrix of size LDA-by-N, if trans = PlasmaNoTrans, LDA-by-M otherwise.
    LDA Leading dimension of the array A. LDA >= max(1,k), with k=M, if trans = PlasmaNoTrans, and k=N otherwise.
    beta Scalar factor of B.
    B Matrix of size LDB-by-N. On exit, B = alpha * op(A) + beta * B
    LDB Leading dimension of the array B. LDB >= max(1,M)
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zgelqt (int M, int N, int IB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_zgelqt - computes a LQ factorization of a complex M-by-N tile A: A = L * Q.
The tile Q is represented as a product of elementary reflectors
Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in A(i,i+1:n), and tau in TAU(i).
Parameters:
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A On entry, the M-by-N tile A. On exit, the elements on and below the diagonal of the array contain the M-by-min(M,N) lower trapezoidal tile L (L is lower triangular if M <= N); the elements above the diagonal, with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
    LDA The leading dimension of the array A. LDA >= max(1,M).
    T The IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    TAU The scalar factors of the elementary reflectors (see Further Details).
    WORK
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zgemm (PLASMA_enum transA, int transB, int M, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t * C, int LDC)
CORE_zgemm - Performs one of the matrix-matrix operations
+
where op( X ) is one of
op( X ) = X or op( X ) = X' or op( X ) = conjg( X' )
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:
    transA Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjugate transposed.
    transB Specifies whether the matrix B is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaConjTrans: B is conjugate transposed.
    M M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0.
    N N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0.
    K K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K >= 0.
    alpha alpha specifies the scalar alpha
    A A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    B B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise.
    LDB The leading dimension of the array B. LDB >= max(1,N).
    beta beta specifies the scalar beta
    C C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )
    LDC The leading dimension of the array C. LDC >= max(1,M).

  void CORE_zgemv (PLASMA_enum trans, int m, int n, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int lda, const PLASMA_Complex64_t * x, int incx, PLASMA_Complex64_t beta, PLASMA_Complex64_t * y, int incy)
CORE_zgemv performs one of the matrix-vector operations
y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*x + beta*y,
where alpha and beta are scalars, x and y are vectors, and A is an m by n matrix.
Parameters:
    trans
    •   PlasmaNoTrans: y := alpha*A*x + beta*y
    •   PlasmaTrans: y := alpha*A**T*x + beta*y
    •   PlasmaConjTrans: y := alpha*A**H*x + beta*y
    m Number of rows of matrix A.
    n Number of columns of matrix A.
    alpha Scalar alpha.
    A On entry, m by n matrix A. Dimension (lda,n).
    lda Leading dimension of array A. lda >= max(1,m).
    x On entry, vector x. If trans == PlasmaNoTrans, the n vector x has dimension 1 + (n-1)*abs(incx). Else, the m vector x has dimension 1 + (m-1)*abs(incx).
    incx Increment between elements of x. incx must not be zero.
    beta Scalar beta.
    y On entry, vector y. On exit, y is overwritten by updated vector y. If trans == PlasmaNoTrans, the m vector y has dimension 1 + (m-1)*abs(incy). Else, the n vector y has dimension 1 + (n-1)*abs(incy).
    incy Increment between elements of y. incy must not be zero.

  void CORE_zgeqp3_init (int n, int * jpvt)
CORE_zgeqp3_init initializes jpvt to [1, ..., n]. Uses 1-based indexing for Fortran compatability.
Parameters:
    n Size of vector.
    jpvt Vector of size n. On exit, jpvt[i] = i+1.

  void CORE_zgeqp3_larfg (PLASMA_desc A, int ii, int jj, int i, int j, PLASMA_Complex64_t * tau, PLASMA_Complex64_t * beta)
CORE_zgeqp3_larfg generates a Householder elementary reflector H, such that
H**H * x = [ beta ]  and  H**H * H = I.
           [ 0    ]
where alpha and beta are scalars, with beta real, and x is an n element vector. H is reperested in the form
H = I - tau * [ 1 ] * [ 1 v**H ],
              [ v ]
where tau is a scalar and v is an (n-1) element vector. If x[1:] = 0 and x[0] is real, then tau = 0 and H = I. Otherwise, 1 <= real(tau) <= 2 and abs(tau-1) <= 1.
Here, x = A[ ii*mb + i : m, jj*nb + j ]. That is, x is j-th column of the jj-th block-column of A, starting in the i-th row of the ii-th block-row of A, and going to the last row. Note that x spans multiple tiles of A.
This DIFFERS from LAPACK in that the 1.0 is stored explicitly in the top element of x and beta is stored separately. (Whereas in LAPACK, the 1.0 is implicit and beta is stored in the top element of x.)
Parameters:
    A Description of m by n matrix A. On entry, A[ ii*mb + i : m, jj*nb + j ] is the vector x. On exit, A[ ii*mb + i : m, jj*nb + j ] is overwritten with [ 1, v ].
    ii Index of block row of A to start in.
    jj Index of block column of A.
    i Index of row within ii-th block row to start in.
    j Index of column within jj-th block column.
    tau The scalar tau.
    beta The scalar beta.

  void CORE_zgeqp3_norms (PLASMA_desc A, int ioff, int joff, double * norms1, double * norms2)
CORE_zgeqp3_norms computes the 2-norm of each column of A[ ioff:m, joff:n ] that is marked with norms2[j] == -1 on entry. Entries that are not marked are assumed to already contain the correct 2-norm, so that the same routine can be used for computing the initial norms and for updating bad norms. The result is stored duplicated in norms1 and norms2.
Parameters:
    A PLASMA descriptor of the matrix A. On entry, the M-by-N matrix described by the descriptor.
    ioff Row offset.
    joff Column offset.
    norms1 Vector of size A.n. On exit, norms1[j] is 2-norm of column j, for j >= joff.
    norms2 Vector of size A.n. On entry, if norms2[j] == -1, re-compute norm of column j. On exit, norms2[j] is 2-norm of column j, for j >= joff.

  void CORE_zgeqp3_pivot (PLASMA_desc A, PLASMA_Complex64_t * F, int ldf, int jj, int k, int * jpvt, double * norms1, double * norms2, int * info)
CORE_zgeqp3_pivot finds next pivot, pvt, based on maximum column norm. It applies the swap to the matrices A, F, and vectors jpvt, norms1, norms2. If info != 0, it returns immediately, doing no work.
Parameters:
    A On entry, descriptor for m by n matrix A. On exit, column k of jj-th block column is swapped with column pvt.
    F On entry, n by nb matrix F. On exit, row k is swapped with row pvt - jj*nb. Currently, F is stored column-wise, not tile-wise.
    ldf Leading dimension of F. ldf >= max(1,A.n).
    jj Index of current block column, 0 <= jj < A.nt.
    k Index of current column within block column, 0 <= k < A.nb.
    jpvt Permutation vector, dimension n. On exit, swaps entries jpvt[k+jj*nb] and jpvt[pvt].
    norms1 On entry, vector of partial column norms, dimension n. On exit, sets norms1[pvt] = norms1[k+jj*nb].
    norms2 On entry, vector of original column norms, dimension n. On exit, sets norms2[pvt] = norms2[k+jj*nb].
    info Error code from zgeqp3_update; zero if no error.

  void CORE_zgeqp3_update (const PLASMA_Complex64_t * Ajj, int lda1, PLASMA_Complex64_t * Ajk, int lda2, const PLASMA_Complex64_t * Fk, int ldf, int joff, int k, int koff, int nb, double * norms1, double * norms2, int * info)
CORE_zgeqp3_update updates row k of one tile of A and subtracts that row from the column norms.
Parameters:
    Ajj Diagonal tile (jj,jj) of A.
    lda1 Leading dimension of Ajj.
    Ajk Tile (jj,kk) of A, kk >= jj. On exit, updates row joff+k (i.e., as if Q was applied to trailing matrix).
    lda2 Leading dimension of Ajk.
    Fk Tile kk of F.
    ldf Leading dimension of Fk.
    joff Row offset.
    k Update row joff+k, based on having factored k columns. (That is, joff columns of this tile were factored in previous panels; k columns have been factored during this panel.)
    koff Column to start updating. For diagonal tile, koff=joff+k+1, else koff=0.
    nb Number of columns in kk-th block-column of A.
    norms1 kk-th block of partial column norms vector, dimension nb. On exit, norms1[koff:nb] -= Ajk[k, koff:nb ].
    norms2 kk-th block of original column norms vector, dimension nb. Unchanged on exit, except if cancellation is detected for some column j, sets norm2[j] = -1 and sets info = 1.
    info Set to true if numerical instability (cancellation) is detected in updating column norms. zgeqp3 handles this error.

  int CORE_zgeqrt (int M, int N, int IB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_zgeqrt computes a QR factorization of a complex M-by-N tile A: A = Q * R.
The tile Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(M,N).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).
Parameters:
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A On entry, the M-by-N tile A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal tile R (R is upper triangular if M >= N); the elements below the diagonal, with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
    LDA The leading dimension of the array A. LDA >= max(1,M).
    T The IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    TAU The scalar factors of the elementary reflectors (see Further Details).
    WORK
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zgessm (int M, int N, int K, int IB, const int * IPIV, const PLASMA_Complex64_t * L, int LDL, PLASMA_Complex64_t * A, int LDA)
CORE_zgessm applies the factors L computed by CORE_zgetrf_incpiv to a complex M-by-N tile A.
Parameters:
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    K The number of columns of the tile L. K >= 0.
    IB The inner-blocking size. IB >= 0.
    IPIV The pivot indices array of size K as returned by CORE_zgetrf_incpiv.
    L The M-by-K lower triangular tile.
    LDL The leading dimension of the array L. LDL >= max(1,M).
    A On entry, the M-by-N tile A. On exit, updated by the application of L.
    LDA The leading dimension of the array A. LDA >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_zgetf2_nopiv (int M, int N, PLASMA_Complex64_t * A, int LDA)
CORE_zgetf2_nopiv computes an LU factorization of a general diagonal dominant M-by-N matrix A witout no pivoting and no blocking. It is the internal function called by CORE_zgetrf_nopiv().
The factorization has the form A = L * U where L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).
This is the right-looking Level 3 BLAS version of the algorithm.
Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    A On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    LDA The leading dimension of the array A. LDA >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value
    >0 if INFO = k, U(k,k) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

  int CORE_zgetrf (int m, int n, PLASMA_Complex64_t * A, int lda, int * IPIV, int * info)
CORE_zgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.
Parameters:
    m The number of rows of the matrix A. m >= 0.
    n The number of columns of the matrix A. n >= 0.
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
    lda The leading dimension of the array A. LDA >= max(1,M).
    IPIV The pivot indices that define the permutations.
    info
    •   0 on successful exit
    •   <0 if -i, the i-th argument had an illegal value
    •   >0 if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Returns:
Return values:
    PLASMA_SUCCESS successful exit

  int CORE_zgetrf_incpiv (int M, int N, int IB, PLASMA_Complex64_t * A, int LDA, int * IPIV, int * INFO)
CORE_zgetrf_incpiv computes an LU factorization of a general M-by-N tile A using partial pivoting with row interchanges.
The factorization has the form
A = P * L * U
where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).
This is the right-looking Level 2.5 BLAS version of the algorithm.
Parameters:
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A On entry, the M-by-N tile to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    IPIV The pivot indices; for 1 <= i <= min(M,N), row i of the tile was interchanged with row IPIV(i).
    INFO See returned value.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value
    >0 if INFO = k, U(k,k) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

  int CORE_zgetrf_nopiv (int M, int N, int IB, PLASMA_Complex64_t * A, int LDA)
CORE_zgetrf_nopiv computes an LU factorization of a general diagonal dominant M-by-N matrix A witout pivoting.
The factorization has the form A = L * U where L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).
This is the right-looking Level 3 BLAS version of the algorithm. WARNING: Your matrix need to be diagonal dominant if you want to call this routine safely.
Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    IB The block size to switch between blocked and unblocked code.
    A On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    LDA The leading dimension of the array A. LDA >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value
    >0 if INFO = k, U(k,k) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

  int CORE_zgetrf_reclap (CORE_zgetrf_data_t * data, int M, int N, PLASMA_Complex64_t * A, int LDA, int * IPIV, int * info)
CORE_zgetrf_reclap computes a LU factorization of a general M-by-N matrix A stored in CCRB layout using partial pivoting with row interchanges.
The factorization has the form
A = P * L * U
where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).
This is the recursive version of the algorithm applied on column major layout.
WARNINGS:
•   The function CORE_zgetrf_reclap_init has to be called prior to any call to this function.
•   You cannot call this kernel on different matrices at the same time.
•   The matrix A cannot be more than one tile wide.
•   The number of threads calling this function has to be excatly the number defined by info[2] with each one of them a different index between 0 included and info[2] excluded.
Parameters:
    data Common data structure to all threads initialized by CORE_zgetrf_reclap_init() that contains information for thread synchronization and maximum reductions. All threads working on a given matrix A must provide the same data structure.
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    A On entry, the M-by-N matrix to be factorized. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    IPIV The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). 1 <= IPIV[i] <= M.
    info Array of 3 integers
    •   info[0], see returned value
    •   info[1], is the thread index 0 <= info[0] < info[2]
    •   info[2], on entry is the number of threads trying to participate to the factorization, on exit is the real number of threads used to perform the factorization. Info[2] threads, and exactly info[2], have to call this function to avoid dead lock.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    -k,the k-th argument had an illegal value
    k if U(k,k) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

  int CORE_zgetrf_rectil (CORE_zgetrf_data_t * data, const PLASMA_desc A, int * IPIV, int * info)
CORE_zgetrf_rectil computes a LU factorization of a general M-by-N matrix A stored in CCRB layout using partial pivoting with row interchanges.
The factorization has the form
A = P * L * U
where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).
This is the recursive version of the algorithm applied on tile layout.
WARNINGS:
•   The function CORE_zgetrf_rectil_init has to be called prior to any call to this function.
•   You cannot call this kernel on different matrices at the same time.
•   The matrix A cannot be more than one tile wide.
•   The number of threads calling this function has to be excatly the number defined by info[2] with each one of them a different index between 0 included and info[2] excluded.
Parameters:
    data Common data structure to all threads initialized by CORE_zgetrf_rectil_init() that contains information for thread synchronization and maximum reductions. All threads working on a given matrix A must provide the same data structure.
    A PLASMA descriptor of the matrix A to be factorized. On entry, the M-by-N matrix to be factorized. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    IPIV The pivot indices; for 0 <= i < min(M,N) stored in Fortran mode (starting at 1), row i of the matrix was interchanged with row IPIV(i). On exit, each value IPIV[i] for 0 <= i < min(M,N) is increased by A.i, which means A.i < IPIV[i] <= A.i+M.
    info Array of 3 integers.
    •   info[0], see returned value
    •   info[1], is the thread index 0 <= info[0] < info[2]
    •   info[2], on entry is the number of threads trying to participate to the factorization, on exit is the real number of threads used to perform the factorization. Info[2] threads, and exactly info[2], have to call this function to avoid dead lock.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    -k,the k-th argument had an illegal value
    k if U(k,k) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

  void CORE_zgetrip (int m, int n, PLASMA_Complex64_t * A, PLASMA_Complex64_t * W)
CORE_zgetrip transposes a m-by-n matrix in place using an extra workspace of size m-by-n. Note : For square tile, workspace is not used.
Parameters:
    m Number of lines of tile A
    n Number of columns of tile A
    A Tile of size m-by-n On exit, A = trans(A)
    W Workspace of size n-by-m if n != m, NULL otherwise.

  int CORE_zhbelr (PLASMA_enum uplo, int N, PLASMA_desc * A, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int eltsize)
CORE_zhbelr is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel eliminate a column by an element-wise annihiliation, and for each annihiliation, it apply a left update, followed by an right update on the diagonal 2x2 element, then it continue until finishing the the whole column. When this is done, it take advantage that data are on cache and will apply the right on the remaining part of this region that has not been updated by the right yet. Note that the column to be eliminated is located at st-1.
Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    N The order of the matrix A.
    A A pointer to the descriptor of the matrix A.
    V PLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    eltsize PLASMA internal value which refer to the size of the precision.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 1-BDL Householder add -1 because of C

  int CORE_zhblrx (PLASMA_enum uplo, int N, PLASMA_desc * A, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int eltsize)
CORE_zhblrx is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply a left update, followed by an right update on the diagonal 2x2 element, then it continue until finishing the the whole column. When this is done, it take advantage that data are on cache and will apply the right on the remaining part of this region that has not been updated by the right yet.
Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    N The order of the matrix A.
    A A pointer to the descriptor of the matrix A.
    V PLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    eltsize PLASMA internal value which refer to the size of the precision.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 1-BDL Householder add -1 because of C

  int CORE_zhbrce (PLASMA_enum uplo, int N, PLASMA_desc * A, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int eltsize)
CORE_zhbrce is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply a right update, create a new nnz, then it eliminate it, and move to the next right update, create a new nnz, eliminate it and so on until finishing. When this is done, it take advantage that data are on cache and will apply the left on the remaining part of this region that has not been updated by the left yet.
Parameters:
    uplo
    •   PlasmaLower:
    •   PlasmaUpper:
    N The order of the matrix A.
    A A pointer to the descriptor of the matrix A.
    V PLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    eltsize PLASMA internal value which refer to the size of the precision.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 1-BDL Householder add -1 because of C

  void CORE_zhbtype1cb (int N, int NB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t * WORK)
CORE_zhbtype1cb is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel eliminate a column by an column-wise annihiliation, then it apply a left+right update on the hermitian triangle. Note that the column to be eliminated is located at st-1.
All detail are available on technical report or SC11 paper. Azzam Haidar, Hatem Ltaief, and Jack Dongarra. 2011. Parallel reduction to condensed forms for symmetric eigenvalue problems using aggregated fine-grained and memory-aware kernels. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). ACM, New York, NY, USA, , Article 8 , 11 pages. http://doi.acm.org/10.1145/2063384.2063394
Parameters:
    N The order of the matrix A.
    NB The size of the band.
    A A pointer to the matrix A of size (2*NB+1)-by-N.
    LDA The leading dimension of the matrix A. LDA >= max(1,2*NB+1)
    V PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    sweep The sweep number that is eliminated. it serve to calculate the pointer to the position where to store the Vs and Ts.
    Vblksiz constant which correspond to the blocking used when applying the Vs. it serve to calculate the pointer to the position where to store the Vs and Ts.
    WANTZ constant which indicate if Eigenvalue are requested or both Eigenvalue/Eigenvectors.
    WORK Workspace of size nb.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zhbtype2cb (int N, int NB, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t * WORK)
CORE_zhbtype2cb is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply the right update remaining from the type1 and this later will create a bulge so it eliminate the first column of the created bulge and do the corresponding Left update.
All detail are available on technical report or SC11 paper. Azzam Haidar, Hatem Ltaief, and Jack Dongarra. 2011. Parallel reduction to condensed forms for symmetric eigenvalue problems using aggregated fine-grained and memory-aware kernels. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). ACM, New York, NY, USA, , Article 8 , 11 pages. http://doi.acm.org/10.1145/2063384.2063394
Parameters:
    N The order of the matrix A.
    NB The size of the band.
    A A pointer to the matrix A of size (2*NB+1)-by-N.
    LDA The leading dimension of the matrix A. LDA >= max(1,2*NB+1)
    V PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors of the previous type 1 are used here to continue update then new one are generated to eliminate the bulge and stored in this array.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors of the previous type 1 are used here to continue update then new one are generated to eliminate the bulge and stored in this array.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    sweep The sweep number that is eliminated. it serve to calculate the pointer to the position where to store the Vs and Ts.
    Vblksiz constant which correspond to the blocking used when applying the Vs. it serve to calculate the pointer to the position where to store the Vs and Ts.
    WANTZ constant which indicate if Eigenvalue are requested or both Eigenvalue/Eigenvectors.
    WORK Workspace of size nb.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zhbtype3cb (int N, int NB, PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * V, const PLASMA_Complex64_t * TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, PLASMA_Complex64_t * WORK)
CORE_zhbtype3cb is a kernel that will operate on a region (triangle) of data bounded by st and ed. This kernel apply a left+right update on the hermitian triangle. Note that this kernel is very similar to type1 but does not do an elimination.
All detail are available on technical report or SC11 paper. Azzam Haidar, Hatem Ltaief, and Jack Dongarra. 2011. Parallel reduction to condensed forms for symmetric eigenvalue problems using aggregated fine-grained and memory-aware kernels. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). ACM, New York, NY, USA, , Article 8 , 11 pages. http://doi.acm.org/10.1145/2063384.2063394
Parameters:
    N The order of the matrix A.
    NB The size of the band.
    A A pointer to the matrix A of size (2*NB+1)-by-N.
    LDA The leading dimension of the matrix A. LDA >= max(1,2*NB+1)
    V PLASMA_Complex64_t array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAU PLASMA_Complex64_t array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    st A pointer to the start index where this kernel will operate.
    ed A pointer to the end index where this kernel will operate.
    sweep The sweep number that is eliminated. it serve to calculate the pointer to the position where to store the Vs and Ts.
    Vblksiz constant which correspond to the blocking used when applying the Vs. it serve to calculate the pointer to the position where to store the Vs and Ts.
    WANTZ constant which indicate if Eigenvalue are requested or both Eigenvalue/Eigenvectors.
    WORK Workspace of size nb.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value TYPE 3-BAND Lower-columnwise-Householder

  void CORE_zhegst (int itype, PLASMA_enum uplo, int N, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * B, int LDB, int * INFO)
CORE_zhegst - reduces a complex Hermitian-definite generalized eigenproblem to standard form. If PlasmaItype == 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If PlasmaItype == 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by CORE_zpotrf.
Parameters:
    itype Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrices A and B. N >= 0.
    A On entry, the symmetric (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value == 0, the transformed matrix, stored in the same format as A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    B On entry, the triangular factor from the Cholesky factorization of B, as returned by PLASMA_ZPOTRF.
    LDB The leading dimension of the array B. LDB >= max(1,N).
    INFO
    •   0 on successful exit
    •   <0 if -i, the i-th argument had an illegal value

  void CORE_zhemm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t * C, int LDC)
CORE_zhemm - Performs one of the matrix-matrix operations
.PP or
.PP where alpha and beta are scalars, A is an hermitian matrix and B and C are m by n matrices.
Parameters:
    side Specifies whether the hermitian matrix A appears on the left or right in the operation as follows: = PlasmaLeft: = PlasmaRight:
    uplo Specifies whether the upper or lower triangular part of the hermitian matrix A is to be referenced as follows: = PlasmaLower: Only the lower triangular part of the hermitian matrix A is to be referenced. = PlasmaUpper: Only the upper triangular part of the hermitian matrix A is to be referenced.
    M Specifies the number of rows of the matrix C. M >= 0.
    N Specifies the number of columns of the matrix C. N >= 0.
    alpha Specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is M when side = PlasmaLeft, and is N otherwise. Only the uplo triangular part is referenced.
    LDA The leading dimension of the array A. LDA >= max(1,ka).
    B B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B.
    LDB The leading dimension of the array B. LDB >= max(1,M).
    beta Specifies the scalar beta.
    C C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N updated matrix.
    LDC The leading dimension of the array C. LDC >= max(1,M).

  void CORE_zher2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * B, int LDB, double beta, PLASMA_Complex64_t * C, int LDC)
CORE_zher2k - Performs one of the hermitian rank 2k operations
+ conjg( lpha ) [ op( B ) imes conjg( op( A )' )] + ts op( B ) ] + conjg( lpha ) [ conjg( op( B )' ) imes op( A ) ] +
where op( X ) is one of
op( X ) = X or op( X ) = conjg( X' )
where alpha and beta are real scalars, C is an n-by-n symmetric matrix and A and B are an n-by-k matrices the first case and k-by-n matrices in the second case.
Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: + conjg( lpha ) [ op( B ) imes conjg( op( A )' )] + ts op( B ) ] + conjg( lpha ) [ conjg( op( B )' ) imes op( A ) ] +
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the A and B matrices with trans = PlasmaNoTrans. K specifies the number of rows of the A and B matrices with trans = PlasmaTrans.
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ), otherwise LDA must be at least max( 1, K ).
    B B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise.
    LDB The leading dimension of the array B. LDB must be at least max( 1, N ), otherwise LDB must be at least max( 1, K ).
    beta beta specifies the scalar beta.
    C C is a LDC-by-N matrix. On exit, the array uplo part of the matrix is overwritten by the uplo part of the updated matrix.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

  int CORE_zherfb (PLASMA_enum uplo, int n, int k, int ib, int nb, const PLASMA_Complex64_t * A, int lda, const PLASMA_Complex64_t * T, int ldt, PLASMA_Complex64_t * C, int ldc, PLASMA_Complex64_t * WORK, int ldwork)
CORE_zherfb overwrites the symmetric complex N-by-N tile C with
Q**T*C*Q
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(1) H(2) . . . H(k)
as returned by CORE_zgeqrt. Only PlasmaLower supported!
Parameters:
    uplo
    •   PlasmaLower : the upper part of the symmetric matrix C is not referenced.
    •   PlasmaUpper : the lower part of the symmetric matrix C is not referenced (not supported).
    n The number of rows/columns of the tile C. N >= 0.
    k The number of elementary reflectors whose product defines the matrix Q. K >= 0.
    ib The inner-blocking size. IB >= 0.
    nb The blocking size. NB >= 0.
    A The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_zgeqrt in the first k columns of its array argument A.
    lda The leading dimension of the array A. LDA >= max(1,N).
    T The IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    ldt The leading dimension of the array T. LDT >= IB.
    C On entry, the symmetric N-by-N tile C. On exit, C is overwritten by Q**T*C*Q.
    ldc The leading dimension of the array C. LDC >= max(1,M).
    WORK On exit, if INFO = 0, WORK(1) returns the optimal LDWORK.
    ldwork The dimension of the array WORK. LDWORK >= max(1,N);
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zherk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, const PLASMA_Complex64_t * A, int LDA, double beta, PLASMA_Complex64_t * C, int LDC)
CORE_zherk - Performs one of the hermitian rank k operations
+
where op( X ) is one of
op( X ) = X or op( X ) = conjg( X' )
where alpha and beta are real scalars, C is an n-by-n hermitian matrix and A is an n-by-k matrix in the first case and a k-by-n matrix in the second case.
Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the matrix op( A ).
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ) if trans == PlasmaNoTrans, otherwise LDA must be at least max( 1, K ).
    beta beta specifies the scalar beta
    C C is a LDC-by-N matrix. On exit, the array uplo part of the matrix is overwritten by the uplo part of the updated matrix.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

  void CORE_zlacpy (PLASMA_enum uplo, int M, int N, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * B, int LDB)
CORE_zlacpy copies all or part of a two-dimensional matrix A to another matrix B
Parameters:
    uplo Specifies the part of the matrix A to be copied to B. = PlasmaUpperLower: All the matrix A = PlasmaUpper: Upper triangular part = PlasmaLower: Lower triangular part
    M The number of rows of the matrices A and B. M >= 0.
    N The number of columns of the matrices A and B. N >= 0.
    A The M-by-N matrix to copy.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    B The M-by-N copy of the matrix A. On exit, B = A ONLY in the locations specified by uplo.
    LDB The leading dimension of the array B. LDB >= max(1,M).

  int CORE_zlacpy_pivot (const PLASMA_desc descA, PLASMA_enum direct, int k1, int k2, const int * ipiv, int * rankin, int * rankout, PLASMA_Complex64_t * A, int lda, int init)
CORE_zlacpy_pivot extracts the original version of the rows selected by the ipiv array and copies them into a new buffer.
This kernel is used by tournament pivoting algorithms, to extract the selected rows from the original matrix that will make it to the next level of the tournament.
Parameters:
    descA The descriptor of the matrix A in which the kernel will extract the original rows.
    direct
    •   PlasmaRowwise: The extracted rows are stored in column major layout.
    •   PlasmaColumnwise: The extracted rows are store in row major layout.
    k1 The first element of IPIV for which a row interchange will be done.
    k2 The last element of IPIV for which a row interchange will be done.
    ipiv The pivot indices; Only the element in position k1 to k2 are accessed. The pivots should be included in the interval 1 to A.m
    rankin On entry, the global indices relative to the full matrix A factorized, in the local sub-matrix. If init == 1, rankin is initialized to A.i, .. A.i+descA.m On exit, rows are permutted according to ipiv.
    rankout On exit, contains the global indices of the first (k2-k1+1) rows.
    A An lda-by-descA.n matrix. On exit, A contains the original version of the rows selected by the pivoting process.
    lda The leading dimension of the array A. lda >= max(1,(k2-k1+1)).
    init True if rankin needs to be initialized. False, if rankin contains already initialized data.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  void CORE_zlag2c (int m, int n, const PLASMA_Complex64_t * A, int lda, PLASMA_Complex32_t * B, int ldb, int * info)
CORE_zlag2c converts a PLASMA_Complex64_t matrix, A, to a PLASMA_Complex32_t matrix, B.
Parameters:
    m The number of rows of the matrices A and B. m >= 0.
    n The number of columns of the matrices A and B. n >= 0.
    A The PLASMA_Complex64_t m-by-n matrix to convert.
    lda The leading dimension of the array A. lda >= max(1,m).
    B The PLASMA_Complex32_t m-by-n matrix to convert.
    ldb The leading dimension of the array B. ldb >= max(1,m).
    info
    •   0 on successful exit.
    •   1 if an entry of the matrix A is greater than the SINGLE PRECISION overflow threshold, in this case, the content of B in exit is unspecified.

  void CORE_zlange (int norm, int M, int N, const PLASMA_Complex64_t * A, int LDA, double * work, double * normA)
CORE_zlange returns the value
zlange = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm
where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    A The M-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    work Array of dimension (MAX(1,LWORK)), where LWORK >= M when NORM = PlasmaInfNorm; otherwise, WORK is not referenced.
    normA On exit, normA is the norm of matrix A.

  void CORE_zlanhe (int norm, PLASMA_enum uplo, int N, const PLASMA_Complex64_t * A, int LDA, double * work, double * normA)
CORE_zlanhe returns the value
zlanhe = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm
where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The number of columns/rows of the matrix A. N >= 0. When N = 0, the returned value is set to zero.
    A The N-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    work Array of dimension (MAX(1,LWORK)), where LWORK >= N when norm = PlasmaInfNorm or PlasmaOneNorm; otherwise, work is not referenced.
    normA On exit, normA is the norm of matrix A.

  void CORE_zlansy (int norm, PLASMA_enum uplo, int N, const PLASMA_Complex64_t * A, int LDA, double * work, double * normA)
CORE_zlansy returns the value
zlansy = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm
where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The number of columns/rows of the matrix A. N >= 0. When N = 0, the returned value is set to zero.
    A The N-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    work Array of dimension (MAX(1,LWORK)), where LWORK >= N when norm = PlasmaInfNorm or PlasmaOneNorm; otherwise, work is not referenced.
    normA On exit, normA is the norm of matrix A.

  void CORE_zlantr (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const PLASMA_Complex64_t * A, int LDA, double * work, double * normA)
CORE_zlantr returns the value
zlantr = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm
where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    M The number of rows of the matrix A. M >= 0. If uplo == PlasmaUpper, M <= N. When M = 0, CORE_zlantr returns 0.
    N The number of columns of the matrix A. N >= 0. If uplo == PlasmaLower, N <= M. When N = 0, CORE_zlantr returns 0.
    A The LDA-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    work Array of dimension (MAX(1,LWORK)), where LWORK >= M when norm = PlasmaInfNorm, or LWORK >= N when norm = PlasmaOneNorm; otherwise, work is not referenced.
    normA On exit, normA is the norm of matrix A.

  int CORE_zlarfb_gemm (PLASMA_enum side, PLASMA_enum trans, int direct, int storev, int M, int N, int K, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * C, int LDC, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_zlarfb_gemm applies a complex block reflector H or its transpose H' to a complex M-by-N matrix C, from either the left or the right. this kernel is similar to the lapack zlarfb but it do a full gemm on the triangular Vs assuming that the upper part of Vs is zero and ones are on the diagonal. It is also based on the fact that a gemm on a small block of k reflectors is faster than a trmm on the triangular (k,k) + gemm below.
NOTE THAT: Only Columnwise/Forward cases are treated here.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    direct Indicates how H is formed from a product of elementary reflectors
    •   PlasmaForward : H = H(1) H(2) . . . H(k) (Forward)
    •   PlasmaBackward : H = H(k) . . . H(2) H(1) (Backward)
    storev Indicates how the vectors which define the elementary reflectors are stored:
    •   PlasmaColumnwise
    •   PlasmaRowwise
    M The number of rows of the matrix C.
    N The number of columns of the matrix C.
    K The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
    V COMPLEX*16 array, dimension (LDV,K) if storev = 'C' (LDV,M) if storev = 'R' and side = 'L' (LDV,N) if storev = 'R' and side = 'R' The matrix V. See further details.
    LDV The leading dimension of the array V. If storev = 'C' and side = 'L', LDV >= max(1,M); if storev = 'C' and side = 'R', LDV >= max(1,N); if storev = 'R', LDV >= K.
    T The triangular K-by-K matrix T in the representation of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= K.
    C COMPLEX*16 array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
    LDC The leading dimension of the array C. LDC >= max(1,M).
    WORK (workspace) COMPLEX*16 array, dimension (LDWORK,K).
    LDWORK The dimension of the array WORK. If side = PlasmaLeft, LDWORK >= max(1,N); if side = PlasmaRight, LDWORK >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zlarfx2 (PLASMA_enum side, int N, PLASMA_Complex64_t V, PLASMA_Complex64_t TAU, PLASMA_Complex64_t * C1, int LDC1, PLASMA_Complex64_t * C2, int LDC2)
CORE_zlarfx2 applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right. H is represented in the form
  H = I - tau * v * v'
where tau is a complex scalar and v is a complex vector.
If tau = 0, then H is taken to be the unit matrix
This version uses inline code if H has order < 11.
Parameters:
    side
    •   PlasmaLeft : form H * C
    •   PlasmaRight: form C * H
    N The number of columns of C1 and C2 if side = PlasmaLeft. The number of rows of C1 and C2 if side = PlasmaRight.
    V The double complex V in the representation of H.
    TAU The value tau in the representation of H.
    C1 dimension (LDC1,N), if side = PlasmaLeft dimension (LDC1,1), if side = PlasmaRight On entry, the m by n matrix C1. On exit, C1 is overwritten by the matrix H * C1 if SIDE = PlasmaLeft, or C1 * H if SIDE = PlasmaRight.
    LDC1 The leading dimension of the array C1. LDC1 >= max(1,N), if side == PlasmaRight. LDC1 >= 1, otherwise.
    C2 dimension (LDC2,N), if side = PlasmaLeft dimension (LDC2,1), if side = PlasmaRight On entry, the m by n matrix C2. On exit, C2 is overwritten by the matrix H * C2 if SIDE = PlasmaLeft, or C2 * H if SIDE = PlasmaRight.
    LDC2 The leading dimension of the array C2. LDC2 >= max(1,N), if side == PlasmaRight. LDC2 >= 1, otherwise.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zlarfx2c (PLASMA_enum uplo, PLASMA_Complex64_t V, PLASMA_Complex64_t TAU, PLASMA_Complex64_t * C1, PLASMA_Complex64_t * C2, PLASMA_Complex64_t * C3)
CORE_zlarfx2c applies a complex elementary reflector H to a diagonal corner C=[C1, C2, C3], from both the left and the right side. C = H * C * H. It is used in the case of Hermetian. If PlasmaLower, a left apply is followed by a right apply. If PlasmaUpper, a right apply is followed by a left apply. H is represented in the form
This routine is a special code for a corner C diagonal block C1 C2 C3
   H = I - tau * v * v'
where tau is a complex scalar and v is a complex vector.
If tau = 0, then H is taken to be the unit matrix
This version uses inline code if H has order < 11.
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    V The double complex V in the representation of H.
    TAU The value tau in the representation of H.
    C1 On entry, the element C1. On exit, C1 is overwritten by the result H * C * H.
    C2 On entry, the element C2. On exit, C2 is overwritten by the result H * C * H.
    C3 On entry, the element C3. On exit, C3 is overwritten by the result H * C * H.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zlarfx2ce (PLASMA_enum uplo, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * C1, PLASMA_Complex64_t * C2, PLASMA_Complex64_t * C3)
CORE_zlarfx2c applies a complex elementary reflector H to a diagonal corner C=[C1, C2, C3], from both the left and the right side. C = H * C * H. It is used in the case of general matrices, where it create a nnz at the NEW_NNZ position, then it eliminate it and update the reflector V and TAU. If PlasmaLower, a left apply is followed by a right apply. If PlasmaUpper, a right apply is followed by a left apply. H is represented in the form
This routine is a special code for a corner C diagonal block C1 NEW_NNZ C2 C3
   H = I - tau * v * v'
where tau is a complex scalar and v is a complex vector.
If tau = 0, then H is taken to be the unit matrix
This version uses inline code if H has order < 11.
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    V On entry, the double complex V in the representation of H. On exit, the double complex V in the representation of H, updated by the elimination of the NEW_NNZ created by the left apply in case of PlasmaLower or the right apply in case of PlasmaUpper.
    TAU On entry, the value tau in the representation of H. On exit, the value tau in the representation of H, updated by the elimination of the NEW_NNZ created by the left apply in case of PlasmaLower or the right apply in case of PlasmaUpper.
    C1 On entry, the element C1. On exit, C1 is overwritten by the result H * C * H.
    C2 On entry, the element C2. On exit, C2 is overwritten by the result H * C * H.
    C3 On entry, the element C3. On exit, C3 is overwritten by the result H * C * H.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zlarfy (int N, PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * V, const PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_zlarfy applies an elementary reflector, or Householder matrix, H, to a N-by-N hermitian matrix C, from both the left and the right.
H is represented in the form
H = I - tau * v * v'
where tau is a scalar and v is a vector.
If tau is zero, then H is taken to be the unit matrix.
Parameters:
    N The number of rows and columns of the matrix C. N >= 0.
    A COMPLEX*16 array, dimension (LDA, N) On entry, the Hermetian matrix A. On exit, A is overwritten by H * A * H'.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    V The vector V that contains the Householder reflectors.
    TAU The value tau.
    WORK Workspace.

  int CORE_zlascal (PLASMA_enum uplo, int m, int n, PLASMA_Complex64_t alpha, PLASMA_Complex64_t * A, int lda)
CORE_zlascal scales a two-dimensional matrix A. As opposite to CORE_zlascl(), no checks is performed to prevent under/overflow. This should have been done at higher level.
Parameters:
    uplo Specifies the shape of A: = PlasmaUpperLower: A is a general matrix. = PlasmaUpper: A is an upper trapezoidal matrix. = PlasmaLower: A is a lower trapezoidal matrix.
    m is the number of rows of the matrix A. m >= 0
    n is the number of columns of the matrix A. n >= 0
    alpha The scalar factor.
    A is the matrix to be multiplied by alpha
    lda is the leading dimension of the array A. lda >= max(1,m).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zlascl (PLASMA_enum type, int kl, int ku, double cfrom, double cto, int m, int n, PLASMA_Complex64_t * A, int lda)
CORE_zlascl scales all or part of a two-dimensional matrix A.
Parameters:
    type Specifies the type of the matrix A. = PlasmaGeneral : A is a general matrix = PlasmaLowerTriangular : A is a lower triangular matrix = PlasmaUpperTriangular : A is an upper triangular matrix = PlasmaUpperHessenberg : A is an upper Hessenberg matrix = PlasmaSymetricBandLowerStored : A is a symmetric band matrix with lower bandwidth KL and upper bandwidth KU and with the only the lower half stored = PlasmaSymetricBandUpperStored : A is a symmetric band matrix with lower bandwidth KL and upper bandwidth KU and with the only the upper half stored = PlasmaBand : A is a band matrix with lower bandwidth KL and upper bandwidth KU. See ZGBTRF for storage details.
    kl is the lower bandwidth of A. Referenced only if type = PlasmaSymetricBandLowerStored, PlasmaSymetricBandUpperStored or PlasmaBand.
    ku is the upper bandwidth of A. Referenced only if type = PlasmaSymetricBandLowerStored, PlasmaSymetricBandUpperStored or PlasmaBand.
    cfrom is double precision
    cto is double precision The matrix A is multiplied bt cto/cfrom. cfrom must be nonzero. The final result ctot*A(i,j)/cfrom is computed without over/underflow
    m is the number of rows of the matrix A. m >= 0
    n is the number of columns of the matrix A. n >= 0
    A is the matrix to be multiplied by cto/cfrom
    lda is the leading dimension of the array A. lda >= max(1,m).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zlaset (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t beta, PLASMA_Complex64_t * A, int LDA)
CORE_zlaset - Sets the elements of the matrix A on the diagonal to beta and on the off-diagonals to alpha
Parameters:
    uplo Specifies which elements of the matrix are to be set = PlasmaUpper: Upper part of A is set; = PlasmaLower: Lower part of A is set; = PlasmaUpperLower: ALL elements of A are set.
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    alpha The constant to which the off-diagonal elements are to be set.
    beta The constant to which the diagonal elements are to be set.
    A On entry, the M-by-N tile A. On exit, A has been set accordingly.
    LDA The leading dimension of the array A. LDA >= max(1,M).

  void CORE_zlaset2 (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t * A, int LDA)
CORE_zlaset2 - Sets the elements of the matrix A to alpha. Not LAPACK compliant! Read below.
Parameters:
    uplo Specifies which elements of the matrix are to be set = PlasmaUpper: STRICT Upper part of A is set to alpha; = PlasmaLower: STRICT Lower part of A is set to alpha; = PlasmaUpperLower: ALL elements of A are set to alpha. Not LAPACK Compliant.
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    alpha The constant to which the elements are to be set.
    A On entry, the M-by-N tile A. On exit, A has been set to alpha accordingly.
    LDA The leading dimension of the array A. LDA >= max(1,M).

  void CORE_zlaswp (int N, PLASMA_Complex64_t * A, int LDA, int I1, int I2, const int * IPIV, int INC)
CORE_zlaswp performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows I1 through I2 of A.
Parameters:
    N The number of columns in the matrix A. N >= 0.
    A On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix.
    LDA The leading dimension of the array A. LDA >= max(1,max(IPIV[I1..I2])).
    I1 The first element of IPIV for which a row interchange will be done.
    I2 The last element of IPIV for which a row interchange will be done.
    IPIV The pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
    INC The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.

  int CORE_zlaswp_ontile (PLASMA_desc descA, int i1, int i2, const int * ipiv, int inc)
CORE_zlaswp_ontile apply the zlaswp function on a matrix stored in tile layout
Parameters:
    descA The descriptor of the matrix A to permute.
    i1 The first element of IPIV for which a row interchange will be done.
    i2 The last element of IPIV for which a row interchange will be done.
    ipiv The pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
    inc The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_zlaswpc_ontile (PLASMA_desc descA, int i1, int i2, const int * ipiv, int inc)
CORE_zlaswpc_ontile apply the zlaswp function on a matrix stored in tile layout
Parameters:
    descA The descriptor of the matrix A to permute.
    i1 The first element of IPIV for which a column interchange will be done.
    i2 The last element of IPIV for which a column interchange will be done.
    ipiv The pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
    inc The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_zlatro (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * B, int LDB)
CORE_zlatro transposes a m-by-n matrix out of place.
Parameters:
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: the upper triangle of A and the lower triangle of B are referenced. = PlasmaLower: the lower triangle of A and the upper triangle of B are referenced. = PlasmaUpperLower: All A and B are referenced.
    trans Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is a copy of A (equivalent to zlacpy); = PlasmaTrans: B is the transpose of A; = PlasmaConjTrans: B is the conjugate transpose of A.
    M Number of rows of the matrix A and number of columns of the matrix B, if trans == Pasma[Conj]Trans. Number of rows of the matrix A and the matrix B, if trans == PasmaNoTrans.
    N Number of columns of the matrix A and number of rows of the matrix B, if trans == Pasma[Conj]Trans. Number of columns of the matrix A and of the matrix B, if trans == PlasmaNoTrans.
    A Matrix of size LDA-by-N, if trans == Pasma[Conj]Trans. Matrix of size LDA-by-M, if trans == PasmaNoTrans.
    LDA The leading dimension of the array A. LDA >= max(1,M), if trans == Pasma[Conj]Trans. LDA >= max(1,N), if trans == PasmaNoTrans.
    B Matrix of size LDB-by-M, if trans == Pasma[Conj]Trans. Matrix of size LDB-by-N, if trans == PasmaNoTrans.
    LDB The leading dimension of the array B. LDB >= max(1,N), if trans == Pasma[Conj]Trans. LDB >= max(1,M), if trans == PasmaNoTrans.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  void CORE_zlauum (PLASMA_enum uplo, int N, PLASMA_Complex64_t * A, int LDA)
CORE_zlauum - Computes the product U * U' or L' * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A.
If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A.
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the triangular factor U or L. N >= 0.
    A On entry, the triangular factor U or L. On exit, if UPLO = 'U', the upper triangle of A is overwritten with the upper triangle of the product U * U'; if UPLO = 'L', the lower triangle of A is overwritten with the lower triangle of the product L' * L.
    LDA The leading dimension of the array A. LDA >= max(1,N).

  int CORE_zpamm (int op, PLASMA_enum side, PLASMA_enum storev, int M, int N, int K, int L, const PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, PLASMA_Complex64_t * W, int LDW)
ZPAMM performs one of the matrix-matrix operations
              LEFT                      RIGHT
 OP PlasmaW : W = A1 + op(V) * A2 or W = A1 + A2 * op(V) OP PlasmaA2 : A2 = A2 - op(V) * W or A2 = A2 - W * op(V)
where op( V ) is one of
op( V ) = V or op( V ) = V**T or op( V ) = V**H,
A1, A2 and W are general matrices, and V is:
  l = k: rectangle + triangle
  l < k: rectangle + trapezoid
  l = 0: rectangle
Size of V, both rowwise and columnwise, is:

  side trans size
left N M x K T K x M right N K x N

  T N x K
LEFT (columnwise and rowwise):
        |    K    |                 |         M         |
     _  __________   _              _______________        _
        |    |    |                 |             |
 V: | | | V': |_____________|___\ K | | | M-L | | M | | | |__________________| _ |____| | _ \ | | | M - L | L | \ | | L _ |____| _
RIGHT (columnwise and rowwise):
    |         K         |                   |    N    |
    _______________        _             _  __________   _
    |             |                        |    |    |
 V': |_____________|___\ N V: | | | | | | | | K-L |__________________| _ K | | | |____| | _ | K - L | L | \ | | \ | | L _ |____| _

Arguments
Parameters:
    op
        OP specifies which operation to perform:
        @arg PlasmaW  : W  = A1 + op(V) * A2  or  W  = A1 + A2 * op(V)
        @arg PlasmaA2 : A2 = A2 - op(V) * W   or  A2 = A2 - W * op(V)
    side
        SIDE specifies whether  op( V ) multiplies A2
        or W from the left or right as follows:
        @arg PlasmaLeft  : multiply op( V ) from the left
                           OP PlasmaW  :  W  = A1 + op(V) * A2
                           OP PlasmaA2 :  A2 = A2 - op(V) * W
        @arg PlasmaRight : multiply op( V ) from the right
                           OP PlasmaW  :  W  = A1 + A2 * op(V)
                           OP PlasmaA2 :  A2 = A2 - W * op(V)
    storev
        Indicates how the vectors which define the elementary
        reflectors are stored in V:
        @arg PlasmaColumnwise
        @arg PlasmaRowwise
    M The number of rows of the A1, A2 and W If SIDE is PlasmaLeft, the number of rows of op( V )
    N The number of columns of the A1, A2 and W If SIDE is PlasmaRight, the number of columns of op( V )
    K If SIDE is PlasmaLeft, the number of columns of op( V ) If SIDE is PlasmaRight, the number of rows of op( V )
    L The size of the triangular part of V
    A1 On entry, the M-by-N tile A1.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M).
    A2 On entry, the M-by-N tile A2. On exit, if OP is PlasmaA2 A2 is overwritten
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M).
    V The matrix V as described above. If SIDE is PlasmaLeft : op( V ) is M-by-K If SIDE is PlasmaRight: op( V ) is K-by-N
    LDV The leading dimension of the array V.
    W On entry, the M-by-N matrix W. On exit, W is overwritten either if OP is PlasmaA2 or PlasmaW. If OP is PlasmaA2, W is an input and is used as a workspace.
    LDW The leading dimension of array WORK.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zparfb (PLASMA_enum side, PLASMA_enum trans, PLASMA_enum direct, PLASMA_enum storev, int M1, int N1, int M2, int N2, int K, int L, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_zparfb applies a complex upper triangular block reflector H or its transpose H' to a complex rectangular matrix formed by coupling two tiles A1 and A2. Matrix V is:
    COLUMNWISE                    ROWWISE
   |     K     |                 |      N2-L     |   L  |
__ _____________ __           __ _________________        __
   |    |      |                 |               |    |    |      |                 |               |       L
 M2-L | | | K |_______________|_____\ __ | | | M2 | | __ |____| | | | K-L \ | | __ |______________________| __ L \ | | __ |______| __ | N2 |
| L | K-L |
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    direct Indicates how H is formed from a product of elementary reflectors
    •   PlasmaForward : H = H(1) H(2) . . . H(k) (Forward)
    •   PlasmaBackward : H = H(k) . . . H(2) H(1) (Backward)
    storev Indicates how the vectors which define the elementary reflectors are stored:
    •   PlasmaColumnwise
    •   PlasmaRowwise
    M1 The number of columns of the tile A1. M1 >= 0.
    N1 The number of rows of the tile A1. N1 >= 0.
    M2 The number of columns of the tile A2. M2 >= 0.
    N2 The number of rows of the tile A2. N2 >= 0.
    K The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
    L The size of the triangular part of V
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,N1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,N2).
    V (LDV,K) if STOREV = 'C' (LDV,M2) if STOREV = 'R' and SIDE = 'L' (LDV,N2) if STOREV = 'R' and SIDE = 'R' Matrix V.
    LDV The leading dimension of the array V. If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M2); if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N2); if STOREV = 'R', LDV >= K.
    T The triangular K-by-K matrix T in the representation of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= K.
    WORK
    LDWORK The dimension of the array WORK.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zpemv (PLASMA_enum trans, int storev, int M, int N, int L, PLASMA_Complex64_t ALPHA, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * X, int INCX, PLASMA_Complex64_t BETA, PLASMA_Complex64_t * Y, int INCY, PLASMA_Complex64_t * WORK)
CORE_zpemv performs one of the matrix-vector operations
y = alpha*op( A )*x + beta*y
where op( A ) is one of
op( A ) = A or op( A ) = A**T or op( A ) = A**H,
alpha and beta are scalars, x and y are vectors and A is a pentagonal matrix (see further details).

Arguments
Parameters:
    storev
        @arg PlasmaColumnwise :  array A stored columwise
        @arg PlasmaRowwise    :  array A stored rowwise
    trans
        @arg PlasmaNoTrans   :  y := alpha*A*x    + beta*y.
        @arg PlasmaTrans     :  y := alpha*A**T*x + beta*y.
        @arg PlasmaConjTrans :  y := alpha*A**H*x + beta*y.
    M Number of rows of the matrix A. M must be at least zero.
    N Number of columns of the matrix A. N must be at least zero.
    L Order of triangle within the matrix A (L specifies the shape of the matrix A; see further details).
    ALPHA Scalar alpha.
    A Array of size LDA-by-N. On entry, the leading M by N part of the array A must contain the matrix of coefficients.
    LDA Leading dimension of array A.
    X On entry, the incremented array X must contain the vector x.
    INCX Increment for the elements of X. INCX must not be zero.
    BETA Scalar beta.
    Y On entry, the incremented array Y must contain the vector y.
    INCY Increment for the elements of Y. INCY must not be zero.
    WORK Workspace array of size at least L.

Further Details
         |     N    |
      _   ___________   _
         |          |
 A: | | M-L | | | | M _ |..... | \ : | L \ : | _ \:_____| _
| L | N-L |
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zplghe (double bump, int m, int n, PLASMA_Complex64_t * A, int lda, int gM, int m0, int n0, unsigned long long int seed)
CORE_zplgsy generates an hermitian matrix.
Parameters:
    bump Scalar added to the diagonal of the full Matrix A to make it diagonal dominant.
    m The number of rows of the tile A. m >= 0.
    n The number of columns of the tile A. n >= 0.
    A On entry, the m-by-n tile to be initialized. On exit, the tile initialized in the mtxtype format.
    lda The leading dimension of the tile A. lda >= max(1,m).
    gM The global number of rows of the full matrix, A is belonging to. gM >= (m0+M).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    seed The seed used for random generation. Must be the same for all tiles initialized with this routine.

  void CORE_zplgsy (PLASMA_Complex64_t bump, int m, int n, PLASMA_Complex64_t * A, int lda, int gM, int m0, int n0, unsigned long long int seed)
CORE_zplgsy generates a symmetric matrix.
Parameters:
    bump Scalar added to the diagonal of the full Matrix A to make it diagonal dominant.
    m The number of rows of the tile A. m >= 0.
    n The number of columns of the tile A. n >= 0.
    A On entry, the m-by-n tile to be initialized. On exit, the tile initialized in the mtxtype format.
    lda The leading dimension of the tile A. lda >= max(1,m).
    gM The global number of rows of the full matrix, A is belonging to. gM >= (m0+M).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    seed The seed used for random generation. Must be the same for all tiles initialized with this routine.

  void CORE_zplrnt (int m, int n, PLASMA_Complex64_t * A, int lda, int gM, int m0, int n0, unsigned long long int seed)
CORE_zplrnt generates a random tile.
Parameters:
    m The number of rows of the tile A. m >= 0.
    n The number of columns of the tile A. n >= 0.
    A On entry, the m-by-n tile to be initialized. On exit, the tile initialized in the mtxtype format.
    lda The leading dimension of the tile A. lda >= max(1,m).
    gM The global number of rows of the full matrix, A is belonging to. gM >= (m0+M).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    seed The seed used for random generation. Must be the same for all tiles initialized with this routine.

  int CORE_zpltmg (PLASMA_enum mtxtype, int M, int N, PLASMA_Complex64_t * A, int LDA, int gM, int gN, int m0, int n0, unsigned long long int seed)
CORE_zpltmg initialize a tile of a random matrix from the MatLab gallery configured with the default parameters, and a few other specific matrices.
Parameters:
    mtxtype Possible types are: PlasmaMatrixRandom, PlasmaMatrixHadamard, PlasmaMatrixParter, PlasmaMatrixRis, PlasmaMatrixKms, PlasmaMatrixMoler, PlasmaMatrixCompan, PlasmaMatrixRiemann, PlasmaMatrixLehmer, PlasmaMatrixMinij, PlasmaMatrixDorr, PlasmaMatrixDemmel, PlasmaMatrixInvhess, PlasmaMatrixCauchy, PlasmaMatrixHilb, PlasmaMatrixLotkin, PlasmaMatrixOrthog, PlasmaMatrixWilkinson, PlasmaMatrixFoster, PlasmaMatrixWright, PlasmaMatrixLangou (See further in the code for more details)
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    A On entry, the M-by-N tile to be initialized. On exit, the tile initialized in the mtxtype format.
    LDA The leading dimension of the tile A. LDA >= max(1,M).
    gM The global number of rows of the full matrix, A is belonging to. gM >= (m0+M).
    gN The global number of columns of the full matrix, A is belonging to. gN >= (n0+gN).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    seed The seed used for random generation. Must be the same for all tiles initialized with this routine.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_zpltmg_chebvand (int M, int N, PLASMA_Complex64_t * A, int LDA, int gN, int m0, int n0, PLASMA_Complex64_t * W)
CORE_zpltmg_chebvand is a kernel used in Vandermonde-like matrix generation
See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999859
Vandermonde-like matrix for the Chebyshev polynomials
Produces the (primal) Chebyshev Vandermonde matrix based on the vector of points p, which define where the Chebyshev polynomial is calculated.
If seed != 0, C(i,j) = Ti – 1(p(j)) where Ti – 1 is the Chebyshev polynomial of degree i – 1, and p is a vector of N equally spaced points on the interval [0,1].
Parameters:
    M The number of rows of the tile A to initialize. M >= 2.
    N The number of columns of the tile A to initialize. N >= 0.
    A On entry, the M-by-N tile to be initialized. On exit, each element of A is defined by: A(i,j) = Ti – 1(p(j)) where Ti – 1 is the Chebyshev polynomial of degree i – 1
    LDA The leading dimension of the tile A. LDA >= max(1,M).
    gN The global number of columns of the full matrix, A is belonging to. gN >= (n0+gN).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    gN The global number of columns of the full matrix, A is belonging to. gN >= (n0+gN).
    W Workspace of size 2-by-N, that contains the N triplets: ( A( m0-2, j), A(m0-1, j) ) On entry, if m == 0, W is uinitialized, otherwise contains the data described above. On exit, contains the triplets ( A(m0+M-2, j), A(m0+M-1, j) )
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_zpltmg_circul (int M, int N, PLASMA_Complex64_t * A, int LDA, int gM, int m0, int n0, const PLASMA_Complex64_t * V)
CORE_zpltmg_circul is a kernel used in circulant matrix generation
See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999880
Circulant matrix
A circulant matrix has the property that each row is obtained from the previous one by cyclically permuting the entries one step forward. It is a special Toeplitz matrix in which the diagonals 'wrap around.'
The eigensystem of C (n-by-n) is known explicitly: If t is an nth root of unity, then the inner product of v and w = [1 t t2 ... t(n – 1)] is an eigenvalue of C and w(n:-1:1) is an eigenvector, where v is the first column of C.
Parameters:
    M The number of rows of the tile A to initialize. M >= 2.
    N The number of columns of the tile A to initialize. N >= 0.
    A On entry, the M-by-N tile to be initialized.
    LDA The leading dimension of the tile A. LDA >= max(1,M).
    gM The global number of rows of the full matrix, A is belonging to. gM >= (m0+gM).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    V Workspace of size gM, that contains the first clumn of the full matrix
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  void CORE_zpltmg_condexq (int M, int N, PLASMA_Complex64_t * Q, int LDQ)
CORE_zpltmg_condexq generates the Q used in condex matrix generation
See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999898 gallery('condex',n,4,100)
Returns a 'counter-example' matrix to a condition estimator. It has order n and scalar parameter theta (default 100).
LAPACK (RCOND): It is the inverse of this matrix that is a counter-example.
Parameters:
    M The number of rows of the matrix Q used in condex generation. M >= 0.
    N The number of columns of the matrix A to be generated. N >= 0.
    Q On entry, the M-by-3 matrix to be initialized. On exit, the housholder reflectors required for condex generation.
    LDQ The leading dimension of the matrix Q. LDQ >= max(1,M).

  void CORE_zpltmg_fiedler (int M, int N, const PLASMA_Complex64_t * X, int incX, const PLASMA_Complex64_t * Y, int incY, PLASMA_Complex64_t * A, int LDA)
CORE_zpltmg_fiedler is a kernel used in fiedler matrix generation
See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999960
Fiedler matrix of size n-by-n is defined throug a random vector c of size n, such that each element is equal to abs(n(i)-n(j)).
Matrix A has a dominant positive eigenvalue and all the other eigenvalues are negative.
Explicit formulas for inv(A) and det(A) are given in [Todd, J., Basic Numerical Mathematics, Vol. 2: Numerical Algebra, Birkhauser, Basel, and Academic Press, New York, 1977, p. 159] and attributed to Fiedler. These indicate that inv(A) is tridiagonal except for nonzero (1,n) and (n,1) elements.
Parameters:
    M The number of rows of the tile A to initialize. M >= 0.
    N The number of columns of the tile A to initialize. N >= 0.
    X X is a vector of dimension at least: ( 1 + ( M - 1 )*abs( incX ) ) On entry, the vector used to initialize A.
    incX On entry, incX specifies the increment for the elements of X. incX != 0.
    Y Y is a vector of dimension at least: ( 1 + ( N - 1 )*abs( incY ) ) On entry, the vector used to initialize A.
    incY On entry, incY specifies the increment for the elements of Y. incY != 0.
    A On entry, the M-by-N tile to be initialized. On exit, each element of A is defined by: A(i,j) = abs( X(i) - Y(j) )
    LDA The leading dimension of the tile A. LDA >= max(1,M).

  int CORE_zpltmg_hankel (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t * A, int LDA, int m0, int n0, int nb, const PLASMA_Complex64_t * V1, const PLASMA_Complex64_t * V2)
CORE_zpltmg_hankel is a kernel used in Hankel matrix generation
See http://en.wikipedia.org/wiki/Hankel_matrix
Hankel matrix
In linear algebra, a Hankel matrix (or catalecticant matrix), named after Hermann Hankel, is a square matrix with constant skew-diagonals (positive sloping diagonals), e.g.:
g \ b & c & d & e & f \ c & d & e & f & g \ d & e & f & g & h \ e & f & g & h & i \ \nd{bmatrix} ].
A(i,j) = A(i-1,j+1)
Parameters:
    uplo Specifies the part of the matrix A to be initialized. = PlasmaUpperLower: All the matrix A = PlasmaUpper: Upper triangular part = PlasmaLower: Lower triangular part
    M The number of rows of the tile A to initialize. M >= 2.
    N The number of columns of the tile A to initialize. N >= 0.
    A On entry, the M-by-N tile to be initialized.
    LDA The leading dimension of the tile A. LDA >= max(1,M).
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    nb The size of the V1 and V2 vectors
    V1 Workspace of size nb, that contains the first column of the tile
    V2 Workspace of size nb), that contains the last column of the tile
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  void CORE_zpltmg_toeppd1 (int gM, int m0, int M, PLASMA_Complex64_t * W, unsigned long long int seed)
CORE_zpltmg_toeppd1 is the first kernel used in toeppd matrix generation.
See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000272
A toeppd matrix is an n-by-n symmetric, positive semi-definite (SPD) Toeplitz matrix composed of the sum of m rank 2 (or, for certain theta, rank 1) SPD Toeplitz matrices. Specifically,
T = w(1)*T(theta(1)) + ... + w(m)*T(theta(m))
where T(theta(k)) has (i,j) element cos(2*pi*theta(k)*(i-j)).
In this matrix generation: w = rand(m,1), and theta = rand(m,1).
This kernel generates a portion of size 2-by-m of the full W and theta vectors.
Parameters:
    gM The size of the full vectors W and theta. gM >= M+m0.
    m0 Index of the first element of W, in the full vector. m0 >= 0
    M The number of elements to generate for w and theta vector. M >= 0.
    W An 2-by-M matrix. On exit, the first row contains the walue of w[m0;m0+M] The second row contains the vector 2*pi*theta[m0;m0+M]
    seed The seed used for random generation. Must be the same for all call to this routines generating the w and theta vectors.

  void CORE_zpltmg_toeppd2 (int M, int N, int K, int m0, int n0, const PLASMA_Complex64_t * W, PLASMA_Complex64_t * A, int LDA)
CORE_zpltmg_toeppd2 is the first kernel used in toeppd matrix generation.
See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000272
A toeppd matrix is an n-by-n symmetric, positive semi-definite (SPD) Toeplitz matrix composed of the sum of m rank 2 (or, for certain theta, rank 1) SPD Toeplitz matrices. Specifically,
T = w(1)*T(theta(1)) + ... + w(m)*T(theta(m))
where T(theta(k)) has (i,j) element cos(2*pi*theta(k)*(i-j)).
In this matrix generation: w = rand(m,1), and theta = rand(m,1).
This kernel adds to the tile A the local sum of: w(1)*T(theta(1)) + ... + w(K) * T(theta(K))
Parameters:
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    K The number of matrices W() * T(theta()) to apply.
    m0 The index of the first row of tile A in the full matrix. m0 >= 0.
    n0 The index of the first column of tile A in the full matrix. n0 >= 0.
    W The 2-by-K array that stores the values of W and 2*pi*Theta. W being stored on the first row, 2*pi*theta on the second.
    A On entry, the M-by-N tile to be initialized with a partial sum of the Toeppliz matrices. On exit, the M-by-N tile update with the sum of K extra Toepplitz matrices
    LDA The leading dimension of the tile A. LDA >= max(1,M).

  void CORE_zpotrf (PLASMA_enum uplo, int N, PLASMA_Complex64_t * A, int LDA, int * info)
CORE_zpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form
A = _{L imes L^H, if uplo = PlasmaLower}^{U^H imes U, if uplo = PlasmaUpper} ].PP where U is an upper triangular matrix and L is a lower triangular matrix.
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A. N >= 0.
    A On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    info
    •   0 on successful exit
    •   <0 if -i, the i-th argument had an illegal value
    •   >0 if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

  void CORE_zsetvar (const PLASMA_Complex64_t * alpha, PLASMA_Complex64_t * x)
CORE_zsetvar sets a single variable, x := alpha.
Parameters:
    alpha Scalar to set x to, passed by pointer so it can depend on runtime value.
    x On exit, x = alpha.

  void CORE_zshiftw (int s, int cl, int m, int n, int L, PLASMA_Complex64_t * A, PLASMA_Complex64_t * W)
CORE_zshiftw Shift a linear chain of block using a supplied workspace by following the cycle defined by: k_(i+1) = (k_i * m) % q;
Parameters:
    s Start value in the cycle
    cl Cycle length if cl == 0, all the permutations from the cycle are done else the cycle is split onto several threads and the number of permutation to do has to be specified to not get overlap
    m Number of lines of tile A
    n Number of columns of tile A
    L Length of each block of data to move
    A Matrix of size m-by-n with each element of size L. On exit, A = A', where A' contains the permutations
    W Array of size L. On entry, must contain: W(:) = A(s*L:s*L+L-1)

  int CORE_zssssm (int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * L1, int LDL1, const PLASMA_Complex64_t * L2, int LDL2, const int * IPIV)
CORE_zssssm applies the LU factorization update from a complex matrix formed by a lower triangular IB-by-K tile L1 on top of a M2-by-K tile L2 to a second complex matrix formed by a M1-by-N1 tile A1 on top of a M2-by-N2 tile A2 (N1 == N2).
This is the right-looking Level 2.5 BLAS version of the algorithm.
Parameters:
    M1 The number of rows of the tile A1. M1 >= 0.
    N1 The number of columns of the tile A1. N1 >= 0.
    M2 The number of rows of the tile A2 and of the tile L2. M2 >= 0.
    N2 The number of columns of the tile A2. N2 >= 0.
    K The number of columns of the tiles L1 and L2. K >= 0.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is updated by the application of L (L1 L2).
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is updated by the application of L (L1 L2).
    LDA2 The leading dimension of the array A2. LDA2 >= max(1,M2).
    L1 The IB-by-K lower triangular tile as returned by CORE_ztstrf.
    LDL1 The leading dimension of the array L1. LDL1 >= max(1,IB).
    L2 The M2-by-K tile as returned by CORE_ztstrf.
    LDL2 The leading dimension of the array L2. LDL2 >= max(1,M2).
    IPIV The pivot indices array of size K as returned by CORE_ztstrf.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_zstedc (PLASMA_enum compz, int n, double * D, double * E, PLASMA_Complex64_t * Z, int LDZ, PLASMA_Complex64_t * WORK, int LWORK, double * RWORK, int LRWORK, int * IWORK, int LIWORK)
CORE_zstedc - solves the symmetric tridiagonal eigensystem using Divide & Conquer
Parameters:
    compz = PlasmaNoVec: computes eigenvalues only. = PlasmaVec: computes eigenpairs of the original symmetric matrix. On entry, Z must contain the orthogonal matrix used to reduce the original matrix to tridiagonal form. = PlasmaIVec: computes eigenpairs of the tridiagonal matrix. Z is initialized to the Identity Matrix.
    n n specifies the order of the matrix. N >= 0
    D On entry, D contains the diagonal elements of the tridiagonal matrix. On exit, D contains the eigenvalues sorted into increasing order.
    E On entry, E contains the extra-diagonal elements of the tridiagonal matrix. On exit, E is destroyed.
    Z On entry, Z has to be set to the Identity matrix. On exit, Z contains the eigenvectors.
    LDZ LDZ specifies the leading direction of Z
    WORK plasma_complex64_t workspace
    LWORK Size of plasma_complex64_t workspace
    RWORK workspace
    LRWORK Size of double workspace
    IWORK Integer workspace
    LIWORK Size of integer workspace
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zsteqr (PLASMA_enum compz, int n, double * D, double * E, PLASMA_Complex64_t * Z, int LDZ, double * WORK)
CORE_zsteqr - solves the symmetric tridiagonal eigensystem using QR
Parameters:
    compz = PlasmaNoVec: computes eigenvalues only. = PlasmaVec: computes eigenpairs of the original symmetric matrix. On entry, Z must contain the orthogonal matrix used to reduce the original matrix to tridiagonal form. = PlasmaIVec: computes eigenpairs of the tridiagonal matrix. Z is initialized to the Identity Matrix.
    n n specifies the order of the matrix. N >= 0
    D On entry, D contains the diagonal elements of the tridiagonal matrix. On exit, D contains the eigenvalues sorted into increasing order.
    E On entry, E contains the extra-diagonal elements of the tridiagonal matrix. On exit, E is destroyed.
    Z On entry, Z has to be set to the Identity matrix. On exit, Z contains the eigenvectors.
    LDZ LDZ specifies the leading direction of Z
    WORK Workspace.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_zswap (int m, int n, PLASMA_Complex64_t * Q, int ldq, const PLASMA_Complex64_t * work, const int * perm, int start, int end)
CORE_zswap - Extract the eigenvectors in the range [start,end-1] from work and copy them in order into the Q matrix thanks to the given permutation.
Parameters:
    m m specifies the number of entries in each eigenvector, i.e. the number of rows of the matrices Q and Work.
    n n specifies the number of eigenvectors to copy from work to Q, i.e. the number of columns of the matrices W and work.
    Q On entry, matrix of size LDQ -by- n. On exit, Q will contain the n sorted eigenvectors.
    ldq ldq specifies the leading dimension of Q. ldq >= max(1,m)
    work On entry work contains the non-sorted eigenvectors and is of dimension m-by-n.
    perm The permutation array used to copy work into Q. On entry, the i-th eigenvector is stored in the column perm[i] of work, and is copied to the i-th column of Q.
    start start specifies the first column index to be considered by this kernel.
    end end specifies the last column index to be considered by this kernel

  void CORE_zswpab (int i, int n1, int n2, PLASMA_Complex64_t * A, PLASMA_Complex64_t * work)
CORE_zswpab swaps two adjacent contiguous blocks of data.
n1                     n2
 +-------------+-------------------------------+
become : n2 n1 +-------------------------------+-------------+
Parameters:
    A Array of size i+n1+n2. On entry, a block of size n1 followed by a block of size n2. On exit, the block of size n1 follows the block of size n2.
    i First block starts at A[i].
    n1 Size of the first block to swap.
    n2 Size of the second block to swap.
    work Workspace array of size min(n1, n2).

  int CORE_zswptr_ontile (PLASMA_desc descA, int i1, int i2, const int * ipiv, int inc, const PLASMA_Complex64_t * Akk, int ldak)
CORE_zswptr_ontile apply the zlaswp function on a matrix stored in tile layout, followed by a ztrsm on the first tile of the panel.
Parameters:
    descA The descriptor of the matrix A to permute.
    i1 The first element of IPIV for which a row interchange will be done.
    i2 The last element of IPIV for which a row interchange will be done.
    ipiv The pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
    inc The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.
    Akk The triangular matrix Akk. The leading descA.nb-by-descA.nb lower triangular part of the array Akk contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. The diagonal elements of A are also not referenced and are assumed to be 1.
    ldak The leading dimension of the array Akk. ldak >= max(1,descA.nb).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  void CORE_zsymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t * C, int LDC)
CORE_zsymm - Performs one of the matrix-matrix operations
.PP or
.PP where alpha and beta are scalars, A is an symmetric matrix and B and C are m by n matrices.
Parameters:
    side Specifies whether the symmetric matrix A appears on the left or right in the operation as follows: = PlasmaLeft: = PlasmaRight:
    uplo Specifies whether the upper or lower triangular part of the symmetric matrix A is to be referenced as follows: = PlasmaLower: Only the lower triangular part of the symmetric matrix A is to be referenced. = PlasmaUpper: Only the upper triangular part of the symmetric matrix A is to be referenced.
    M Specifies the number of rows of the matrix C. M >= 0.
    N Specifies the number of columns of the matrix C. N >= 0.
    alpha Specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is M when side = PlasmaLeft, and is N otherwise. Only the uplo triangular part is referenced.
    LDA The leading dimension of the array A. LDA >= max(1,ka).
    B B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B.
    LDB The leading dimension of the array B. LDB >= max(1,M).
    beta Specifies the scalar beta.
    C C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N updated matrix.
    LDC The leading dimension of the array C. LDC >= max(1,M).

  void CORE_zsyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t * C, int LDC)
CORE_zsyr2k - Performs one of the symmetric rank 2k operations
+ lpha [ op( B ) imes conjg( op( A )' )] + ts op( B ) ] + lpha [ conjg( op( B )' ) imes op( A ) ] +
where op( X ) is one of
op( X ) = X or op( X ) = conjg( X' )
where alpha and beta are real scalars, C is an n-by-n symmetric matrix and A and B are an n-by-k matrices the first case and k-by-n matrices in the second case.
Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: + lpha [ op( B ) imes conjg( op( A )' )] + ts op( B ) ] + lpha [ conjg( op( B )' ) imes op( A ) ] +
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the A and B matrices with trans = PlasmaNoTrans. K specifies the number of rows of the A and B matrices with trans = PlasmaTrans.
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ), otherwise LDA must be at least max( 1, K ).
    B B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise.
    LDB The leading dimension of the array B. LDB must be at least max( 1, N ), otherwise LDB must be at least max( 1, K ).
    beta beta specifies the scalar beta.
    C C is a LDC-by-N matrix. On exit, the array uplo part of the matrix is overwritten by the uplo part of the updated matrix.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

  void CORE_zsyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t * C, int LDC)
CORE_zsyrk - Performs one of the hermitian rank k operations
+
where op( X ) is one of
op( X ) = X or op( X ) = conjg( X' )
where alpha and beta are real scalars, C is an n-by-n hermitian matrix and A is an n-by-k matrix in the first case and a k-by-n matrix in the second case.
Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans : A is transposed.
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the matrix op( A ).
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ) if trans == PlasmaNoTrans, otherwise LDA must be at least max( 1, K ).
    beta beta specifies the scalar beta
    C C is a LDC-by-N matrix. On exit, the array uplo part of the matrix is overwritten by the uplo part of the updated matrix.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

  int CORE_ztradd (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t * B, int LDB)
CORE_ztradd adds two matrices together as in PBLAS pztradd.
 B <- alpha * op(A)  + beta * B,
where op(X) = X, X', or conj(X')
Parameters:
    uplo Specifies the shape of A and B matrices: = PlasmaUpperLower: A and B are general matrices. = PlasmaUpper: op(A) and B are upper trapezoidal matrices. = PlasmaLower: op(A) and B are lower trapezoidal matrices.
    trans Specifies whether the matrix A is non-transposed, transposed, or conjugate transposed = PlasmaNoTrans: op(A) = A = PlasmaTrans: op(A) = A' = PlasmaConjTrans: op(A) = conj(A')
    M Number of rows of the matrices A and B.
    N Number of columns of the matrices A and B.
    alpha Scalar factor of A.
    A Matrix of size LDA-by-N.
    LDA Leading dimension of the array A. LDA >= max(1,M)
    beta Scalar factor of B.
    B Matrix of size LDB-by-N. On exit, B = alpha * op(A) + beta * B
    LDB Leading dimension of the array B. LDB >= max(1,M)
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
PlasmaLower
PlasmaUpper

  void CORE_ztrasm (PLASMA_enum storev, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const PLASMA_Complex64_t * A, int lda, double * work)
CORE_ztrasm - Computes the sums of the absolute values of elements in a same row or column in a triangular matrix. This function is an auxiliary function to triangular matrix norm computations.
Parameters:
    storev Specifies whether the sums are made per column or row. = PlasmaColumnwise: Computes the sum on each column = PlasmaRowwise: Computes the sum on each row
    uplo Specifies whether the matrix A is upper triangular or lower triangular = PlasmaUpper: Upper triangle of A is referenced; = PlasmaLower: Lower triangle of A is referenced.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    M M specifies the number of rows of the matrix A. M >= 0.
    N N specifies the number of columns of the matrix A. N >= 0.
    A A is a M-by-N matrix.
    lda The leading dimension of the array A. lda >= max(1,M).
    work Array of dimension M if storev = PlasmaRowwise; N otherwise. On exit, contains the sums of the absolute values per column or row added to the input values.

  void CORE_ztrdalg1 (int n, int nb, PLASMA_Complex64_t * A, int lda, PLASMA_Complex64_t * V, PLASMA_Complex64_t * TAU, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, PLASMA_Complex64_t * work)
CORE_ztrdalg1 is a part of the tridiagonal reduction algorithm (bulgechasing) It correspond to a local driver of the kernels that should be executed on a single core.
Parameters:
    n The order of the matrix A. n >= 0.
    nb The size of the Bandwidth of the matrix A, which correspond to the tile size. nb >= 0.
    A PLASMA_Complex64_t array, dimension (lda,n) On entry, the (nb+1)-by-n band lower hermetian matrix to be reduced to tridiagonal. On exit, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal.
    lda (input) INTEGER The leading dimension of the array A. LDA >= max(1,nb+1).
    V PLASMA_Complex64_t array, dimension (n) if wantz=0 or ldv*Vblksiz*blkcnt if wantz>0. The scalar elementary reflectors are written in this array.
    TAU PLASMA_Complex64_t array, dimension (n) if wantz=0 or Vblksiz*Vblksiz*blkcnt if wantz>0. The scalar factors of the elementary reflectors are written in this array.
    Vblksiz Local parameter to Plasma. It correspond to the local bloccking of the applyQ2 used to apply the orthogonal matrix Q2.
    wantz integer tobe 0 or 1. if wantz=0 the V and TAU are not stored on only they are kept for next step then overwritten.
    i Integer that refer to the current sweep. (outer loop).
    sweepid Integer that refer to the sweep to chase.(inner loop).
    m Integer that refer to a sweep step, to ensure order dependencies.
    grsiz Integer that refer to the size of a group. group mean the number of kernel that should be executed sequentially on the same core. group size is a trade-off between locality (cache reuse) and parallelism. a small group size increase parallelism while a large group size increase cache reuse.
    work Workspace of size nb. Used by the core_zhbtype[123]cb.

  void CORE_ztrmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * B, int LDB)
CORE_ztrmm - Computes B = alpha*op( A )*B or B = alpha*B*op( A ).
Parameters:
    side Specifies whether A appears on the left or on the right of X: = PlasmaLeft: B = alpha*op( A )*B. = PlasmaRight: B = alpha*B*op( A ).
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    transA Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    M The number of rows of the matrix B. M >= 0.
    N The number of columns pf the matrix B. N >= 0.
    alpha alpha specifies the scalar alpha.
    A A is an array of dimansion LDA-by-k, where k = M if side = PlasmaLeft and k =N when side = PlasmaRight. The triangular matrix A. If uplo = PlasmaUpper, the leading k-by-k upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading k-by-k lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1.
    LDA The leading dimension of the array A. LDA >= max(1,k). Where k = M if side = PlasmaLeft and k =N when side = PlasmaRight.
    B On entry, the LDB-by-N matrix B. On exit, if return value = 0, the M-by-N matrix is overwritten by the transformed matrix.
    LDB The leading dimension of the array B. LDB >= max(1,M).

  void CORE_ztrsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, PLASMA_Complex64_t alpha, const PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * B, int LDB)
CORE_ztrsm - Computes triangular solve A*X = B or X*A = B.
Parameters:
    side Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    transA Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    M The order of the matrix A. M >= 0.
    N The number of right hand sides, i.e., the number of columns of the matrix B. N >= 0.
    alpha alpha specifies the scalar alpha.
    A The triangular matrix A. If uplo = PlasmaUpper, the leading M-by-M upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading M-by-M lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    B On entry, the M-by-N right hand side matrix B. On exit, if return value = 0, the M-by-N solution matrix X.
    LDB The leading dimension of the array B. LDB >= max(1,M).

  void CORE_ztrtri (PLASMA_enum uplo, PLASMA_enum diag, int N, PLASMA_Complex64_t * A, int LDA, int * info)
CORE_ztrtri - Computes the inverse of a complex upper or lower triangular matrix A.
Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    diag = PlasmaNonUnit: A is non-unit triangular; = PlasmaUnit: A is unit triangular.
    N The order of the matrix A. N >= 0.
    A On entry, the triangular matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If DIAG = 'U', the diagonal elements of A are also not referenced and are assumed to be 1. On exit, the (triangular) inverse of the original matrix.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    info
    •   0 on successful exit
    •   <0 if -i, the i-th argument had an illegal value
    •   >0 if i, A(i,i) is exactly zero. The triangular matrix is singular and its inverse can not be computed.

  int CORE_ztslqt (int M, int N, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_ztslqt computes a LQ factorization of a rectangular matrix formed by coupling side-by-side a complex M-by-M lower triangular tile A1 and a complex M-by-N tile A2:
| A1 A2 | = L * Q
The tile Q is represented as a product of elementary reflectors
Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in A2(i,1:n), and tau in TAU(i).
Parameters:
    M The number of rows of the tile A1 and A2. M >= 0. The number of columns of the tile A1.
    N The number of columns of the tile A2. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M-by-M tile A1. On exit, the elements on and below the diagonal of the array contain the M-by-M lower trapezoidal tile L; the elements above the diagonal are not referenced.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M).
    A2 On entry, the M-by-N tile A2. On exit, all the elements with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M).
    T The IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    TAU The scalar factors of the elementary reflectors (see Further Details).
    WORK
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_ztsmlq overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 with
                  SIDE = 'L'        SIDE = 'R'
 TRANS = 'N': Q * | A1 | | A1 A2 | * Q | A2 |
TRANS = 'C': Q**H * | A1 | | A1 A2 | * Q**H | A2 |
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(k)' . . . H(2)' H(1)'
as returned by CORE_ZTSLQT.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    M1 The number of rows of the tile A1. M1 >= 0.
    N1 The number of columns of the tile A1. N1 >= 0.
    M2 The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
    N2 The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
    K The number of elementary reflectors whose product defines the matrix Q.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M2).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSLQT in the first k rows of its array argument V.
    LDV The leading dimension of the array V. LDV >= max(1,K).
    T The IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    WORK Workspace array of size LDWORK-by-M1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
    LDWORK The leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,N1) if side == PlasmaRight
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsmlq_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t * A1, int lda1, PLASMA_Complex64_t * A2, int lda2, PLASMA_Complex64_t * A3, int lda3, const PLASMA_Complex64_t * V, int ldv, const PLASMA_Complex64_t * T, int ldt, PLASMA_Complex64_t * WORK, int ldwork)
CORE_ztsmlq_corner: see CORE_ztsmlq
This kernel applies left and right transformations as depicted below: |I -VTV'| * | A1 A2 | * |I - VT'V'| | A2' A3 | where A1 and A3 are symmetric matrices. Only the lower part is referenced. This is an adhoc implementation, can be further optimized...
Parameters:
    m1 The number of rows of the tile A1. m1 >= 0.
    n1 The number of columns of the tile A1. n1 >= 0.
    m2 The number of rows of the tile A2. m2 >= 0.
    n2 The number of columns of the tile A2. n2 >= 0.
    m3 The number of rows of the tile A3. m3 >= 0.
    n3 The number of columns of the tile A3. n3 >= 0.
    k The number of elementary reflectors whose product defines the matrix Q.
    ib The inner-blocking size. ib >= 0.
    nb The blocking size. nb >= 0.
    A1 On entry, the m1-by-n1 tile A1. On exit, A1 is overwritten by the application of Q.
    lda1 The leading dimension of the array A1. lda1 >= max(1,m1).
    A2 On entry, the m2-by-n2 tile A2. On exit, A2 is overwritten by the application of Q.
    lda2 The leading dimension of the tile A2. lda2 >= max(1,m2).
    A3 On entry, the m3-by-n3 tile A3.
    lda3 The leading dimension of the tile A3. lda3 >= max(1,m3).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSLQT in the first k rows of its array argument V.
    ldv The leading dimension of the array V. ldv >= max(1,K).
    T The IB-by-n1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    ldt The leading dimension of the array T. ldt >= IB.
    WORK Workspace array of size LDWORK-by-m1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
    ldwork The leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,n1) if side == PlasmaRight
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsmlq_hetra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, PLASMA_Complex64_t * A1, int lda1, PLASMA_Complex64_t * A2, int lda2, const PLASMA_Complex64_t * V, int ldv, const PLASMA_Complex64_t * T, int ldt, PLASMA_Complex64_t * WORK, int ldwork)
CORE_ztsmlq_hetra1: see CORE_ztsmlq
This kernel applies a Right transformation on | A1' A2 | and does not handle the transpose of A1. Needs therefore to make the explicit transpose of A1 before and after the application of the block of reflectors Can be further optimized by changing accordingly the underneath kernel ztsrfb!
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    m1 The number of rows of the tile A1. m1 >= 0.
    n1 The number of columns of the tile A1. n1 >= 0.
    m2 The number of rows of the tile A2. m2 >= 0. m2 = m1 if side == PlasmaRight.
    n2 The number of columns of the tile A2. n2 >= 0. n2 = n1 if side == PlasmaLeft.
    k The number of elementary reflectors whose product defines the matrix Q.
    ib The inner-blocking size. ib >= 0.
    A1 On entry, the m1-by-n1 tile A1. On exit, A1 is overwritten by the application of Q.
    lda1 The leading dimension of the array A1. lda1 >= max(1,m1).
    A2 On entry, the m2-by-n2 tile A2. On exit, A2 is overwritten by the application of Q.
    lda2 The leading dimension of the tile A2. lda2 >= max(1,m2).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSLQT in the first k rows of its array argument V. !
    ldv The leading dimension of the array V. ldv >= max(1,K).
    T The IB-by-n1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    ldt The leading dimension of the array T. ldt >= IB.
    WORK Workspace array of size LDWORK-by-m1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
    ldwork The leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,n1) if side == PlasmaRight
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_ztsmqr overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 with
                  SIDE = 'L'        SIDE = 'R'
 TRANS = 'N': Q * | A1 | | A1 A2 | * Q | A2 |
TRANS = 'C': Q**H * | A1 | | A1 A2 | * Q**H | A2 |
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(1) H(2) . . . H(k)
as returned by CORE_ZTSQRT.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    M1 The number of rows of the tile A1. M1 >= 0.
    N1 The number of columns of the tile A1. N1 >= 0.
    M2 The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
    N2 The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
    K The number of elementary reflectors whose product defines the matrix Q.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M2).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSQRT in the first k columns of its array argument V.
    LDV The leading dimension of the array V. LDV >= max(1,K).
    T The IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    WORK Workspace array of size LDWORK-by-N1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
    LDWORK The leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,M1) if side == PlasmaRight
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsmqr_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t * A1, int lda1, PLASMA_Complex64_t * A2, int lda2, PLASMA_Complex64_t * A3, int lda3, const PLASMA_Complex64_t * V, int ldv, const PLASMA_Complex64_t * T, int ldt, PLASMA_Complex64_t * WORK, int ldwork)
CORE_ztsmqr_corner: see CORE_ztsmqr
This kernel applies left and right transformations as depicted below: |I -VT'V'| * | A1 A2'| * |I - VTV'| | A2 A3 | where A1 and A3 are symmetric matrices. Only the lower part is referenced. This is an adhoc implementation, can be further optimized...
Parameters:
    m1 The number of rows of the tile A1. m1 >= 0.
    n1 The number of columns of the tile A1. n1 >= 0.
    m2 The number of rows of the tile A2. m2 >= 0.
    n2 The number of columns of the tile A2. n2 >= 0.
    m3 The number of rows of the tile A3. m3 >= 0.
    n3 The number of columns of the tile A3. n3 >= 0.
    k The number of elementary reflectors whose product defines the matrix Q.
    ib The inner-blocking size. IB >= 0.
    nb The blocking size. NB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    lda1 The leading dimension of the array A1. lda1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    lda2 The leading dimension of the tile A2. lda2 >= max(1,M2).
    A3 On entry, the m3-by-n3 tile A3.
    lda3 The leading dimension of the tile A3. lda3 >= max(1,m3).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSQRT in the first k columns of its array argument V.
    ldv The leading dimension of the array V. ldv >= max(1,K).
    T The IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    ldt The leading dimension of the array T. ldt >= IB.
    WORK Workspace array of size LDWORK-by-N1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
    ldwork The leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,M1) if side == PlasmaRight
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsmqr_hetra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, PLASMA_Complex64_t * A1, int lda1, PLASMA_Complex64_t * A2, int lda2, const PLASMA_Complex64_t * V, int ldv, const PLASMA_Complex64_t * T, int ldt, PLASMA_Complex64_t * WORK, int ldwork)
CORE_ztsmqr_hetra1: see CORE_ztsmqr
This kernel applies a left transformation on | A1'| | A2 |
Needs therefore to make the explicit transpose of A1 before and after the application of the block of reflectors Can be further optimized by changing accordingly the underneath kernel ztsrfb!
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    m1 The number of rows of the tile A1. M1 >= 0.
    n1 The number of columns of the tile A1. N1 >= 0.
    m2 The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
    n2 The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
    k The number of elementary reflectors whose product defines the matrix Q.
    ib The inner-blocking size. IB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    lda1 The leading dimension of the array A1. LDA1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    lda2 The leading dimension of the tile A2. LDA2 >= max(1,M2).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSQRT in the first k columns of its array argument V.
    ldv The leading dimension of the array V. LDV >= max(1,K).
    T The IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    ldt The leading dimension of the array T. LDT >= IB.
    WORK Workspace array of size LDWORK-by-N1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
    ldwork The leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,M1) if side == PlasmaRight
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsqrt (int M, int N, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_ztsqrt computes a QR factorization of a rectangular matrix formed by coupling a complex N-by-N upper triangular tile A1 on top of a complex M-by-N tile A2:
| A1 | = Q * R | A2 |
Parameters:
    M The number of columns of the tile A2. M >= 0.
    N The number of rows of the tile A1. The number of columns of the tiles A1 and A2. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the N-by-N tile A1. On exit, the elements on and above the diagonal of the array contain the N-by-N upper trapezoidal tile R; the elements below the diagonal are not referenced.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,N).
    A2 On entry, the M-by-N tile A2. On exit, all the elements with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M).
    T The IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    TAU The scalar factors of the elementary reflectors (see Further Details).
    WORK
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztsrfb (PLASMA_enum side, PLASMA_enum trans, int direct, int storev, int M1, int N1, int M2, int N2, int K, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_ztsrfb applies a complex block reflector H or its transpose H' to a complex rectangular matrix formed by coupling two tiles A1 and A2, from either the left or the right.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    direct Indicates how H is formed from a product of elementary reflectors
    •   PlasmaForward : H = H(1) H(2) . . . H(k) (Forward)
    •   PlasmaBackward : H = H(k) . . . H(2) H(1) (Backward)
    storev Indicates how the vectors which define the elementary reflectors are stored:
    •   PlasmaColumnwise
    •   PlasmaRowwise
    M1 The number of columns of the tile A1. M1 >= 0.
    N1 The number of rows of the tile A1. N1 >= 0.
    M2 The number of columns of the tile A2. M2 >= 0.
    N2 The number of rows of the tile A2. N2 >= 0.
    K The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,N1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,N2).
    V (LDV,K) if STOREV = 'C' (LDV,M2) if STOREV = 'R' and SIDE = 'L' (LDV,N2) if STOREV = 'R' and SIDE = 'R' The matrix V.
    LDV The leading dimension of the array V. If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M2); if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N2); if STOREV = 'R', LDV >= K.
    T The triangular K-by-K matrix T in the representation of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= K.
    WORK
    LDWORK The dimension of the array WORK.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_ztstrf (int M, int N, int IB, int NB, PLASMA_Complex64_t * U, int LDU, PLASMA_Complex64_t * A, int LDA, PLASMA_Complex64_t * L, int LDL, int * IPIV, PLASMA_Complex64_t * WORK, int LDWORK, int * INFO)
CORE_ztstrf computes an LU factorization of a complex matrix formed by an upper triangular NB-by-N tile U on top of a M-by-N tile A using partial pivoting with row interchanges.
This is the right-looking Level 2.5 BLAS version of the algorithm.
Parameters:
    M The number of rows of the tile A. M >= 0.
    N The number of columns of the tile A. N >= 0.
    IB The inner-blocking size. IB >= 0.
    NB
    U On entry, the NB-by-N upper triangular tile. On exit, the new factor U from the factorization
    LDU The leading dimension of the array U. LDU >= max(1,NB).
    A On entry, the M-by-N tile to be factored. On exit, the factor L from the factorization
    LDA The leading dimension of the array A. LDA >= max(1,M).
    L On entry, the IB-by-N lower triangular tile. On exit, the interchanged rows form the tile A in case of pivoting.
    LDL The leading dimension of the array L. LDL >= max(1,IB).
    IPIV The pivot indices; for 1 <= i <= min(M,N), row i of the tile U was interchanged with row IPIV(i) of the tile A.
    WORK
    LDWORK The leading dimension of the array WORK.
    INFO
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value
    >0 if INFO = k, U(k,k) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

  int CORE_zttlqt (int M, int N, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_zttlqt computes a LQ factorization of a rectangular matrix formed by coupling side-by-side a complex M-by-M lower triangular tile A1 and a complex M-by-N lower triangular tile A2:
| A1 A2 | = L * Q
The tile Q is represented as a product of elementary reflectors
Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in A2(i,1:n), and tau in TAU(i).
Parameters:
    M The number of rows of the tile A1 and A2. M >= 0. The number of columns of the tile A1.
    N The number of columns of the tile A2. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M-by-M tile A1. On exit, the elements on and below the diagonal of the array contain the M-by-M lower trapezoidal tile L; the elements above the diagonal are not referenced.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,N).
    A2 On entry, the M-by-N lower triangular tile A2. On exit, the elements on and below the diagonal of the array with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
    LDA2 The leading dimension of the array A2. LDA2 >= max(1,M).
    T The IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    TAU The scalar factors of the elementary reflectors (see Further Details).
    WORK
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zttmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_zttmlq overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 (N1 == N2) with
                  SIDE = 'L'        SIDE = 'R'
 TRANS = 'N': Q * | A1 | | A1 | * Q | A2 | | A2 |
TRANS = 'C': Q**H * | A1 | | A1 | * Q**H | A2 | | A2 |
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(1) H(2) . . . H(k)
as returned by CORE_zttqrt.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    M1 The number of rows of the tile A1. M1 >= 0.
    N1 The number of columns of the tile A1. N1 >= 0.
    M2 The number of rows of the tile A2. M2 >= 0.
    N2 The number of columns of the tile A2. N2 >= 0.
    K The number of elementary reflectors whose product defines the matrix Q.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M2).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTTQRT in the first k rows of its array argument V.
    LDV The leading dimension of the array V. LDV >= max(1,K).
    T The IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    WORK Workspace array of size LDWORK-by-N1.
    LDWORK The dimension of the array WORK. LDWORK >= max(1,IB).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zttmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, const PLASMA_Complex64_t * V, int LDV, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_zttmqr overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 (N1 == N2) with
                  SIDE = 'L'        SIDE = 'R'
 TRANS = 'N': Q * | A1 | | A1 | * Q | A2 | | A2 |
TRANS = 'C': Q**H * | A1 | | A1 | * Q**H | A2 | | A2 |
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(1) H(2) . . . H(k)
as returned by CORE_zttqrt.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : ConjTranspose, apply Q**H.
    M1 The number of rows of the tile A1. M1 >= 0.
    N1 The number of columns of the tile A1. N1 >= 0.
    M2 The number of rows of the tile A2. M2 >= 0.
    N2 The number of columns of the tile A2. N2 >= 0.
    K The number of elementary reflectors whose product defines the matrix Q.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,M1).
    A2 On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
    LDA2 The leading dimension of the tile A2. LDA2 >= max(1,M2).
    V The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTTQRT in the first k rows of its array argument V.
    LDV The leading dimension of the array V. LDV >= max(1,K).
    T The IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    WORK Workspace array of size LDWORK-by-N1.
    LDWORK The dimension of the array WORK. LDWORK >= max(1,IB).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zttqrt (int M, int N, int IB, PLASMA_Complex64_t * A1, int LDA1, PLASMA_Complex64_t * A2, int LDA2, PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * TAU, PLASMA_Complex64_t * WORK)
CORE_zttqrt computes a QR factorization of a rectangular matrix formed by coupling a complex N-by-N upper triangular tile A1 on top of a complex M-by-N upper trapezoidal tile A2:
| A1 | = Q * R | A2 |
The tile Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(M,N).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A2(1:m,i), and tau in TAU(i).
Parameters:
    M The number of rows of the tile A2. M >= 0.
    N The number of columns of the tile A1 and A2. N >= 0.
    IB The inner-blocking size. IB >= 0.
    A1 On entry, the N-by-N tile A1. On exit, the elements on and above the diagonal of the array contain the N-by-N upper trapezoidal tile R; the elements below the diagonal are not referenced.
    LDA1 The leading dimension of the array A1. LDA1 >= max(1,N).
    A2 On entry, the M-by-N upper triangular tile A2. On exit, the elements on and above the diagonal of the array with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
    LDA2 The leading dimension of the array A2. LDA2 >= max(1,M).
    T The IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    TAU The scalar factors of the elementary reflectors (see Further Details).
    WORK
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zunmlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * C, int LDC, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_zunmlq overwrites the general complex M-by-N tile C with
              SIDE = 'L'     SIDE = 'R'
 TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(k) . . . H(2) H(1)
as returned by CORE_zgelqt. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : Transpose, apply Q**H.
    M The number of rows of the tile C. M >= 0.
    N The number of columns of the tile C. N >= 0.
    K The number of elementary reflectors whose product defines the matrix Q. If SIDE = PlasmaLeft, M >= K >= 0; if SIDE = PlasmaRight, N >= K >= 0.
    IB The inner-blocking size. IB >= 0.
    A Dimension: (LDA,M) if SIDE = PlasmaLeft, (LDA,N) if SIDE = PlasmaRight, The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_zgelqt in the first k rows of its array argument A.
    LDA The leading dimension of the array A. LDA >= max(1,K).
    T The IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    C On entry, the M-by-N tile C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
    LDC The leading dimension of the array C. LDC >= max(1,M).
    WORK On exit, if INFO = 0, WORK(1) returns the optimal LDWORK.
    LDWORK The dimension of the array WORK. If SIDE = PlasmaLeft, LDWORK >= max(1,N); if SIDE = PlasmaRight, LDWORK >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  int CORE_zunmqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const PLASMA_Complex64_t * A, int LDA, const PLASMA_Complex64_t * T, int LDT, PLASMA_Complex64_t * C, int LDC, PLASMA_Complex64_t * WORK, int LDWORK)
CORE_zunmqr overwrites the general complex M-by-N tile C with
              SIDE = 'L'     SIDE = 'R'
 TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H
where Q is a complex unitary matrix defined as the product of k elementary reflectors
Q = H(1) H(2) . . . H(k)
as returned by CORE_zgeqrt. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**H from the Left;
    •   PlasmaRight : apply Q or Q**H from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaConjTrans : Transpose, apply Q**H.
    M The number of rows of the tile C. M >= 0.
    N The number of columns of the tile C. N >= 0.
    K The number of elementary reflectors whose product defines the matrix Q. If SIDE = PlasmaLeft, M >= K >= 0; if SIDE = PlasmaRight, N >= K >= 0.
    IB The inner-blocking size. IB >= 0.
    A Dimension: (LDA,K) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_zgeqrt in the first k columns of its array argument A.
    LDA The leading dimension of the array A. If SIDE = PlasmaLeft, LDA >= max(1,M); if SIDE = PlasmaRight, LDA >= max(1,N).
    T The IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
    LDT The leading dimension of the array T. LDT >= IB.
    C On entry, the M-by-N tile C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
    LDC The leading dimension of the array C. LDC >= max(1,M).
    WORK On exit, if INFO = 0, WORK(1) returns the optimal LDWORK.
    LDWORK The dimension of the array WORK. If SIDE = PlasmaLeft, LDWORK >= max(1,N); if SIDE = PlasmaRight, LDWORK >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

Author
Generated automatically by Doxygen for PLASMA from the source code.