int PLASMA_Version(int *ver_major, int *ver_minor, int *ver_micro)

PLASMA_VERSION(INTEGER VER_MAJOR, INTEGER VER_MINOR, INTEGER VER_MICRO, INTEGER INFO)

ver_major    int (OUT)
             PLASMA major version number.

ver_minor    int (OUT)
             PLASMA minor version number.

ver_micro    int (OUT)
             PLASMA micro version number.

          = PLASMA_SUCCESS: successful exit

int PLASMA_cgelqf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T)

PLASMA_CGELQF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER T, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N)
         lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the
         diagonal represent the unitary matrix Q as a product of elementary reflectors, stored
         by tiles.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_cgelqs to solve the system
         of equations.

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

int PLASMA_cgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_CGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N)
         lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the
         diagonal represent the unitary matrix Q as a product of elementary reflectors, stored
         by tiles.

T        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_cgelqs to solve the system
         of equations.

          = 0: successful exit

int PLASMA_cgelqs(int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CGELQS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= M >= 0.

NRHS     int (IN)
         The number of columns of B. NRHS >= 0.

A        PLASMA_Complex32_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= M.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgelqf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-NRHS right hand side matrix B.
         On exit, the N-by-NRHS solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= N.

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

int PLASMA_cgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)

PLASMA_CGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)

A        PLASMA_Complex32_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgelqf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-NRHS right hand side matrix B.
         On exit, the N-by-NRHS solution matrix X.

          = 0: successful exit

int PLASMA_cgels(PLASMA_enum trans, int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   the linear system involves A;
         = PlasmaConjTrans: the linear system involves A**H.
         Currently only PlasmaNoTrans is supported.

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrices B and X.
         NRHS >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix A.
         On exit,
         if M >= N, A is overwritten by details of its QR factorization as returned by
                    PLASMA_cgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_cgelqf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise;
         On exit, if return value = 0, B is overwritten by the solution vectors, stored
         columnwise:
         if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual
         sum of squares for the solution in each column is given by the sum of squares of the
         modulus of elements N+1 to M in that column;
         if M < N, rows 1 to N of B contain the minimum norm solution vectors;

LDB      int (IN)
         The leading dimension of the array B. LDB >= MAX(1,M,N).

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

int PLASMA_cgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)

PLASMA_CGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   the linear system involves A;
         = PlasmaConjTrans: the linear system involves A**H.
         Currently only PlasmaNoTrans is supported.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix A.
         On exit,
         if M >= N, A is overwritten by details of its QR factorization as returned by
                    PLASMA_cgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_cgelqf.

T        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise;
         On exit, if return value = 0, B is overwritten by the solution vectors, stored
         columnwise:
         if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual
         sum of squares for the solution in each column is given by the sum of squares of the
         modulus of elements N+1 to M in that column;
         if M < N, rows 1 to N of B contain the minimum norm solution vectors;

          = 0: successful exit

int PLASMA_cgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)

PLASMA_CGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, COMPLEX alpha, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, COMPLEX beta, COMPLEX C, INTEGER LDC, INTEGER INFO)

transA   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaConjTrans: A is conjugate transposed.
         Currently only PlasmaNoTrans is supported

transB   PLASMA_enum (IN)
         Specifies whether the matrix B is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   B is transposed;
         = PlasmaTrans:     B is not transposed;
         = PlasmaConjTrans: B is conjugate transposed.
         Currently only PlasmaNoTrans is supported

M        int (IN)
         M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0.

N        int (IN)
         N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0.

K        int (IN)
         K specifies the number of columns of the matrix op( A ) and the number of rows of
         the matrix op( B ). K >= 0.

alpha    PLASMA_Complex32_t (IN)
         alpha specifies the scalar alpha

A        PLASMA_Complex32_t* (IN)
         A is a LDA-by-ka matrix, where ka is K when  transA = PlasmaNoTrans,
         and is  M  otherwise.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

B        PLASMA_Complex32_t* (IN)
         B is a LDB-by-kb matrix, where kb is N when  transB = PlasmaNoTrans,
         and is  K  otherwise.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

beta     PLASMA_Complex32_t (IN)
         beta specifies the scalar beta

