PLASMA_Version

Purpose

PLASMA_Version - Reports PLASMA version number.

C Bindings
int PLASMA_Version(int *ver_major, int *ver_minor, int *ver_micro)
Fortran Bindings
PLASMA_VERSION(INTEGER VER_MAJOR, INTEGER VER_MINOR, INTEGER VER_MICRO, INTEGER INFO)
Arguments
ver_major    int (OUT)
             PLASMA major version number.

ver_minor    int (OUT)
             PLASMA minor version number.

ver_micro    int (OUT)
             PLASMA micro version number.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Version

PLASMA_cgelqf

Purpose

PLASMA_cgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.

C Bindings
int PLASMA_cgelqf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T)
Fortran Bindings
PLASMA_CGELQF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cgelqf

PLASMA_cgelqf_Tile

Purpose

PLASMA_cgelqf_Tile - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_CGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgelqf_Tile

PLASMA_cgelqs

Purpose

PLASMA_cgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_cgelqf.

C Bindings
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)
Fortran Bindings
PLASMA_CGELQS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cgelqs

PLASMA_cgelqs_Tile

Purpose

PLASMA_cgelqs_Tile - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_cgelqf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_CGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgelqs_Tile

PLASMA_cgels

Purpose

PLASMA_cgels - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

C Bindings
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)
Fortran Bindings
PLASMA_CGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cgels

PLASMA_cgels_Tile

Purpose

PLASMA_cgels_Tile - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_CGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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;
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgels_Tile

PLASMA_cgemm

Purpose

PLASMA_cgemm - Performs one of the matrix-matrix operations

C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

op( X ) = X  or op( X ) = X'

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

C Bindings
int PLASMA_cgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
Fortran Bindings
PLASMA_CGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, COMPLEX alpha, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, COMPLEX beta, COMPLEX C, INTEGER LDC, INTEGER INFO)
Arguments
transA   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaConjTrans: A is conjugate transposed.
         Currently only PlasmaNoTrans is supported

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

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

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

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

alpha    PLASMA_Complex32_t (IN)
         alpha specifies the scalar alpha

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

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

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

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

beta     PLASMA_Complex32_t (IN)
         beta specifies the scalar beta

C        PLASMA_Complex32_t* (INOUT)
         C is a LDC-by-N matrix.
         On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )

LDC      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgemm

PLASMA_cgeqrf

Purpose

PLASMA_cgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.

C Bindings
int PLASMA_cgeqrf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T)
Fortran Bindings
PLASMA_CGEQRF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cgeqrf

PLASMA_cgeqrf_Tile

Purpose

PLASMA_cgeqrf_Tile - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_CGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgeqrf_Tile

PLASMA_cgeqrs

Purpose

PLASMA_cgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_cgeqrf.

C Bindings
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)
Fortran Bindings
PLASMA_CGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cgeqrs

PLASMA_cgeqrs_Tile

Purpose

PLASMA_cgeqrs_Tile - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_cgeqrf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_CGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgeqrs_Tile

PLASMA_cgesv

Purpose

PLASMA_cgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
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)
Fortran Bindings
PLASMA_CGESV(INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cgesv

PLASMA_cgesv_Tile

Purpose

PLASMA_cgesv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_CGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cgesv_Tile

PLASMA_cgetrf

Purpose

PLASMA_cgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

C Bindings
int PLASMA_cgetrf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV)
Fortran Bindings
PLASMA_CGETRF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cgetrf

PLASMA_cgetrf_Tile

Purpose

PLASMA_cgetrf_Tile - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
Fortran Bindings
PLASMA_CGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cgetrf_Tile

PLASMA_cgetrs

Purpose

PLASMA_cgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_cgetrf.

C Bindings
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)
Fortran Bindings
PLASMA_CGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cgetrs

PLASMA_cgetrs_Tile

Purpose

PLASMA_cgetrs_Tile - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_cgetrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_CGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cgetrs_Tile

PLASMA_Enable

Purpose

PLASMA_Enable - Enable PLASMA feature.

C Bindings
int PLASMA_Enable(PLASMA_enum lever)
Fortran Bindings
PLASMA_ENABLE(INTEGER lever, INTEGER INFO)
Arguments
lever    PLASMA_enum (IN)
         Feature to be enabled:
         = PLASMA_WARNINGS:   printing of warning messages,
         = PLASMA_ERRORS:     printing of error messages,
         = PLASMA_AUTOTUNING: autotuning for tile size and inner block size.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Enable

PLASMA_Disable

Purpose

PLASMA_Disable - Disable PLASMA feature.

C Bindings
int PLASMA_Disable(PLASMA_enum lever)
Fortran Bindings
PLASMA_DISABLE(INTEGER lever, INTEGER INFO)
Arguments
lever    PLASMA_enum (IN)
         Feature to be disabled:
         = PLASMA_WARNINGS:   printing of warning messages,
         = PLASMA_ERRORS:     printing of error messages,
         = PLASMA_AUTOTUNING: autotuning for tile size and inner block size.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Disable

PLASMA_Set

Purpose

PLASMA_Set - Set PLASMA parameter

C Bindings
int PLASMA_Set(PLASMA_enum param, int value)
Fortran Bindings
PLASMA_SET(INTEGER param, INTEGER value, INTEGER INFO)
Arguments
param    PLASMA_enum (IN)
         PLASMA parameter:
         = PLASMA_TILE_SIZE:        size matrix tile,
         = PLASMA_INNER_BLOCK_SIZE: size of tile inner block.

value    int (IN)
         Value of the parameter.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Set

PLASMA_Get

Purpose

PLASMA_Get - Get value of PLASMA parameter

C Bindings
int PLASMA_Get(PLASMA_enum param, int *value)
Fortran Bindings
PLASMA_GET(INTEGER param, INTEGER value, INTEGER INFO)
Arguments
param    PLASMA_enum (IN)
         PLASMA parameter:
         = PLASMA_TILE_SIZE:        size matrix tile,
         = PLASMA_INNER_BLOCK_SIZE: size of tile inner block.

