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(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)

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_cgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_CGELQF_TILE(INTEGER*4 A, INTEGER*4 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 >= 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(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)

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_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)

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

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_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)

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(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)

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_cgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_CGEQRF_TILE(INTEGER*4 A, INTEGER*4 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 >= 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(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)

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_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)

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(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)

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_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)

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(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)

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_cgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)

PLASMA_CGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, 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(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)

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_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)

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

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_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)
         = 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(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.

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

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

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_cpotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)

PLASMA_CPOTRS_TILE(INTEGER uplo, 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.

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(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)

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(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)

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_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)

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_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)

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(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)

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_cunglq_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)

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(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)

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_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)

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

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

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

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_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)

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(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)

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_dgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_DGELQF_TILE(INTEGER*4 A, INTEGER*4 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 >= 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(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)

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_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)

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

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_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)

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(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)

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_dgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)

PLASMA_DGEQRF_TILE(INTEGER*4 A, INTEGER*4 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 >= 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).

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

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)

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

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.

          = 0: successful exit

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

PLASMA_DGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, 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        double* (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        double* (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        double* (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_dgesv(int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)

PLASMA_DGESV(INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)

A        double* (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        double* (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        double* (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_dgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)

PLASMA_DGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, 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 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        double* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_dgetrs 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_dgetrf(int M, int N, double *A, int LDA, double *L, int *IPIV)

PLASMA_DGETRF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)

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

L        double* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_dgetrs 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_dgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)

PLASMA_DGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, 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)
         = PlasmaTrans: A**T * 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        double* (IN)
         The tile factors L and U from the factorization, computed by PLASMA_dgetrf.

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

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

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

B        double* (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_dgetrs(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)

PLASMA_DGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)

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

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

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

B        double* (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_dgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)

PLASMA_DGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, 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.

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        double* (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**T*U or A = L*L**T.

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

B        double* (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).