CORE_float(3)

NAME
CORE_float - Kernel Interface - Single Real

  Macros
#define SELECT 20

  Functions
void CORE_sasum (PLASMA_enum storev, PLASMA_enum uplo, int M, int N, const float *A, int lda, float *work)
void CORE_sbrdalg1 (PLASMA_enum uplo, int n, int nb, float *A, int lda, float *VQ, float *TAUQ, float *VP, float *TAUP, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, float *work)
int CORE_sgbelr (PLASMA_enum uplo, int N, PLASMA_desc *A, float *V, float *TAU, int st, int ed, int eltsize)
int CORE_sgblrx (PLASMA_enum uplo, int N, PLASMA_desc *A, float *V, float *TAU, int st, int ed, int eltsize)
int CORE_sgbrce (PLASMA_enum uplo, int N, PLASMA_desc *A, float *V, float *TAU, int st, int ed, int eltsize)
void CORE_sgbtype1cb (PLASMA_enum uplo, int N, int NB, float *A, int LDA, float *VQ, float *TAUQ, float *VP, float *TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, float *WORK)
void CORE_sgbtype2cb (PLASMA_enum uplo, int N, int NB, float *A, int LDA, float *VQ, float *TAUQ, float *VP, float *TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, float *WORK)
void CORE_sgbtype3cb (PLASMA_enum uplo, int N, int NB, float *A, int LDA, float *VQ, float *TAUQ, float *VP, float *TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, float *WORK)
int CORE_sgeadd (PLASMA_enum trans, int M, int N, float alpha, const float *A, int LDA, float beta, float *B, int LDB)
int CORE_sgelqt (int M, int N, int IB, float *A, int LDA, float *T, int LDT, float *TAU, float *WORK)
void CORE_sgemm (PLASMA_enum transA, int transB, int M, int N, int K, float alpha, const float *A, int LDA, const float *B, int LDB, float beta, float *C, int LDC)
void CORE_sgemv (PLASMA_enum trans, int m, int n, float alpha, const float *A, int lda, const float *x, int incx, float beta, float *y, int incy)
void CORE_sgeqp3_init (int n, int *jpvt)
void CORE_sgeqp3_larfg (PLASMA_desc A, int ii, int jj, int i, int j, float *tau, float *beta)
void CORE_sgeqp3_norms (PLASMA_desc A, int ioff, int joff, float *norms1, float *norms2)
void CORE_sgeqp3_pivot (PLASMA_desc A, float *F, int ldf, int jj, int k, int *jpvt, float *norms1, float *norms2, int *info)
void CORE_sgeqp3_update (const float *Ajj, int lda1, float *Ajk, int lda2, const float *Fk, int ldf, int joff, int k, int koff, int nb, float *norms1, float *norms2, int *info)
int CORE_sgeqrt (int M, int N, int IB, float *A, int LDA, float *T, int LDT, float *TAU, float *WORK)
int CORE_sgessm (int M, int N, int K, int IB, const int *IPIV, const float *L, int LDL, float *A, int LDA)
int CORE_sgetf2_nopiv (int M, int N, float *A, int LDA)
int CORE_sgetrf (int m, int n, float *A, int lda, int *IPIV, int *info)
int CORE_sgetrf_incpiv (int M, int N, int IB, float *A, int LDA, int *IPIV, int *INFO)
int CORE_sgetrf_nopiv (int M, int N, int IB, float *A, int LDA)
int CORE_sgetrf_reclap (CORE_sgetrf_data_t *data, int M, int N, float *A, int LDA, int *IPIV, int *info)
int CORE_sgetrf_rectil (CORE_sgetrf_data_t *data, const PLASMA_desc A, int *IPIV, int *info)
void CORE_sgetrip (int m, int n, float *A, float *W)
int CORE_shbelr (PLASMA_enum uplo, int N, PLASMA_desc *A, float *V, float *TAU, int st, int ed, int eltsize)
int CORE_shblrx (PLASMA_enum uplo, int N, PLASMA_desc *A, float *V, float *TAU, int st, int ed, int eltsize)
int CORE_shbrce (PLASMA_enum uplo, int N, PLASMA_desc *A, float *V, float *TAU, int st, int ed, int eltsize)
void CORE_slacpy (PLASMA_enum uplo, int M, int N, const float *A, int LDA, float *B, int LDB)
int CORE_slacpy_pivot (const PLASMA_desc descA, PLASMA_enum direct, int k1, int k2, const int *ipiv, int *rankin, int *rankout, float *A, int lda, int init)
void CORE_slaed0_betaapprox (int subpbs, const int *subpbs_info, float *D, const float *E)
void CORE_slaed2_compressq (int n, int n1, const int *INDX, const int *ctot, const float *Q, int LDQ, float *Q2, int start, int end)
void CORE_slaed2_copydef (int n, int n1, int K, const int *ctot, float *Q, int LDQ, const float *Q2, int start, int end)
void CORE_slaed2_computeK (int *Kptr, int n, int n1, float *betaptr, float *D, float *Q, int LDQ, float *Z, float *DLAMBDA, float *W, int *INDX, int *INDXC, int *INDXP, int *INDXQ, int *COLTYP)
void CORE_slaed3_computevectors (int K, int il_nondef, int iu_nondef, float *Q, int LDQ, float *W, float *S, const int *INDXC, int start, int end)
void CORE_slaed3_computeW (int n, int K, const float *Q, int LDQ, const float *DLAMBDA, float *W, const int *INDX, int start, int end)
void CORE_slaed3_merge (int n, int K, float *D, int *INDXQ)
void CORE_slaed3_reduceW (int n, int n1, int K, int l, const float *Q, int LDQ, const float *Wred, float *W)
void CORE_slaed3_updatevectors (int op, int wsmode, int n, int n1, int K, int il_nondef, int iu_nondef, float *Q, int ldq, float *Q2, const int *ctot, float *W, int start, int end)
int CORE_slaed4 (int n, int K, float *D, float beta, float *Q, int LDQ, const float *D0, const float *Z, const int *INDX, int start, int end)
void CORE_slange (int norm, int M, int N, const float *A, int LDA, float *work, float *normA)
void CORE_slansy (int norm, PLASMA_enum uplo, int N, const float *A, int LDA, float *work, float *normA)
void CORE_slantr (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const float *A, int LDA, float *work, float *normA)
int CORE_slarfb_gemm (PLASMA_enum side, PLASMA_enum trans, int direct, int storev, int M, int N, int K, const float *V, int LDV, const float *T, int LDT, float *C, int LDC, float *WORK, int LDWORK)
int CORE_slarfx2 (PLASMA_enum side, int N, float V, float TAU, float *C1, int LDC1, float *C2, int LDC2)
int CORE_slarfx2c (PLASMA_enum uplo, float V, float TAU, float *C1, float *C2, float *C3)
int CORE_slarfx2ce (PLASMA_enum uplo, float *V, float *TAU, float *C1, float *C2, float *C3)
void CORE_slarfy (int N, float *A, int LDA, const float *V, const float *TAU, float *WORK)
int CORE_slascal (PLASMA_enum uplo, int m, int n, float alpha, float *A, int lda)
int CORE_slascl (PLASMA_enum type, int kl, int ku, float cfrom, float cto, int m, int n, float *A, int lda)
void CORE_slaset (PLASMA_enum uplo, int M, int N, float alpha, float beta, float *A, int LDA)
void CORE_slaset2 (PLASMA_enum uplo, int M, int N, float alpha, float *A, int LDA)
void CORE_slaswp (int N, float *A, int LDA, int I1, int I2, const int *IPIV, int INC)
int CORE_slaswp_ontile (PLASMA_desc descA, int i1, int i2, const int *ipiv, int inc)
int CORE_sswptr_ontile (PLASMA_desc descA, int i1, int i2, const int *ipiv, int inc, const float *Akk, int ldak)
int CORE_slaswpc_ontile (PLASMA_desc descA, int i1, int i2, const int *ipiv, int inc)
int CORE_slatro (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, const float *A, int LDA, float *B, int LDB)
void CORE_slauum (PLASMA_enum uplo, int N, float *A, int LDA)
int CORE_sormlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const float *A, int LDA, const float *T, int LDT, float *C, int LDC, float *WORK, int LDWORK)
int CORE_sormqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const float *A, int LDA, const float *T, int LDT, float *C, int LDC, float *WORK, int LDWORK)
int CORE_spamm (int op, PLASMA_enum side, PLASMA_enum storev, int M, int N, int K, int L, const float *A1, int LDA1, float *A2, int LDA2, const float *V, int LDV, float *W, int LDW)
int CORE_sparfb (PLASMA_enum side, PLASMA_enum trans, PLASMA_enum direct, PLASMA_enum storev, int M1, int N1, int M2, int N2, int K, int L, float *A1, int LDA1, float *A2, int LDA2, const float *V, int LDV, const float *T, int LDT, float *WORK, int LDWORK)
int CORE_spemv (PLASMA_enum trans, int storev, int M, int N, int L, float ALPHA, const float *A, int LDA, const float *X, int INCX, float BETA, float *Y, int INCY, float *WORK)
void CORE_splgsy (float bump, int m, int n, float *A, int lda, int gM, int m0, int n0, unsigned long long int seed)
void CORE_splrnt (int m, int n, float *A, int lda, int gM, int m0, int n0, unsigned long long int seed)
int CORE_spltmg (PLASMA_enum mtxtype, int M, int N, float *A, int LDA, int gM, int gN, int m0, int n0, unsigned long long int seed)
int CORE_spltmg_chebvand (int M, int N, float *A, int LDA, int gN, int m0, int n0, float *W)
int CORE_spltmg_circul (int M, int N, float *A, int LDA, int gM, int m0, int n0, const float *V)
void CORE_spltmg_condexq (int M, int N, float *Q, int LDQ)
void CORE_spltmg_fiedler (int M, int N, const float *X, int incX, const float *Y, int incY, float *A, int LDA)
int CORE_spltmg_hankel (PLASMA_enum uplo, int M, int N, float *A, int LDA, int m0, int n0, int nb, const float *V1, const float *V2)
void CORE_spltmg_toeppd1 (int gM, int m0, int M, float *W, unsigned long long int seed)
void CORE_spltmg_toeppd2 (int M, int N, int K, int m0, int n0, const float *W, float *A, int LDA)
void CORE_spotrf (PLASMA_enum uplo, int N, float *A, int LDA, int *info)
void CORE_ssbtype1cb (int N, int NB, float *A, int LDA, float *V, float *TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, float *WORK)
void CORE_ssbtype2cb (int N, int NB, float *A, int LDA, float *V, float *TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, float *WORK)
void CORE_ssbtype3cb (int N, int NB, float *A, int LDA, const float *V, const float *TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, float *WORK)
void CORE_ssetvar (const float *alpha, float *x)
void CORE_sshiftw (int s, int cl, int m, int n, int L, float *A, float *W)
int CORE_sssssm (int M1, int N1, int M2, int N2, int K, int IB, float *A1, int LDA1, float *A2, int LDA2, const float *L1, int LDL1, const float *L2, int LDL2, const int *IPIV)
int CORE_sstedc (PLASMA_enum compz, int n, float *D, float *E, float *Z, int LDZ, float *WORK, int LWORK, int *IWORK, int LIWORK)
int CORE_ssteqr (PLASMA_enum compz, int n, float *D, float *E, float *Z, int LDZ, float *WORK)
void CORE_sswap (int m, int n, float *Q, int ldq, const float *work, const int *perm, int start, int end)
void CORE_sswpab (int i, int n1, int n2, float *A, float *work)
void CORE_ssygst (int itype, PLASMA_enum uplo, int N, float *A, int LDA, float *B, int LDB, int *INFO)
void CORE_ssymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, float alpha, const float *A, int LDA, const float *B, int LDB, float beta, float *C, int LDC)
void CORE_ssyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, float alpha, const float *A, int LDA, const float *B, int LDB, float beta, float *C, int LDC)
int CORE_ssyrfb (PLASMA_enum uplo, int n, int k, int ib, int nb, const float *A, int lda, const float *T, int ldt, float *C, int ldc, float *WORK, int ldwork)
void CORE_ssyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, float alpha, const float *A, int LDA, float beta, float *C, int LDC)
int CORE_stradd (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, float alpha, const float *A, int LDA, float beta, float *B, int LDB)
void CORE_strasm (PLASMA_enum storev, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const float *A, int lda, float *work)
void CORE_strdalg1 (int n, int nb, float *A, int lda, float *V, float *TAU, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, float *work)
void CORE_strmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, float alpha, const float *A, int LDA, float *B, int LDB)
void CORE_strsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, float alpha, const float *A, int LDA, float *B, int LDB)
void CORE_strtri (PLASMA_enum uplo, PLASMA_enum diag, int N, float *A, int LDA, int *info)
int CORE_stslqt (int M, int N, int IB, float *A1, int LDA1, float *A2, int LDA2, float *T, int LDT, float *TAU, float *WORK)
int CORE_stsmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float *A1, int LDA1, float *A2, int LDA2, const float *V, int LDV, const float *T, int LDT, float *WORK, int LDWORK)
int CORE_stsmlq_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, float *A1, int lda1, float *A2, int lda2, float *A3, int lda3, const float *V, int ldv, const float *T, int ldt, float *WORK, int ldwork)
int CORE_stsmlq_sytra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, float *A1, int lda1, float *A2, int lda2, const float *V, int ldv, const float *T, int ldt, float *WORK, int ldwork)
int CORE_stsmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float *A1, int LDA1, float *A2, int LDA2, const float *V, int LDV, const float *T, int LDT, float *WORK, int LDWORK)
int CORE_stsmqr_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, float *A1, int lda1, float *A2, int lda2, float *A3, int lda3, const float *V, int ldv, const float *T, int ldt, float *WORK, int ldwork)
int CORE_stsmqr_sytra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, float *A1, int lda1, float *A2, int lda2, const float *V, int ldv, const float *T, int ldt, float *WORK, int ldwork)
int CORE_stsqrt (int M, int N, int IB, float *A1, int LDA1, float *A2, int LDA2, float *T, int LDT, float *TAU, float *WORK)
int CORE_ststrf (int M, int N, int IB, int NB, float *U, int LDU, float *A, int LDA, float *L, int LDL, int *IPIV, float *WORK, int LDWORK, int *INFO)
int CORE_sttlqt (int M, int N, int IB, float *A1, int LDA1, float *A2, int LDA2, float *T, int LDT, float *TAU, float *WORK)
int CORE_sttmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float *A1, int LDA1, float *A2, int LDA2, const float *V, int LDV, const float *T, int LDT, float *WORK, int LDWORK)
int CORE_sttmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float *A1, int LDA1, float *A2, int LDA2, const float *V, int LDV, const float *T, int LDT, float *WORK, int LDWORK)
int CORE_sttqrt (int M, int N, int IB, float *A1, int LDA1, float *A2, int LDA2, float *T, int LDT, float *TAU, float *WORK)

