int PLASMA_Version(int *ver_major, int *ver_minor, int *ver_micro)
PLASMA_Version - Reports PLASMA version number.
int PLASMA_Version(int *ver_major, int *ver_minor, int *ver_micro)
PLASMA_VERSION(INTEGER VER_MAJOR, INTEGER VER_MINOR, INTEGER VER_MICRO, INTEGER INFO)
ver_major int (OUT) PLASMA major version number. ver_minor int (OUT) PLASMA minor version number. ver_micro int (OUT) PLASMA micro version number.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Version
PLASMA_cgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.
int PLASMA_cgelqf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T)
PLASMA_CGELQF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal represent the unitary matrix Q as a product of elementary reflectors, stored by tiles. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, required by PLASMA_cgelqs to solve the system of equations.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cgelqf
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.
int PLASMA_cgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_CGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal represent the unitary matrix Q as a product of elementary reflectors, stored by tiles. T PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, required by PLASMA_cgelqs to solve the system of equations.
= 0: successful exit
Dive into PLASMA_cgelqf_Tile
PLASMA_cgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_cgelqf.
int PLASMA_cgelqs(int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CGELQS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A PLASMA_Complex32_t* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf. LDA int (IN) The leading dimension of the array A. LDA >= M. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgelqf. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= N.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cgelqs
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.
int PLASMA_cgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_CGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
A PLASMA_Complex32_t* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgelqf. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_cgelqs_Tile
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:
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 ||.
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.
int PLASMA_cgels(PLASMA_enum trans, int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported. M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_cgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_cgelqf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise; On exit, if return value = 0, B is overwritten by the solution vectors, stored columnwise: if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual sum of squares for the solution in each column is given by the sum of squares of the modulus of elements N+1 to M in that column; if M < N, rows 1 to N of B contain the minimum norm solution vectors; LDB int (IN) The leading dimension of the array B. LDB >= MAX(1,M,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cgels
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:
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 ||.
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.
int PLASMA_cgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_CGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported. A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_cgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_cgelqf. T PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise; On exit, if return value = 0, B is overwritten by the solution vectors, stored columnwise: if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual sum of squares for the solution in each column is given by the sum of squares of the modulus of elements N+1 to M in that column; if M < N, rows 1 to N of B contain the minimum norm solution vectors;
= 0: successful exit
Dive into PLASMA_cgels_Tile
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.
int PLASMA_cgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
PLASMA_CGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, COMPLEX alpha, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, COMPLEX beta, COMPLEX C, INTEGER LDC, INTEGER INFO)
transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed. Currently only PlasmaNoTrans is supported transB PLASMA_enum (IN) Specifies whether the matrix B is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is transposed; = PlasmaTrans: B is not transposed; = PlasmaConjTrans: B is conjugate transposed. Currently only PlasmaNoTrans is supported M int (IN) M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0. N int (IN) N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0. K int (IN) K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K >= 0. alpha PLASMA_Complex32_t (IN) alpha specifies the scalar alpha A PLASMA_Complex32_t* (IN) A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). B PLASMA_Complex32_t* (IN) B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N). beta PLASMA_Complex32_t (IN) beta specifies the scalar beta C PLASMA_Complex32_t* (INOUT) C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C ) LDC int (IN) The leading dimension of the array C. LDC >= max(1,M).
= 0: successful exit
Dive into PLASMA_cgemm
PLASMA_cgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.
int PLASMA_cgeqrf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T)
PLASMA_CGEQRF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, required by PLASMA_cgeqrs to solve the system of equations.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cgeqrf
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.
int PLASMA_cgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_CGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles. T PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, required by PLASMA_cgeqrs to solve the system of equations.
= 0: successful exit
Dive into PLASMA_cgeqrf_Tile
PLASMA_cgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_cgeqrf.
int PLASMA_cgeqrs(int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A PLASMA_Complex32_t* (INOUT) Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf. LDA int (IN) The leading dimension of the array A. LDA >= M. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgeqrf. B PLASMA_Complex32_t* (INOUT) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cgeqrs
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.
int PLASMA_cgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_CGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
A PLASMA_Complex32_t* (INOUT) Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgeqrf. B PLASMA_Complex32_t* (INOUT) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.
= 0: successful exit
Dive into PLASMA_cgeqrs_Tile
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.
int PLASMA_cgesv(int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV, PLASMA_Complex32_t *B, int LDB)
PLASMA_CGESV(INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)
N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. IPIV int* (OUT) On exit, the pivot indices that define the permutations (not equivalent to LAPACK). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
Dive into PLASMA_cgesv
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.
int PLASMA_cgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_CGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A PLASMA_Complex32_t* (INOUT) On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). L PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. IPIV int* (OUT) On exit, the pivot indices that define the permutations (not equivalent to LAPACK). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
Dive into PLASMA_cgesv_Tile
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.
int PLASMA_cgetrf(int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV)
PLASMA_CGETRF(INTEGER M, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). L PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_cgetrs to solve the system of equations. IPIV int* (OUT) The pivot indices that define the permutations (not equivalent to LAPACK).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Dive into PLASMA_cgetrf
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.
int PLASMA_cgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
PLASMA_CGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
A PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. L PLASMA_Complex32_t* (OUT) On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_cgetrs to solve the system of equations. IPIV int* (OUT) The pivot indices that define the permutations (not equivalent to LAPACK).
= 0: successful exit > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Dive into PLASMA_cgetrf_Tile
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.
int PLASMA_cgetrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV, PLASMA_Complex32_t *B, int LDB)
PLASMA_CGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended to specify the the form of the system of equations: = PlasmaNoTrans: A * X = B (No transpose) = PlasmaTrans: A**T * X = B (Transpose) = PlasmaConjTrans: A**H * X = B (Conjugate transpose) Currently only PlasmaNoTrans is supported. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_Complex32_t* (IN) The tile factors L and U from the factorization, computed by PLASMA_cgetrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L PLASMA_Complex32_t* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf. IPIV int* (IN) The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cgetrs
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.
int PLASMA_cgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_CGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A PLASMA_Complex32_t* (IN) The tile factors L and U from the factorization, computed by PLASMA_cgetrf. L PLASMA_Complex32_t* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf. IPIV int* (IN) The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.
= 0: successful exit
Dive into PLASMA_cgetrs_Tile
PLASMA_Enable - Enable PLASMA feature.
int PLASMA_Enable(PLASMA_enum lever)
PLASMA_ENABLE(INTEGER lever, INTEGER INFO)
lever PLASMA_enum (IN) Feature to be enabled: = PLASMA_WARNINGS: printing of warning messages, = PLASMA_ERRORS: printing of error messages, = PLASMA_AUTOTUNING: autotuning for tile size and inner block size.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Enable
PLASMA_Disable - Disable PLASMA feature.
int PLASMA_Disable(PLASMA_enum lever)
PLASMA_DISABLE(INTEGER lever, INTEGER INFO)
lever PLASMA_enum (IN) Feature to be disabled: = PLASMA_WARNINGS: printing of warning messages, = PLASMA_ERRORS: printing of error messages, = PLASMA_AUTOTUNING: autotuning for tile size and inner block size.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Disable
PLASMA_Set - Set PLASMA parameter
int PLASMA_Set(PLASMA_enum param, int value)
PLASMA_SET(INTEGER param, INTEGER value, INTEGER INFO)
param PLASMA_enum (IN) PLASMA parameter: = PLASMA_TILE_SIZE: size matrix tile, = PLASMA_INNER_BLOCK_SIZE: size of tile inner block. value int (IN) Value of the parameter.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Set
PLASMA_Get - Get value of PLASMA parameter
int PLASMA_Get(PLASMA_enum param, int *value)
PLASMA_GET(INTEGER param, INTEGER value, INTEGER INFO)
param PLASMA_enum (IN) PLASMA parameter: = PLASMA_TILE_SIZE: size matrix tile, = PLASMA_INNER_BLOCK_SIZE: size of tile inner block. value int* (OUT) Value of the parameter.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Get
PLASMA_Init - Initialize PLASMA.
int PLASMA_Init(int cores)
PLASMA_INIT(INTEGER CORES, INTEGER INFO)
cores int (IN) Number of cores to use (threads to launch)
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Init
PLASMA_Finalize - Finalize PLASMA.
int PLASMA_Finalize()
PLASMA_FINALIZE(INTEGER INFO)
Dive into PLASMA_Finalize
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.
int PLASMA_cposv(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
PLASMA_CPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_cposv
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.
int PLASMA_cposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_CPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A PLASMA_Complex32_t* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H. B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_cposv_Tile
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.
int PLASMA_cpotrf(PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA)
PLASMA_CPOTRF(INTEGER uplo, INTEGER N, COMPLEX A, INTEGER LDA, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. A PLASMA_Complex32_t* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_cpotrf
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.
int PLASMA_cpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
PLASMA_CPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A PLASMA_Complex32_t* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H.
= 0: successful exit > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_cpotrf_Tile
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.
int PLASMA_cpotrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
PLASMA_CPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_Complex32_t* (IN) The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, computed by PLASMA_cpotrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cpotrs
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.
int PLASMA_cpotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_CPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A PLASMA_Complex32_t* (IN) The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, computed by PLASMA_cpotrf. B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_cpotrs_Tile
PLASMA_ctrsm - Computes triangular solve A*X = B or X*A = B
int PLASMA_ctrsm(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
PLASMA_CTRSM(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, COMPLEX B, INTEGER LDB, INTEGER INFO)
side PLASMA_enum (IN) Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed. diag PLASMA_enum (IN) Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_Complex32_t* (IN) The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB PLASMA_Complex32_t* (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_ctrsm
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.
int PLASMA_ctrsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_CTRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
side PLASMA_enum (IN) Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed. diag PLASMA_enum (IN) Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. A PLASMA_Complex32_t* (IN) The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_ctrsm_Tile
PLASMA_ctrsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.
int PLASMA_ctrsmpl(int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *L, int *IPIV, PLASMA_Complex32_t *B, int LDB)
PLASMA_CTRSMPL(INTEGER N, INTEGER NRHS, COMPLEX A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX B, INTEGER LDB, INTEGER INFO)
N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_Complex32_t* (IN) The tile factor L from the factorization, computed by PLASMA_cgetrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L PLASMA_Complex32_t* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf. IPIV int* (IN) The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB PLASMA_Complex32_t* (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_ctrsmpl
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.
int PLASMA_ctrsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_CTRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A PLASMA_Complex32_t* (IN) The tile factor L from the factorization, computed by PLASMA_cgetrf. L PLASMA_Complex32_t* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf. IPIV int* (IN) The pivot indices from PLASMA_cgetrf (not equivalent to LAPACK). B PLASMA_Complex32_t* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_ctrsmpl_Tile
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.
int PLASMA_cunglq(int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CUNGLQ(INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix Q. M >= 0. N int (IN) The number of columns of the matrix Q. N >= M. K int (IN) The number of rows of elementary tile reflectors whose product defines the matrix Q. M >= K >= 0. A PLASMA_Complex32_t* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgelqf. B PLASMA_Complex32_t* (OUT) On exit, the M-by-N matrix Q. LDA int (IN) The leading dimension of the array B. LDB >= max(1,M).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cunglq
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.
int PLASMA_cunglq_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
A PLASMA_Complex32_t* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgelqf. B PLASMA_Complex32_t* (OUT) On exit, the M-by-N matrix Q.
= 0: successful exit
Dive into PLASMA_cunglq_Tile
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.
int PLASMA_cungqr(int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CUNGQR(INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix Q. M >= 0. N int (IN) The number of columns of the matrix Q. N >= M. K int (IN) The number of columns of elementary tile reflectors whose product defines the matrix Q. M >= K >= 0. A PLASMA_Complex32_t* (IN) Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgeqrf. B PLASMA_Complex32_t* (OUT) On exit, the M-by-N matrix Q. LDB int (IN) The leading dimension of the array B. LDB >= max(1,M).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cungqr
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.
int PLASMA_cungqr_Tile(PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
PLASMA_CUNGQR_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)
A PLASMA_Complex32_t* (IN) Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgeqrf. B PLASMA_Complex32_t* (OUT) On exit, the M-by-N matrix Q.
= 0: successful exit
Dive into PLASMA_cungqr_Tile
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.
int PLASMA_cunmlq(PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CUNMLQ(INTEGER side, INTEGER trans, INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
side PLASMA_enum (IN) Intended usage: = PlasmaLeft: apply Q or Q**H from the left; = PlasmaRight: apply Q or Q**H from the right. Currently only PlasmaLeft is supported. trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjugate transpose, apply Q**H. Currently only PlasmaConjTrans is supported. M int (IN) The number of rows of the matrix C. M >= 0. N int (IN) The number of columns of the matrix C. N >= 0. K int (IN) The number of rows of elementary tile reflectors whose product defines the matrix Q. M >= K >= 0. A PLASMA_Complex32_t* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,K). T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgelqf. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix B. On exit, B is overwritten by Q*B or Q**H*B. LDB int (IN) The leading dimension of the array C. LDC >= max(1,M).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cunmlq
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.
int PLASMA_cunmlq_Tile(PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
PLASMA_CUNMLQ_TILE(INTEGER side, INTEGER trans, INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)
side PLASMA_enum (IN) Intended usage: = PlasmaLeft: apply Q or Q**H from the left; = PlasmaRight: apply Q or Q**H from the right. Currently only PlasmaLeft is supported. trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjugate transpose, apply Q**H. Currently only PlasmaConjTrans is supported. A PLASMA_Complex32_t* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgelqf. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix B. On exit, B is overwritten by Q*B or Q**H*B.
= 0: successful exit
Dive into PLASMA_cunmlq_Tile
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.
int PLASMA_cunmqr(PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *T, PLASMA_Complex32_t *B, int LDB)
PLASMA_CUNMQR(INTEGER side, INTEGER trans, INTEGER M, INTEGER N, INTEGER K, COMPLEX A, INTEGER LDA, INTEGER T, COMPLEX B, INTEGER LDB, INTEGER INFO)
side PLASMA_enum (IN) Intended usage: = PlasmaLeft: apply Q or Q**H from the left; = PlasmaRight: apply Q or Q**H from the right. Currently only PlasmaLeft is supported. trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjugate transpose, apply Q**H. Currently only PlasmaConjTrans is supported. M int (IN) The number of rows of the matrix C. M >= 0. N int (IN) The number of columns of the matrix C. N >= 0. K int (IN) The number of columns of elementary tile reflectors whose product defines the matrix Q. M >= K >= 0. A PLASMA_Complex32_t* (IN) Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M); T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgeqrf. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix B. On exit, B is overwritten by Q*B or Q**H*B. LDB int (IN) The leading dimension of the array C. LDC >= max(1,M).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_cunmqr
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.
int PLASMA_cunmqr_Tile(PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
PLASMA_CUNMQR_TILE(INTEGER side, INTEGER trans, INTEGER*4 A, INTEGER*4 T, INTEGER*4 B, INTEGER INFO)
side PLASMA_enum (IN) Intended usage: = PlasmaLeft: apply Q or Q**H from the left; = PlasmaRight: apply Q or Q**H from the right. Currently only PlasmaLeft is supported. trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjugate transpose, apply Q**H. Currently only PlasmaConjTrans is supported. A PLASMA_Complex32_t* (IN) Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf. T PLASMA_Complex32_t* (IN) Auxiliary factorization data, computed by PLASMA_cgeqrf. B PLASMA_Complex32_t* (INOUT) On entry, the M-by-N matrix B. On exit, B is overwritten by Q*B or Q**H*B.
= 0: successful exit
Dive into PLASMA_cunmqr_Tile
PLASMA_Desc_Create - Create matrix descriptor.
int PLASMA_Desc_Create(PLASMA_desc **desc, void *mat, PLASMA_enum dtyp, int mb, int nb, int bsiz, int lm, int ln, int i, int j, int m, int n)
PLASMA_DESC_CREATE(INTEGER*4 desc, INTEGER mat, INTEGER dtyp, INTEGER mb, INTEGER nb, INTEGER bsiz, INTEGER lm, INTEGER ln, INTEGER i, INTEGER j, INTEGER m, INTEGER n, INTEGER INFO)
desc PLASMA_desc** (OUT) On exit, descriptor of the matrix. mat void* (IN) Memory location of the matrix. dtyp PLASMA_enum (IN) Data type of the matrix: = PlasmaRealFloat: single precision real (S), = PlasmaRealDouble: double precision real (D), = PlasmaComplexFloat: single precision complex (C), = PlasmaComplexDouble: double precision complex (Z). mb int (IN) Number of rows in a tile. nb int (IN) Number of columns in a tile. bsiz int (IN) Nize in elements including padding. lm int (IN) Number of rows of the entire matrix. ln int (IN) Number of columns of the entire matrix. i int (IN) Row index to the beginning of the submatrix. j int (IN) Column indes to the beginning of the submatrix. m int (IN) Number of rows of the submatrix. n int (IN) Number of columns of the submatrix.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Desc_Create
PLASMA_Desc_Destroy - Destroys matrix descriptor.
int PLASMA_Desc_Destroy(PLASMA_desc **desc)
PLASMA_DESC_DESTROY(INTEGER*4 desc, INTEGER INFO)
desc PLASMA_desc** (IN) Matrix descriptor.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Desc_Destroy
PLASMA_dgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.
int PLASMA_dgelqf(int M, int N, double *A, int LDA, double *T)
PLASMA_DGELQF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A double* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal represent the unitary matrix Q as a product of elementary reflectors, stored by tiles. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T double* (OUT) On exit, auxiliary factorization data, required by PLASMA_dgelqs to solve the system of equations.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dgelqf
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.
int PLASMA_dgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_DGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
A double* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal represent the unitary matrix Q as a product of elementary reflectors, stored by tiles. T double* (OUT) On exit, auxiliary factorization data, required by PLASMA_dgelqs to solve the system of equations.
= 0: successful exit
Dive into PLASMA_dgelqf_Tile
PLASMA_dgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_dgelqf.
int PLASMA_dgelqs(int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)
PLASMA_DGELQS(INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A double* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_dgelqf. LDA int (IN) The leading dimension of the array A. LDA >= M. T double* (IN) Auxiliary factorization data, computed by PLASMA_dgelqf. B double* (INOUT) On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= N.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dgelqs
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.
int PLASMA_dgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_DGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
A double* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_dgelqf. T double* (IN) Auxiliary factorization data, computed by PLASMA_dgelqf. B double* (INOUT) On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_dgelqs_Tile
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:
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 ||.
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.
int PLASMA_dgels(PLASMA_enum trans, int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)
PLASMA_DGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**T. Currently only PlasmaNoTrans is supported. M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. A double* (INOUT) On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_dgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_dgelqf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T double* (OUT) On exit, auxiliary factorization data. B double* (INOUT) On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise; On exit, if return value = 0, B is overwritten by the solution vectors, stored columnwise: if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual sum of squares for the solution in each column is given by the sum of squares of the modulus of elements N+1 to M in that column; if M < N, rows 1 to N of B contain the minimum norm solution vectors; LDB int (IN) The leading dimension of the array B. LDB >= MAX(1,M,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dgels
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:
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 ||.
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.
int PLASMA_dgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_DGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**T. Currently only PlasmaNoTrans is supported. A double* (INOUT) On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_dgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_dgelqf. T double* (OUT) On exit, auxiliary factorization data. B double* (INOUT) On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise; On exit, if return value = 0, B is overwritten by the solution vectors, stored columnwise: if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual sum of squares for the solution in each column is given by the sum of squares of the modulus of elements N+1 to M in that column; if M < N, rows 1 to N of B contain the minimum norm solution vectors;
= 0: successful exit
Dive into PLASMA_dgels_Tile
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.
int PLASMA_dgemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, double alpha, double *A, int LDA, double *B, int LDB, double beta, double *C, int LDC)
PLASMA_DGEMM(INTEGER transA, INTEGER transB, INTEGER M, INTEGER N, INTEGER K, DOUBLE PRECISION alpha, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, DOUBLE PRECISION beta, DOUBLE PRECISION C, INTEGER LDC, INTEGER INFO)
transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is conjugate transposed. Currently only PlasmaNoTrans is supported transB PLASMA_enum (IN) Specifies whether the matrix B is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is transposed; = PlasmaTrans: B is not transposed; = PlasmaTrans: B is conjugate transposed. Currently only PlasmaNoTrans is supported M int (IN) M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0. N int (IN) N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0. K int (IN) K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K >= 0. alpha double (IN) alpha specifies the scalar alpha A double* (IN) A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). B double* (IN) B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N). beta double (IN) beta specifies the scalar beta C double* (INOUT) C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C ) LDC int (IN) The leading dimension of the array C. LDC >= max(1,M).
= 0: successful exit
Dive into PLASMA_dgemm
PLASMA_dgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.
int PLASMA_dgeqrf(int M, int N, double *A, int LDA, double *T)
PLASMA_DGEQRF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A double* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T double* (OUT) On exit, auxiliary factorization data, required by PLASMA_dgeqrs to solve the system of equations.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dgeqrf
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.
int PLASMA_dgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_DGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
A double* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles. T double* (OUT) On exit, auxiliary factorization data, required by PLASMA_dgeqrs to solve the system of equations.
= 0: successful exit
Dive into PLASMA_dgeqrf_Tile
PLASMA_dgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_dgeqrf.
int PLASMA_dgeqrs(int M, int N, int NRHS, double *A, int LDA, double *T, double *B, int LDB)
PLASMA_DGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER T, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A double* (INOUT) Details of the QR factorization of the original matrix A as returned by PLASMA_dgeqrf. LDA int (IN) The leading dimension of the array A. LDA >= M. T double* (IN) Auxiliary factorization data, computed by PLASMA_dgeqrf. B double* (INOUT) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dgeqrs
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.
int PLASMA_dgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_DGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
A double* (INOUT) Details of the QR factorization of the original matrix A as returned by PLASMA_dgeqrf. T double* (IN) Auxiliary factorization data, computed by PLASMA_dgeqrf. B double* (INOUT) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.
= 0: successful exit
Dive into PLASMA_dgeqrs_Tile
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.
int PLASMA_dgesv(int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)
PLASMA_DGESV(INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A double* (INOUT) On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L double* (OUT) On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. IPIV int* (OUT) On exit, the pivot indices that define the permutations (not equivalent to LAPACK). B double* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
Dive into PLASMA_dgesv
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.
int PLASMA_dgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_DGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A double* (INOUT) On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). L double* (OUT) On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. IPIV int* (OUT) On exit, the pivot indices that define the permutations (not equivalent to LAPACK). B double* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
Dive into PLASMA_dgesv_Tile
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.
int PLASMA_dgetrf(int M, int N, double *A, int LDA, double *L, int *IPIV)
PLASMA_DGETRF(INTEGER M, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A double* (INOUT) On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). L double* (OUT) On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_dgetrs to solve the system of equations. IPIV int* (OUT) The pivot indices that define the permutations (not equivalent to LAPACK).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Dive into PLASMA_dgetrf
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.
int PLASMA_dgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
PLASMA_DGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
A double* (INOUT) On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. L double* (OUT) On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_dgetrs to solve the system of equations. IPIV int* (OUT) The pivot indices that define the permutations (not equivalent to LAPACK).
= 0: successful exit > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Dive into PLASMA_dgetrf_Tile
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.
int PLASMA_dgetrs(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)
PLASMA_DGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended to specify the the form of the system of equations: = PlasmaNoTrans: A * X = B (No transpose) = PlasmaTrans: A**T * X = B (Transpose) = PlasmaTrans: A**T * X = B (Conjugate transpose) Currently only PlasmaNoTrans is supported. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A double* (IN) The tile factors L and U from the factorization, computed by PLASMA_dgetrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L double* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_dgetrf. IPIV int* (IN) The pivot indices from PLASMA_dgetrf (not equivalent to LAPACK). B double* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dgetrs
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.
int PLASMA_dgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_DGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A double* (IN) The tile factors L and U from the factorization, computed by PLASMA_dgetrf. L double* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_dgetrf. IPIV int* (IN) The pivot indices from PLASMA_dgetrf (not equivalent to LAPACK). B double* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.
= 0: successful exit
Dive into PLASMA_dgetrs_Tile
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.
int PLASMA_dposv(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)
PLASMA_DPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A double* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_dposv
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.
int PLASMA_dposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_DPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A double* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T. B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_dposv_Tile
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.
int PLASMA_dpotrf(PLASMA_enum uplo, int N, double *A, int LDA)
PLASMA_DPOTRF(INTEGER uplo, INTEGER N, DOUBLE PRECISION A, INTEGER LDA, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. A double* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_dpotrf
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.
int PLASMA_dpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
PLASMA_DPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A double* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
= 0: successful exit > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_dpotrf_Tile
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.
int PLASMA_dpotrs(PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)
PLASMA_DPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A double* (IN) The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, computed by PLASMA_dpotrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dpotrs
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.
int PLASMA_dpotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_DPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A double* (IN) The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, computed by PLASMA_dpotrf. B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_dpotrs_Tile
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
ITER is the number of the current iteration in the iterative refinement process
RNRM is the infinity-norm of the residual
XNRM is the infinity-norm of the solution
ANRM is the infinity-operator-norm of the matrix A
EPS is the machine epsilon returned by DLAMCH(Epsilon).
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.
int PLASMA_dsgesv(int N, int NRHS, double *A, int LDA, double *B, int LDB, double *X, int LDX, int *ITER)
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)
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
= 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.
Dive into PLASMA_dsgesv
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
ITER is the number of the current iteration in the iterative refinement process
RNRM is the infinity-norm of the residual
XNRM is the infinity-norm of the solution
ANRM is the infinity-operator-norm of the matrix A
EPS is the machine epsilon returned by DLAMCH(Epsilon).
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.
int PLASMA_dsgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
PLASMA_DSGESV_TILE(INTEGER*4 A, INTEGER4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER*4 X, INTEGER ITER, INTEGER INFO)
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.
= 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.
Dive into PLASMA_dsgesv_Tile
PLASMA_dtrsm - Computes triangular solve A*X = B or X*A = B
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)
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)
side PLASMA_enum (IN) Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is conjugate transposed. diag PLASMA_enum (IN) Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A double* (IN) The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB double* (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dtrsm
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.
int PLASMA_dtrsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_DTRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
side PLASMA_enum (IN) Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is conjugate transposed. diag PLASMA_enum (IN) Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. A double* (IN) The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_dtrsm_Tile
PLASMA_dtrsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.
int PLASMA_dtrsmpl(int N, int NRHS, double *A, int LDA, double *L, int *IPIV, double *B, int LDB)
PLASMA_DTRSMPL(INTEGER N, INTEGER NRHS, DOUBLE PRECISION A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, DOUBLE PRECISION B, INTEGER LDB, INTEGER INFO)
N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A double* (IN) The tile factor L from the factorization, computed by PLASMA_dgetrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L double* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_dgetrf. IPIV int* (IN) The pivot indices from PLASMA_dgetrf (not equivalent to LAPACK). B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB double* (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_dtrsmpl
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.
int PLASMA_dtrsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_DTRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A double* (IN) The tile factor L from the factorization, computed by PLASMA_dgetrf. L double* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_dgetrf. IPIV int* (IN) The pivot indices from PLASMA_dgetrf (not equivalent to LAPACK). B double* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_dtrsmpl_Tile
PLASMA_sgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.
int PLASMA_sgelqf(int M, int N, float *A, int LDA, float *T)
PLASMA_SGELQF(INTEGER M, INTEGER N, REAL A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A float* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal represent the unitary matrix Q as a product of elementary reflectors, stored by tiles. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T float* (OUT) On exit, auxiliary factorization data, required by PLASMA_sgelqs to solve the system of equations.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_sgelqf
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.
int PLASMA_sgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_SGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
A float* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and below the diagonal of the array contain the m-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal represent the unitary matrix Q as a product of elementary reflectors, stored by tiles. T float* (OUT) On exit, auxiliary factorization data, required by PLASMA_sgelqs to solve the system of equations.
= 0: successful exit
Dive into PLASMA_sgelqf_Tile
PLASMA_sgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_sgelqf.
int PLASMA_sgelqs(int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)
PLASMA_SGELQS(INTEGER M, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER T, REAL B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A float* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf. LDA int (IN) The leading dimension of the array A. LDA >= M. T float* (IN) Auxiliary factorization data, computed by PLASMA_sgelqf. B float* (INOUT) On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= N.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_sgelqs
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.
int PLASMA_sgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_SGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
A float* (IN) Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf. T float* (IN) Auxiliary factorization data, computed by PLASMA_sgelqf. B float* (INOUT) On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_sgelqs_Tile
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:
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 ||.
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.
int PLASMA_sgels(PLASMA_enum trans, int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)
PLASMA_SGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER T, REAL B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**T. Currently only PlasmaNoTrans is supported. M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. A float* (INOUT) On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_sgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_sgelqf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T float* (OUT) On exit, auxiliary factorization data. B float* (INOUT) On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise; On exit, if return value = 0, B is overwritten by the solution vectors, stored columnwise: if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual sum of squares for the solution in each column is given by the sum of squares of the modulus of elements N+1 to M in that column; if M < N, rows 1 to N of B contain the minimum norm solution vectors; LDB int (IN) The leading dimension of the array B. LDB >= MAX(1,M,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_sgels
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:
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 ||.
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.
int PLASMA_sgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_SGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**T. Currently only PlasmaNoTrans is supported. A float* (INOUT) On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_sgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_sgelqf. T float* (OUT) On exit, auxiliary factorization data. B float* (INOUT) On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise; On exit, if return value = 0, B is overwritten by the solution vectors, stored columnwise: if M >= N, rows 1 to N of B contain the least squares solution vectors; the residual sum of squares for the solution in each column is given by the sum of squares of the modulus of elements N+1 to M in that column; if M < N, rows 1 to N of B contain the minimum norm solution vectors;
= 0: successful exit
Dive into PLASMA_sgels_Tile
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.
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)
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)
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).
= 0: successful exit
Dive into PLASMA_sgemm
PLASMA_sgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.
int PLASMA_sgeqrf(int M, int N, float *A, int LDA, float *T)
PLASMA_SGEQRF(INTEGER M, INTEGER N, REAL A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A float* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). T float* (OUT) On exit, auxiliary factorization data, required by PLASMA_sgeqrs to solve the system of equations.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_sgeqrf
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.
int PLASMA_sgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_SGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
A float* (INOUT) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles. T float* (OUT) On exit, auxiliary factorization data, required by PLASMA_sgeqrs to solve the system of equations.
= 0: successful exit
Dive into PLASMA_sgeqrf_Tile
PLASMA_sgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_sgeqrf.
int PLASMA_sgeqrs(int M, int N, int NRHS, float *A, int LDA, float *T, float *B, int LDB)
PLASMA_SGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER T, REAL B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A float* (INOUT) Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf. LDA int (IN) The leading dimension of the array A. LDA >= M. T float* (IN) Auxiliary factorization data, computed by PLASMA_sgeqrf. B float* (INOUT) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_sgeqrs
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.
int PLASMA_sgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_SGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
A float* (INOUT) Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf. T float* (IN) Auxiliary factorization data, computed by PLASMA_sgeqrf. B float* (INOUT) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.
= 0: successful exit
Dive into PLASMA_sgeqrs_Tile
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.
int PLASMA_sgesv(int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)
PLASMA_SGESV(INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, REAL B, INTEGER LDB, INTEGER INFO)
N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A float* (INOUT) On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L float* (OUT) On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. IPIV int* (OUT) On exit, the pivot indices that define the permutations (not equivalent to LAPACK). B float* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
Dive into PLASMA_sgesv
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.
int PLASMA_sgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_SGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A float* (INOUT) On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). L float* (OUT) On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. IPIV int* (OUT) On exit, the pivot indices that define the permutations (not equivalent to LAPACK). B float* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
Dive into PLASMA_sgesv_Tile
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.
int PLASMA_sgetrf(int M, int N, float *A, int LDA, float *L, int *IPIV)
PLASMA_SGETRF(INTEGER M, INTEGER N, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A float* (INOUT) On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. LDA int (IN) The leading dimension of the array A. LDA >= max(1,M). L float* (OUT) On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_sgetrs to solve the system of equations. IPIV int* (OUT) The pivot indices that define the permutations (not equivalent to LAPACK).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Dive into PLASMA_sgetrf
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.
int PLASMA_sgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
PLASMA_SGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
A float* (INOUT) On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. L float* (OUT) On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_sgetrs to solve the system of equations. IPIV int* (OUT) The pivot indices that define the permutations (not equivalent to LAPACK).
= 0: successful exit > 0: if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
Dive into PLASMA_sgetrf_Tile
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.
int PLASMA_sgetrs(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)
PLASMA_SGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, REAL B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended to specify the the form of the system of equations: = PlasmaNoTrans: A * X = B (No transpose) = PlasmaTrans: A**T * X = B (Transpose) = PlasmaTrans: A**T * X = B (Conjugate transpose) Currently only PlasmaNoTrans is supported. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A float* (IN) The tile factors L and U from the factorization, computed by PLASMA_sgetrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L float* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf. IPIV int* (IN) The pivot indices from PLASMA_sgetrf (not equivalent to LAPACK). B float* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_sgetrs
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.
int PLASMA_sgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_SGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A float* (IN) The tile factors L and U from the factorization, computed by PLASMA_sgetrf. L float* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf. IPIV int* (IN) The pivot indices from PLASMA_sgetrf (not equivalent to LAPACK). B float* (INOUT) On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.
= 0: successful exit
Dive into PLASMA_sgetrs_Tile
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.
int PLASMA_sposv(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *B, int LDB)
PLASMA_SPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, REAL B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A float* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_sposv
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.
int PLASMA_sposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_SPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A float* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T. B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_sposv_Tile
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.
int PLASMA_spotrf(PLASMA_enum uplo, int N, float *A, int LDA)
PLASMA_SPOTRF(INTEGER uplo, INTEGER N, REAL A, INTEGER LDA, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. A float* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_spotrf
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.
int PLASMA_spotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
PLASMA_SPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A float* (INOUT) On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
= 0: successful exit > 0: if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
Dive into PLASMA_spotrf_Tile
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.
int PLASMA_spotrs(PLASMA_enum uplo, int N, int NRHS, float *A, int LDA, float *B, int LDB)
PLASMA_SPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, REAL B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A float* (IN) The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, computed by PLASMA_spotrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB int (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_spotrs
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.
int PLASMA_spotrs_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_SPOTRS_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A float* (IN) The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, computed by PLASMA_spotrf. B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_spotrs_Tile
PLASMA_strsm - Computes triangular solve A*X = B or X*A = B
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)
PLASMA_STRSM(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, REAL B, INTEGER LDB, INTEGER INFO)
side PLASMA_enum (IN) Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is conjugate transposed. diag PLASMA_enum (IN) Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A float* (IN) The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB float* (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_strsm
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.
int PLASMA_strsm_Tile(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_STRSM_TILE(INTEGER side, INTEGER uplo, INTEGER transA, INTEGER diag, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
side PLASMA_enum (IN) Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. transA PLASMA_enum (IN) Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is conjugate transposed. diag PLASMA_enum (IN) Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. A float* (IN) The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_strsm_Tile
PLASMA_strsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.
int PLASMA_strsmpl(int N, int NRHS, float *A, int LDA, float *L, int *IPIV, float *B, int LDB)
PLASMA_STRSMPL(INTEGER N, INTEGER NRHS, REAL A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, REAL B, INTEGER LDB, INTEGER INFO)
N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A float* (IN) The tile factor L from the factorization, computed by PLASMA_sgetrf. LDA int (IN) The leading dimension of the array A. LDA >= max(1,N). L float* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf. IPIV int* (IN) The pivot indices from PLASMA_sgetrf (not equivalent to LAPACK). B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. LDB float* (IN) The leading dimension of the array B. LDB >= max(1,N).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_strsmpl
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.
int PLASMA_strsmpl_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_STRSMPL_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
A float* (IN) The tile factor L from the factorization, computed by PLASMA_sgetrf. L float* (IN) Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf. IPIV int* (IN) The pivot indices from PLASMA_sgetrf (not equivalent to LAPACK). B float* (INOUT) On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
= 0: successful exit
Dive into PLASMA_strsmpl_Tile
PLASMA_Lapack_to_Tile - Conversion from LAPACK layout to tile layout.
int PLASMA_Lapack_to_Tile(void *Af77, int LDA, PLASMA_desc *A)
PLASMA_LAPACK_TO_TILE(INTEGER*4 Af77, INTEGER LDA, INTEGER*4 A, INTEGER INFO)
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.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Lapack_to_Tile
PLASMA_Tile_to_Lapack - Conversion from tile layout to LAPACK layout
int PLASMA_Tile_to_Lapack(PLASMA_desc *A, void *Af77, int LDA)
PLASMA_TILE_TO_LAPACK(INTEGER*4 A, INTEGER*4 Af77, INTEGER LDA, INTEGER INFO)
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.
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Tile_to_Lapack
PLASMA_Dealloc_Handle - Deallocate workspace handle allocated by any workspace allocation routine.
PLASMA_DEALLOC_HANDLE(INTEGER sp, INTEGER INFO)
handle void** (IN) Workspace handle
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Dealloc_Handle
PLASMA_Dealloc_Handle - Deallocate workspace handle allocated by any workspace allocation routine.
PLASMA_DEALLOC_HANDLE(INTEGER sp, INTEGER INFO)
handle void** (IN) Workspace handle
= PLASMA_SUCCESS: successful exit
Dive into PLASMA_Dealloc_Handle
PLASMA_Alloc_Workspace_cgels - Allocates workspace for PLASMA_cgels or PLASMA_cgels_Tile routine.
int PLASMA_Alloc_Workspace_cgels(int M, int N, PLASMA_Complex32_t **T)
PLASMA_ALLOC_WORKSPACE_CGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. 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.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_cgels
PLASMA_Alloc_Workspace_cgeqrf - Allocates workspace for PLASMA_cgeqrf or PLASMA_cgeqrf_Tile routine.
int PLASMA_Alloc_Workspace_cgeqrf(int M, int N, PLASMA_Complex32_t **T)
PLASMA_ALLOC_WORKSPACE_CGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T PLASMA_Complex32_t* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile QR factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_cgeqrf
PLASMA_Alloc_Workspace_cgelqf - Allocates workspace for PLASMA_cgelqf or PLASMA_cgelqf_Tile routines.
int PLASMA_Alloc_Workspace_cgelqf(int M, int N, PLASMA_Complex32_t **T)
PLASMA_ALLOC_WORKSPACE_CGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T PLASMA_Complex32_t* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile LQ factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_cgelqf
PLASMA_Alloc_Workspace_cgesv - Allocates workspace for PLASMA_cgesv or PLASMA_cgesv_Tile routines.
int PLASMA_Alloc_Workspace_cgesv(int N, PLASMA_Complex32_t **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_CGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_cgesv
PLASMA_Alloc_Workspace_cgetrf - Allocates workspace for PLASMA_cgetrf or PLASMA_cgetrf_Tile routines.
int PLASMA_Alloc_Workspace_cgetrf(int M, int N, PLASMA_Complex32_t **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_CGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. 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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_cgetrf
PLASMA_Alloc_Workspace_dgels - Allocates workspace for PLASMA_dgels or PLASMA_dgels_Tile routine.
int PLASMA_Alloc_Workspace_dgels(int M, int N, double **T)
PLASMA_ALLOC_WORKSPACE_DGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T double* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile QR or the tile LQ factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_dgels
PLASMA_Alloc_Workspace_dgeqrf - Allocates workspace for PLASMA_dgeqrf or PLASMA_dgeqrf_Tile routine.
int PLASMA_Alloc_Workspace_dgeqrf(int M, int N, double **T)
PLASMA_ALLOC_WORKSPACE_DGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T double* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile QR factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_dgeqrf
PLASMA_Alloc_Workspace_dgelqf - Allocates workspace for PLASMA_dgelqf or PLASMA_dgelqf_Tile routines.
int PLASMA_Alloc_Workspace_dgelqf(int M, int N, double **T)
PLASMA_ALLOC_WORKSPACE_DGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T double* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile LQ factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_dgelqf
PLASMA_Alloc_Workspace_dgesv - Allocates workspace for PLASMA_dgesv or PLASMA_dgesv_Tile routines.
int PLASMA_Alloc_Workspace_dgesv(int N, double **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_DGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_dgesv
PLASMA_Alloc_Workspace_dgetrf - Allocates workspace for PLASMA_dgetrf or PLASMA_dgetrf_Tile routines.
int PLASMA_Alloc_Workspace_dgetrf(int M, int N, double **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_DGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. 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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_dgetrf
PLASMA_Alloc_Workspace_sgels - Allocates workspace for PLASMA_sgels or PLASMA_sgels_Tile routine.
int PLASMA_Alloc_Workspace_sgels(int M, int N, float **T)
PLASMA_ALLOC_WORKSPACE_SGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T float* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile QR or the tile LQ factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_sgels
PLASMA_Alloc_Workspace_sgeqrf - Allocates workspace for PLASMA_sgeqrf or PLASMA_sgeqrf_Tile routine.
int PLASMA_Alloc_Workspace_sgeqrf(int M, int N, float **T)
PLASMA_ALLOC_WORKSPACE_SGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T float* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile QR factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_sgeqrf
PLASMA_Alloc_Workspace_sgelqf - Allocates workspace for PLASMA_sgelqf or PLASMA_sgelqf_Tile routines.
int PLASMA_Alloc_Workspace_sgelqf(int M, int N, float **T)
PLASMA_ALLOC_WORKSPACE_SGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T float* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile LQ factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_sgelqf
PLASMA_Alloc_Workspace_sgesv - Allocates workspace for PLASMA_sgesv or PLASMA_sgesv_Tile routines.
int PLASMA_Alloc_Workspace_sgesv(int N, float **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_SGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_sgesv
PLASMA_Alloc_Workspace_sgetrf - Allocates workspace for PLASMA_sgetrf or PLASMA_sgetrf_Tile routines.
int PLASMA_Alloc_Workspace_sgetrf(int M, int N, float **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_SGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. 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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_sgetrf
PLASMA_Alloc_Workspace_zgels - Allocates workspace for PLASMA_zgels or PLASMA_zgels_Tile routine.
int PLASMA_Alloc_Workspace_zgels(int M, int N, PLASMA_Complex64_t **T)
PLASMA_ALLOC_WORKSPACE_ZGELS(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. 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.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_zgels
PLASMA_Alloc_Workspace_zgeqrf - Allocates workspace for PLASMA_zgeqrf or PLASMA_zgeqrf_Tile routine.
int PLASMA_Alloc_Workspace_zgeqrf(int M, int N, PLASMA_Complex64_t **T)
PLASMA_ALLOC_WORKSPACE_ZGEQRF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T PLASMA_Complex64_t* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile QR factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_zgeqrf
PLASMA_Alloc_Workspace_zgelqf - Allocates workspace for PLASMA_zgelqf or PLASMA_zgelqf_Tile routines.
int PLASMA_Alloc_Workspace_zgelqf(int M, int N, PLASMA_Complex64_t **T)
PLASMA_ALLOC_WORKSPACE_ZGELQF(INTEGER M, INTEGER N, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. T PLASMA_Complex64_t* (OUT) On exit, workspace handle for storage of the extra T factors required by the tile LQ factorization.
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_zgelqf
PLASMA_Alloc_Workspace_zgesv - Allocates workspace for PLASMA_zgesv or PLASMA_zgesv_Tile routines.
int PLASMA_Alloc_Workspace_zgesv(int N, PLASMA_Complex64_t **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_ZGESV(INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_zgesv
PLASMA_Alloc_Workspace_zgetrf - Allocates workspace for PLASMA_zgetrf or PLASMA_zgetrf_Tile routines.
int PLASMA_Alloc_Workspace_zgetrf(int M, int N, PLASMA_Complex64_t **L, int **IPIV)
PLASMA_ALLOC_WORKSPACE_ZGETRF(INTEGER M, INTEGER N, INTEGER L, INTEGER IPIV, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. 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).
= 0: successful exit
Dive into PLASMA_Alloc_Workspace_zgetrf
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
ITER is the number of the current iteration in the iterative refinement process
RNRM is the infinity-norm of the residual
XNRM is the infinity-norm of the solution
ANRM is the infinity-operator-norm of the matrix A
EPS is the machine epsilon returned by DLAMCH(Epsilon).
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.
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)
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)
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
= 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.
Dive into PLASMA_zcgesv
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
ITER is the number of the current iteration in the iterative refinement process
RNRM is the infinity-norm of the residual
XNRM is the infinity-norm of the solution
ANRM is the infinity-operator-norm of the matrix A
EPS is the machine epsilon returned by DLAMCH(Epsilon).
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.
int PLASMA_zcgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
PLASMA_ZCGESV_TILE(INTEGER*4 A, INTEGER4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER*4 X, ITER, INTEGER INFO)
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.
= 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.
Dive into PLASMA_zcgesv_Tile
PLASMA_zgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.
int PLASMA_zgelqf(int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T)
PLASMA_ZGELQF(INTEGER M, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A PLASMA_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.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_zgelqf
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.
int PLASMA_zgelqf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_ZGELQF_TILE(INTEGER*4 A, INTEGER*4 T,INTEGER INFO)
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.
= 0: successful exit
Dive into PLASMA_zgelqf_Tile
PLASMA_zgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_zgelqf.
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)
PLASMA_ZGELQS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER T, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A PLASMA_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.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_zgelqs
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.
int PLASMA_zgelqs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_ZGELQS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
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.
= 0: successful exit
Dive into PLASMA_zgelqs_Tile
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:
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 ||.
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.
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)
PLASMA_ZGELS(INTEGER trans, INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER T, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported. M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. A PLASMA_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).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_zgels
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:
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 ||.
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.
int PLASMA_zgels_Tile(PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_ZGELS_TILE(INTEGER trans, INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
trans PLASMA_enum (IN) Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported. A PLASMA_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;
= 0: successful exit
Dive into PLASMA_zgels_Tile
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.
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)
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)
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).
= 0: successful exit
Dive into PLASMA_zgemm
PLASMA_zgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.
int PLASMA_zgeqrf(int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T)
PLASMA_ZGEQRF(INTEGER M, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER T, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A PLASMA_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.
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_zgeqrf
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.
int PLASMA_zgeqrf_Tile(PLASMA_desc *A, PLASMA_desc *T)
PLASMA_ZGEQRF_TILE(INTEGER*4 A, INTEGER*4 T, INTEGER INFO)
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.
= 0: successful exit
Dive into PLASMA_zgeqrf_Tile
PLASMA_zgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_zgeqrf.
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)
PLASMA_ZGEQRS(INTEGER M, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER T, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= M >= 0. NRHS int (IN) The number of columns of B. NRHS >= 0. A PLASMA_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).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_zgeqrs
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.
int PLASMA_zgeqrs_Tile(PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *T)
PLASMA_ZGEQRS_TILE(INTEGER*4 A, INTEGER*4 B, INTEGER*4 T, INTEGER INFO)
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.
= 0: successful exit
Dive into PLASMA_zgeqrs_Tile
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.
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)
PLASMA_ZGESV(INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_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).
= 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.
Dive into PLASMA_zgesv
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.
int PLASMA_zgesv_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_ZGESV_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
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.
= 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.
Dive into PLASMA_zgesv_Tile
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.
int PLASMA_zgetrf(int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *L, int *IPIV)
PLASMA_ZGETRF(INTEGER M, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, INTEGER INFO)
M int (IN) The number of rows of the matrix A. M >= 0. N int (IN) The number of columns of the matrix A. N >= 0. A PLASMA_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).
= 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.
Dive into PLASMA_zgetrf
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.
int PLASMA_zgetrf_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
PLASMA_ZGETRF_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER INFO)
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).
= 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.
Dive into PLASMA_zgetrf_Tile
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.
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)
PLASMA_ZGETRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, INTEGER LH, INTEGER IPIVH, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
trans PLASMA_enum (IN) Intended to specify the the form of the system of equations: = PlasmaNoTrans: A * X = B (No transpose) = PlasmaTrans: A**T * X = B (Transpose) = PlasmaConjTrans: A**H * X = B (Conjugate transpose) Currently only PlasmaNoTrans is supported. N int (IN) The order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_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).
= 0: successful exit < 0: if -i, the i-th argument had an illegal value
Dive into PLASMA_zgetrs
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.
int PLASMA_zgetrs_Tile(PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
PLASMA_ZGETRS_TILE(INTEGER*4 A, INTEGER*4 L, INTEGER IPIVH, INTEGER*4 B, INTEGER INFO)
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.
= 0: successful exit
Dive into PLASMA_zgetrs_Tile
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.
int PLASMA_zposv(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
PLASMA_ZPOSV(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The number of linear equations, i.e., the order of the matrix A. N >= 0. NRHS int (IN) The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A PLASMA_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).
= 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.
Dive into PLASMA_zposv
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.
int PLASMA_zposv_Tile(PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
PLASMA_ZPOSV_TILE(INTEGER uplo, INTEGER*4 A, INTEGER*4 B, INTEGER INFO)
uplo PLASMA_enum (IN) Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A PLASMA_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.
= 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.
Dive into PLASMA_zposv_Tile
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.
int PLASMA_zpotrf(PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA)
PLASMA_ZPOTRF(INTEGER uplo, INTEGER N, COMPLEX*16 A, INTEGER LDA, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. N int (IN) The order of the matrix A. N >= 0. A PLASMA_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).
= 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.
Dive into PLASMA_zpotrf
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.
int PLASMA_zpotrf_Tile(PLASMA_enum uplo, PLASMA_desc *A)
PLASMA_ZPOTRF_TILE(INTEGER uplo, INTEGER*4 A, INTEGER INFO)
uplo PLASMA_enum (IN) = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. A PLASMA_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.
= 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.
Dive into PLASMA_zpotrf_Tile
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.
int PLASMA_zpotrs(PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
PLASMA_ZPOTRS(INTEGER uplo, INTEGER N, INTEGER NRHS, COMPLEX*16 A, INTEGER LDA, COMPLEX*16 B, INTEGER LDB, INTEGER INFO)