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)

void PLASMA_DGELQF(int *M, int *N, double *A, int *LDA, double **T, int *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)

void PLASMA_DGELQF_TILE(long long int *A, long long int *T,int *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)

void PLASMA_DGELQS(int *M, int *N, int *NRHS, double *A, int *LDA, double **T, double *B, int *LDB, int *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)

void PLASMA_DGELQS_TILE(long long int *A, long long int *B, long long int *T, int *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)

void PLASMA_DGELS(PLASMA_enum *trans, int *M, int *N, int *NRHS, double *A, int *LDA, double **T, double *B, int *LDB, int *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)

void PLASMA_DGELS_TILE(PLASMA_enum *trans, long long int *A, long long int *B, long long int *T, int *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)

void PLASMA_DGEQRF(int *M, int *N, double *A, int *LDA, double **T, int *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)

void PLASMA_DGEQRF_TILE(long long int *A, long long int *T, int *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)

void PLASMA_DGEQRS(int *M, int *N, int *NRHS, double *A, int *LDA, double **T, double *B, int *LDB, int *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)

void PLASMA_DGEQRS_TILE(long long int *A, long long int *B, long long int *T, int *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)

void PLASMA_DGESV(int *N, int *NRHS, double *A, int *LDA, double **LH, int **IPIVH, double *B, int *LDB, int *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)

void PLASMA_DGESV_TILE(long long int *A, long long int *L, int **IPIVH, long long int *B, int *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)

void PLASMA_DGETRF(int *M, int *N, double *A, int *LDA, double **LH, int **IPIVH, int *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)

void PLASMA_DGETRF_TILE(long long int *A, long long int *L, int **IPIVH, int *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)

void PLASMA_DGETRS(PLASMA_enum *uplo, int *N, int *NRHS, double *A, int *LDA, double **LH, int **IPIVH, double *B, int *LDB, int *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)

void PLASMA_DGETRS_TILE(long long int *A, long long int *L, int **IPIVH, long long int *B, int *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).

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