Detailed Description

This is the group of single real kernels available in coreblas library.

Macro Definition Documentation

  #define SELECT 20
CORE_slapst - It is a modified version of the LAPACK routine D inspired from the ScaLAPACK dlapst.

Define a permutation INDX that sorts the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ).

Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.

Parameters:
    type The type of sorting 'PlasmaIncreasingOrder' for increasing order 'PlasmaDecreasingOrder' for decreasing order
    n n specifies the dimension of the array D
    D D is the array to be sorted of dimension n.
    INDX On exit, contains the permutation which sorts the array D. INDX is of dimension n.

Function Documentation

  void CORE_sasum (PLASMA_enum storev, PLASMA_enum uplo, int M, int N, const float * A, int lda, float * work)
CORE_sasum - 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_sbrdalg1 (PLASMA_enum uplo, int n, int nb, float * A, int lda, float * VQ, float * TAUQ, float * VP, float * TAUP, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, float * work)
CORE_sbrdalg1 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 float 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 float array, dimension (n) if wantz=0 or ldv*Vblksiz*blkcnt if wantz>0. The scalar elementary left reflectors are written in this array.
    TAUQ float 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 float array, dimension (n) if wantz=0 or ldv*Vblksiz*blkcnt if wantz>0. The scalar elementary right reflectors are written in this array.
    TAUP float 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_sgbtype[123]cb.

  int CORE_sgbelr (PLASMA_enum uplo, int N, PLASMA_desc * A, float * V, float * TAU, int st, int ed, int eltsize)