C        PLASMA_Complex32_t* (INOUT)
         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      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).

          = 0: successful exit

int PLASMA_cgeqrf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T)

PLASMA_CGEQRF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER T, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A.  N >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N
         upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the
         diagonal represent the unitary matrix Q as a product of elementary reflectors stored
         by tiles.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_cgeqrs to solve the system
         of equations.

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

int PLASMA_cgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_CGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N
         upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the
         diagonal represent the unitary matrix Q as a product of elementary reflectors stored
         by tiles.

T        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_cgeqrs to solve the system
         of equations.

          = 0: successful exit

int PLASMA_cgeqrs(int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= M >= 0.

NRHS     int (IN)
         The number of columns of B. NRHS >= 0.

A        PLASMA_Complex32_t* (INOUT)
         Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= M.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgeqrf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the m-by-nrhs right hand side matrix B.
         On exit, the n-by-nrhs solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

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

int PLASMA_cgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)

PLASMA_CGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)

A        PLASMA_Complex32_t* (INOUT)
         Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgeqrf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the m-by-nrhs right hand side matrix B.
         On exit, the n-by-nrhs solution matrix X.

          = 0: successful exit

int PLASMA_cgesv(int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV, PLASMA_Complex32_t *B, int LDB)

PLASMA_CGESV(INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)

N        int (IN)
         The number of linear equations, i.e., the order of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrix B.
         NRHS >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-N coefficient matrix A.
         On exit, the tile L and U factors from the factorization (not equivalent to LAPACK).

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

L        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         necessary to solve the system of equations.

IPIV     int* (OUT)
         On exit, the pivot indices that define the permutations (not equivalent to LAPACK).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS matrix of right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

          = 0: 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, so the solution could not be computed.

int PLASMA_cgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)

PLASMA_CGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)

A        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-N coefficient matrix A.
         On exit, the tile L and U factors from the factorization (not equivalent to LAPACK).

L        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         necessary to solve the system of equations.

IPIV     int* (OUT)
         On exit, the pivot indices that define the permutations (not equivalent to LAPACK).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS matrix of right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

          = 0: successful exit
          > 0: if i, U(i,i) is exactly zero. The factorization has been completed,
               but the factor U is exactly singular, so the solution could not be computed.

int PLASMA_cgetrf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV)

PLASMA_CGETRF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix to be factored.
         On exit, the tile factors L and U from the factorization.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

L        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_cgetrs to solve the system of equations.

IPIV     int* (OUT)
         The pivot indices that define the permutations (not equivalent to LAPACK).

          = 0: 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.

int PLASMA_cgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)

PLASMA_CGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)

A        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix to be factored.
         On exit, the tile factors L and U from the factorization.

L        PLASMA_Complex32_t* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_cgetrs to solve the system of equations.

IPIV     int* (OUT)
         The pivot indices that define the permutations (not equivalent to LAPACK).

          = 0: successful exit
          > 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.

int PLASMA_cgetrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV, PLASMA_Complex32_t *B, int LDB)

PLASMA_CGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)

trans    PLASMA_enum (IN)
         Intended to specify the the form of the system of equations:
         = PlasmaNoTrans:   A * X = B     (No transpose)
         = PlasmaTrans:     A**T * X = B  (Transpose)
         = PlasmaConjTrans: A**H * X = B  (Conjugate transpose)
         Currently only PlasmaNoTrans is supported.

N        int (IN)
         The order of the matrix A.  N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrix B.
         NRHS >= 0.

A        PLASMA_Complex32_t* (IN)
         The tile factors L and U from the factorization, computed by PLASMA_cgetrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

L        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf.

IPIV     int* (IN)
         The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS matrix of right hand side matrix B.
         On exit, the solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

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

int PLASMA_cgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)

PLASMA_CGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)

A        PLASMA_Complex32_t* (IN)
         The tile factors L and U from the factorization, computed by PLASMA_cgetrf.

L        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf.

IPIV     int* (IN)
         The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS matrix of right hand side matrix B.
         On exit, the solution matrix X.

          = 0: successful exit

int PLASMA_Enable(PLASMA_enum lever)

PLASMA_ENABLE(INTEGER lever, INTEGER INFO)