void PLASMA_DPOSV(PLASMA_enum *uplo, int *N, int *NRHS, double *A, int *LDA, double *B, int *LDB, int *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        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.

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.

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

void PLASMA_DPOSV_TILE(PLASMA_enum *uplo, long long int *A, long long int *B, int *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        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).

          = 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_dpotrf(PLASMA_enum uplo, int N, double *A, int LDA)

void PLASMA_DPOTRF(PLASMA_enum *uplo, int *N, double *A, int *LDA, int *INFO)

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

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.

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

void PLASMA_DPOTRF_TILE(PLASMA_enum *uplo, long long int *A, int *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        double* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T,
         computed by PLASMA_dpotrf.

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

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

int PLASMA_dpotrs(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)

void PLASMA_DPOTRS(PLASMA_enum *uplo, int *N, int *NRHS, double *A, int *LDA, double *B, int* LDB, int * INFO)

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

A        double* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T,
         computed by PLASMA_dpotrf.

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.

          = 0: successful exit

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

void PLASMA_DPOTRS_TILE(PLASMA_enum *uplo, long long int *A, long long int *B, int *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* (IN)
         The N-by-NRHS matrix of right hand side matrix B.

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

X        double* (OUT)
         If return value = 0, the N-by-NRHS solution matrix X.

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

ITER     int* (OUT)is the number of the current iteration in the iterative refinement process

          = 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_dsgesv(int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB, double *X, int LDX, int *ITER)

void PLASMA_DSGESV(int *N, int *NRHS, double *A, int *LDA, double **LH, int **IPIVH, double *B, int *LDB, double *X, int *LDX, int *ITER, int *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* (IN)
         The N-by-NRHS matrix of right hand side matrix B.

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

X        double* (OUT)
         If return value = 0, the N-by-NRHS solution matrix X.

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

ITER     int* (OUT)is the number of the current iteration in the iterative refinement process

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

void PLASMA_DSGESV_TILE(long long int *A, long long int *L, int **IPIVH, long long int *B, long long *X, int *ITER, int *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;
         = PlasmaTrans: 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        double* (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        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      double* (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_dtrsm(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double *A, int LDA, double *B, int LDB)

void PLASMA_DTRSM(PLASMA_enum *side, PLASMA_enum *uplo, PLASMA_enum *transA, PLASMA_enum *diag, int *N, int *NRHS, double *A, int *LDA, double *B, int *LDB, int *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;
         = PlasmaTrans: 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        double* (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        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.

          = 0: successful exit

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

void PLASMA_DTRSM_TILE(PLASMA_enum *side, PLASMA_enum *uplo, PLASMA_enum *transA, PLASMA_enum *diag, long long int *A, long long int *B, int *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        double* (IN)
         The tile factor L 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 right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

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

void PLASMA_DTRSMPL(int *N, int *NRHS, double *A, int *LDA, double **LH, int **IPIVH, double *B, int *LDB, int *INFO)

A        double* (IN)
         The tile factor L 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 right hand side matrix B.
         On exit, if return value = 0, the N-by-NRHS solution matrix X.

          = 0: successful exit

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

void PLASMA_DTRSMPL_TILE(long long int *A, long long int *L, int **IPIVH, long long int *B, int *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        float* (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        float* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_sgelqs to solve the system
         of equations.

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

int PLASMA_sgelqf(int M, int N, float *A, int LDA, float *T)

void PLASMA_SGELQF(int *M, int *N, float *A, int *LDA, float **T, int *INFO)

A        float* (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        float* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_sgelqs to solve the system
         of equations.

          = 0: successful exit

int PLASMA_sgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)

void PLASMA_SGELQF_TILE(long long int *A, long long int *T,int *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        float* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf.

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

T        float* (IN)
         Auxiliary factorization data, computed by PLASMA_sgelqf.

B        float* (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_sgelqs(int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)

void PLASMA_SGELQS(int *M, int *N, int *NRHS, float *A, int *LDA, float **T, float *B, int *LDB, int *INFO)

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

T        float* (IN)
         Auxiliary factorization data, computed by PLASMA_sgelqf.

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

void PLASMA_SGELQS_TILE(long long int *A, long long int *B, long long int *T, int *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        float* (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_sgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_sgelqf.

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

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

B        float* (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_sgels(PLASMA_enum trans, int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)

void PLASMA_SGELS(PLASMA_enum *trans, int *M, int *N, int *NRHS, float *A, int *LDA, float **T, float *B, int *LDB, int *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        float* (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_sgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_sgelqf.

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

B        float* (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_sgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)

void PLASMA_SGELS_TILE(PLASMA_enum *trans, long long int *A, long long int *B, long long int *T, int *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        float* (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        float* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_sgeqrs to solve the system
         of equations.

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

int PLASMA_sgeqrf(int M, int N, float *A, int LDA, float *T)

void PLASMA_SGEQRF(int *M, int *N, float *A, int *LDA, float **T, int *INFO)

A        float* (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        float* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_sgeqrs to solve the system
         of equations.

          = 0: successful exit

int PLASMA_sgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)

void PLASMA_SGEQRF_TILE(long long int *A, long long int *T, int *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        float* (INOUT)
         Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf.

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

T        float* (IN)
         Auxiliary factorization data, computed by PLASMA_sgeqrf.

B        float* (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_sgeqrs(int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)

void PLASMA_SGEQRS(int *M, int *N, int *NRHS, float *A, int *LDA, float **T, float *B, int *LDB, int *INFO)

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

T        float* (IN)
         Auxiliary factorization data, computed by PLASMA_sgeqrf.

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

void PLASMA_SGEQRS_TILE(long long int *A, long long int *B, long long int *T, int *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        float* (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        float* (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        float* (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_sgesv(int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)

void PLASMA_SGESV(int *N, int *NRHS, float *A, int *LDA, float **LH, int **IPIVH, float *B, int *LDB, int *INFO)

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

void PLASMA_SGESV_TILE(long long int *A, long long int *L, int **IPIVH, long long int *B, int *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        float* (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        float* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_sgetrs 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_sgetrf(int M, int N, float *A, int LDA, float *L, int *IPIV)

void PLASMA_SGETRF(int *M, int *N, float *A, int *LDA, float **LH, int **IPIVH, int *INFO)

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

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

void PLASMA_SGETRF_TILE(long long int *A, long long int *L, int **IPIVH, int *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        float* (IN)
         The tile factors L and U from the factorization, computed by PLASMA_sgetrf.

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

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

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

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

void PLASMA_SGETRS(PLASMA_enum *uplo, int *N, int *NRHS, float *A, int *LDA, float **LH, int **IPIVH, float *B, int *LDB, int *INFO)

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

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

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

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

void PLASMA_SGETRS_TILE(long long int *A, long long int *L, int **IPIVH, long long int *B, int *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        float* (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        float* (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_sposv(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *B, int LDB)

void PLASMA_SPOSV(PLASMA_enum *uplo, int *N, int *NRHS, float *A, int *LDA, float *B, int *LDB, int *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        float* (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.

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

void PLASMA_SPOSV_TILE(PLASMA_enum *uplo, long long int *A, long long int *B, int *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        float* (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).

          = 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_spotrf(PLASMA_enum uplo, int N, float *A, int LDA)

void PLASMA_SPOTRF(PLASMA_enum *uplo, int *N, float *A, int *LDA, int *INFO)

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

A        float* (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.

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

void PLASMA_SPOTRF_TILE(PLASMA_enum *uplo, long long int *A, int *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        float* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T,
         computed by PLASMA_spotrf.

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

B        float* (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_spotrs(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *B, int LDB)

void PLASMA_SPOTRS(PLASMA_enum *uplo, int *N, int *NRHS, float *A, int *LDA, float *B, int* LDB, int * INFO)

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

A        float* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T,
         computed by PLASMA_spotrf.

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

void PLASMA_SPOTRS_TILE(PLASMA_enum *uplo, long long int *A, long long int *B, int *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;
         = PlasmaTrans: 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        float* (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        float* (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      float* (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_strsm(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, float *A, int LDA, float *B, int LDB)

void PLASMA_STRSM(PLASMA_enum *side, PLASMA_enum *uplo, PLASMA_enum *transA, PLASMA_enum *diag, int *N, int *NRHS, float *A, int *LDA, float *B, int *LDB, int *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;
         = PlasmaTrans: 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        float* (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        float* (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_strsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)

void PLASMA_STRSM_TILE(PLASMA_enum *side, PLASMA_enum *uplo, PLASMA_enum *transA, PLASMA_enum *diag, long long int *A, long long int *B, int *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        float* (IN)
         The tile factor L from the factorization, computed by PLASMA_sgetrf.

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

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

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

B        float* (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      float* (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_strsmpl(int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)

void PLASMA_STRSMPL(int *N, int *NRHS, float *A, int *LDA, float **LH, int **IPIVH, float *B, int *LDB, int *INFO)

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

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

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

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