CORE_sgbelr 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 float 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 float 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_sgblrx (PLASMA_enum uplo, int N, PLASMA_desc * A, float * V, float * TAU, int st, int ed, int eltsize)
CORE_sgblrx 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 float 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 float 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_sgbrce (PLASMA_enum uplo, int N, PLASMA_desc * A, float * V, float * TAU, int st, int ed, int eltsize)
CORE_sgbrce 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 float 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 float 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_sgbtype1cb (PLASMA_enum uplo, int N, int NB, float * A, int LDA, float * VQ, float * TAUQ, float * VP, float * TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, float * WORK)
CORE_sgbtype1cb 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 float 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 float array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    VQ TODO: Check and fix doc float 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 float 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_sgbtype2cb (PLASMA_enum uplo, int N, int NB, float * A, int LDA, float * VQ, float * TAUQ, float * VP, float * TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, float * WORK)
CORE_sgbtype2cb 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 float 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 float 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 float 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 float 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_sgbtype3cb (PLASMA_enum uplo, int N, int NB, float * A, int LDA, float * VQ, float * TAUQ, float * VP, float * TAUP, int st, int ed, int sweep, int Vblksiz, int WANTZ, float * WORK)
CORE_sgbtype3cb 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 float 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 float array, dimension (N). The scalar factors of the Householder reflectors are stored in this array.
    VQ TODO: Check and fix doc float 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 float 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_sgeadd (PLASMA_enum trans, int M, int N, float alpha, const float * A, int LDA, float beta, float * B, int LDB)
CORE_sgeadd adds two matrices together as in PBLAS psgeadd.
 B <- alpha * op(A)  + beta * B,
where op(X) = X, X', or (X')
Parameters:
    trans Specifies whether the matrix A is non-transposed, transposed, or ugate transposed = PlasmaNoTrans: op(A) = A = PlasmaTrans: op(A) = A' = PlasmaTrans: op(A) = (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_sgelqt (int M, int N, int IB, float * A, int LDA, float * T, int LDT, float * TAU, float * WORK)