lever    PLASMA_enum (IN)
         Feature to be enabled:
         = PLASMA_WARNINGS:   printing of warning messages,
         = PLASMA_ERRORS:     printing of error messages,
         = PLASMA_AUTOTUNING: autotuning for tile size and inner block size.

          = PLASMA_SUCCESS: successful exit

int PLASMA_Disable(PLASMA_enum lever)

PLASMA_DISABLE(INTEGER lever, INTEGER INFO)

lever    PLASMA_enum (IN)
         Feature to be disabled:
         = PLASMA_WARNINGS:   printing of warning messages,
         = PLASMA_ERRORS:     printing of error messages,
         = PLASMA_AUTOTUNING: autotuning for tile size and inner block size.

          = PLASMA_SUCCESS: successful exit

int PLASMA_Set(PLASMA_enum param, int value)

PLASMA_SET(INTEGER param, INTEGER value, INTEGER INFO)

param    PLASMA_enum (IN)
         PLASMA parameter:
         = PLASMA_TILE_SIZE:        size matrix tile,
         = PLASMA_INNER_BLOCK_SIZE: size of tile inner block.

value    int (IN)
         Value of the parameter.

          = PLASMA_SUCCESS: successful exit

int PLASMA_Get(PLASMA_enum param, int *value)

PLASMA_GET(INTEGER param, INTEGER value, INTEGER INFO)

param    PLASMA_enum (IN)
         PLASMA parameter:
         = PLASMA_TILE_SIZE:        size matrix tile,
         = PLASMA_INNER_BLOCK_SIZE: size of tile inner block.

value    int* (OUT)
         Value of the parameter.

          = PLASMA_SUCCESS: successful exit

int PLASMA_Init(int cores)

PLASMA_INIT(INTEGER CORES, INTEGER INFO)

cores    int (IN)
         Number of cores to use (threads to launch)

          = PLASMA_SUCCESS: successful exit

int PLASMA_Finalize()

PLASMA_FINALIZE(INTEGER INFO)

int PLASMA_cposv(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)

PLASMA_CPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)

uplo     PLASMA_enum (IN)
         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        int (IN)
         The number of linear equations, i.e., the order of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the symmetric positive definite (or Hermitian) matrix A.
         If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A
         contains the upper triangular part of the matrix A, and the strictly lower triangular
         part of A is not referenced.
         If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower
         triangular part of the matrix A, and the strictly upper triangular part of A is not
         referenced.
         On exit, if return value = 0, the factor U or L from the Cholesky factorization
         A = U**H*U or A = L*L**H.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

          = 0: 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.

int PLASMA_cposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)

PLASMA_CPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)

uplo     PLASMA_enum (IN)
         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.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the symmetric positive definite (or Hermitian) matrix A.
         If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A
         contains the upper triangular part of the matrix A, and the strictly lower triangular
         part of A is not referenced.
         If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower
         triangular part of the matrix A, and the strictly upper triangular part of A is not
         referenced.
         On exit, if return value = 0, the factor U or L from the Cholesky factorization
         A = U**H*U or A = L*L**H.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

          = 0: successful exit
          > 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.

int PLASMA_cpotrf(PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA)

PLASMA_CPOTRF(INTEGER uplo, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER INFO)

uplo     PLASMA_enum (IN)
         = PlasmaUpper: Upper triangle of A is stored;
         = PlasmaLower: Lower triangle of A is stored.

N        int (IN)
         The order of the matrix A. N >= 0.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the symmetric positive definite (or Hermitian) matrix A.
         If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A
         contains the upper triangular part of the matrix A, and the strictly lower triangular
         part of A is not referenced.
         If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower
         triangular part of the matrix A, and the strictly upper triangular part of A is not
         referenced.
         On exit, if return value = 0, the factor U or L from the Cholesky factorization
         A = U**H*U or A = L*L**H.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

          = 0: 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.

int PLASMA_cpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)

PLASMA_CPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)

uplo     PLASMA_enum (IN)
         = PlasmaUpper: Upper triangle of A is stored;
         = PlasmaLower: Lower triangle of A is stored.

