/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* 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 = U**H*U or A = L*L**H computed by PLASMA_zpotrf.
*
*******************************************************************************
*
* @param[in] uplo
* = PlasmaUpper: Upper triangle of A is stored;
* = PlasmaLower: Lower triangle of A is stored.
*
* @param[in] N
* The order of the matrix A. N >= 0.
*
* @param[in] NRHS
* The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
*
* @param[in] A
* The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H,
* computed by PLASMA_zpotrf.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,N).
*
* @param[in,out] B
* On entry, the N-by-NRHS right hand side matrix B.
* On exit, if return value = 0, the N-by-NRHS solution matrix X.
*
* @param[in] LDB
* The leading dimension of the array B. LDB >= max(1,N).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
*
*******************************************************************************
*
* @sa PLASMA_zpotrs_Tile
* @sa PLASMA_zpotrs_Tile_Async
* @sa PLASMA_cpotrs
* @sa PLASMA_dpotrs
* @sa PLASMA_spotrs
* @sa PLASMA_zpotrf
*
******************************************************************************/
int PLASMA_zpotrs(PLASMA_enum uplo, int N, int NRHS,
PLASMA_Complex64_t *A, int LDA,
PLASMA_Complex64_t *B, int LDB)
{
int NB;
int status;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA, descB;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zpotrs", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_zpotrs", "illegal value of uplo");
return -1;
}
if (N < 0) {
plasma_error("PLASMA_zpotrs", "illegal value of N");
return -2;
}
if (NRHS < 0) {
plasma_error("PLASMA_zpotrs", "illegal value of NRHS");
return -3;
}
if (LDA < max(1, N)) {
plasma_error("PLASMA_zpotrs", "illegal value of LDA");
return -5;
}
if (LDB < max(1, N)) {
plasma_error("PLASMA_zpotrs", "illegal value of LDB");
return -7;
}
/* Quick return */
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZPOSV, N, N, NRHS);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zpotrs", "plasma_tune() failed");
return status;
}
/* Set NT & NTRHS */
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N , plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)));
} else {
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zgesv_incpiv - 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.
*
*******************************************************************************
*
* @param[in] N
* The number of linear equations, i.e., the order of the matrix A. N >= 0.
*
* @param[in] NRHS
* The number of right hand sides, i.e., the number of columns of the matrix B.
* NRHS >= 0.
*
* @param[in,out] A
* On entry, the N-by-N coefficient matrix A.
* On exit, the tile L and U factors from the factorization (not equivalent to LAPACK).
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,N).
*
* @param[out] L
* On exit, auxiliary factorization data, related to the tile L factor,
* necessary to solve the system of equations.
*
* @param[out] IPIV
* On exit, the pivot indices that define the permutations (not equivalent to LAPACK).
*
* @param[in,out] B
* 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.
*
* @param[in] LDB
* The leading dimension of the array B. LDB >= max(1,N).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
* \retval >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.
*
*******************************************************************************
*
* @sa PLASMA_zgesv_incpiv_Tile
* @sa PLASMA_zgesv_incpiv_Tile_Async
* @sa PLASMA_cgesv_incpiv
* @sa PLASMA_dgesv_incpiv
* @sa PLASMA_sgesv_incpiv
*
******************************************************************************/
int PLASMA_zgesv_incpiv(int N, int NRHS,
PLASMA_Complex64_t *A, int LDA,
PLASMA_Complex64_t *L, int *IPIV,
PLASMA_Complex64_t *B, int LDB)
{
int NB, IB, IBNB, NT;
int status;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA, descB, descL;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_error("PLASMA_zgesv_incpiv", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if (N < 0) {
plasma_error("PLASMA_zgesv_incpiv", "illegal value of N");
return -1;
}
if (NRHS < 0) {
plasma_error("PLASMA_zgesv_incpiv", "illegal value of NRHS");
return -2;
}
if (LDA < max(1, N)) {
plasma_error("PLASMA_zgesv_incpiv", "illegal value of LDA");
return -4;
}
if (LDB < max(1, N)) {
plasma_error("PLASMA_zgesv_incpiv", "illegal value of LDB");
return -8;
}
/* Quick return */
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
/* Tune NB & IB depending on M, N & NRHS; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZGESV, N, N, NRHS);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zgesv_incpiv", "plasma_tune() failed");
return status;
}
/* Set NT & NTRHS */
NB = PLASMA_NB;
IB = PLASMA_IB;
IBNB = IB*NB;
NT = (N%NB==0) ? (N/NB) : (N/NB+1);
plasma_sequence_create(plasma, &sequence);
descL = plasma_desc_init(
PlasmaComplexDouble,
IB, NB, IBNB,
NT*IB, NT*NB, 0, 0, NT*IB, NT*NB);
descL.mat = L;
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N , plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)));
} else {
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zgesvd - computes the singular value decomposition (SVD) of a complex
* M-by-N matrix A, optionally computing the left and/or right singular
* vectors. The SVD is written
*
* A = U * SIGMA * transpose(V)
*
* where SIGMA is an M-by-N matrix which is zero except for its
* min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
* V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA
* are the singular values of A; they are real and non-negative, and
* are returned in descending order. The first min(m,n) columns of
* U and V are the left and right singular vectors of A.
*
* Note that the routine returns V**T, not V.
* Not LAPACK Compliant for now!
* Note: Only PlasmaNoVec supported!
*******************************************************************************
*
* @param[in] jobu
* Specifies options for computing all or part of the matrix U.
* Intended usage:
* = PlasmaVec: all M columns of U are returned in array U;
* = PlasmaNoVec: no columns of U (no left singular vectors) are
* computed.
* Note: Only PlasmaNoVec supported!
*
* @param[in] jobvt
* Specifies options for computing all or part of the matrix V**H.
* Intended usage:
* = PlasmaVec: all M columns of U are returned in array U;
* = PlasmaNoVec: no columns of U (no left singular vectors) are
* computed.
* Note: Only PlasmaNoVec supported!
*
* @param[in] M
* The number of rows of the matrix A. M >= 0.
*
* @param[in] N
* The number of columns of the matrix A. N >= 0.
*
* @param[in,out] A
* On entry, the M-by-N matrix A.
* On exit,
* if JOBU = 'O', A is overwritten with the first min(m,n)
* columns of U (the left singular vectors,
* stored columnwise);
* if JOBVT = 'O', A is overwritten with the first min(m,n)
* rows of V**H (the right singular vectors,
* stored rowwise);
* if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A
* are destroyed.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,M).
*
* @param[out] S
* The double precision singular values of A, sorted so that S(i) >= S(i+1).
*
* @param[out] U
* (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.
* If JOBU = 'A', U contains the M-by-M unitary matrix U;
* if JOBU = 'S', U contains the first min(m,n) columns of U
* (the left singular vectors, stored columnwise);
* if JOBU = 'N' or 'O', U is not referenced.
*
* @param[in] LDU
* The leading dimension of the array U. LDU >= 1; if
* JOBU = 'S' or 'A', LDU >= M.
*
* @param[out] VT
* If JOBVT = 'A', VT contains the N-by-N unitary matrix
* V**H;
* if JOBVT = 'S', VT contains the first min(m,n) rows of
* V**H (the right singular vectors, stored rowwise);
* if JOBVT = 'N' or 'O', VT is not referenced.
*
* @param[in] LDVT
* The leading dimension of the array VT. LDVT >= 1; if
* JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N).
*
* @param[in, out] descT
* On entry, descriptor as return by PLASMA_Alloc_Workspace_zgesvd
* On exit, contains auxiliary factorization data.
*
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
*
*******************************************************************************
*
* @sa PLASMA_zgesvd_Tile
* @sa PLASMA_zgesvd_Tile_Async
* @sa PLASMA_cgesvd
* @sa PLASMA_dgesvd
* @sa PLASMA_sgesvd
*
******************************************************************************/
int PLASMA_zgesvd(PLASMA_enum jobu, PLASMA_enum jobvt, int M, int N,
PLASMA_Complex64_t *A, int LDA,
double *S,
PLASMA_Complex64_t *U, int LDU,
PLASMA_Complex64_t *VT, int LDVT,
PLASMA_desc *descT)
{
int NB, IB, IBNB, minMN, MT, NT, minMTNT;
int status;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA, descU, descVT;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zgesvd", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Tune NB & IB depending on M & N; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZGESVD, M, N, 0);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zgesvd", "plasma_tune() failed");
return status;
}
/* Set MT, NT */
NB = PLASMA_NB;
IB = PLASMA_IB;
IBNB = IB*NB;
MT = (M%NB==0) ? (M/NB) : (M/NB+1);
NT = (N%NB==0) ? (N/NB) : (N/NB+1);
minMN = min(M,N);
minMTNT = min(MT,NT);
/* Check input arguments */
if (jobu != PlasmaNoVec && jobu !=PlasmaVec) {
plasma_error("PLASMA_zgesvd", "illegal value of jobu");
return -1;
}
if (jobvt != PlasmaNoVec && jobvt != PlasmaVec) {
plasma_error("PLASMA_zgesvd", "illegal value of jobvt");
return -2;
}
if (M < 0) {
plasma_error("PLASMA_zgesvd", "illegal value of M");
return -3;
}
if (N < 0) {
plasma_error("PLASMA_zgesvd", "illegal value of N");
return -4;
}
if (LDA < max(1, M)) {
plasma_error("PLASMA_zgesvd", "illegal value of LDA");
return -6;
}
if (LDU < 1) {
plasma_error("PLASMA_zgesvd", "illegal value of LDU");
return -9;
}
if (LDVT < 1) {
plasma_error("PLASMA_zgesvd", "illegal value of LDVT");
return -11;
}
if ( (plasma_desc_check(descT) != PLASMA_SUCCESS) ||
( descT->m != MT*IB ) || (descT->n != NT*NB) ) {
plasma_error("PLASMA_zgesvd", "invalid T descriptor");
return -12;
}
/* Quick return */
if (min(M, N) == 0) {
return PLASMA_SUCCESS;
}
if (jobu == PlasmaVec) {
plasma_error("PLASMA_zgesvd", "computing the singular vectors is not supported in this version");
return -1;
}
if (jobvt == PlasmaVec) {
plasma_error("PLASMA_zgesvd", "computing the singular vectors is not supported in this version");
return -2;
}
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N, plasma_desc_mat_free(&(descA)) );
if (jobu == PlasmaVec){
plasma_zooplap2tile( descU, U, NB, NB, LDU, M, 0, 0, M, M, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descU)));
}
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zgetri - Computes the inverse of a matrix using the LU factorization
* computed by PLASMA_zgetrf.
* This method inverts U and then computes inv(A) by solving the system
* inv(A)*L = inv(U) for inv(A).
*
*******************************************************************************
*
* @param[in] N
* The order of the matrix A. N >= 0.
*
* @param[in,out] A
* On entry, the triangular factor L or U from the
* factorization A = P*L*U as computed by PLASMA_zgetrf.
* On exit, if return value = 0, the inverse of the original
* matrix A.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,N).
*
* @param[in] IPIV
* The pivot indices that define the permutations
* as returned by PLASMA_zgetrf.
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
* \retval >0 if i, the (i,i) element of the factor U is
* exactly zero; The matrix is singular
* and its inverse could not be computed.
*
*******************************************************************************
*
* @sa PLASMA_zgetri_Tile
* @sa PLASMA_zgetri_Tile_Async
* @sa PLASMA_cgetri
* @sa PLASMA_dgetri
* @sa PLASMA_sgetri
* @sa PLASMA_zgetrf
*
******************************************************************************/
int PLASMA_zgetri(int N,
PLASMA_Complex64_t *A, int LDA,
int *IPIV)
{
int NB;
int status;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA;
PLASMA_desc descW;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zgetri", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if (N < 0) {
plasma_error("PLASMA_zgetri", "illegal value of N");
return -1;
}
if (LDA < max(1, N)) {
plasma_error("PLASMA_zgetri", "illegal value of LDA");
return -3;
}
/* Quick return */
if (max(N, 0) == 0)
return PLASMA_SUCCESS;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZGESV, N, N, 0);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zgetri", "plasma_tune() failed");
return status;
}
/* Set NT */
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N, sequence, &request,
plasma_desc_mat_free(&(descA)) );
} else {
plasma_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N,
sequence, &request);
}
/* Allocate workspace */
PLASMA_Alloc_Workspace_zgetri_Tile_Async(&descA, &descW);
/* Call the tile interface */
PLASMA_zgetri_Tile_Async(&descA, IPIV, &descW, sequence, &request);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooptile2lap( descA, A, NB, NB, LDA, N, sequence, &request);
plasma_dynamic_sync();
plasma_desc_mat_free(&descA);
} else {
plasma_ziptile2lap( descA, A, NB, NB, LDA, N, sequence, &request);
plasma_dynamic_sync();
}
plasma_desc_mat_free(&(descW));
status = sequence->status;
plasma_sequence_destroy(plasma, sequence);
return status;
}
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zcposv - 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.
*
* PLASMA_zcposv 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.
*
*******************************************************************************
*
* @param[in] uplo
* 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.
*
* @param[in] N
* The number of linear equations, i.e., the order of the matrix A. N >= 0.
*
* @param[in] NRHS
* The number of right hand sides, i.e., the number of columns of the matrix B.
* NRHS >= 0.
*
* @param[in] A
* The N-by-N symmetric positive definite (or Hermitian) coefficient 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.
* This matrix is not modified.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,N).
*
* @param[in] B
* The N-by-NRHS matrix of right hand side matrix B.
*
* @param[in] LDB
* The leading dimension of the array B. LDB >= max(1,N).
*
* @param[out] X
* If return value = 0, the N-by-NRHS solution matrix X.
*
* @param[in] LDX
* The leading dimension of the array B. LDX >= max(1,N).
*
* @param[out] ITER
* The number of the current iteration in the iterative refinement process
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
* \retval >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.
*
*******************************************************************************
*
* @sa PLASMA_zcposv_Tile
* @sa PLASMA_zcposv_Tile_Async
* @sa PLASMA_dsposv
* @sa PLASMA_zposv
*
******************************************************************************/
int PLASMA_zcposv(PLASMA_enum uplo, int N, int NRHS,
PLASMA_Complex64_t *A, int LDA,
PLASMA_Complex64_t *B, int LDB,
PLASMA_Complex64_t *X, int LDX, int *ITER)
{
int NB;
int status;
PLASMA_desc descA;
PLASMA_desc descB;
PLASMA_desc descX;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zcposv", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_zcposv", "illegal value of uplo");
return -1;
}
if (N < 0) {
plasma_error("PLASMA_zcposv", "illegal value of N");
return -2;
}
if (NRHS < 0) {
plasma_error("PLASMA_zcposv", "illegal value of NRHS");
return -3;
}
if (LDA < max(1, N)) {
plasma_error("PLASMA_zcposv", "illegal value of LDA");
return -5;
}
if (LDB < max(1, N)) {
plasma_error("PLASMA_zcposv", "illegal value of LDB");
return -7;
}
if (LDX < max(1, N)) {
plasma_error("PLASMA_zcposv", "illegal value of LDX");
return -10;
}
/* Quick return - currently NOT equivalent to LAPACK's
* LAPACK does not have such check for ZCPOSV */
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
/* Tune NB depending on M, N & NRHS; Set NBNBSIZE */
status = plasma_tune(PLASMA_FUNC_ZCPOSV, N, N, NRHS);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zcposv", "plasma_tune() failed");
return status;
}
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
/* DOUBLE PRECISION INITIALIZATION */
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N , plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)) );
plasma_zdesc_alloc( descX, NB, NB, N, NRHS, 0, 0, N, NRHS, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)); plasma_desc_mat_free(&(descX)) );
} else {
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zhemm - Performs one of the matrix-matrix operations
*
* \f[ C = \alpha \times A \times B + \beta \times C \f]
*
* or
*
* \f[ C = \alpha \times B \times A + \beta \times C \f]
*
* where alpha and beta are scalars, A is an hermitian matrix and B and
* C are m by n matrices.
*
*******************************************************************************
*
* @param[in] side
* Specifies whether the hermitian matrix A appears on the
* left or right in the operation as follows:
* = PlasmaLeft: \f[ C = \alpha \times A \times B + \beta \times C \f]
* = PlasmaRight: \f[ C = \alpha \times B \times A + \beta \times C \f]
*
* @param[in] uplo
* Specifies whether the upper or lower triangular part of
* the hermitian matrix A is to be referenced as follows:
* = PlasmaLower: Only the lower triangular part of the
* hermitian matrix A is to be referenced.
* = PlasmaUpper: Only the upper triangular part of the
* hermitian matrix A is to be referenced.
*
* @param[in] M
* Specifies the number of rows of the matrix C. M >= 0.
*
* @param[in] N
* Specifies the number of columns of the matrix C. N >= 0.
*
* @param[in] alpha
* Specifies the scalar alpha.
*
* @param[in] A
* A is a LDA-by-ka matrix, where ka is M when side = PlasmaLeft,
* and is N otherwise. Only the uplo triangular part is referenced.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,ka).
*
* @param[in] B
* B is a LDB-by-N matrix, where the leading M-by-N part of
* the array B must contain the matrix B.
*
* @param[in] LDB
* The leading dimension of the array B. LDB >= max(1,M).
*
* @param[in] beta
* Specifies the scalar beta.
*
* @param[in,out] C
* C is a LDC-by-N matrix.
* On exit, the array is overwritten by the M by N updated matrix.
*
* @param[in] LDC
* The leading dimension of the array C. LDC >= max(1,M).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
*
*******************************************************************************
*
* @sa PLASMA_zhemm_Tile
* @sa PLASMA_chemm
* @sa PLASMA_dhemm
* @sa PLASMA_shemm
*
******************************************************************************/
int PLASMA_zhemm(PLASMA_enum side, PLASMA_enum uplo, int M, int N,
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)
{
int NB;
int Am;
int status;
PLASMA_desc descA, descB, descC;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zhemm", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if ( (side != PlasmaLeft) && (side != PlasmaRight) ){
plasma_error("PLASMA_zhemm", "illegal value of side");
return -1;
}
if ((uplo != PlasmaLower) && (uplo != PlasmaUpper)) {
plasma_error("PLASMA_zhemm", "illegal value of uplo");
return -2;
}
Am = ( side == PlasmaLeft ) ? M : N;
if (M < 0) {
plasma_error("PLASMA_zhemm", "illegal value of M");
return -3;
}
if (N < 0) {
plasma_error("PLASMA_zhemm", "illegal value of N");
return -4;
}
if (LDA < max(1, Am)) {
plasma_error("PLASMA_zhemm", "illegal value of LDA");
return -7;
}
if (LDB < max(1, M)) {
plasma_error("PLASMA_zhemm", "illegal value of LDB");
return -9;
}
if (LDC < max(1, M)) {
plasma_error("PLASMA_zhemm", "illegal value of LDC");
return -12;
}
/* Quick return */
if (M == 0 || N == 0 ||
((alpha == (PLASMA_Complex64_t)0.0) && beta == (PLASMA_Complex64_t)1.0))
return PLASMA_SUCCESS;
/* Tune NB depending on M, N & NRHS; Set NBNBSIZE */
status = plasma_tune(PLASMA_FUNC_ZHEMM, M, N, 0);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zhemm", "plasma_tune() failed");
return status;
}
/* Set MT & NT & KT */
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, Am, 0, 0, Am, Am,
plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descB, B, NB, NB, LDB, N, 0, 0, M, N,
plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)));
plasma_zooplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M, N,
plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)); plasma_desc_mat_free(&(descC)));
} else {
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zunglq - 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_zgelqf.
*
*******************************************************************************
*
* @param[in] M
* The number of rows of the matrix Q. M >= 0.
*
* @param[in] N
* The number of columns of the matrix Q. N >= M.
*
* @param[in] K
* The number of rows of elementary tile reflectors whose product defines the matrix Q.
* M >= K >= 0.
*
* @param[in] A
* Details of the LQ factorization of the original matrix A as returned by PLASMA_zgelqf.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,M).
*
* @param[in] T
* Auxiliary factorization data, computed by PLASMA_zgelqf.
*
* @param[out] Q
* On exit, the M-by-N matrix Q.
*
* @param[in] LDQ
* The leading dimension of the array Q. LDQ >= max(1,M).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval PLASMA_SUCCESS <0 if -i, the i-th argument had an illegal value
*
*******************************************************************************
*
* @sa PLASMA_zunglq_Tile
* @sa PLASMA_zunglq_Tile_Async
* @sa PLASMA_cunglq
* @sa PLASMA_dorglq
* @sa PLASMA_sorglq
* @sa PLASMA_zgelqf
*
******************************************************************************/
int PLASMA_zunglq(int M, int N, int K,
PLASMA_Complex64_t *A, int LDA,
PLASMA_Complex64_t *T,
PLASMA_Complex64_t *Q, int LDQ)
{
int NB, IB, IBNB, KT, NT;
int status;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA, descQ, descT;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zunglq", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (M < 0) {
plasma_error("PLASMA_zunglq", "illegal value of M");
return -1;
}
if (N < M) {
plasma_error("PLASMA_zunglq", "illegal value of N");
return -2;
}
if (K < 0 || K > M) {
plasma_error("PLASMA_zunglq", "illegal value of K");
return -3;
}
if (LDA < max(1, M)) {
plasma_error("PLASMA_zunglq", "illegal value of LDA");
return -5;
}
if (LDQ < max(1, M)) {
plasma_error("PLASMA_zunglq", "illegal value of LDQ");
return -8;
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, B, LDQ ) */
if (min(M, min(N, K)) == 0)
return PLASMA_SUCCESS;
/* Tune NB & IB depending on M, N & NRHS; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZGELS, M, N, 0);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zunglq", "plasma_tune() failed");
return status;
}
/* Set MT & NT */
NB = PLASMA_NB;
IB = PLASMA_IB;
IBNB = IB*NB;
NT = (N%NB==0) ? (N/NB) : (N/NB+1);
KT = (K%NB==0) ? (K/NB) : (K/NB+1);
plasma_sequence_create(plasma, &sequence);
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
descT = plasma_desc_init(
PlasmaComplexDouble,
IB, NB, IBNB,
KT*IB, NT*NB, 0, 0, KT*IB, NT*NB);
}
else {
/* Double the size of T to accomodate the tree reduction phase */
descT = plasma_desc_init(
PlasmaComplexDouble,
IB, NB, IBNB,
KT*IB, 2*NT*NB, 0, 0, KT*IB, 2*NT*NB);
}
descT.mat = T;
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, K, N, plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descQ, Q, NB, NB, LDQ, N, 0, 0, M, N, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descQ)));
} else {
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zlansy returns the value
*
* zlansy = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm
* (
* ( norm1(A), NORM = PlasmaOneNorm
* (
* ( normI(A), NORM = PlasmaInfNorm
* (
* ( normF(A), NORM = PlasmaFrobeniusNorm
*
* where norm1 denotes the one norm of a matrix (maximum column sum),
* normI denotes the infinity norm of a matrix (maximum row sum) and
* normF denotes the Frobenius norm of a matrix (square root of sum
* of squares). Note that max(abs(A(i,j))) is not a consistent matrix
* norm.
*
*******************************************************************************
*
* @param[in] norm
* = PlasmaMaxNorm: Max norm
* = PlasmaOneNorm: One norm
* = PlasmaInfNorm: Infinity norm
* = PlasmaFrobeniusNorm: Frobenius norm
*
* @param[in] uplo
* = PlasmaUpper: Upper triangle of A is stored;
* = PlasmaLower: Lower triangle of A is stored.
*
* @param[in] N
* The number of columns/rows of the matrix A. N >= 0. When N = 0,
* the returned value is set to zero.
*
* @param[in] A
* The N-by-N matrix A.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,N).
*
*******************************************************************************
*
* @return
* \retval the norm described above.
*
*******************************************************************************
*
* @sa PLASMA_zlansy_Tile
* @sa PLASMA_zlansy_Tile_Async
* @sa PLASMA_clansy
* @sa PLASMA_dlansy
* @sa PLASMA_slansy
*
******************************************************************************/
double PLASMA_zlansy(PLASMA_enum norm, PLASMA_enum uplo, int N,
PLASMA_Complex64_t *A, int LDA)
{
int NB;
int status;
double value;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zlansy", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if ( (norm != PlasmaMaxNorm) && (norm != PlasmaOneNorm)
&& (norm != PlasmaInfNorm) && (norm != PlasmaFrobeniusNorm) ) {
plasma_error("PLASMA_zlansy", "illegal value of norm");
return -1;
}
if ( (uplo != PlasmaUpper) && (uplo != PlasmaLower) ) {
plasma_error("PLASMA_zlansy", "illegal value of uplo");
return -2;
}
if (N < 0) {
plasma_error("PLASMA_zlansy", "illegal value of N");
return -3;
}
if (LDA < max(1, N)) {
plasma_error("PLASMA_zlansy", "illegal value of LDA");
return -5;
}
/* Quick return */
if ( N == 0)
return (double)0.0;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZGEMM, N, N, 0);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zlansy", "plasma_tune() failed");
return status;
}
/* Set NT */
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N, sequence, &request,
plasma_desc_mat_free(&(descA)) );
} else {
plasma_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N,
sequence, &request);
}
/* Call the tile interface */
PLASMA_zlansy_Tile_Async(norm, uplo, &descA, &value, sequence, &request);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_dynamic_sync();
plasma_desc_mat_free(&descA);
} else {
plasma_ziptile2lap( descA, A, NB, NB, LDA, N, sequence, &request);
plasma_dynamic_sync();
}
plasma_sequence_destroy(plasma, sequence);
return value;
}
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_zsyrk - Performs one of the hermitian rank k operations
*
* \f[ C = \alpha [ op( A ) \times conjg( op( A )' )] + \beta C \f],
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = conjg( X' )
*
* where alpha and beta are real scalars, C is an n-by-n hermitian
* matrix and A is an n-by-k matrix in the first case and a k-by-n
* matrix in the second case.
*
*******************************************************************************
*
* @param[in] uplo
* = PlasmaUpper: Upper triangle of C is stored;
* = PlasmaLower: Lower triangle of C is stored.
*
* @param[in] trans
* Specifies whether the matrix A is transposed or conjugate transposed:
* = PlasmaNoTrans: A is not transposed;
* = PlasmaTrans : A is transposed.
*
* @param[in] N
* N specifies the order of the matrix C. N must be at least zero.
*
* @param[in] K
* K specifies the number of columns of the matrix op( A ).
*
* @param[in] alpha
* alpha specifies the scalar alpha.
*
* @param[in] A
* A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans,
* and is N otherwise.
*
* @param[in] LDA
* The leading dimension of the array A. LDA must be at least
* max( 1, N ), otherwise LDA must be at least max( 1, K ).
*
* @param[in] beta
* beta specifies the scalar beta
*
* @param[in,out] C
* C is a LDC-by-N matrix.
* On exit, the array uplo part of the matrix is overwritten
* by the uplo part of the updated matrix.
*
* @param[in] LDC
* The leading dimension of the array C. LDC >= max( 1, N ).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
*
*******************************************************************************
*
* @sa PLASMA_zsyrk_Tile
* @sa PLASMA_csyrk
* @sa PLASMA_dsyrk
* @sa PLASMA_ssyrk
*
******************************************************************************/
int PLASMA_zsyrk(PLASMA_enum uplo, PLASMA_enum trans, int N, int K,
PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA,
PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
{
int NB;
int Am, An;
int status;
PLASMA_desc descA, descC;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_zsyrk", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check input arguments */
if ((uplo != PlasmaUpper) && (uplo != PlasmaLower)) {
plasma_error("PLASMA_zsyrk", "illegal value of uplo");
return -1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans)) {
plasma_error("PLASMA_zsyrk", "illegal value of trans");
return -2;
}
if ( trans == PlasmaNoTrans ) {
Am = N;
An = K;
} else {
Am = K;
An = N;
}
if (N < 0) {
plasma_error("PLASMA_zsyrk", "illegal value of N");
return -3;
}
if (K < 0) {
plasma_error("PLASMA_zsyrk", "illegal value of K");
return -4;
}
if (LDA < max(1, Am)) {
plasma_error("PLASMA_zsyrk", "illegal value of LDA");
return -7;
}
if (LDC < max(1, N)) {
plasma_error("PLASMA_zsyrk", "illegal value of LDC");
return -10;
}
/* Quick return */
if (N == 0 ||
((alpha == (PLASMA_Complex64_t)0.0 || K == 0.0) && beta == (PLASMA_Complex64_t)1.0))
return PLASMA_SUCCESS;
/* Tune NB depending on M, N & NRHS; Set NBNBSIZE */
status = plasma_tune(PLASMA_FUNC_ZSYRK, N, K, 0);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_zsyrk", "plasma_tune() failed");
return status;
}
/* Set MT & NT & KT */
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descC, C, NB, NB, LDC, N, 0, 0, N, N, plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descC)));
} else {
/***************************************************************************//**
*
* @ingroup PLASMA_Complex64_t
*
* PLASMA_ztrmm - Computes B = alpha*op( A )*B or B = alpha*B*op( A ).
*
*******************************************************************************
*
* @param[in] side
* Specifies whether A appears on the left or on the right of X:
* = PlasmaLeft: alpha*op( A )*B
* = PlasmaRight: alpha*B*op( A )
*
* @param[in] uplo
* 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.
*
* @param[in] transA
* 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.
*
* @param[in] diag
* Specifies whether or not A is unit triangular:
* = PlasmaNonUnit: A is non unit;
* = PlasmaUnit: A us unit.
*
* @param[in] N
* The order of the matrix A. N >= 0.
*
* @param[in] NRHS
* The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
*
* @param[in] alpha
* alpha specifies the scalar alpha.
*
* @param[in] A
* 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.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,N).
*
* @param[in,out] B
* On entry, the N-by-NRHS right hand side matrix B.
* On exit, if return value = 0, the N-by-NRHS solution matrix X.
*
* @param[in] LDB
* The leading dimension of the array B. LDB >= max(1,N).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if -i, the i-th argument had an illegal value
*
*******************************************************************************
*
* @sa PLASMA_ztrmm_Tile
* @sa PLASMA_ztrmm_Tile_Async
* @sa PLASMA_ctrmm
* @sa PLASMA_dtrmm
* @sa PLASMA_strmm
*
******************************************************************************/
int PLASMA_ztrmm(PLASMA_enum side, PLASMA_enum uplo,
PLASMA_enum transA, PLASMA_enum diag,
int N, int NRHS, PLASMA_Complex64_t alpha,
PLASMA_Complex64_t *A, int LDA,
PLASMA_Complex64_t *B, int LDB)
{
int NB, NA;
int status;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
PLASMA_desc descA, descB;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_ztrmm", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (side == PlasmaLeft) {
NA = N;
} else {
NA = NRHS;
}
/* Check input arguments */
if (side != PlasmaLeft && side != PlasmaRight) {
plasma_error("PLASMA_ztrmm", "illegal value of side");
return -1;
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_ztrmm", "illegal value of uplo");
return -2;
}
if (transA != PlasmaConjTrans &&
transA != PlasmaNoTrans &&
transA != PlasmaTrans )
{
plasma_error("PLASMA_ztrmm", "illegal value of transA");
return -3;
}
if (diag != PlasmaUnit && diag != PlasmaNonUnit) {
plasma_error("PLASMA_ztrmm", "illegal value of diag");
return -4;
}
if (N < 0) {
plasma_error("PLASMA_ztrmm", "illegal value of N");
return -5;
}
if (NRHS < 0) {
plasma_error("PLASMA_ztrmm", "illegal value of NRHS");
return -6;
}
if (LDA < max(1, NA)) {
plasma_error("PLASMA_ztrmm", "illegal value of LDA");
return -8;
}
if (LDB < max(1, N)) {
plasma_error("PLASMA_ztrmm", "illegal value of LDB");
return -10;
}
/* Quick return */
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
/* Tune NB depending on M, N & NRHS; Set NBNB */
status = plasma_tune(PLASMA_FUNC_ZPOSV, N, N, NRHS);
if (status != PLASMA_SUCCESS) {
plasma_error("PLASMA_ztrmm", "plasma_tune() failed");
return status;
}
/* Set NT & NTRHS */
NB = PLASMA_NB;
plasma_sequence_create(plasma, &sequence);
if ( PLASMA_TRANSLATION == PLASMA_OUTOFPLACE ) {
plasma_zooplap2tile( descA, A, NB, NB, LDA, NA, 0, 0, NA, NA, sequence, &request,
plasma_desc_mat_free(&(descA)) );
plasma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, sequence, &request,
plasma_desc_mat_free(&(descA)); plasma_desc_mat_free(&(descB)));
} else {