CORE_sgelqt - 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; g(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_sgemm (PLASMA_enum transA, int transB, int M, int N, int K, float alpha, const float * A, int LDA, const float * B, int LDB, float beta, float * C, int LDC)
CORE_sgemm - Performs one of the matrix-matrix operations
+
where op( X ) is one of
op( X ) = X or op( X ) = X' or op( X ) = g( 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 ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaTrans: A is ugate transposed.
    transB Specifies whether the matrix B is transposed, not transposed or ugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaTrans: B is ugate 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_sgemv (PLASMA_enum trans, int m, int n, float alpha, const float * A, int lda, const float * x, int incx, float beta, float * y, int incy)
CORE_sgemv 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**T*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
    •   PlasmaTrans: y := alpha*A**T*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_sgeqp3_init (int n, int * jpvt)
CORE_sgeqp3_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_sgeqp3_larfg (PLASMA_desc A, int ii, int jj, int i, int j, float * tau, float * beta)
CORE_sgeqp3_larfg generates a Householder elementary reflector H, such that
H**T * x = [ beta ]  and  H**T * 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**T ],
              [ 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_sgeqp3_norms (PLASMA_desc A, int ioff, int joff, float * norms1, float * norms2)
CORE_sgeqp3_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_sgeqp3_pivot (PLASMA_desc A, float * F, int ldf, int jj, int k, int * jpvt, float * norms1, float * norms2, int * info)
CORE_sgeqp3_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 sgeqp3_update; zero if no error.

  void CORE_sgeqp3_update (const float * Ajj, int lda1, float * Ajk, int lda2, const float * Fk, int ldf, int joff, int k, int koff, int nb, float * norms1, float * norms2, int * info)
CORE_sgeqp3_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. sgeqp3 handles this error.

  int CORE_sgeqrt (int M, int N, int IB, float * A, int LDA, float * T, int LDT, float * TAU, float * WORK)
CORE_sgeqrt 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_sgessm (int M, int N, int K, int IB, const int * IPIV, const float * L, int LDL, float * A, int LDA)
CORE_sgessm applies the factors L computed by CORE_sgetrf_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_sgetrf_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_sgetf2_nopiv (int M, int N, float * A, int LDA)
CORE_sgetf2_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_sgetrf_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_sgetrf (int m, int n, float * A, int lda, int * IPIV, int * info)
CORE_sgetrf - 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_sgetrf_incpiv (int M, int N, int IB, float * A, int LDA, int * IPIV, int * INFO)
CORE_sgetrf_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_sgetrf_nopiv (int M, int N, int IB, float * A, int LDA)
CORE_sgetrf_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_sgetrf_reclap (CORE_sgetrf_data_t * data, int M, int N, float * A, int LDA, int * IPIV, int * info)
CORE_sgetrf_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_sgetrf_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_sgetrf_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_sgetrf_rectil (CORE_sgetrf_data_t * data, const PLASMA_desc A, int * IPIV, int * info)
CORE_sgetrf_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_sgetrf_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_sgetrf_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_sgetrip (int m, int n, float * A, float * W)
CORE_sgetrip 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_shbelr (PLASMA_enum uplo, int N, PLASMA_desc * A, float * V, float * TAU, int st, int ed, int eltsize)
CORE_shbelr 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 float 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 float 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_shblrx (PLASMA_enum uplo, int N, PLASMA_desc * A, float * V, float * TAU, int st, int ed, int eltsize)
CORE_shblrx 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 float 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 float 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_shbrce (PLASMA_enum uplo, int N, PLASMA_desc * A, float * V, float * TAU, int st, int ed, int eltsize)
CORE_shbrce 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 float 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 float 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_slacpy (PLASMA_enum uplo, int M, int N, const float * A, int LDA, float * B, int LDB)
CORE_slacpy 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_slacpy_pivot (const PLASMA_desc descA, PLASMA_enum direct, int k1, int k2, const int * ipiv, int * rankin, int * rankout, float * A, int lda, int init)
CORE_slacpy_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_slaed0_betaapprox (int subpbs, const int * subpbs_info, float * D, const float * E)
CORE_slaed0_betaapprox - compute the rank-1 approximation for each subproblem. When a larger problem is split into two subproblems, the last diagonal element of the first subproblem and the first diagonal element of the second subproblem are set to D[i]-E[i+1]
Parameters:
    subpbs specifies the number of merge to be done at the leaf of the tree
    subpbs_info subpbs_info[i] is the position of the first eigenvalue of the ith eigenproblem.
    D On entry, D contains the diagonal elements of the two submatrices to be merged. On exit, D contains the updated rank-1 approximated diagonal elements.
    E E contains the extra-diagonal elements of the two submatrices to be merged.

  void CORE_slaed2_compressq (int n, int n1, const int * INDX, const int * ctot, const float * Q, int LDQ, float * Q2, int start, int end)
CORE_slaed2_compressq - Copy a set of vectors from the Q matrix into the compressed Q2 matrix. Q2 matrix is oragnized as follow:
Q2 = ( q1_1 mix1 0 def1 ) ( 0 mix2 q2 def2 ) and stored in memory by columns in the order (q1_1, mix1, mix2, q2, def), with q1 and q2 the non deflated values, of the two subproblems, (mix1, mix2) the mixed eigenvalues and def the deflated eiegnvalues.
Rk: Note that here we follow the same order that LAPACK slaed2 routine, so the copy from Q to Q2 is done such that Q2 is filled in a continuous manner.
Parameters:
    n n specifies the dimension of the symmetric tridiagonal matrix
    n1 n1 specifies the location of the last eigenvalue of the first subproblem min(1, n) <= n1 <= n/2
    start start specifies the first sorted column index to be considered by this kernel.
    end end specifies the last column index to be considered by this kernel. start <= end <= n.
    INDX The permutation array used to sort Q into Q2. Array of dimension n, but only INDX[i] for start <= i < end are referenced.
    ctot ctot[i] is the number of columns of type i, as defined with INDX. 0- number of colums with non-zero in the upper half only 1- number of dense colums 2- number of colums with non-zero in the lower half only 3- number of deflated columns
    Q On entry, Q contains the eigenvectors in the uncompressed form. WARNING: Q is the pointer to the full matrix even if only a subset of vectors will be extract.
    LDQ LDQ specifies the leading dimension of Q
    Q2 On exit, columns start to end from Q2 stores the eigenvectors in the compressed form and sorted by type. WARNING: Q2 is the pointer to the full matrix even if only columns start to end are touched.

  void CORE_slaed2_computeK (int * Kptr, int n, int n1, float * betaptr, float * D, float * Q, int LDQ, float * Z, float * DLAMBDA, float * W, int * INDX, int * INDXC, int * INDXP, int * INDXQ, int * COLTYP)
CORE_slaed2_computeK - Computes the number of deflated eigenvalues of a symmetric tridiagonal matrix. A eigenvalue is deflated if it's close enough to another eigenvalue or if the vector Z contains a tiny entry. This operation is useful when two subproblems, which were previously solved, are merge into a larger problem.
Parameters:
    Kptr On exit, Kptr stores the number of non-deflated eigenvalues
    n n specifies the dimension of the symmetric tridiagonal matrix
    n1 n1 specifies the location of the last eigenvalue of the first subproblem min(1, n) <= n1 <= n/2
    betaptr betaptr[0] specifies the rank-1 approximation that was used for splitting the problem into two subproblems. On exit, it contains the updated beta for LAED3.
    D On entry, D contains the eigenvalues of the two submatrices to be merged. On exit, D contains the updated eigenvalues sorted into increasing order.
    Q On entry, Q contains the eigenvectors of each subproblem. On exit, Q contains the updated eigenvectors, which can be modified through givens rotation (with close eigenvalues).
    LDQ LDQ specifies the leading direction of Q
    Z Z will contain the updating vectors, composed of the last row of the first subproblem and the first row of the second subproblem.
    DLAMBDA DLAMBDA will contain a copy of the first K eigenvalues and then an update of those eigenvalues for usage in LAED3. In LAPACK, the call of slamc3 is done at the beginning of LAED3.
    W W will contain the fisrt K values of the final Z vector, for future use in LAED3.
    INDX The permutation used to sort the contents of DLAMBDA into ascending order
    INDXC The permutation used to arrange the columns of the deflated Q matrix 1- non-zero elements only at and above n1 2- non-zero elements only below n1 3- dense
    INDXP INDXP is the permutation used to place deflated eigenvalues at the end of the array INDXP(0:K-1) points to the non-deflated D values INDXP(K-1:N-1) points to the deflated D values
    INDXQ The permutation which separetely sorts each subprobem in D into ascending order. In the second half of the permutation, elements will have n1 added to their value.
    COLTYP COLTYP indicate the type of the Q matrix columns during the process. 1- non-zero in the upper half only 2- dense 3- non-zero in the lower half only 4- deflated

  void CORE_slaed2_copydef (int n, int n1, int K, const int * ctot, float * Q, int LDQ, const float * Q2, int start, int end)
CORE_slaed2_copydef - Copy back a portion of the deflated eigenvectors from Q2 to Q.
Parameters:
    n n specifies the dimension of the symmetric tridiagonal matrix
    n1 n1 specifies the location of the last eigenvalue of the first subproblem min(1, n) <= n1 <= n/2
    K K specifies the number of non-deflated eigenvalues
    start start specifies the first column index to be considered by this kernel note that this index can be < K, it is supported
    end end specifies the last column index to be considered by this kernel
    ctot ctot[i] is the number of columns of type i, as defined with INDX. 0- number of colums with non-zero in the upper half only 1- number of dense colums 2- number of colums with non-zero in the lower half only 3- number of deflated columns
    Q On exit, Q(start:end-1) contains the updated eigenvectors
    LDQ LDQ specifies the leading direction of Q
    Q2 On entry, Q2 contains the saved eigenvectors in the compressed form.

  void CORE_slaed3_computevectors (int K, int il_nondef, int iu_nondef, float * Q, int LDQ, float * W, float * S, const int * INDXC, int start, int end)
CORE_slaed3_computevectors - Compute the subset(start:end) of eigenvectors of the modified rank-1 system.
Parameters:
    K K specifies the number of non-deflated eigenvalues
    il_nondef The first eigenvector index when computing only a subset of all eigenpairs
    iu_nondef The last eigenvector index when computing only a subset of all eigenpairs
    Q Q is an array of dimension (LDQ, end) Initially the first K columns of the full Q matrix are used as workspace. On output the Q(start:end) contain the updated eigenvectors.
    LDQ LDQ specifies the leading dimension of Q
    W W is the result of the previous computation after reduction. See core_slaed3_computeW() and core_slaed3_reduceW(). The first K elements of this array contain the components of the deflation-adjusted updating vector. Destroyed on output.
    S S is local workspace of size K.
    INDXC INDXC is the permutation used to arrange the columns of the deflated Q matrix into three groups (see core_slaed2_computeK()). The rows of the eigenvectors found by core_slaed4() must be likewise permuted before the matrix multiply of core_slaed3_updatevectors() can take place.
    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_slaed3_computeW (int n, int K, const float * Q, int LDQ, const float * DLAMBDA, float * W, const int * INDX, int start, int end)
CORE_slaed2_computeK - Computes the number of deflated eigenvalues of a symmetric tridiagonal matrix. A eigenvalue is deflated if it's close enough to another eigenvalue or if the vector Z contains a tiny entry. This operation is useful when two subproblems, which were previously solved, are merge into a larger problem.
Parameters:
    n n specifies the dimension of the symmetric tridiagonal matrix
    K K specifies the number of non-deflated eigenvalues
    Q On entry, Q contains the eigenvectors after slaed4
    LDQ LDQ specifies the leading direction of Q
    DLAMBDA DLAMBDA contains a copy of the first K eigenvalues
    W W
    INDX The permutation used to sort the contents of DLAMBDA into ascending order
    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 note that this index can be > n, it is supported

  void CORE_slaed3_merge (int n, int K, float * D, int * INDXQ)
CORE_slaed3_merge - Merge the eigenvalues of two subproblems and generates the index arrays to sort the associated eigenvectors.
Parameters:
    n n specifies the dimension of the symmetric tridiagonal matrix
    K K specifies the number of non-deflated eigenvalues
    D Array of float of size n. On exit, stores the sorted eigenvalues.
    INDXQ Array of integers of size n. On exit, INDXQ stores the permutation array to sort the eigenvectors.

  void CORE_slaed3_reduceW (int n, int n1, int K, int l, const float * Q, int LDQ, const float * Wred, float * W)
CORE_slaed3_reduceW - Computes the reduction of multiple W l threads were computing Wred(:,j) and this kernel will compute the Pi( Wred(i,j), j=1..l )
Parameters:
    n n specifies the dimension of the symmetric tridiagonal matrix
    n1 n1 specifies the location of the last eigenvalue of the first subproblem min(1, n) <= n1 <= n/2
    K K specifies the number of non-deflated eigenvalues
    l l specifies the number of columns of Wred
    Q
    LDQ LDQ specifies the leading direction of Q
    Wred Wred[:,j] corresponds to the local W for a previous task
    W On exit, W(i) = sqrt( Pi( Wred(i,j), j=1..l ) * Q(i,i) )

  void CORE_slaed3_updatevectors (int op, int wsmode, int n, int n1, int K, int il_nondef, int iu_nondef, float * Q, int ldq, float * Q2, const int * ctot, float * W, int start, int end)
CORE_slaed3_updatevectors -
Parameters:
    op Type of operation to apply = PlasmaLaed3Update1: Apply the GEMM on the first subproblem = PlasmaLaed3Update2: Apply the GEMM on the second subproblem and merge the eigenvalues. = PlasmaLaed3UpdateAll: Apply all operations in one call.
    wsmode Specifies the amount of extra workspace used for the computations. = 0 : means that no extra workspace is available (WORK = NULL). S = Q2 + n12 * n1 + n23 * (n-n1) is used as the workspace to sequentially apply the updates = 1 : means that extra workspace has been allocated in CORE_slaed3_computevectors() to apply the updates in parallel. If op = PlasmaLaed3Update1, the first subproblem is updated. If op = PlasmaLaed3Update2, the second subproblem is updated. = 3 : means that extra workspace has been allocated in after K has been computed in CORE_slaed2_computeK(). Allows to apply both updates in parallel as previously.
    n n specifies the dimension of the symmetric tridiagonal matrix
    n1 n1 specifies the location of the last eigenvalue of the first subproblem min(1, n) <= n1 <= n/2
    K K specifies the number of non-deflated eigenvalues
    il_nondef The first eigenvector index when computing only a subset of all eigenpairs
    iu_nondef The last eigenvector index when computing only a subset of all eigenpairs
    Q The current eigenvectors
    ldq LDQ specifies the leading direction of Q
    Q2 The updated eigenvectors
    ctot ctot indicates the number of vectors of each type in the Q matrix. 0- non-zero in the upper half only 1- dense 2- non-zero in the lower half only 3- deflated
    W W is the place were will be stored the updated eigenvectors
    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

  int CORE_slaed4 (int n, int K, float * D, float beta, float * Q, int LDQ, const float * D0, const float * Z, const int * INDX, int start, int end)
CORE_slaed4 - solve the secular equation for indexes between start and end
Parameters:
    n n specifies the dimension of the symmetric tridiagonal matrix
    K K specifies the number of non-deflated eigenvalues
    D On entry, D contains the eigenvalues of the two submatrices to be merged. On exit, D contains the updated eigenvalues sorted into increasing order.
    beta beta_bis[0] specifies the rank-1 approximation that was used for splitting the problem into two subproblems.
    Q On exit, Q contains the updated eigenvectors
    LDQ LDQ specifies the leading direction of Q
    D0 On entry, D0 conatins the original sorted eigenvalues.
    Z Z contains the components of the updating vectors.
    INDX The permutation used to sort the contents of DLAMBDA into ascending order
    start start specifies the first column index to be considered by this kernel 0 <= start <= end
    end end specifies the last column index to be considered by this kernel start <= end <= n
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value

  void CORE_slange (int norm, int M, int N, const float * A, int LDA, float * work, float * normA)
CORE_slange returns the value
slange = ( 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_slansy (int norm, PLASMA_enum uplo, int N, const float * A, int LDA, float * work, float * normA)
CORE_slansy returns the value
slansy = ( 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_slantr (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const float * A, int LDA, float * work, float * normA)
CORE_slantr returns the value
slantr = ( 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_slantr returns 0.
    N The number of columns of the matrix A. N >= 0. If uplo == PlasmaLower, N <= M. When N = 0, CORE_slantr 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_slarfb_gemm (PLASMA_enum side, PLASMA_enum trans, int direct, int storev, int M, int N, int K, const float * V, int LDV, const float * T, int LDT, float * C, int LDC, float * WORK, int LDWORK)
CORE_slarfb_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 slarfb 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**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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 REAL 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 REAL 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) REAL 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_slarfx2 (PLASMA_enum side, int N, float V, float TAU, float * C1, int LDC1, float * C2, int LDC2)
CORE_slarfx2 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 float 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_slarfx2c (PLASMA_enum uplo, float V, float TAU, float * C1, float * C2, float * C3)
CORE_slarfx2c 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 float 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_slarfx2ce (PLASMA_enum uplo, float * V, float * TAU, float * C1, float * C2, float * C3)
CORE_slarfx2c 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 float complex V in the representation of H. On exit, the float 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_slarfy (int N, float * A, int LDA, const float * V, const float * TAU, float * WORK)
CORE_slarfy 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 REAL 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_slascal (PLASMA_enum uplo, int m, int n, float alpha, float * A, int lda)
CORE_slascal scales a two-dimensional matrix A. As opposite to CORE_slascl(), 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_slascl (PLASMA_enum type, int kl, int ku, float cfrom, float cto, int m, int n, float * A, int lda)
CORE_slascl 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 real
    cto is real 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_slaset (PLASMA_enum uplo, int M, int N, float alpha, float beta, float * A, int LDA)
CORE_slaset - 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_slaset2 (PLASMA_enum uplo, int M, int N, float alpha, float * A, int LDA)
CORE_slaset2 - 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_slaswp (int N, float * A, int LDA, int I1, int I2, const int * IPIV, int INC)
CORE_slaswp 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_slaswp_ontile (PLASMA_desc descA, int i1, int i2, const int * ipiv, int inc)
CORE_slaswp_ontile apply the slaswp 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_slaswpc_ontile (PLASMA_desc descA, int i1, int i2, const int * ipiv, int inc)
CORE_slaswpc_ontile apply the slaswp 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_slatro (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, const float * A, int LDA, float * B, int LDB)
CORE_slatro 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 ugate transposed: = PlasmaNoTrans: B is a copy of A (equivalent to slacpy); = PlasmaTrans: B is the transpose of A; = PlasmaTrans: B is the ugate 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_slauum (PLASMA_enum uplo, int N, float * A, int LDA)
CORE_slauum - 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_sormlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const float * A, int LDA, const float * T, int LDT, float * C, int LDC, float * WORK, int LDWORK)
CORE_sormlq overwrites the general complex M-by-N tile C with
              SIDE = 'L'     SIDE = 'R'
 TRANS = 'N': Q * C C * Q TRANS = 'C': Q**T * C C * Q**T
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_sgelqt. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : Transpose, apply Q**T.
    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_sgelqt 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_sormqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, int IB, const float * A, int LDA, const float * T, int LDT, float * C, int LDC, float * WORK, int LDWORK)
CORE_sormqr overwrites the general complex M-by-N tile C with
              SIDE = 'L'     SIDE = 'R'
 TRANS = 'N': Q * C C * Q TRANS = 'C': Q**T * C C * Q**T
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_sgeqrt. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : Transpose, apply Q**T.
    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_sgeqrt 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

  int CORE_spamm (int op, PLASMA_enum side, PLASMA_enum storev, int M, int N, int K, int L, const float * A1, int LDA1, float * A2, int LDA2, const float * V, int LDV, float * 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**T,
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_sparfb (PLASMA_enum side, PLASMA_enum trans, PLASMA_enum direct, PLASMA_enum storev, int M1, int N1, int M2, int N2, int K, int L, float * A1, int LDA1, float * A2, int LDA2, const float * V, int LDV, const float * T, int LDT, float * WORK, int LDWORK)
CORE_sparfb 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**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_spemv (PLASMA_enum trans, int storev, int M, int N, int L, float ALPHA, const float * A, int LDA, const float * X, int INCX, float BETA, float * Y, int INCY, float * WORK)
CORE_spemv 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**T,
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 PlasmaTrans :  y := alpha*A**T*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_splgsy (float bump, int m, int n, float * A, int lda, int gM, int m0, int n0, unsigned long long int seed)
CORE_splgsy 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_splrnt (int m, int n, float * A, int lda, int gM, int m0, int n0, unsigned long long int seed)
CORE_splrnt 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_spltmg (PLASMA_enum mtxtype, int M, int N, float * A, int LDA, int gM, int gN, int m0, int n0, unsigned long long int seed)
CORE_spltmg 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_spltmg_chebvand (int M, int N, float * A, int LDA, int gN, int m0, int n0, float * W)
CORE_spltmg_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_spltmg_circul (int M, int N, float * A, int LDA, int gM, int m0, int n0, const float * V)
CORE_spltmg_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_spltmg_condexq (int M, int N, float * Q, int LDQ)
CORE_spltmg_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_spltmg_fiedler (int M, int N, const float * X, int incX, const float * Y, int incY, float * A, int LDA)
CORE_spltmg_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_spltmg_hankel (PLASMA_enum uplo, int M, int N, float * A, int LDA, int m0, int n0, int nb, const float * V1, const float * V2)
CORE_spltmg_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_spltmg_toeppd1 (int gM, int m0, int M, float * W, unsigned long long int seed)
CORE_spltmg_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_spltmg_toeppd2 (int M, int N, int K, int m0, int n0, const float * W, float * A, int LDA)
CORE_spltmg_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_spotrf (PLASMA_enum uplo, int N, float * A, int LDA, int * info)
CORE_spotrf - 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**T*U or A = L*L**T.
    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_ssbtype1cb (int N, int NB, float * A, int LDA, float * V, float * TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, float * WORK)
CORE_ssbtype1cb 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 float array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAU float 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_ssbtype2cb (int N, int NB, float * A, int LDA, float * V, float * TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, float * WORK)
CORE_ssbtype2cb 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 float 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 float 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_ssbtype3cb (int N, int NB, float * A, int LDA, const float * V, const float * TAU, int st, int ed, int sweep, int Vblksiz, int WANTZ, float * WORK)
CORE_ssbtype3cb 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 float array, dimension N if eigenvalue only requested or (LDV*blkcnt*Vblksiz) if Eigenvectors requested The Householder reflectors are stored in this array.
    TAU float 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_ssetvar (const float * alpha, float * x)
CORE_ssetvar 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_sshiftw (int s, int cl, int m, int n, int L, float * A, float * W)
CORE_sshiftw 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_sssssm (int M1, int N1, int M2, int N2, int K, int IB, float * A1, int LDA1, float * A2, int LDA2, const float * L1, int LDL1, const float * L2, int LDL2, const int * IPIV)
CORE_sssssm 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_ststrf.
    LDL1 The leading dimension of the array L1. LDL1 >= max(1,IB).
    L2 The M2-by-K tile as returned by CORE_ststrf.
    LDL2 The leading dimension of the array L2. LDL2 >= max(1,M2).
    IPIV The pivot indices array of size K as returned by CORE_ststrf.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if INFO = -k, the k-th argument had an illegal value

  int CORE_sstedc (PLASMA_enum compz, int n, float * D, float * E, float * Z, int LDZ, float * WORK, int LWORK, int * IWORK, int LIWORK)
CORE_sstedc - 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 float 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_ssteqr (PLASMA_enum compz, int n, float * D, float * E, float * Z, int LDZ, float * WORK)
CORE_ssteqr - 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_sswap (int m, int n, float * Q, int ldq, const float * work, const int * perm, int start, int end)
CORE_sswap - 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_sswpab (int i, int n1, int n2, float * A, float * work)
CORE_sswpab 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_sswptr_ontile (PLASMA_desc descA, int i1, int i2, const int * ipiv, int inc, const float * Akk, int ldak)
CORE_sswptr_ontile apply the slaswp function on a matrix stored in tile layout, followed by a strsm 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_ssygst (int itype, PLASMA_enum uplo, int N, float * A, int LDA, float * B, int LDB, int * INFO)
CORE_ssygst - 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**T)*A*inv(U) or inv(L)*A*inv(L**T) 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**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by CORE_spotrf.
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_SPOTRF.
    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_ssymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, float alpha, const float * A, int LDA, const float * B, int LDB, float beta, float * C, int LDC)