A        PLASMA_Complex32_t* (INOUT)
         On entry, the symmetric positive definite (or Hermitian) matrix A.
         If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A
         contains the upper triangular part of the matrix A, and the strictly lower triangular
         part of A is not referenced.
         If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower
         triangular part of the matrix A, and the strictly upper triangular part of A is not
         referenced.
         On exit, if return value = 0, the factor U or L from the Cholesky factorization
         A = U**H*U or A = L*L**H.

          = 0: successful exit
          > 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.

int PLASMA_cpotrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)

PLASMA_CPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER  LDB, INTEGER  INFO)

uplo     PLASMA_enum (IN)
         = PlasmaUpper: Upper triangle of A is stored;
         = PlasmaLower: Lower triangle of A is stored.

N        int (IN)
         The order of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.

A        PLASMA_Complex32_t* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H,
         computed by PLASMA_cpotrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

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

int PLASMA_cpotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)

PLASMA_CPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)

uplo     PLASMA_enum (IN)
         = PlasmaUpper: Upper triangle of A is stored;
         = PlasmaLower: Lower triangle of A is stored.

A        PLASMA_Complex32_t* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H,
         computed by PLASMA_cpotrf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

          = 0: successful exit

int PLASMA_ctrsm(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)

PLASMA_CTRSM(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)

side     PLASMA_enum (IN)
         Specifies whether A appears on the left or on the right of X:
         = PlasmaLeft:  A*X = B
         = PlasmaRight: X*A = B

uplo     PLASMA_enum (IN)
         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   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaConjTrans: A is conjugate transposed.

diag     PLASMA_enum (IN)
         Specifies whether or not A is unit triangular:
         = PlasmaNonUnit: A is non unit;
         = PlasmaUnit:    A us unit.

N        int (IN)
         The order of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.

A        PLASMA_Complex32_t* (IN)
         The triangular matrix A. If uplo = PlasmaUpper, 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 = PlasmaLower, 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 = PlasmaUnit, the
         diagonal elements of A are also not referenced and are assumed to be 1.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

LDB      PLASMA_Complex32_t* (IN)
         The leading dimension of the array B. LDB >= max(1,N).

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

int PLASMA_ctrsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)

PLASMA_CTRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)

side     PLASMA_enum (IN)
         Specifies whether A appears on the left or on the right of X:
         = PlasmaLeft:  A*X = B
         = PlasmaRight: X*A = B

uplo     PLASMA_enum (IN)
         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   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaConjTrans: A is conjugate transposed.

diag     PLASMA_enum (IN)
         Specifies whether or not A is unit triangular:
         = PlasmaNonUnit: A is non unit;
         = PlasmaUnit:    A us unit.

A        PLASMA_Complex32_t* (IN)
         The triangular matrix A. If uplo = PlasmaUpper, 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 = PlasmaLower, 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 = PlasmaUnit, the
         diagonal elements of A are also not referenced and are assumed to be 1.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

          = 0: successful exit

int PLASMA_ctrsmpl(int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV, PLASMA_Complex32_t *B, int LDB)

PLASMA_CTRSMPL(INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)

N        int (IN)
         The order of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.

A        PLASMA_Complex32_t* (IN)
         The tile factor L from the factorization, computed by PLASMA_cgetrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,N).

L        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf.

IPIV     int* (IN)
         The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

LDB      PLASMA_Complex32_t* (IN)
         The leading dimension of the array B. LDB >= max(1,N).

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

int PLASMA_ctrsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)

PLASMA_CTRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)

A        PLASMA_Complex32_t* (IN)
         The tile factor L from the factorization, computed by PLASMA_cgetrf.

L        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf.

IPIV     int* (IN)
         The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK).

B        PLASMA_Complex32_t* (INOUT)
         On entry, the N-by-NRHS right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

          = 0: successful exit