value    int* (OUT)
         Value of the parameter.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Get

PLASMA_Init

Purpose

PLASMA_Init - Initialize PLASMA.

C Bindings
int PLASMA_Init(int cores)
Fortran Bindings
PLASMA_INIT(INTEGER CORES, INTEGER INFO)
Arguments
cores    int (IN)
         Number of cores to use (threads to launch)
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Init

PLASMA_Finalize

Purpose

PLASMA_Finalize - Finalize PLASMA.

C Bindings
int PLASMA_Finalize()
Fortran Bindings
PLASMA_FINALIZE(INTEGER INFO)
Online Browsing

Dive into PLASMA_Finalize

PLASMA_cposv

Purpose

PLASMA_cposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_cposv(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
Fortran Bindings
PLASMA_CPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cposv

PLASMA_cposv_Tile

Purpose

PLASMA_cposv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_CPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cposv_Tile

PLASMA_cpotrf

Purpose

PLASMA_cpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix.

C Bindings
int PLASMA_cpotrf(PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA)
Fortran Bindings
PLASMA_CPOTRF(INTEGER uplo, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cpotrf

PLASMA_cpotrf_Tile

Purpose

PLASMA_cpotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
Fortran Bindings
PLASMA_CPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_cpotrf_Tile

PLASMA_cpotrs

Purpose

PLASMA_cpotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UH*U or A = L*LH computed by PLASMA_cpotrf.

C Bindings
int PLASMA_cpotrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
Fortran Bindings
PLASMA_CPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER  LDB, INTEGER  INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cpotrs

PLASMA_cpotrs_Tile

Purpose

PLASMA_cpotrs_Tile - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UH*U or A = L*LH computed by PLASMA_cpotrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cpotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_CPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cpotrs_Tile

PLASMA_ctrsm

Purpose

PLASMA_ctrsm - Computes triangular solve A*X = B or X*A = B

C Bindings
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)
Fortran Bindings
PLASMA_CTRSM(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_ctrsm

PLASMA_ctrsm_Tile

Purpose

PLASMA_ctrsm_Tile - Computes triangular solve A*X = B or X*A = B All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_ctrsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_CTRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_ctrsm_Tile

PLASMA_ctrsmpl

Purpose

PLASMA_ctrsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.

C Bindings
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)
Fortran Bindings
PLASMA_CTRSMPL(INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_ctrsmpl

PLASMA_ctrsmpl_Tile

Purpose

PLASMA_ctrsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_ctrsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_CTRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_ctrsmpl_Tile

PLASMA_cunglq

Purpose

PLASMA_cunglq - Generates an M-by-N matrix Q with orthonormal rows, which is defined as the first M rows of a product of the elementary reflectors returned by PLASMA_cgelqf.

C Bindings
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)
Fortran Bindings
PLASMA_CUNGLQ(INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cunglq

PLASMA_cunglq_Tile

Purpose

PLASMA_cunglq_Tile - Generates an M-by-N matrix Q with orthonormal rows, which is defined as the first M rows of a product of the elementary reflectors returned by PLASMA_cgelqf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cunglq_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
Fortran Bindings
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cunglq_Tile

PLASMA_cungqr

Purpose

PLASMA_cungqr - Generates an M-by-N matrix Q with orthonormal columns, which is defined as the first N columns of a product of the elementary reflectors returned by PLASMA_cgeqrf.

C Bindings
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)
Fortran Bindings
PLASMA_CUNGQR(INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cungqr

PLASMA_cungqr_Tile

Purpose

PLASMA_cungqr_Tile - Generates an M-by-N matrix Q with orthonormal columns, which is defined as the first N columns of a product of the elementary reflectors returned by PLASMA_cgeqrf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cungqr_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
Fortran Bindings
PLASMA_CUNGQR_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cungqr_Tile

PLASMA_cunmlq

Purpose

PLASMA_cunmlq - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal matrix (unitary in the complex case) defined as the product of elementary reflectors returned by PLASMA_cgelqf. Q is of order M.

C Bindings
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)
Fortran Bindings
PLASMA_CUNMLQ(INTEGER side, INTEGER trans, INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cunmlq

PLASMA_cunmlq_Tile

Purpose

PLASMA_cunmlq_Tile - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal matrix (unitary in the complex case) defined as the product of elementary reflectors returned by PLASMA_cgelqf_Tile Q is of order M. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cunmlq_Tile(PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
Fortran Bindings
PLASMA_CUNMLQ_TILE(INTEGER side, INTEGER trans, INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cunmlq_Tile

PLASMA_cunmqr

Purpose

PLASMA_cunmqr - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal matrix (unitary in the complex case) defined as the product of elementary reflectors returned by PLASMA_cgeqrf. Q is of order M.

C Bindings
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)
Fortran Bindings
PLASMA_CUNMQR(INTEGER side, INTEGER trans, INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_cunmqr

PLASMA_cunmqr_Tile

Purpose

PLASMA_cunmqr_Tile - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal matrix (unitary in the complex case) defined as the product of elementary reflectors returned by PLASMA_cgeqrf_Tile Q is of order M. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_cunmqr_Tile(PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
Fortran Bindings
PLASMA_CUNMQR_TILE(INTEGER side, INTEGER trans, INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_cunmqr_Tile

PLASMA_Desc_Create

Purpose

PLASMA_Desc_Create - Create matrix descriptor.

C Bindings
int PLASMA_Desc_Create(PLASMA_desc **desc, void *mat, PLASMA_enum dtyp, int mb, int nb, int bsiz, int lm, int ln, int i, int j, int m, int n)
Fortran Bindings
PLASMA_DESC_CREATE(INTEGER*4 desc, INTEGER mat, INTEGER dtyp, INTEGER mb, INTEGER nb, INTEGER bsiz, INTEGER lm, INTEGER ln, INTEGER i, INTEGER j, INTEGER m, INTEGER n, INTEGER INFO)
Arguments
desc     PLASMA_desc** (OUT)
         On exit, descriptor of the matrix.

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

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

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

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

bsiz     int (IN)
         Nize in elements including padding.

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

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

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

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

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

n        int (IN)
         Number of columns of the submatrix.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Desc_Create

PLASMA_Desc_Destroy

Purpose

PLASMA_Desc_Destroy - Destroys matrix descriptor.

C Bindings
int PLASMA_Desc_Destroy(PLASMA_desc **desc)
Fortran Bindings
PLASMA_DESC_DESTROY(INTEGER*4 desc, INTEGER INFO)
Arguments
desc     PLASMA_desc** (IN)
         Matrix descriptor.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Desc_Destroy

PLASMA_dgelqf

Purpose

PLASMA_dgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.

C Bindings
int PLASMA_dgelqf(int M, int N, double *A, int LDA, double *T)
Fortran Bindings
PLASMA_DGELQF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dgelqf

PLASMA_dgelqf_Tile

Purpose

PLASMA_dgelqf_Tile - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_DGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgelqf_Tile

PLASMA_dgelqs

Purpose

PLASMA_dgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_dgelqf.

C Bindings
int PLASMA_dgelqs(int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)
Fortran Bindings
PLASMA_DGELQS(INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dgelqs

PLASMA_dgelqs_Tile

Purpose

PLASMA_dgelqs_Tile - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_dgelqf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_DGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgelqs_Tile

PLASMA_dgels

Purpose

PLASMA_dgels - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

C Bindings
int PLASMA_dgels(PLASMA_enum trans, int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)
Fortran Bindings
PLASMA_DGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dgels

PLASMA_dgels_Tile

Purpose

PLASMA_dgels_Tile - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_DGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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;
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgels_Tile

PLASMA_dgemm

Purpose

PLASMA_dgemm - Performs one of the matrix-matrix operations

C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

op( X ) = X  or op( X ) = X'

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

C Bindings
int PLASMA_dgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, double alpha, double *A, int LDA, double *B, int LDB, double beta, double *C, int LDC)
Fortran Bindings
PLASMA_DGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, DOUBLE PRECISION alpha, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, DOUBLE PRECISION beta, DOUBLE PRECISION C, INTEGER LDC, INTEGER INFO)
Arguments
transA   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaTrans: A is conjugate transposed.
         Currently only PlasmaNoTrans is supported

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

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

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

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

alpha    double (IN)
         alpha specifies the scalar alpha

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

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

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

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

beta     double (IN)
         beta specifies the scalar beta

C        double* (INOUT)
         C is a LDC-by-N matrix.
         On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )

LDC      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgemm

PLASMA_dgeqrf

Purpose

PLASMA_dgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.

C Bindings
int PLASMA_dgeqrf(int M, int N, double *A, int LDA, double *T)
Fortran Bindings
PLASMA_DGEQRF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dgeqrf

PLASMA_dgeqrf_Tile

Purpose

PLASMA_dgeqrf_Tile - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_DGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgeqrf_Tile

PLASMA_dgeqrs

Purpose

PLASMA_dgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_dgeqrf.

C Bindings
int PLASMA_dgeqrs(int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)
Fortran Bindings
PLASMA_DGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dgeqrs

PLASMA_dgeqrs_Tile

Purpose

PLASMA_dgeqrs_Tile - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_dgeqrf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_DGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgeqrs_Tile

PLASMA_dgesv

Purpose

PLASMA_dgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_dgesv(int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)
Fortran Bindings
PLASMA_DGESV(INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dgesv

PLASMA_dgesv_Tile

Purpose

PLASMA_dgesv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_DGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dgesv_Tile

PLASMA_dgetrf

Purpose

PLASMA_dgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

C Bindings
int PLASMA_dgetrf(int M, int N, double *A, int LDA, double *L, int *IPIV)
Fortran Bindings
PLASMA_DGETRF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dgetrf

PLASMA_dgetrf_Tile

Purpose

PLASMA_dgetrf_Tile - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
Fortran Bindings
PLASMA_DGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dgetrf_Tile

PLASMA_dgetrs

Purpose

PLASMA_dgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_dgetrf.

C Bindings
int PLASMA_dgetrs(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)
Fortran Bindings
PLASMA_DGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dgetrs

PLASMA_dgetrs_Tile

Purpose

PLASMA_dgetrs_Tile - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_dgetrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_DGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dgetrs_Tile

PLASMA_dposv

Purpose

PLASMA_dposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_dposv(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)
Fortran Bindings
PLASMA_DPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dposv

PLASMA_dposv_Tile

Purpose

PLASMA_dposv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_DPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dposv_Tile

PLASMA_dpotrf

Purpose

PLASMA_dpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix.

C Bindings
int PLASMA_dpotrf(PLASMA_enum uplo, int N, double *A, int LDA)
Fortran Bindings
PLASMA_DPOTRF(INTEGER uplo, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dpotrf

PLASMA_dpotrf_Tile

Purpose

PLASMA_dpotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
Fortran Bindings
PLASMA_DPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dpotrf_Tile

PLASMA_dpotrs

Purpose

PLASMA_dpotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by PLASMA_dpotrf.

C Bindings
int PLASMA_dpotrs(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)
Fortran Bindings
PLASMA_DPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER  LDB, INTEGER  INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dpotrs

PLASMA_dpotrs_Tile

Purpose

PLASMA_dpotrs_Tile - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by PLASMA_dpotrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dpotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_DPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dpotrs_Tile

PLASMA_dsgesv

Purpose

PLASMA_dsgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices.

PLASMA_dsgesv first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.

The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.

The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where

Actually, in its current state (PLASMA 2.1.0), the test is slightly relaxed.

The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

C Bindings
int PLASMA_dsgesv(int N, int NRHS, double *A, int LDA, double *B, int LDB, double *X, int LDX, int *ITER)
Fortran Bindings
PLASMA_DSGESV(INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, DOUBLE PRECISION X, INTEGER LDX, INTEGER ITER, INTEGER INFO)
Arguments
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* (IN)
         The N-by-N coefficient matrix A. This matrix is not modified.

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

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

Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dsgesv

PLASMA_dsgesv_Tile

Purpose

PLASMA_dsgesv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

PLASMA_dsgesv_Tile first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.

The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.

The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where

Actually, in his current state (PLASMA 2.1.0), the test is slightly relaxed.

The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

C Bindings
int PLASMA_dsgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
Fortran Bindings
PLASMA_DSGESV_TILE(INTEGER*4 A, INTEGER4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER*4 X, INTEGER ITER, INTEGER INFO)
Arguments
A        double* (In or INOUT)
         On entry, the N-by-N coefficient matrix A.
         - if the iterative refinement converged, A is not modified;
         - otherwise, it falled backed to double precision solution,
         and then A contains the tile L and U factors from the factorization (not equivalent to LAPACK).

L        double* (NODEP or OUT)
         On exit:
         - if the iterative refinement converged, L is not modified;
         - otherwise, it falled backed to double precision solution,
         and then L is an auxiliary factorization data, related to the tile L factor,
         necessary to solve the system of equations (not equivalent to LAPACK).

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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_dsgesv_Tile

PLASMA_dtrsm

Purpose

PLASMA_dtrsm - Computes triangular solve A*X = B or X*A = B

C Bindings
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)
Fortran Bindings
PLASMA_DTRSM(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dtrsm

PLASMA_dtrsm_Tile

Purpose

PLASMA_dtrsm_Tile - Computes triangular solve A*X = B or X*A = B All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dtrsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_DTRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dtrsm_Tile

PLASMA_dtrsmpl

Purpose

PLASMA_dtrsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.

C Bindings
int PLASMA_dtrsmpl(int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)
Fortran Bindings
PLASMA_DTRSMPL(INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_dtrsmpl

PLASMA_dtrsmpl_Tile

Purpose

PLASMA_dtrsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_dtrsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_DTRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_dtrsmpl_Tile

PLASMA_sgelqf

Purpose

PLASMA_sgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.

C Bindings
int PLASMA_sgelqf(int M, int N, float *A, int LDA, float *T)
Fortran Bindings
PLASMA_SGELQF(INTEGER M, INTEGER N, REAL A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_sgelqf

PLASMA_sgelqf_Tile

Purpose

PLASMA_sgelqf_Tile - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_SGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgelqf_Tile

PLASMA_sgelqs

Purpose

PLASMA_sgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_sgelqf.

C Bindings
int PLASMA_sgelqs(int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)
Fortran Bindings
PLASMA_SGELQS(INTEGER M, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER T, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_sgelqs

PLASMA_sgelqs_Tile

Purpose

PLASMA_sgelqs_Tile - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_sgelqf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_SGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgelqs_Tile

PLASMA_sgels

Purpose

PLASMA_sgels - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

C Bindings
int PLASMA_sgels(PLASMA_enum trans, int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)
Fortran Bindings
PLASMA_SGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER T, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_sgels

PLASMA_sgels_Tile

Purpose

PLASMA_sgels_Tile - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_SGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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;
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgels_Tile

PLASMA_sgemm

Purpose

PLASMA_sgemm - Performs one of the matrix-matrix operations

C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

op( X ) = X  or op( X ) = X'

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

C Bindings
int PLASMA_sgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, float alpha, float *A, int LDA, float *B, int LDB, float beta, float *C, int LDC)
Fortran Bindings
PLASMA_SGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, REAL alpha, REAL A, INTEGER LDA, REAL B, INTEGER LDB, REAL beta, REAL C, INTEGER LDC, INTEGER INFO)
Arguments
transA   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaTrans: A is conjugate transposed.
         Currently only PlasmaNoTrans is supported

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

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

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

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

alpha    float (IN)
         alpha specifies the scalar alpha

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

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

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

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

beta     float (IN)
         beta specifies the scalar beta

C        float* (INOUT)
         C is a LDC-by-N matrix.
         On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )

LDC      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgemm

PLASMA_sgeqrf

Purpose

PLASMA_sgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.

C Bindings
int PLASMA_sgeqrf(int M, int N, float *A, int LDA, float *T)
Fortran Bindings
PLASMA_SGEQRF(INTEGER M, INTEGER N, REAL A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_sgeqrf

PLASMA_sgeqrf_Tile

Purpose

PLASMA_sgeqrf_Tile - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_SGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgeqrf_Tile

PLASMA_sgeqrs

Purpose

PLASMA_sgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_sgeqrf.

C Bindings
int PLASMA_sgeqrs(int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)
Fortran Bindings
PLASMA_SGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER T, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_sgeqrs

PLASMA_sgeqrs_Tile

Purpose

PLASMA_sgeqrs_Tile - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_sgeqrf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_SGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgeqrs_Tile

PLASMA_sgesv

Purpose

PLASMA_sgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_sgesv(int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)
Fortran Bindings
PLASMA_SGESV(INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_sgesv

PLASMA_sgesv_Tile

Purpose

PLASMA_sgesv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_SGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_sgesv_Tile

PLASMA_sgetrf

Purpose

PLASMA_sgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

C Bindings
int PLASMA_sgetrf(int M, int N, float *A, int LDA, float *L, int *IPIV)
Fortran Bindings
PLASMA_SGETRF(INTEGER M, INTEGER N, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_sgetrf

PLASMA_sgetrf_Tile

Purpose

PLASMA_sgetrf_Tile - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
Fortran Bindings
PLASMA_SGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_sgetrf_Tile

PLASMA_sgetrs

Purpose

PLASMA_sgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_sgetrf.

C Bindings
int PLASMA_sgetrs(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)
Fortran Bindings
PLASMA_SGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_sgetrs

PLASMA_sgetrs_Tile

Purpose

PLASMA_sgetrs_Tile - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_sgetrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_SGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_sgetrs_Tile

PLASMA_sposv

Purpose

PLASMA_sposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_sposv(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *B, int LDB)
Fortran Bindings
PLASMA_SPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_sposv

PLASMA_sposv_Tile

Purpose

PLASMA_sposv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_sposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_SPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_sposv_Tile

PLASMA_spotrf

Purpose

PLASMA_spotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix.

C Bindings
int PLASMA_spotrf(PLASMA_enum uplo, int N, float *A, int LDA)
Fortran Bindings
PLASMA_SPOTRF(INTEGER uplo, INTEGER N, REAL A, INTEGER LDA, INTEGER INFO)
Arguments
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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_spotrf

PLASMA_spotrf_Tile

Purpose

PLASMA_spotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**T * U, if uplo = PlasmaUpper, or
A = L * L**T, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_spotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
Fortran Bindings
PLASMA_SPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
Arguments
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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_spotrf_Tile

PLASMA_spotrs

Purpose

PLASMA_spotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by PLASMA_spotrf.

C Bindings
int PLASMA_spotrs(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *B, int LDB)
Fortran Bindings
PLASMA_SPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, REAL B, INTEGER  LDB, INTEGER  INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_spotrs

PLASMA_spotrs_Tile

Purpose

PLASMA_spotrs_Tile - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by PLASMA_spotrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_spotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_SPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_spotrs_Tile

PLASMA_strsm

Purpose

PLASMA_strsm - Computes triangular solve A*X = B or X*A = B

C Bindings
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)
Fortran Bindings
PLASMA_STRSM(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_strsm

PLASMA_strsm_Tile

Purpose

PLASMA_strsm_Tile - Computes triangular solve A*X = B or X*A = B All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_strsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_STRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_strsm_Tile

PLASMA_strsmpl

Purpose

PLASMA_strsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.

C Bindings
int PLASMA_strsmpl(int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)
Fortran Bindings
PLASMA_STRSMPL(INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, REAL B, INTEGER LDB, INTEGER INFO)
Arguments
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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_strsmpl

PLASMA_strsmpl_Tile

Purpose

PLASMA_strsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_strsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_STRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
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.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_strsmpl_Tile

PLASMA_Lapack_to_Tile

Purpose

PLASMA_Lapack_to_Tile - Conversion from LAPACK layout to tile layout.

C Bindings
int PLASMA_Lapack_to_Tile(void *Af77, int LDA, PLASMA_desc *A)
Fortran Bindings
PLASMA_LAPACK_TO_TILE(INTEGER*4 Af77, INTEGER LDA, INTEGER*4 A, INTEGER INFO)
Arguments
Af77     void* (IN)
         LAPACK matrix.

LDA      int (IN)
         The leading dimension of the matrix Af77.

A        PLASMA_desc* (OUT)
         Descriptor of the PLASMA matrix in tile layout.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Lapack_to_Tile

PLASMA_Tile_to_Lapack

Purpose

PLASMA_Tile_to_Lapack - Conversion from tile layout to LAPACK layout

C Bindings
int PLASMA_Tile_to_Lapack(PLASMA_desc *A, void *Af77, int LDA)
Fortran Bindings
PLASMA_TILE_TO_LAPACK(INTEGER*4 A, INTEGER*4 Af77, INTEGER LDA, INTEGER INFO)
Arguments
A        PLASMA_desc* (OUT)
         Descriptor of the PLASMA matrix in tile layout.

Af77     void* (IN)
         LAPACK matrix.

LDA      int (IN)
         The leading dimension of the matrix Af77.
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Tile_to_Lapack

PLASMA_Dealloc_Handle

Purpose

PLASMA_Dealloc_Handle - Deallocate workspace handle allocated by any workspace allocation routine.

C Bindings
Fortran Bindings
PLASMA_DEALLOC_HANDLE(INTEGER sp, INTEGER INFO)
Arguments
handle   void** (IN)
         Workspace handle
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Dealloc_Handle

PLASMA_Dealloc_Handle

Purpose

PLASMA_Dealloc_Handle - Deallocate workspace handle allocated by any workspace allocation routine.

C Bindings
Fortran Bindings
PLASMA_DEALLOC_HANDLE(INTEGER sp, INTEGER INFO)
Arguments
handle   void** (IN)
         Workspace handle
Return Value:
          = PLASMA_SUCCESS: successful exit
Online Browsing

Dive into PLASMA_Dealloc_Handle

PLASMA_Alloc_Workspace_cgels

Purpose

PLASMA_Alloc_Workspace_cgels - Allocates workspace for PLASMA_cgels or PLASMA_cgels_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_cgels(int M, int N, PLASMA_Complex32_t **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_CGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        PLASMA_Complex32_t* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         or the tile LQ factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_cgels

PLASMA_Alloc_Workspace_cgeqrf

Purpose

PLASMA_Alloc_Workspace_cgeqrf - Allocates workspace for PLASMA_cgeqrf or PLASMA_cgeqrf_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_cgeqrf(int M, int N, PLASMA_Complex32_t **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_CGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        PLASMA_Complex32_t* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_cgeqrf

PLASMA_Alloc_Workspace_cgelqf

Purpose

PLASMA_Alloc_Workspace_cgelqf - Allocates workspace for PLASMA_cgelqf or PLASMA_cgelqf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_cgelqf(int M, int N, PLASMA_Complex32_t **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_CGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        PLASMA_Complex32_t* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile LQ
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_cgelqf

PLASMA_Alloc_Workspace_cgesv

Purpose

PLASMA_Alloc_Workspace_cgesv - Allocates workspace for PLASMA_cgesv or PLASMA_cgesv_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_cgesv(int N, PLASMA_Complex32_t **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_CGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
N        int (IN)
         The number of linear equations, i.e., the order of the matrix A. N >= 0.

L        PLASMA_Complex32_t* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_cgesv

PLASMA_Alloc_Workspace_cgetrf

Purpose

PLASMA_Alloc_Workspace_cgetrf - Allocates workspace for PLASMA_cgetrf or PLASMA_cgetrf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_cgetrf(int M, int N, PLASMA_Complex32_t **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_CGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
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.

L        PLASMA_Complex32_t* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_cgetrf

PLASMA_Alloc_Workspace_dgels

Purpose

PLASMA_Alloc_Workspace_dgels - Allocates workspace for PLASMA_dgels or PLASMA_dgels_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_dgels(int M, int N, double **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_DGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        double* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         or the tile LQ factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_dgels

PLASMA_Alloc_Workspace_dgeqrf

Purpose

PLASMA_Alloc_Workspace_dgeqrf - Allocates workspace for PLASMA_dgeqrf or PLASMA_dgeqrf_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_dgeqrf(int M, int N, double **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_DGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        double* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_dgeqrf

PLASMA_Alloc_Workspace_dgelqf

Purpose

PLASMA_Alloc_Workspace_dgelqf - Allocates workspace for PLASMA_dgelqf or PLASMA_dgelqf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_dgelqf(int M, int N, double **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_DGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        double* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile LQ
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_dgelqf

PLASMA_Alloc_Workspace_dgesv

Purpose

PLASMA_Alloc_Workspace_dgesv - Allocates workspace for PLASMA_dgesv or PLASMA_dgesv_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_dgesv(int N, double **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_DGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
N        int (IN)
         The number of linear equations, i.e., the order of the matrix A. N >= 0.

L        double* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_dgesv

PLASMA_Alloc_Workspace_dgetrf

Purpose

PLASMA_Alloc_Workspace_dgetrf - Allocates workspace for PLASMA_dgetrf or PLASMA_dgetrf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_dgetrf(int M, int N, double **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_DGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
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.

L        double* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_dgetrf

PLASMA_Alloc_Workspace_sgels

Purpose

PLASMA_Alloc_Workspace_sgels - Allocates workspace for PLASMA_sgels or PLASMA_sgels_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_sgels(int M, int N, float **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_SGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        float* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         or the tile LQ factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_sgels

PLASMA_Alloc_Workspace_sgeqrf

Purpose

PLASMA_Alloc_Workspace_sgeqrf - Allocates workspace for PLASMA_sgeqrf or PLASMA_sgeqrf_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_sgeqrf(int M, int N, float **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_SGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        float* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_sgeqrf

PLASMA_Alloc_Workspace_sgelqf

Purpose

PLASMA_Alloc_Workspace_sgelqf - Allocates workspace for PLASMA_sgelqf or PLASMA_sgelqf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_sgelqf(int M, int N, float **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_SGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        float* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile LQ
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_sgelqf

PLASMA_Alloc_Workspace_sgesv

Purpose

PLASMA_Alloc_Workspace_sgesv - Allocates workspace for PLASMA_sgesv or PLASMA_sgesv_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_sgesv(int N, float **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_SGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
N        int (IN)
         The number of linear equations, i.e., the order of the matrix A. N >= 0.

L        float* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_sgesv

PLASMA_Alloc_Workspace_sgetrf

Purpose

PLASMA_Alloc_Workspace_sgetrf - Allocates workspace for PLASMA_sgetrf or PLASMA_sgetrf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_sgetrf(int M, int N, float **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_SGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
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.

L        float* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_sgetrf

PLASMA_Alloc_Workspace_zgels

Purpose

PLASMA_Alloc_Workspace_zgels - Allocates workspace for PLASMA_zgels or PLASMA_zgels_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_zgels(int M, int N, PLASMA_Complex64_t **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_ZGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        PLASMA_Complex64_t* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         or the tile LQ factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_zgels

PLASMA_Alloc_Workspace_zgeqrf

Purpose

PLASMA_Alloc_Workspace_zgeqrf - Allocates workspace for PLASMA_zgeqrf or PLASMA_zgeqrf_Tile routine.

C Bindings
int PLASMA_Alloc_Workspace_zgeqrf(int M, int N, PLASMA_Complex64_t **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_ZGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        PLASMA_Complex64_t* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile QR
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_zgeqrf

PLASMA_Alloc_Workspace_zgelqf

Purpose

PLASMA_Alloc_Workspace_zgelqf - Allocates workspace for PLASMA_zgelqf or PLASMA_zgelqf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_zgelqf(int M, int N, PLASMA_Complex64_t **T)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_ZGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
Arguments
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.

T        PLASMA_Complex64_t* (OUT)
         On exit, workspace handle for storage of the extra T factors required by the tile LQ
         factorization.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_zgelqf

PLASMA_Alloc_Workspace_zgesv

Purpose

PLASMA_Alloc_Workspace_zgesv - Allocates workspace for PLASMA_zgesv or PLASMA_zgesv_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_zgesv(int N, PLASMA_Complex64_t **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_ZGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
N        int (IN)
         The number of linear equations, i.e., the order of the matrix A. N >= 0.

L        PLASMA_Complex64_t* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_zgesv

PLASMA_Alloc_Workspace_zgetrf

Purpose

PLASMA_Alloc_Workspace_zgetrf - Allocates workspace for PLASMA_zgetrf or PLASMA_zgetrf_Tile routines.

C Bindings
int PLASMA_Alloc_Workspace_zgetrf(int M, int N, PLASMA_Complex64_t **L, int **IPIV)
Fortran Bindings
PLASMA_ALLOC_WORKSPACE_ZGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
Arguments
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.

L        PLASMA_Complex64_t* (OUT)
         On exit, workspace handle for storage of the extra L factors required by the tile LU
         factorization.

IPIV     int** (OUT)
         On exit, workspace handle for storage of pivot indexes required by the tile LU
         factorization (not equivalent to LAPACK).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_Alloc_Workspace_zgetrf

PLASMA_zcgesv

Purpose

PLASMA_zcgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices.

PLASMA_zcgesv first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.

The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.

The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where

Actually, in its current state (PLASMA 2.1.0), the test is slightly relaxed.

The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

C Bindings
int PLASMA_zcgesv(int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t *X, int LDX, int *ITER)
Fortran Bindings
PLASMA_ZCGESV(INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX*16 B, INTEGER LDB, COMPLEX*16 X, INTEGER LDX, INTEGER ITER, INTEGER INFO)
Arguments
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_Complex64_t* (IN)
         The N-by-N coefficient matrix A. This matrix is not modified.

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

B        PLASMA_Complex64_t* (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        PLASMA_Complex64_t* (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

Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zcgesv

PLASMA_zcgesv_Tile

Purpose

PLASMA_zcgesv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

PLASMA_zcgesv_Tile first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.

The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.

The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where

Actually, in his current state (PLASMA 2.1.0), the test is slightly relaxed.

The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

C Bindings
int PLASMA_zcgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
Fortran Bindings
PLASMA_ZCGESV_TILE(INTEGER*4 A, INTEGER4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER*4 X,  ITER, INTEGER INFO)
Arguments
A        PLASMA_Complex64_t* (In or INOUT)
         On entry, the N-by-N coefficient matrix A.
         - if the iterative refinement converged, A is not modified;
         - otherwise, it falled backed to double precision solution,
         and then A contains the tile L and U factors from the factorization (not equivalent to LAPACK).

L        PLASMA_Complex64_t* (NODEP or OUT)
         On exit:
         - if the iterative refinement converged, L is not modified;
         - otherwise, it falled backed to double precision solution,
         and then L is an auxiliary factorization data, related to the tile L factor,
         necessary to solve the system of equations (not equivalent to LAPACK).

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

B        PLASMA_Complex64_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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zcgesv_Tile

PLASMA_zgelqf

Purpose

PLASMA_zgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.

C Bindings
int PLASMA_zgelqf(int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T)
Fortran Bindings
PLASMA_ZGELQF(INTEGER M, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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_Complex64_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_Complex64_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_zgelqs to solve the system
         of equations.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_zgelqf

PLASMA_zgelqf_Tile

Purpose

PLASMA_zgelqf_Tile - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_ZGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
Arguments
A        PLASMA_Complex64_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_Complex64_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_zgelqs to solve the system
         of equations.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgelqf_Tile

PLASMA_zgelqs

Purpose

PLASMA_zgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_zgelqf.

C Bindings
int PLASMA_zgelqs(int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZGELQS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER T, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
Arguments
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_Complex64_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_zgelqf.

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

T        PLASMA_Complex64_t* (IN)
         Auxiliary factorization data, computed by PLASMA_zgelqf.

B        PLASMA_Complex64_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.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_zgelqs

PLASMA_zgelqs_Tile

Purpose

PLASMA_zgelqs_Tile - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_zgelqf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_ZGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
A        PLASMA_Complex64_t* (IN)
         Details of the LQ factorization of the original matrix A as returned by PLASMA_zgelqf.

T        PLASMA_Complex64_t* (IN)
         Auxiliary factorization data, computed by PLASMA_zgelqf.

B        PLASMA_Complex64_t* (INOUT)
         On entry, the M-by-NRHS right hand side matrix B.
         On exit, the N-by-NRHS solution matrix X.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgelqs_Tile

PLASMA_zgels

Purpose

PLASMA_zgels - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.

C Bindings
int PLASMA_zgels(PLASMA_enum trans, int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER T, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
Arguments
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_Complex64_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_zgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_zgelqf.

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

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

B        PLASMA_Complex64_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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_zgels

PLASMA_zgels_Tile

Purpose

PLASMA_zgels_Tile - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

  1. trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined system, i.e., solve the least squares problem: minimize || B - A*X ||.

  2. trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined system A * X = B.

Several right hand side vectors B and solution vectors X can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_ZGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
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_Complex64_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_zgeqrf;
         if M < N, A is overwritten by details of its LQ factorization as returned by
                     PLASMA_zgelqf.

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

B        PLASMA_Complex64_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;
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgels_Tile

PLASMA_zgemm

Purpose

PLASMA_zgemm - Performs one of the matrix-matrix operations

C = alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

op( X ) = X  or op( X ) = X'

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

C Bindings
int PLASMA_zgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
Fortran Bindings
PLASMA_ZGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, COMPLEX*16 alpha, COMPLEX*16 A, INTEGER LDA, COMPLEX*16 B, INTEGER LDB, COMPLEX*16 beta, COMPLEX*16 C, INTEGER LDC, INTEGER INFO)
Arguments
transA   PLASMA_enum (IN)
         Specifies whether the matrix A is transposed, not transposed or conjugate transposed:
         = PlasmaNoTrans:   A is transposed;
         = PlasmaTrans:     A is not transposed;
         = PlasmaConjTrans: A is conjugate transposed.
         Currently only PlasmaNoTrans is supported

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

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

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

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

alpha    PLASMA_Complex64_t (IN)
         alpha specifies the scalar alpha

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

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

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

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

beta     PLASMA_Complex64_t (IN)
         beta specifies the scalar beta

C        PLASMA_Complex64_t* (INOUT)
         C is a LDC-by-N matrix.
         On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )

LDC      int (IN)
         The leading dimension of the array C. LDC >= max(1,M).
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgemm

PLASMA_zgeqrf

Purpose

PLASMA_zgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.

C Bindings
int PLASMA_zgeqrf(int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T)
Fortran Bindings
PLASMA_ZGEQRF(INTEGER M, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER T, INTEGER INFO)
Arguments
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_Complex64_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_Complex64_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_zgeqrs to solve the system
         of equations.
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_zgeqrf

PLASMA_zgeqrf_Tile

Purpose

PLASMA_zgeqrf_Tile - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
Fortran Bindings
PLASMA_ZGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
Arguments
A        PLASMA_Complex64_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_Complex64_t* (OUT)
         On exit, auxiliary factorization data, required by PLASMA_zgeqrs to solve the system
         of equations.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgeqrf_Tile

PLASMA_zgeqrs

Purpose

PLASMA_zgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_zgeqrf.

C Bindings
int PLASMA_zgeqrs(int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER T, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
Arguments
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_Complex64_t* (INOUT)
         Details of the QR factorization of the original matrix A as returned by PLASMA_zgeqrf.

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

T        PLASMA_Complex64_t* (IN)
         Auxiliary factorization data, computed by PLASMA_zgeqrf.

B        PLASMA_Complex64_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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_zgeqrs

PLASMA_zgeqrs_Tile

Purpose

PLASMA_zgeqrs_Tile - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_zgeqrf_Tile. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
Fortran Bindings
PLASMA_ZGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
Arguments
A        PLASMA_Complex64_t* (INOUT)
         Details of the QR factorization of the original matrix A as returned by PLASMA_zgeqrf.

T        PLASMA_Complex64_t* (IN)
         Auxiliary factorization data, computed by PLASMA_zgeqrf.

B        PLASMA_Complex64_t* (INOUT)
         On entry, the m-by-nrhs right hand side matrix B.
         On exit, the n-by-nrhs solution matrix X.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgeqrs_Tile

PLASMA_zgesv

Purpose

PLASMA_zgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_zgesv(int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *L, int *IPIV, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZGESV(INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
Arguments
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_Complex64_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_Complex64_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_Complex64_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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zgesv

PLASMA_zgesv_Tile

Purpose

PLASMA_zgesv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_ZGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
A        PLASMA_Complex64_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_Complex64_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_Complex64_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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zgesv_Tile

PLASMA_zgetrf

Purpose

PLASMA_zgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

C Bindings
int PLASMA_zgetrf(int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *L, int *IPIV)
Fortran Bindings
PLASMA_ZGETRF(INTEGER M, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
Arguments
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_Complex64_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_Complex64_t* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_zgetrs to solve the system of equations.

IPIV     int* (OUT)
         The pivot indices that define the permutations (not equivalent to LAPACK).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zgetrf

PLASMA_zgetrf_Tile

Purpose

PLASMA_zgetrf_Tile - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
Fortran Bindings
PLASMA_ZGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
Arguments
A        PLASMA_Complex64_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_Complex64_t* (OUT)
         On exit, auxiliary factorization data, related to the tile L factor,
         required by PLASMA_zgetrs to solve the system of equations.

IPIV     int* (OUT)
         The pivot indices that define the permutations (not equivalent to LAPACK).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zgetrf_Tile

PLASMA_zgetrs

Purpose

PLASMA_zgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_zgetrf.

C Bindings
int PLASMA_zgetrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *L, int *IPIV, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
Arguments
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_Complex64_t* (IN)
         The tile factors L and U from the factorization, computed by PLASMA_zgetrf.

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

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

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

B        PLASMA_Complex64_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).
Return Value:
          = 0: successful exit
          < 0: if -i, the i-th argument had an illegal value
Online Browsing

Dive into PLASMA_zgetrs

PLASMA_zgetrs_Tile

Purpose

PLASMA_zgetrs_Tile - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_zgetrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
Fortran Bindings
PLASMA_ZGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
Arguments
A        PLASMA_Complex64_t* (IN)
         The tile factors L and U from the factorization, computed by PLASMA_zgetrf.

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

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

B        PLASMA_Complex64_t* (INOUT)
         On entry, the N-by-NRHS matrix of right hand side matrix B.
         On exit, the solution matrix X.
Return Value:
          = 0: successful exit
Online Browsing

Dive into PLASMA_zgetrs_Tile

PLASMA_zposv

Purpose

PLASMA_zposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

C Bindings
int PLASMA_zposv(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
Arguments
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_Complex64_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_Complex64_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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zposv

PLASMA_zposv_Tile

Purpose

PLASMA_zposv_Tile - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
Fortran Bindings
PLASMA_ZPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
Arguments
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_Complex64_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_Complex64_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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zposv_Tile

PLASMA_zpotrf

Purpose

PLASMA_zpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix.

C Bindings
int PLASMA_zpotrf(PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA)
Fortran Bindings
PLASMA_ZPOTRF(INTEGER uplo, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER INFO)
Arguments
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_Complex64_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).
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zpotrf

PLASMA_zpotrf_Tile

Purpose

PLASMA_zpotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = U**H * U, if uplo = PlasmaUpper, or
A = L * L**H, if uplo =  PlasmaLower,

where U is an upper triangular matrix and L is a lower triangular matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

C Bindings
int PLASMA_zpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
Fortran Bindings
PLASMA_ZPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
Arguments
uplo     PLASMA_enum (IN)
         = PlasmaUpper: Upper triangle of A is stored;
         = PlasmaLower: Lower triangle of A is stored.

A        PLASMA_Complex64_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.
Return Value:
          = 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.
Online Browsing

Dive into PLASMA_zpotrf_Tile

PLASMA_zpotrs

Purpose

PLASMA_zpotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = UH*U or A = L*LH computed by PLASMA_zpotrf.

C Bindings
int PLASMA_zpotrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
Fortran Bindings
PLASMA_ZPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, COMPLEX*16 B, INTEGER  LDB, INTEGER  INFO)
Arguments
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_Complex64_t* (IN)
         The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H,
         computed by PLASMA_zpotrf.

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

B        PLASMA_Complex64_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).
Return Value:
          = 0: successful exit
          < 0: if -i,