CORE_ssymm - 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_ssyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, float alpha, const float * A, int LDA, const float * B, int LDB, float beta, float * C, int LDC)
CORE_ssyr2k - Performs one of the symmetric rank 2k operations
+ lpha [ op( B ) imes g( op( A )' )] + ts op( B ) ] + lpha [ g( op( B )' ) imes op( A ) ] +
where op( X ) is one of
op( X ) = X or op( X ) = g( 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 ugate transposed: = PlasmaNoTrans: + lpha [ op( B ) imes g( op( A )' )] + ts op( B ) ] + lpha [ g( 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_ssyrfb (PLASMA_enum uplo, int n, int k, int ib, int nb, const float * A, int lda, const float * T, int ldt, float * C, int ldc, float * WORK, int ldwork)
CORE_ssyrfb 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_sgeqrt. 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_sgeqrt 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_ssyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, float alpha, const float * A, int LDA, float beta, float * C, int LDC)
CORE_ssyrk - Performs one of the hermitian rank k operations
+
where op( X ) is one of
op( X ) = X or op( X ) = g( 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 ugate 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_stradd (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, float alpha, const float * A, int LDA, float beta, float * B, int LDB)
CORE_stradd adds two matrices together as in PBLAS pstradd.
 B <- alpha * op(A)  + beta * B,
where op(X) = X, X', or (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 ugate transposed = PlasmaNoTrans: op(A) = A = PlasmaTrans: op(A) = A' = PlasmaTrans: op(A) = (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_strasm (PLASMA_enum storev, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, const float * A, int lda, float * work)
CORE_strasm - 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_strdalg1 (int n, int nb, float * A, int lda, float * V, float * TAU, int Vblksiz, int wantz, int i, int sweepid, int m, int grsiz, float * work)
CORE_strdalg1 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 float 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 float array, dimension (n) if wantz=0 or ldv*Vblksiz*blkcnt if wantz>0. The scalar elementary reflectors are written in this array.
    TAU float 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_ssbtype[123]cb.

  void CORE_strmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, float alpha, const float * A, int LDA, float * B, int LDB)
CORE_strmm - 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 ugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is ugate 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_strsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int M, int N, float alpha, const float * A, int LDA, float * B, int LDB)
CORE_strsm - 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 ugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is ugate 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_strtri (PLASMA_enum uplo, PLASMA_enum diag, int N, float * A, int LDA, int * info)
CORE_strtri - 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_stslqt (int M, int N, int IB, float * A1, int LDA1, float * A2, int LDA2, float * T, int LDT, float * TAU, float * WORK)
CORE_stslqt 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; g(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_stsmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float * A1, int LDA1, float * A2, int LDA2, const float * V, int LDV, const float * T, int LDT, float * WORK, int LDWORK)
CORE_stsmlq 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**T * | A1 | | A1 A2 | * Q**T | 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_STSLQT.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_STSLQT 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_stsmlq_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, float * A1, int lda1, float * A2, int lda2, float * A3, int lda3, const float * V, int ldv, const float * T, int ldt, float * WORK, int ldwork)
CORE_stsmlq_corner: see CORE_stsmlq
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_STSLQT 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_stsmlq_sytra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, float * A1, int lda1, float * A2, int lda2, const float * V, int ldv, const float * T, int ldt, float * WORK, int ldwork)
CORE_stsmlq_sytra1: see CORE_stsmlq
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**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_STSLQT 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_stsmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float * A1, int LDA1, float * A2, int LDA2, const float * V, int LDV, const float * T, int LDT, float * WORK, int LDWORK)
CORE_stsmqr 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**T * | A1 | | A1 A2 | * Q**T | 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_STSQRT.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_STSQRT 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_stsmqr_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, float * A1, int lda1, float * A2, int lda2, float * A3, int lda3, const float * V, int ldv, const float * T, int ldt, float * WORK, int ldwork)
CORE_stsmqr_corner: see CORE_stsmqr
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_STSQRT 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_stsmqr_sytra1 (PLASMA_enum side, PLASMA_enum trans, int m1, int n1, int m2, int n2, int k, int ib, float * A1, int lda1, float * A2, int lda2, const float * V, int ldv, const float * T, int ldt, float * WORK, int ldwork)
CORE_stsmqr_sytra1: see CORE_stsmqr
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**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_STSQRT 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_stsqrt (int M, int N, int IB, float * A1, int LDA1, float * A2, int LDA2, float * T, int LDT, float * TAU, float * WORK)
CORE_stsqrt 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_ststrf (int M, int N, int IB, int NB, float * U, int LDU, float * A, int LDA, float * L, int LDL, int * IPIV, float * WORK, int LDWORK, int * INFO)
CORE_ststrf 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_sttlqt (int M, int N, int IB, float * A1, int LDA1, float * A2, int LDA2, float * T, int LDT, float * TAU, float * WORK)
CORE_sttlqt 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; g(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_sttmlq (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float * A1, int LDA1, float * A2, int LDA2, const float * V, int LDV, const float * T, int LDT, float * WORK, int LDWORK)
CORE_sttmlq 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**T * | A1 | | A1 | * Q**T | 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_sttqrt.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_STTQRT 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_sttmqr (PLASMA_enum side, PLASMA_enum trans, int M1, int N1, int M2, int N2, int K, int IB, float * A1, int LDA1, float * A2, int LDA2, const float * V, int LDV, const float * T, int LDT, float * WORK, int LDWORK)
CORE_sttmqr 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**T * | A1 | | A1 | * Q**T | 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_sttqrt.
Parameters:
    side
    •   PlasmaLeft : apply Q or Q**T from the Left;
    •   PlasmaRight : apply Q or Q**T from the Right.
    trans
    •   PlasmaNoTrans : No transpose, apply Q;
    •   PlasmaTrans : ConjTranspose, apply Q**T.
    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_STTQRT 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_sttqrt (int M, int N, int IB, float * A1, int LDA1, float * A2, int LDA2, float * T, int LDT, float * TAU, float * WORK)
CORE_sttqrt 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

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