int PLASMA_cunglq(int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CUNGLQ(INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix Q. M >= 0.

N        int (IN)
         The number of columns of the matrix Q. N >= M.

K        int (IN)
         The number of rows of elementary tile reflectors whose product defines the matrix Q.
         M >= K >= 0.

A        PLASMA_Complex32_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgelqf.

B        PLASMA_Complex32_t* (OUT)
         On exit, the M-by-N matrix Q.

LDA      int (IN)
         The leading dimension of the array B. LDB >= max(1,M).

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

int PLASMA_cunglq_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)

A        PLASMA_Complex32_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgelqf.

B        PLASMA_Complex32_t* (OUT)
         On exit, the M-by-N matrix Q.

          = 0: successful exit

int PLASMA_cungqr(int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CUNGQR(INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix Q. M >= 0.

N        int (IN)
         The number of columns of the matrix Q. N >= M.

K        int (IN)
         The number of columns of elementary tile reflectors whose product defines the matrix Q.
         M >= K >= 0.

A        PLASMA_Complex32_t* (IN)
         Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgeqrf.

B        PLASMA_Complex32_t* (OUT)
         On exit, the M-by-N matrix Q.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,M).

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

int PLASMA_cungqr_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)

PLASMA_CUNGQR_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)

A        PLASMA_Complex32_t* (IN)
         Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgeqrf.

B        PLASMA_Complex32_t* (OUT)
         On exit, the M-by-N matrix Q.

          = 0: successful exit

int PLASMA_cunmlq(PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CUNMLQ(INTEGER side, INTEGER trans, INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

side     PLASMA_enum (IN)
         Intended usage:
         = PlasmaLeft:  apply Q or Q**H from the left;
         = PlasmaRight: apply Q or Q**H from the right.
         Currently only PlasmaLeft is supported.

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   no transpose, apply Q;
         = PlasmaConjTrans: conjugate transpose, apply Q**H.
         Currently only PlasmaConjTrans is supported.

M        int (IN)
         The number of rows of the matrix C. M >= 0.

N        int (IN)
         The number of columns of the matrix C. N >= 0.

K        int (IN)
         The number of rows of elementary tile reflectors whose product defines the matrix Q.
         M >= K >= 0.

A        PLASMA_Complex32_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,K).

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgelqf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix B.
         On exit, B is overwritten by Q*B or Q**H*B.

LDB      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).

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

int PLASMA_cunmlq_Tile(PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)

PLASMA_CUNMLQ_TILE(INTEGER side, INTEGER trans, INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)

side     PLASMA_enum (IN)
         Intended usage:
         = PlasmaLeft:  apply Q or Q**H from the left;
         = PlasmaRight: apply Q or Q**H from the right.
         Currently only PlasmaLeft is supported.

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   no transpose, apply Q;
         = PlasmaConjTrans: conjugate transpose, apply Q**H.
         Currently only PlasmaConjTrans is supported.

A        PLASMA_Complex32_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgelqf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix B.
         On exit, B is overwritten by Q*B or Q**H*B.

          = 0: successful exit

int PLASMA_cunmqr(PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)

PLASMA_CUNMQR(INTEGER side, INTEGER trans, INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)

side     PLASMA_enum (IN)
         Intended usage:
         = PlasmaLeft:  apply Q or Q**H from the left;
         = PlasmaRight: apply Q or Q**H from the right.
         Currently only PlasmaLeft is supported.

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   no transpose, apply Q;
         = PlasmaConjTrans: conjugate transpose, apply Q**H.
         Currently only PlasmaConjTrans is supported.

M        int (IN)
         The number of rows of the matrix C. M >= 0.

N        int (IN)
         The number of columns of the matrix C. N >= 0.

K        int (IN)
         The number of columns of elementary tile reflectors whose product defines the matrix Q.
         M >= K >= 0.

A        PLASMA_Complex32_t* (IN)
         Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M);

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgeqrf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix B.
         On exit, B is overwritten by Q*B or Q**H*B.

LDB      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).

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

int PLASMA_cunmqr_Tile(PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)

PLASMA_CUNMQR_TILE(INTEGER side, INTEGER trans, INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)

side     PLASMA_enum (IN)
         Intended usage:
         = PlasmaLeft:  apply Q or Q**H from the left;
         = PlasmaRight: apply Q or Q**H from the right.
         Currently only PlasmaLeft is supported.

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   no transpose, apply Q;
         = PlasmaConjTrans: conjugate transpose, apply Q**H.
         Currently only PlasmaConjTrans is supported.

A        PLASMA_Complex32_t* (IN)
         Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.

T        PLASMA_Complex32_t* (IN)
         Auxiliary factorization data, computed by PLASMA_cgeqrf.

B        PLASMA_Complex32_t* (INOUT)
         On entry, the M-by-N matrix B.
         On exit, B is overwritten by Q*B or Q**H*B.

          = 0: successful exit

int PLASMA_Desc_Create(PLASMA_desc **desc, void *mat, PLASMA_enum dtyp, int mb, int nb, int bsiz, int lm, int ln, int i, int j, int m, int n)

PLASMA_DESC_CREATE(INTEGER*4 desc, INTEGER mat, INTEGER dtyp, INTEGER mb, INTEGER nb, INTEGER bsiz, INTEGER lm, INTEGER ln, INTEGER i, INTEGER j, INTEGER m, INTEGER n, INTEGER INFO)

desc     PLASMA_desc** (OUT)
         On exit, descriptor of the matrix.

mat      void* (IN)
         Memory location of the matrix.

dtyp     PLASMA_enum (IN)
         Data type of the matrix:
         = PlasmaRealFloat:     single precision real (S),
         = PlasmaRealDouble:    double precision real (D),
         = PlasmaComplexFloat:  single precision complex (C),
         = PlasmaComplexDouble: double precision complex (Z).

mb       int (IN)
         Number of rows in a tile.

nb       int (IN)
         Number of columns in a tile.

bsiz     int (IN)
         Nize in elements including padding.

lm       int (IN)
         Number of rows of the entire matrix.

ln       int (IN)
         Number of columns of the entire matrix.

i        int (IN)
         Row index to the beginning of the submatrix.

j        int (IN)
         Column indes to the beginning of the submatrix.

m        int (IN)
         Number of rows of the submatrix.

n        int (IN)
         Number of columns of the submatrix.

          = PLASMA_SUCCESS: successful exit

int PLASMA_Desc_Destroy(PLASMA_desc **desc)

PLASMA_DESC_DESTROY(INTEGER*4 desc, INTEGER INFO)

desc     PLASMA_desc** (IN)
         Matrix descriptor.

          = PLASMA_SUCCESS: successful exit

int PLASMA_dgelqf(int M, int N, double *A, int LDA, double *T)

PLASMA_DGELQF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= 0.

A        double* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N)
         lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the
         diagonal represent the unitary matrix Q as a product of elementary reflectors, stored
         by tiles.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        double* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_dgelqs to solve the system
         of equations.

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

int PLASMA_dgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_DGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)

A        double* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N)
         lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the
         diagonal represent the unitary matrix Q as a product of elementary reflectors, stored
         by tiles.

T        double* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_dgelqs to solve the system
         of equations.

          = 0: successful exit

int PLASMA_dgelqs(int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)

PLASMA_DGELQS(INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= M >= 0.

NRHS     int (IN)
         The number of columns of B. NRHS >= 0.

A        double* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_dgelqf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= M.

T        double* (IN)
         Auxiliary factorization data, computed by PLASMA_dgelqf.

B        double* (INOUT)
         On entry, the M-by-NRHS right hand side matrix B.
         On exit, the N-by-NRHS solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= N.

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

int PLASMA_dgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)

PLASMA_DGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)

A        double* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_dgelqf.

T        double* (IN)
         Auxiliary factorization data, computed by PLASMA_dgelqf.

B        double* (INOUT)
         On entry, the M-by-NRHS right hand side matrix B.
         On exit, the N-by-NRHS solution matrix X.

          = 0: successful exit

int PLASMA_dgels(PLASMA_enum trans, int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)

PLASMA_DGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   the linear system involves A;
         = PlasmaTrans: the linear system involves A**T.
         Currently only PlasmaNoTrans is supported.

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= 0.

NRHS     int (IN)
         The number of right hand sides, i.e., the number of columns of the matrices B and X.
         NRHS >= 0.

A        double* (INOUT)
         On entry, the M-by-N matrix A.
         On exit,
         if M >= N, A is overwritten by details of its QR factorization as returned by
                    PLASMA_dgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_dgelqf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        double* (OUT)
         On exit, auxiliary factorization data.

B        double* (INOUT)
         On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise;
         On exit, if return value = 0, B is overwritten by the solution vectors, stored
         columnwise:
         if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual
         sum of squares for the solution in each column is given by the sum of squares of the
         modulus of elements N+1 to M in that column;
         if M < N, rows 1 to N of B contain the minimum norm solution vectors;

LDB      int (IN)
         The leading dimension of the array B. LDB >= MAX(1,M,N).

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

int PLASMA_dgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)

PLASMA_DGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)

trans    PLASMA_enum (IN)
         Intended usage:
         = PlasmaNoTrans:   the linear system involves A;
         = PlasmaTrans: the linear system involves A**T.
         Currently only PlasmaNoTrans is supported.

A        double* (INOUT)
         On entry, the M-by-N matrix A.
         On exit,
         if M >= N, A is overwritten by details of its QR factorization as returned by
                    PLASMA_dgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_dgelqf.

T        double* (OUT)
         On exit, auxiliary factorization data.

B        double* (INOUT)
         On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise;
         On exit, if return value = 0, B is overwritten by the solution vectors, stored
         columnwise:
         if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual
         sum of squares for the solution in each column is given by the sum of squares of the
         modulus of elements N+1 to M in that column;
         if M < N, rows 1 to N of B contain the minimum norm solution vectors;

          = 0: successful exit

int PLASMA_dgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, double alpha, double *A, int LDA, double *B, int LDB, double beta, double *C, int LDC)

PLASMA_DGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, DOUBLE PRECISION alpha, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, DOUBLE PRECISION beta, DOUBLE PRECISION C, INTEGER LDC, INTEGER INFO)

transA   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaTrans: A is conjugate transposed.
         Currently only PlasmaNoTrans is supported

transB   PLASMA_enum (IN)
         Specifies whether the matrix B is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   B is transposed;
         = PlasmaTrans:     B is not transposed;
         = PlasmaTrans: B is conjugate transposed.
         Currently only PlasmaNoTrans is supported

M        int (IN)
         M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0.

N        int (IN)
         N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0.

K        int (IN)
         K specifies the number of columns of the matrix op( A ) and the number of rows of
         the matrix op( B ). K >= 0.

alpha    double (IN)
         alpha specifies the scalar alpha

A        double* (IN)
         A is a LDA-by-ka matrix, where ka is K when  transA = PlasmaNoTrans,
         and is  M  otherwise.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

B        double* (IN)
         B is a LDB-by-kb matrix, where kb is N when  transB = PlasmaNoTrans,
         and is  K  otherwise.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).

beta     double (IN)
         beta specifies the scalar beta

C        double* (INOUT)
         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      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).

          = 0: successful exit

int PLASMA_dgeqrf(int M, int N, double *A, int LDA, double *T)

PLASMA_DGEQRF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A.  N >= 0.

A        double* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N
         upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the
         diagonal represent the unitary matrix Q as a product of elementary reflectors stored
         by tiles.

LDA      int (IN)
         The leading dimension of the array A. LDA >= max(1,M).

T        double* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_dgeqrs to solve the system
         of equations.

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

int PLASMA_dgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_DGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)

A        double* (INOUT)
         On entry, the M-by-N matrix A.
         On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N
         upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the
         diagonal represent the unitary matrix Q as a product of elementary reflectors stored
         by tiles.

T        double* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_dgeqrs to solve the system
         of equations.

          = 0: successful exit

int PLASMA_dgeqrs(int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)

PLASMA_DGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)

M        int (IN)
         The number of rows of the matrix A. M >= 0.

N        int (IN)
         The number of columns of the matrix A. N >= M >= 0.

NRHS     int (IN)
         The number of columns of B. NRHS >= 0.

A        double* (INOUT)
         Details of the QR factorization of the original matrix A as returned by PLASMA_dgeqrf.

LDA      int (IN)
         The leading dimension of the array A. LDA >= M.

T        double* (IN)
         Auxiliary factorization data, computed by PLASMA_dgeqrf.

B        double* (INOUT)
         On entry, the m-by-nrhs right hand side matrix B.
         On exit, the n-by-nrhs solution matrix X.

LDB      int (IN)
         The leading dimension of the array B. LDB >= max(1,N).