PLASMA_Complex64_t_Tile(3)

NAME
PLASMA_Complex64_t_Tile - Advanced Interface: Synchronous - Double Complex

  Functions
int PLASMA_zcgels_Tile (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
int PLASMA_zcgesv_Tile (PLASMA_desc *A, int *IPIV, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
int PLASMA_zcposv_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
int PLASMA_zcungesv_Tile (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_desc *X, int *ITER)
int PLASMA_zgeadd_Tile (PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_Complex64_t beta, PLASMA_desc *B)
int PLASMA_zgebrd_Tile (PLASMA_enum jobq, PLASMA_enum jobp, PLASMA_desc *A, double *D, double *E, PLASMA_desc *T, PLASMA_Complex64_t *Q, int LDQ, PLASMA_Complex64_t *P, int LDP)
int PLASMA_zgecon_Tile (PLASMA_enum norm, PLASMA_desc *A, double Anorm, double *rcond)
int PLASMA_zgelqf_Tile (PLASMA_desc *A, PLASMA_desc *T)
int PLASMA_zgelqs_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
int PLASMA_zgels_Tile (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
int PLASMA_zgemm_Tile (PLASMA_enum transA, PLASMA_enum transB, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex64_t beta, PLASMA_desc *C)
int PLASMA_zgeqp3_Tile (PLASMA_desc *A, int *jpvt, PLASMA_Complex64_t *tau, PLASMA_Complex64_t *work, double *rwork)
int PLASMA_zgeqrf_Tile (PLASMA_desc *A, PLASMA_desc *T)
int PLASMA_zgeqrs_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
int PLASMA_zgesdd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, double *S, PLASMA_desc *T, PLASMA_Complex64_t *U, int LDU, PLASMA_Complex64_t *VT, int LDVT)
int PLASMA_zgesv_Tile (PLASMA_desc *A, int *IPIV, PLASMA_desc *B)
int PLASMA_zgesv_incpiv_Tile (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
int PLASMA_zgesvd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, double *S, PLASMA_desc *T, PLASMA_Complex64_t *U, int LDU, PLASMA_Complex64_t *VT, int LDVT)
int PLASMA_zgetrf_Tile (PLASMA_desc *A, int *IPIV)
int PLASMA_zgetrf_incpiv_Tile (PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
int PLASMA_zgetrf_nopiv_Tile (PLASMA_desc *A)
int PLASMA_zgetrf_tntpiv_Tile (PLASMA_desc *A, int *IPIV)
int PLASMA_zgetri_Tile (PLASMA_desc *A, int *IPIV)
int PLASMA_zgetrs_Tile (PLASMA_enum trans, PLASMA_desc *A, const int *IPIV, PLASMA_desc *B)
int PLASMA_zgetrs_incpiv_Tile (PLASMA_desc *A, PLASMA_desc *L, const int *IPIV, PLASMA_desc *B)
int PLASMA_zheev_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, double *W, PLASMA_desc *T, PLASMA_Complex64_t *Q, int LDQ)
int PLASMA_zheevd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, double *W, PLASMA_desc *T, PLASMA_Complex64_t *Q, int LDQ)
int PLASMA_zheevr_Tile (PLASMA_enum jobz, PLASMA_enum range, PLASMA_enum uplo, PLASMA_desc *A, double vl, double vu, int il, int iu, double abstol, int *nbcomputedeig, double *W, PLASMA_desc *T, PLASMA_Complex64_t *Q, int LDQ)
int PLASMA_zhegst_Tile (PLASMA_enum itype, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_zhegv_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, double *W, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_zhegvd_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, double *W, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_zhemm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex64_t beta, PLASMA_desc *C)
int PLASMA_zher2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B, double beta, PLASMA_desc *C)
int PLASMA_zherk_Tile (PLASMA_enum uplo, PLASMA_enum trans, double alpha, PLASMA_desc *A, double beta, PLASMA_desc *C)
int PLASMA_zhetrd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, double *D, double *E, PLASMA_desc *T, PLASMA_Complex64_t *Q, int LDQ)
int PLASMA_zlacpy_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
double PLASMA_zlange_Tile (PLASMA_enum norm, PLASMA_desc *A)
double PLASMA_zlanhe_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc *A)
double PLASMA_zlansy_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc *A)
double PLASMA_zlantr_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc *A)
int PLASMA_zlascal_Tile (PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_desc *A)
int PLASMA_zlaset_Tile (PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_Complex64_t beta, PLASMA_desc *A)
int PLASMA_zlaswp_Tile (PLASMA_desc *A, int K1, int K2, const int *IPIV, int INCX)
int PLASMA_zlaswpc_Tile (PLASMA_desc *A, int K1, int K2, const int *IPIV, int INCX)
int PLASMA_zlauum_Tile (PLASMA_enum uplo, PLASMA_desc *A)
int PLASMA_zplghe_Tile (double bump, PLASMA_desc *A, unsigned long long int seed)
int PLASMA_zplgsy_Tile (PLASMA_Complex64_t bump, PLASMA_desc *A, unsigned long long int seed)
int PLASMA_zplrnt_Tile (PLASMA_desc *A, unsigned long long int seed)
int PLASMA_zpltmg_Tile (PLASMA_enum mtxtype, PLASMA_desc *A, unsigned long long int seed)
int PLASMA_zpocon_Tile (PLASMA_enum uplo, PLASMA_desc *A, double Anorm, double *rcond)
int PLASMA_zposv_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_zpotrf_Tile (PLASMA_enum uplo, PLASMA_desc *A)
int PLASMA_zpotri_Tile (PLASMA_enum uplo, PLASMA_desc *A)
int PLASMA_zpotrs_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_zstedc (PLASMA_enum jobz, int n, double *D, double *E, PLASMA_Complex64_t *Z, int LDZ)
int PLASMA_zsymm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex64_t beta, PLASMA_desc *C)
int PLASMA_zsyr2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex64_t beta, PLASMA_desc *C)
int PLASMA_zsyrk_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_Complex64_t beta, PLASMA_desc *C)
int PLASMA_ztradd_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_Complex64_t beta, PLASMA_desc *B)
int PLASMA_ztrmm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_ztrsm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_ztrsmpl_Tile (PLASMA_desc *A, PLASMA_desc *L, const int *IPIV, PLASMA_desc *B)
int PLASMA_ztrsmrv_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_ztrtri_Tile (PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc *A)
int PLASMA_zunglq_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_zungqr_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_zunmlq_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *C)
int PLASMA_zunmqr_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *C)

Detailed Description

This is the group of double complex functions using the advanced synchronous user interface.

Function Documentation

  int PLASMA_zcgels_Tile (PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B, PLASMA_desc * X, int * ITER)
PLASMA_zcgels_Tile - Solves overdetermined or underdetermined linear system of equations using the tile QR or the tile LQ factorization and mixed-precision iterative refinement. Tile equivalent of PLASMA_zcgesv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    trans Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported.
    A

    •   If the iterative refinement converged, A is not modified;

    •   otherwise, it fell back to double precision solution, and on exit the M-by-N matrix A contains: 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 On exit:

    •   if the iterative refinement converged, T is not modified;

    •   otherwise, it fell back to double precision solution, and then T is an auxiliary factorization data.

    B 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;
    B The descriptor of the M-by-NRHS matrix B of right hand side vectors, stored columnwise. Not modified.
    X On entry, it's only the descriptor where to store the result. On exit, if return value = 0, X is the solution vectors, stored columnwise: if M >= N, rows 1 to N of X 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 X contain the minimum norm solution vectors;
    ITER If > 0, ITER is the number of the current iteration in the iterative refinement process. -ITERMAX-1, if the refinment step failed and the double precision factorization has been used.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zcgels

    PLASMA_zcgels_Tile_Async

    PLASMA_dsgels_Tile

    PLASMA_zgels_Tile

  int PLASMA_zcgesv_Tile (PLASMA_desc * A, int * IPIV, PLASMA_desc * B, PLASMA_desc * X, int * ITER)
PLASMA_zcgesv_Tile - Solves a system of linear equations using the tile LU factorization and mixed-precision iterative refinement. Tile equivalent of PLASMA_zcgesv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On entry, the N-by-N coefficient matrix A.

    •   If the iterative refinement converged, A is not modified;

    •   otherwise, it fell back to double precision solution, and then A contains the tile L and U factors from the factorization (not equivalent to LAPACK).

    IPIV On exit, the pivot indices that define the permutations (not equivalent to LAPACK).
    B On entry, the N-by-NRHS matrix of right hand side matrix B.
    X On exit, if return value = 0, the N-by-NRHS solution matrix X.
    ITER The number of the current iteration in the iterative refinement process

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zcgesv

    PLASMA_zcgesv_Tile_Async

    PLASMA_dsgesv_Tile

    PLASMA_zgesv_Tile

  int PLASMA_zcposv_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B, PLASMA_desc * X, int * ITER)
PLASMA_zcposv_Tile - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization and mixed-precision iterative refinement. Tile equivalent of PLASMA_zcposv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    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.
    A On entry, 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.

    •   If the iterative refinement converged, A is not modified;

    •   otherwise, it falled backed to double precision solution,

    B On entry, the N-by-NRHS matrix of right hand side matrix B.
    X On exit, if return value = 0, the N-by-NRHS solution matrix X.
    ITER The number of the current iteration in the iterative refinement process

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zcposv

    PLASMA_zcposv_Tile_Async

    PLASMA_dsposv_Tile

    PLASMA_zposv_Tile

  int PLASMA_zcungesv_Tile (PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B, PLASMA_desc * X, int * ITER)
PLASMA_zcungesv_Tile - Solves symmetric linear system of equations using the tile QR or the tile LQ factorization and mixed-precision iterative refinement. Tile equivalent of PLASMA_zcungesv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    trans Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported.
    A

    •   If the iterative refinement converged, A is not modified;

    •   otherwise, it fell back to double precision solution, and on exit the M-by-N matrix A contains: 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 On exit:

    •   if the iterative refinement converged, T is not modified;

    •   otherwise, it fell back to double precision solution, and then T is an auxiliary factorization data.

    B On entry, the M-by-NRHS matrix B of right hand side vectors, stored columnwise;
    B The N-by-NRHS matrix of right hand side matrix B.
    X If return value = 0, X is the solution vectors, stored columnwise: if M >= N, rows 1 to N of X 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 X contain the minimum norm solution vectors;
    ITER The number of the current iteration in the iterative refinement process

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zcungesv

    PLASMA_zcungesv_Tile_Async

    PLASMA_dsungesv_Tile

    PLASMA_zgels_Tile

  int PLASMA_zgeadd_Tile (PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_Complex64_t beta, PLASMA_desc * B)
PLASMA_zgeadd_Tile - Performs a matrix addition similarly to the pzgeadd() function from the PBLAS library. Tile equivalent of PLASMA_zgeadd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    trans Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjugate transposed.
    alpha alpha specifies the scalar alpha
    A A is a LDA-by-ka matrix, where ka is N when trans = PlasmaNoTrans, and is M otherwise.
    beta beta specifies the scalar beta
    B B is a LDB-by-N matrix.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgeadd

    PLASMA_zgeadd_Tile_Async

    PLASMA_cgeadd_Tile

    PLASMA_dgeadd_Tile

    PLASMA_sgeadd_Tile

  int PLASMA_zgebrd_Tile (PLASMA_enum jobq, PLASMA_enum jobp, PLASMA_desc * A, double * D, double * E, PLASMA_desc * T, PLASMA_Complex64_t * Q, int LDQ, PLASMA_Complex64_t * P, int LDP)
PLASMA_zgebrd_Tile - reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B using a two-stage approach First stage: reduction to band bidiagonal form (orthogonal matrices Q1 and P1); Second stage: reduction from band to bidiagonal form (orthogonal matrices Q2 and P2). Let Q = Q1 * Q2 be the global left unitary transformation; Let P = P1 * P2 be the global right unitary transformation; Q**H * A * P = B. If M >= N, B is upper bidiagonal; if M < N, B is lower bidiagonal. Note: T is incomplete and contains only the block reflectors of the first stage. Therefore, Q and P can not be built completely. Tile equivalent of PLASMA_zgebrd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobq Specifies options for computing all or part of the matrix Q. Intended usage: = PlasmaVec: all M columns of Q are returned in array Q; = PlasmaNoVec: not referenced.
    jobp Specifies options for computing all or part of the matrix V**H. Intended usage: = PlasmaVec: all M columns of Q are returned in array Q; = PlasmaNoVec: not referenced.
    A On entry, the M-by-N matrix A. On exit, if M >= N, the diagonal and the first superdiagonal are overwritten with the upper bidiagonal matrix B; the elements below the diagonal, with the array T, represent the unitary matrix Q as a product of elementary reflectors, and the elements above the first superdiagonal, with the array T, represent the unitary matrix P as a product of elementary reflectors; if M < N, the diagonal and the first subdiagonal are overwritten with the lower bidiagonal matrix B; the elements below the first subdiagonal, with the array T, represent the unitary matrix Q as a product of elementary reflectors, and the elements above the diagonal, with the array T, represent the unitary matrix P as a product of elementary reflectors.
    D The double precision array containing the diagonal elements of the bidiagonal matrix B: D(i) = A(i,i). Dimension (min(M,N)).
    E The double precision array containing the off-diagonal elements of the bidiagonal matrix B: if M >= N, E(i) = A(i,i+1) for i = 1,2,...,N-1; if M < N, E(i) = A(i+1,i) for i = 1,2,...,M-1. Dimension (min(M,N)-1).
    T On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec, then if return value = 0, Q contains the M-by-M unitary matrix Q. If jobz = PlasmaNoVec, then it is not referenced.
    LDQ The leading dimension of the array Q. LDQ >= M.
    P On exit, if jobz = PlasmaVec, then if return value = 0, P contains the N-by-N unitary matrix P. If jobz = PlasmaNoVec, then it is not referenced.
    LDP The leading dimension of the array P. LDP >= N.

Returns:

    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgebrd

    PLASMA_zgebrd_Tile_Async

    PLASMA_cgebrd_Tile

    PLASMA_dgebrd_Tile

    PLASMA_sgebrd_Tile

  int PLASMA_zgecon_Tile (PLASMA_enum norm, PLASMA_desc * A, double Anorm, double * rcond)
PLASMA_zgecon_Tile - estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm. Tile equivalent of PLASMA_zgecon(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    norm Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm
    A The N-by-N matrix A.
    Anorm If norm = PlasmaOneNorm, the 1-norm of the original matrix A. If norm = PlasmaInfNorm, the infinity-norm of the original matrix A.
    rcond The reciprocal of the condition number of the matrix A, computed as stated above.

Returns:

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

See also:
    PLASMA_zgecon

    PLASMA_zgecon_Tile_Async

    PLASMA_cgecon_Tile

    PLASMA_dgecon_Tile

    PLASMA_sgecon_Tile

  int PLASMA_zgelqf_Tile (PLASMA_desc * A, PLASMA_desc * T)
PLASMA_zgelqf_Tile - Computes the tile LQ factorization of a matrix. Tile equivalent of PLASMA_zgelqf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A 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 On exit, auxiliary factorization data, required by PLASMA_zgelqs to solve the system of equations.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgelqf

    PLASMA_zgelqf_Tile_Async

    PLASMA_cgelqf_Tile

    PLASMA_dgelqf_Tile

    PLASMA_sgelqf_Tile

    PLASMA_zgelqs_Tile

  int PLASMA_zgelqs_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B)
PLASMA_zgelqs_Tile - Computes a minimum-norm solution using previously computed LQ factorization. Tile equivalent of PLASMA_zgelqs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_zgelqf.
    T Auxiliary factorization data, computed by PLASMA_zgelqf.
    B On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgelqs

    PLASMA_zgelqs_Tile_Async

    PLASMA_cgelqs_Tile

    PLASMA_dgelqs_Tile

    PLASMA_sgelqs_Tile

    PLASMA_zgelqf_Tile

  int PLASMA_zgels_Tile (PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B)
PLASMA_zgels_Tile - Solves overdetermined or underdetermined linear system of equations using the tile QR or the tile LQ factorization. Tile equivalent of PLASMA_zgels(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    trans Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported.
    A 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 On exit, auxiliary factorization data.
    B 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;

Returns:

    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgels

    PLASMA_zgels_Tile_Async

    PLASMA_cgels_Tile

    PLASMA_dgels_Tile

    PLASMA_sgels_Tile

  int PLASMA_zgemm_Tile (PLASMA_enum transA, PLASMA_enum transB, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B, PLASMA_Complex64_t beta, PLASMA_desc * C)
PLASMA_zgemm_Tile - Performs matrix multiplication. Tile equivalent of PLASMA_zgemm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    transA Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjugate transposed.
    transB Specifies whether the matrix B is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaConjTrans: B is conjugate transposed.
    alpha alpha specifies the scalar alpha
    A A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise.
    B B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise.
    beta beta specifies the scalar beta
    C 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 )

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgemm

    PLASMA_zgemm_Tile_Async

    PLASMA_cgemm_Tile

    PLASMA_dgemm_Tile

    PLASMA_sgemm_Tile

  int PLASMA_zgeqp3_Tile (PLASMA_desc * A, int * jpvt, PLASMA_Complex64_t * tau, PLASMA_Complex64_t * work, double * rwork)
PLASMA_zgeqp3_Tile - Computes the tile QR factorization with column pivoting of a matrix. Tile equivalent of PLASMA_zgeqp3(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A 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.
    jpvt Integer array of dimension N. On exit, if jpvt(j)=k, then the j-th column of A*P was the k-th column of A.
    tau On exit, scalars that define Householder reflectors, size n.
    work Workspace of size (n + 1)*nb.
    rwork Workspace of size 2*n.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgeqp3

    PLASMA_zgeqp3_Tile_Async

    PLASMA_cgeqp3_Tile

    PLASMA_dgeqp3_Tile

    PLASMA_sgeqp3_Tile

  int PLASMA_zgeqrf_Tile (PLASMA_desc * A, PLASMA_desc * T)
PLASMA_zgeqrf_Tile - Computes the tile QR factorization of a matrix. Tile equivalent of PLASMA_zgeqrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A 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 On exit, auxiliary factorization data, required by PLASMA_zgeqrs to solve the system of equations.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgeqrf

    PLASMA_zgeqrf_Tile_Async

    PLASMA_cgeqrf_Tile

    PLASMA_dgeqrf_Tile

    PLASMA_sgeqrf_Tile

    PLASMA_zgeqrs_Tile

  int PLASMA_zgeqrs_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B)
PLASMA_zgeqrs_Tile - Computes a minimum-norm solution using the tile QR factorization. Tile equivalent of PLASMA_zgeqrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A Details of the QR factorization of the original matrix A as returned by PLASMA_zgeqrf.
    T Auxiliary factorization data, computed by PLASMA_zgeqrf.
    B On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgeqrs

    PLASMA_zgeqrs_Tile_Async

    PLASMA_cgeqrs_Tile

    PLASMA_dgeqrs_Tile

    PLASMA_sgeqrs_Tile

    PLASMA_zgeqrf_Tile

  int PLASMA_zgesdd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc * A, double * S, PLASMA_desc * T, PLASMA_Complex64_t * U, int LDU, PLASMA_Complex64_t * VT, int LDVT)
PLASMA_zgesdd_Tile - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. Tile equivalent of PLASMA_zgesdd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobu Specifies options for computing all or part of the matrix U. Intended usage: = PlasmaVec = 'A'(lapack): all M columns of U are returned in array U; = PlasmaNoVec = 'N': no columns of U (no left singular vectors) are computed. = PlasmaSVec = 'S': the first min(m,n) columns of U (the left singular vectors) are returned in the array U; NOT SUPPORTTED YET = PlasmaOVec = 'O': the first min(m,n) columns of U (the left singular vectors) are overwritten on the array A; NOT SUPPORTTED YET
    jobvt Specifies options for computing all or part of the matrix V**H. Intended usage: = PlasmaVec = 'A'(lapack): all N rows of V**H are returned in the array VT; = PlasmaNoVec = 'N': no rows of V**H (no right singular vectors) are computed. = PlasmaSVec = 'S': the first min(m,n) rows of V**H (the right singular vectors) are returned in the array VT; NOT SUPPORTTED YET = PlasmaOVec = 'O': the first min(m,n) rows of V**H (the right singular vectors) are overwritten on the array A; NOT SUPPORTTED YET

Note: jobu and jobvt cannot both be PlasmaOVec.

Parameters:
    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.
    S The singular values of A, sorted so that S(i) >= S(i+1).
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zgesdd On exit, contains auxiliary factorization data.
    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.
    LDU The leading dimension of the array U. LDU >= 1; if JOBU = 'S' or 'A', LDU >= M.
    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.
    LDVT The leading dimension of the array VT. LDVT >= 1; if JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N).

Returns:

    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgesdd

    PLASMA_zgesdd_Tile_Async

    PLASMA_cgesdd_Tile

    PLASMA_dgesdd_Tile

    PLASMA_sgesdd_Tile

  int PLASMA_zgesv_incpiv_Tile (PLASMA_desc * A, PLASMA_desc * L, int * IPIV, PLASMA_desc * B)
PLASMA_zgesv_incpiv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of PLASMA_zgetrf_incpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    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).
    L On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations.
    IPIV On exit, the pivot indices that define the permutations (not equivalent to LAPACK).
    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.

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zgesv_incpiv

    PLASMA_zgesv_incpiv_Tile_Async

    PLASMA_cgesv_incpiv_Tile

    PLASMA_dgesv_incpiv_Tile

    PLASMA_sgesv_incpiv_Tile

    PLASMA_zcgesv_Tile

  int PLASMA_zgesv_Tile (PLASMA_desc * A, int * IPIV, PLASMA_desc * B)
PLASMA_zgesv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of PLASMA_zgesv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization.
    IPIV On exit, the pivot indices that define the permutations.
    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.

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zgesv

    PLASMA_zgesv_Tile_Async

    PLASMA_cgesv_Tile

    PLASMA_dgesv_Tile

    PLASMA_sgesv_Tile

    PLASMA_zcgesv_Tile

  int PLASMA_zgesvd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc * A, double * S, PLASMA_desc * T, PLASMA_Complex64_t * U, int LDU, PLASMA_Complex64_t * VT, int LDVT)
PLASMA_zgesvd_Tile - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. Tile equivalent of PLASMA_zgesvd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobu Specifies options for computing all or part of the matrix U. Intended usage: = PlasmaVec = 'A'(lapack): all M columns of U are returned in array U; = PlasmaNoVec = 'N': no columns of U (no left singular vectors) are computed. = PlasmaSVec = 'S': the first min(m,n) columns of U (the left singular vectors) are returned in the array U; NOT SUPPORTTED YET = PlasmaOVec = 'O': the first min(m,n) columns of U (the left singular vectors) are overwritten on the array A; NOT SUPPORTTED YET
    jobvt Specifies options for computing all or part of the matrix V**H. Intended usage: = PlasmaVec = 'A'(lapack): all N rows of V**H are returned in the array VT; = PlasmaNoVec = 'N': no rows of V**H (no right singular vectors) are computed. = PlasmaSVec = 'S': the first min(m,n) rows of V**H (the right singular vectors) are returned in the array VT; NOT SUPPORTTED YET = PlasmaOVec = 'O': the first min(m,n) rows of V**H (the right singular vectors) are overwritten on the array A; NOT SUPPORTTED YET

Note: jobu and jobvt cannot both be PlasmaOVec.

Parameters:
    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.
    S The singular values of A, sorted so that S(i) >= S(i+1).
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zgesvd On exit, contains auxiliary factorization data.
    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.
    LDU The leading dimension of the array U. LDU >= 1; if JOBU = 'S' or 'A', LDU >= M.
    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.
    LDVT The leading dimension of the array VT. LDVT >= 1; if JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N).

Returns:

    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgesvd

    PLASMA_zgesvd_Tile_Async

    PLASMA_cgesvd_Tile

    PLASMA_dgesvd_Tile

    PLASMA_sgesvd_Tile

  int PLASMA_zgetrf_incpiv_Tile (PLASMA_desc * A, PLASMA_desc * L, int * IPIV)
PLASMA_zgetrf_incpiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_zgetrf_incpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
    L On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_zgetrs_incpiv to solve the system of equations.
    IPIV The pivot indices that define the permutations (not equivalent to LAPACK).

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zgetrf_incpiv

    PLASMA_zgetrf_incpiv_Tile_Async

    PLASMA_cgetrf_incpiv_Tile

    PLASMA_dgetrf_incpiv_Tile

    PLASMA_sgetrf_incpiv_Tile

    PLASMA_zgetrs_incpiv_Tile

  int PLASMA_zgetrf_nopiv_Tile (PLASMA_desc * A)
PLASMA_zgetrf_nopiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_zgetrf_nopiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zgetrf_nopiv

    PLASMA_zgetrf_nopiv_Tile_Async

    PLASMA_cgetrf_nopiv_Tile

    PLASMA_dgetrf_nopiv_Tile

    PLASMA_sgetrf_nopiv_Tile

    PLASMA_zgetrs_Tile

  int PLASMA_zgetrf_Tile (PLASMA_desc * A, int * IPIV)
PLASMA_zgetrf_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_zgetrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
    IPIV The pivot indices that define the permutations (not equivalent to LAPACK).

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zgetrf

    PLASMA_zgetrf_Tile_Async

    PLASMA_cgetrf_Tile

    PLASMA_dgetrf_Tile

    PLASMA_sgetrf_Tile

    PLASMA_zgetrs_Tile

  int PLASMA_zgetrf_tntpiv_Tile (PLASMA_desc * A, int * IPIV)
PLASMA_zgetrf_tntpiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_zgetrf_tntpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
    IPIV The pivot indices that define the permutations

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zgetrf_tntpiv

    PLASMA_zgetrf_tntpiv_Tile_Async

    PLASMA_cgetrf_tntpiv_Tile

    PLASMA_dgetrf_tntpiv_Tile

    PLASMA_sgetrf_tntpiv_Tile

  int PLASMA_zgetri_Tile (PLASMA_desc * A, int * IPIV)
PLASMA_zgetri_Tile - 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). Tile equivalent of PLASMA_zgetri(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    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.
    IPIV The pivot indices that define the permutations as returned by PLASMA_zgetrf.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    >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.

See also:
    PLASMA_zgetri

    PLASMA_zgetri_Tile_Async

    PLASMA_cgetri_Tile

    PLASMA_dgetri_Tile

    PLASMA_sgetri_Tile

    PLASMA_zgetrf_Tile

  int PLASMA_zgetrs_incpiv_Tile (PLASMA_desc * A, PLASMA_desc * L, const int * IPIV, PLASMA_desc * B)
PLASMA_zgetrs_incpiv_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of PLASMA_zgetrs_incpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A The tile factors L and U from the factorization, computed by PLASMA_zgetrf_incpiv.
    L Auxiliary factorization data, related to the tile L factor, computed by PLASMA_zgetrf_incpiv.
    IPIV The pivot indices from PLASMA_zgetrf_incpiv (not equivalent to LAPACK).
    B On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgetrs_incpiv

    PLASMA_zgetrs_incpiv_Tile_Async

    PLASMA_cgetrs_incpiv_Tile

    PLASMA_dgetrs_incpiv_Tile

    PLASMA_sgetrs_incpiv_Tile

    PLASMA_zgetrf_incpiv_Tile

  int PLASMA_zgetrs_Tile (PLASMA_enum trans, PLASMA_desc * A, const int * IPIV, PLASMA_desc * B)
PLASMA_zgetrs_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of PLASMA_zgetrs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    trans 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)
    A The tile factors L and U from the factorization, computed by PLASMA_zgetrf.
    IPIV The pivot indices from PLASMA_zgetrf.
    B On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zgetrs

    PLASMA_zgetrs_Tile_Async

    PLASMA_cgetrs_Tile

    PLASMA_dgetrs_Tile

    PLASMA_sgetrs_Tile

    PLASMA_zgetrf_Tile

  int PLASMA_zheev_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, double * W, PLASMA_desc * T, PLASMA_Complex64_t * Q, int LDQ)
PLASMA_zheev_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobz Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors.
    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.
    A On entry, the symmetric (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 jobz = PlasmaVec, then if return value = 0, A contains the orthonormal eigenvectors of the matrix A. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.*
    W On exit, if info = 0, the eigenvalues.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zheev On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimention of the eigenvectors matrix Q. LDQ >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.

See also:
    PLASMA_zheev_Tile

    PLASMA_zheev_Tile_Async

    PLASMA_cheev

    PLASMA_dsyev

    PLASMA_ssyev

  int PLASMA_zheevd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, double * W, PLASMA_desc * T, PLASMA_Complex64_t * Q, int LDQ)
PLASMA_zheevd_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobz Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors.
    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.
    A On entry, the symmetric (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 jobz = PlasmaVec, then if return value = 0, A contains the orthonormal eigenvectors of the matrix A. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.*
    W On exit, if info = 0, the eigenvalues.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zheevd On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimention of the eigenvectors matrix Q. LDQ >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.

See also:
    PLASMA_zheevd_Tile

    PLASMA_zheevd_Tile_Async

    PLASMA_cheevd

    PLASMA_dsyev

    PLASMA_ssyev

  int PLASMA_zheevr_Tile (PLASMA_enum jobz, PLASMA_enum range, PLASMA_enum uplo, PLASMA_desc * A, double vl, double vu, int il, int iu, double abstol, int * nbcomputedeig, double * W, PLASMA_desc * T, PLASMA_Complex64_t * Q, int LDQ)
PLASMA_zheevr_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobz Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors.
    range = PlasmaAllVec: all eigenvalues will be found. = PlasmaVec: all eigenvalues in the half-open interval (VL,VU] will be found. = PlasmaIvec: the IL-th through IU-th eigenvalues will be found. For range = PlasmaVec or PlasmaIvec and IU - IL < N - 1, DSTEBZ and ZSTEIN are called.
    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.
    A On entry, the symmetric (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 jobz = PlasmaVec, then if return value = 0, A contains the orthonormal eigenvectors of the matrix A. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.*
    vl see vu.
    vu If RANGE=PlasmaVec, the lower and upper bounds of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = PlasmaAllVec or PlasmaIvec.
    il see iu.
    iu If RANGE=PlasmaIvec, the indices (in ascending order) of the smallest and largest eigenvalues to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = PlasmaAllVec or PlasmaVec.
    abstol The absolute error tolerance for the eigenvalues. An approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b] of width less than or equal to

        ABSTOL + EPS *   max( |a|,|b| ) ,

where EPS is the machine precision. If ABSTOL is less than or equal to zero, then EPS*|T| will be used in its place, where |T| is the 1-norm of the tridiagonal matrix obtained by reducing A to tridiagonal form.

See 'Computing Small Singular Values of Bidiagonal Matrices
         with Guaranteed High Relative Accuracy,' by Demmel and Kahan, LAPACK Working Note #3.

If high relative accuracy is important, set ABSTOL to DLAMCH( 'Safe minimum' ). Doing so will guarantee that eigenvalues are computed to high relative accuracy when possible in future releases. The current code does not make any guarantees about high relative accuracy, but furutre releases will. See J. Barlow and J. Demmel, 'Computing Accurate Eigensystems of Scaled Diagonally
         Dominant Matrices', LAPACK Working Note #7, for a discussion of which matrices define their eigenvalues to high relative accuracy. (hard set to use tryrac=1).

Parameters:
    nbcomputedeig The total number of eigenvalues found. 0 <= M <= N. If RANGE = PlasmaAllVec, M = N, and if RANGE = PlasmaIvec, M = IU-IL+1.
    W On exit, if info = 0, the eigenvalues.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zheevr On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimention of the eigenvectors matrix Q. LDQ >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.

See also:
    PLASMA_zheevr_Tile

    PLASMA_zheevr_Tile_Async

    PLASMA_cheevr

    PLASMA_dsyevr

    PLASMA_ssyevr

  int PLASMA_zhegst_Tile (PLASMA_enum itype, PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_zhegst_Tile - reduces a complex Hermitian-definite generalized eigenproblem to standard form. If PlasmaItype == 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If PlasmaItype == 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by PLASMA_ZPOTRF. ONLY PlasmaItype == 1 and PlasmaLower supported! Tile equivalent of PLASMA_zhegst(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    itype Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x Currently only PlasmaItype == 1 is supported.
    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. Currently only PlasmaLower is supported.
    A On entry, the symmetric (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 = PlasmaLower, 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 transformed matrix, stored in the same format as A.
    B On entry, the triangular factor from the Cholesky factorization of B, as returned by PLASMA_ZPOTRF.

Returns:

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

See also:
    PLASMA_zhegst

    PLASMA_zhegst_Tile_Async

    PLASMA_chegst_Tile

    PLASMA_dsygst_Tile

    PLASMA_ssygst_Tile

    PLASMA_zhegst_Tile

  int PLASMA_zhegv_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B, double * W, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_zhegv_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem of the form: A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.

Tile equivalent of PLASMA_zhegv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    itype Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x
    jobz Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors.
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A and B are stored; = PlasmaLower: Lower triangle of A and B are stored.
    A On entry, the symmetric (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 = PlasmaLower, 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 jobz = PlasmaVec, then if return value = 0, A contains the matrix Z of eigenvectors. The eigenvectors are normalized as follows: if ITYPE = 1 or 2, Z**H*B*Z = I; if ITYPE = 3, Z**H*inv(B)*Z = I. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.
    B On entry, the symmetric (or Hermitian) positive definite matrix B. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of B contains the upper triangular part of the matrix B, and the strictly lower triangular part of B is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of B contains the lower triangular part of the matrix B, and the strictly upper triangular part of B is not referenced. On exit, if return value <= N, the part of B containing the matrix is overwritten by the triangular factor U or L from the Cholesky factorization B = U**H*U or B = L*L**H.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zhegv On exit, contains auxiliary factorization data.
    W On exit, if info = 0, the eigenvalues.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    <=N if INFO = i, plasma_zhegv failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
    >N if INFO = N + i, for 1 <= i <= N, then the leading minor of order i of B is not positive definite. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed.

See also:
    PLASMA_zhegv

    PLASMA_zhegv_Tile_Async

    PLASMA_chegv_Tile

    PLASMA_dsygv_Tile

    PLASMA_ssygv_Tile

  int PLASMA_zhegvd_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B, double * W, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_zhegvd_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem of the form: A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.

Tile equivalent of PLASMA_zhegvd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    itype Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x
    jobz Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors.
    uplo Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A and B are stored; = PlasmaLower: Lower triangle of A and B are stored.
    A On entry, the symmetric (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 = PlasmaLower, 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 jobz = PlasmaVec, then if return value = 0, A contains the matrix Z of eigenvectors. The eigenvectors are normalized as follows: if ITYPE = 1 or 2, Z**H*B*Z = I; if ITYPE = 3, Z**H*inv(B)*Z = I. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.
    B On entry, the symmetric (or Hermitian) positive definite matrix B. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of B contains the upper triangular part of the matrix B, and the strictly lower triangular part of B is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of B contains the lower triangular part of the matrix B, and the strictly upper triangular part of B is not referenced. On exit, if return value <= N, the part of B containing the matrix is overwritten by the triangular factor U or L from the Cholesky factorization B = U**H*U or B = L*L**H.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_zhegvd On exit, contains auxiliary factorization data.
    W On exit, if info = 0, the eigenvalues.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    <=N if INFO = i, plasma_zhegvd failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
    >N if INFO = N + i, for 1 <= i <= N, then the leading minor of order i of B is not positive definite. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed.

See also:
    PLASMA_zhegvd

    PLASMA_zhegvd_Tile_Async

    PLASMA_chegvd_Tile

    PLASMA_dsygvd_Tile

    PLASMA_ssygvd_Tile

  int PLASMA_zhemm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B, PLASMA_Complex64_t beta, PLASMA_desc * C)
PLASMA_zhemm_Tile - Performs Hermitian matrix multiplication. Tile equivalent of PLASMA_zhemm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side Specifies whether the hermitian matrix A appears on the left or right in the operation as follows: = PlasmaLeft: = PlasmaRight:
    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.
    alpha Specifies the scalar alpha.
    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.
    B B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B.
    beta Specifies the scalar beta.
    C C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N updated matrix.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zhemm

    PLASMA_zhemm_Tile_Async

    PLASMA_chemm_Tile

    PLASMA_dhemm_Tile

    PLASMA_shemm_Tile

  int PLASMA_zher2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B, double beta, PLASMA_desc * C)
PLASMA_zher2k_Tile - Performs hermitian rank k update. Tile equivalent of PLASMA_zher2k(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    B B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise.
    beta beta specifies the scalar beta
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zher2k

    PLASMA_zher2k_Tile_Async

    PLASMA_cher2k_Tile

    PLASMA_dher2k_Tile

    PLASMA_sher2k_Tile

  int PLASMA_zherk_Tile (PLASMA_enum uplo, PLASMA_enum trans, double alpha, PLASMA_desc * A, double beta, PLASMA_desc * C)
PLASMA_zherk_Tile - Performs hermitian rank k update. Tile equivalent of PLASMA_zherk(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    beta beta specifies the scalar beta
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zherk

    PLASMA_zherk_Tile_Async

    PLASMA_cherk_Tile

    PLASMA_dherk_Tile

    PLASMA_sherk_Tile

  int PLASMA_zhetrd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, double * D, double * E, PLASMA_desc * T, PLASMA_Complex64_t * Q, int LDQ)
PLASMA_zhetrd_Tile - reduces a complex Hermitian matrix A to real symmetric tridiagonal form S using a two-stage approach First stage: reduction to band tridiagonal form (unitary Q1); Second stage: reduction from band to tridiagonal form (unitary Q2). Let Q = Q1 * Q2 be the global unitary transformation; Q**H * A * Q = S. Tile equivalent of PLASMA_zhetrd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    jobz Intended usage: = PlasmaNoVec: computes tridiagonal only; = PlasmaVec: computes tridiagonal and generate the orthogonal matrix Q.
    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.
    A On entry, the symmetric (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 jobz = PlasmaVec, then if return value = 0, A contains the orthonormal eigenvectors of the matrix A. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.*
    D On exit, the diagonal elements of the tridiagonal matrix: D(i) = A(i,i).
    E On exit, he off-diagonal elements of the tridiagonal matrix: E(i) = A(i,i+1) if uplo = PlasmaUpper, E(i) = A(i+1,i) if uplo = PlasmaLower.
    T On exit, auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec, then if return value = 0, Q contains the N-by-N unitary matrix Q. If jobz = PlasmaNoVec, then it is not referenced.
    LDQ The leading dimension of the array Q. LDQ >= N.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.

See also:
    PLASMA_zhetrd

    PLASMA_zhetrd_Tile_Async

    PLASMA_chetrd_Tile

    PLASMA_dsytrd_Tile

    PLASMA_ssytrd_Tile

    PLASMA_zhetrd_Tile

  int PLASMA_zlacpy_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_zlacpy_Tile - Tile equivalent of PLASMA_zlacpy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo Specifies the part of the matrix A to be copied to B. = PlasmaUpperLower: All the matrix A = PlasmaUpper: Upper triangular part = PlasmaLower: Lower triangular part
    A The M-by-N matrix A. If uplo = PlasmaUpper, only the upper trapezium is accessed; if UPLO = PlasmaLower, only the lower trapezium is accessed.
    B The M-by-N matrix B. On exit, B = A in the locations specified by UPLO.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlacpy

    PLASMA_zlacpy_Tile_Async

    PLASMA_clacpy_Tile

    PLASMA_dlacpy_Tile

    PLASMA_slacpy_Tile

  double PLASMA_zlange_Tile (PLASMA_enum norm, PLASMA_desc * A)
PLASMA_zlange_Tile - Tile equivalent of PLASMA_zlange(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    A On entry, the triangular factor U or L. On exit, if UPLO = 'U', the upper triangle of A is overwritten with the upper triangle of the product U * U'; if UPLO = 'L', the lower triangle of A is overwritten with the lower triangle of the product L' * L.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlange

    PLASMA_zlange_Tile_Async

    PLASMA_clange_Tile

    PLASMA_dlange_Tile

    PLASMA_slange_Tile

  double PLASMA_zlanhe_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_zlanhe_Tile - Tile equivalent of PLASMA_zlanhe(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A On entry, the triangular factor U or L. On exit, if UPLO = 'U', the upper triangle of A is overwritten with the upper triangle of the product U * U'; if UPLO = 'L', the lower triangle of A is overwritten with the lower triangle of the product L' * L.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlanhe

    PLASMA_zlanhe_Tile_Async

    PLASMA_clanhe_Tile

    PLASMA_dlanhe_Tile

    PLASMA_slanhe_Tile

  double PLASMA_zlansy_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_zlansy_Tile - Tile equivalent of PLASMA_zlansy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A On entry, the triangular factor U or L. On exit, if UPLO = 'U', the upper triangle of A is overwritten with the upper triangle of the product U * U'; if UPLO = 'L', the lower triangle of A is overwritten with the lower triangle of the product L' * L.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlansy

    PLASMA_zlansy_Tile_Async

    PLASMA_clansy_Tile

    PLASMA_dlansy_Tile

    PLASMA_slansy_Tile

  double PLASMA_zlantr_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc * A)
PLASMA_zlantr_Tile - Tile equivalent of PLASMA_zlantr(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    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.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    A Descriptor of matrix A.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlantr

    PLASMA_zlantr_Tile_Async

    PLASMA_clantr_Tile

    PLASMA_dlantr_Tile

    PLASMA_slantr_Tile

  int PLASMA_zlascal_Tile (PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_desc * A)
PLASMA_zlascal_Tile - Scales a matrix by the scalar alpha as in ScaLAPACK pzlascal().

,

alpha is a scalar, and A a general, upper or lower trapezoidal matrix.

Parameters:
    uplo Specifies the shape of A: = PlasmaUpperLower: A is a general matrix. = PlasmaUpper: A is an upper trapezoidal matrix. = PlasmaLower: A is a lower trapezoidal matrix.
    alpha alpha specifies the scalar alpha
    A A is a LDA-by-N matrix.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlascal

    PLASMA_zlascal_Tile_Async

    PLASMA_clascal_Tile

    PLASMA_dlascal_Tile

    PLASMA_slascal_Tile

  int PLASMA_zlaset_Tile (PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_Complex64_t beta, PLASMA_desc * A)
PLASMA_zlaset_Tile - Tile equivalent of PLASMA_zlaset(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo Specifies the part of the matrix A to be set. = PlasmaUpperLower: All the matrix A = PlasmaUpper: Upper triangular part = PlasmaLower: Lower triangular part
    alpha All the offdiagonal array elements are set to alpha.
    beta All the diagonal array elements are set to beta.
    A On entry, the m by n matrix A. On exit, A(i,j) = ALPHA, 1 <= i <= m, 1 <= j <= n, i.ne.j; A(i,i) = BETA, 1 <= i <= min(m,n)

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlaset

    PLASMA_zlaset_Tile_Async

    PLASMA_claset_Tile

    PLASMA_dlaset_Tile

    PLASMA_slaset_Tile

  int PLASMA_zlaswp_Tile (PLASMA_desc * A, int K1, int K2, const int * IPIV, int INCX)
PLASMA_zlaswp_Tile - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. Tile equivalent of PLASMA_zlaswp(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A The tile factors L and U from the factorization, computed by PLASMA_zgetrf.
    K1 The first element of IPIV for which a row interchange will be done.
    K2 The last element of IPIV for which a row interchange will be done.
    IPIV The pivot indices from PLASMA_zgetrf.
    INCX The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlaswp

    PLASMA_zlaswp_Tile_Async

    PLASMA_claswp_Tile

    PLASMA_dlaswp_Tile

    PLASMA_slaswp_Tile

    PLASMA_zgetrf_Tile

  int PLASMA_zlaswpc_Tile (PLASMA_desc * A, int K1, int K2, const int * IPIV, int INCX)
PLASMA_zlaswpc_Tile - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. Tile equivalent of PLASMA_zlaswpc(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A The tile factors L and U from the factorization, computed by PLASMA_zgetrf.
    K1 The first element of IPIV for which a row interchange will be done.
    K2 The last element of IPIV for which a row interchange will be done.
    IPIV The pivot indices from PLASMA_zgetrf.
    INCX The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlaswpc

    PLASMA_zlaswpc_Tile_Async

    PLASMA_claswpc_Tile

    PLASMA_dlaswpc_Tile

    PLASMA_slaswpc_Tile

    PLASMA_zgetrf_Tile

  int PLASMA_zlauum_Tile (PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_zlauum_Tile - Computes the product U * U' or L' * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. Tile equivalent of PLASMA_zlauum(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A On entry, the triangular factor U or L. On exit, if UPLO = 'U', the upper triangle of A is overwritten with the upper triangle of the product U * U'; if UPLO = 'L', the lower triangle of A is overwritten with the lower triangle of the product L' * L.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zlauum

    PLASMA_zlauum_Tile_Async

    PLASMA_clauum_Tile

    PLASMA_dlauum_Tile

    PLASMA_slauum_Tile

    PLASMA_zpotri_Tile

  int PLASMA_zplghe_Tile (double bump, PLASMA_desc * A, unsigned long long int seed)
PLASMA_zplghe_Tile - Generate a random hermitian matrix by tiles. Tile equivalent of PLASMA_zplghe(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    bump The value to add to the diagonal to be sure to have a positive definite matrix.
    A On exit, The random hermitian matrix A generated.
    seed The seed used in the random generation.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zplghe

    PLASMA_zplghe_Tile_Async

    PLASMA_cplghe_Tile

    PLASMA_dplghe_Tile

    PLASMA_splghe_Tile

    PLASMA_zplrnt_Tile

    PLASMA_zplgsy_Tile

  int PLASMA_zplgsy_Tile (PLASMA_Complex64_t bump, PLASMA_desc * A, unsigned long long int seed)
PLASMA_zplgsy_Tile - Generate a random hermitian matrix by tiles. Tile equivalent of PLASMA_zplgsy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    bump The value to add to the diagonal to be sure to have a positive definite matrix.
    A On exit, The random hermitian matrix A generated.
    seed The seed used in the random generation.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zplgsy

    PLASMA_zplgsy_Tile_Async

    PLASMA_cplgsy_Tile

    PLASMA_dplgsy_Tile

    PLASMA_splgsy_Tile

    PLASMA_zplrnt_Tile

    PLASMA_zplgsy_Tile

  int PLASMA_zplrnt_Tile (PLASMA_desc * A, unsigned long long int seed)
PLASMA_zplrnt_Tile - Generate a random matrix by tiles. Tile equivalent of PLASMA_zplrnt(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A On exit, The random matrix A generated.
    seed The seed used in the random generation.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zplrnt

    PLASMA_zplrnt_Tile_Async

    PLASMA_cplrnt_Tile

    PLASMA_dplrnt_Tile

    PLASMA_splrnt_Tile

    PLASMA_zplghe_Tile

    PLASMA_zplgsy_Tile

  int PLASMA_zpltmg_Tile (PLASMA_enum mtxtype, PLASMA_desc * A, unsigned long long int seed)
PLASMA_zpltmg_Tile - Generate a random matrix by tiles. Tile equivalent of PLASMA_zpltmg(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    mtxtype See PLASMA_zpltmg()
    A On exit, The random matrix A generated.
    seed The seed used in the random generation.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zpltmg

    PLASMA_zpltmg_Tile_Async

    PLASMA_cpltmg_Tile

    PLASMA_dpltmg_Tile

    PLASMA_spltmg_Tile

  int PLASMA_zpocon_Tile (PLASMA_enum uplo, PLASMA_desc * A, double Anorm, double * rcond)
PLASMA_zpocon_Tile - estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm. Tile equivalent of PLASMA_zpocon(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A The N-by-N matrix A.
    Anorm If norm = PlasmaOneNorm, the 1-norm of the original matrix A. If norm = PlasmaInfNorm, the infinity-norm of the original matrix A.
    rcond The reciprocal of the condition number of the matrix A, computed as stated above.

Returns:

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

See also:
    PLASMA_zpocon

    PLASMA_zpocon_Tile_Async

    PLASMA_cpocon_Tile

    PLASMA_dpocon_Tile

    PLASMA_spocon_Tile

  int PLASMA_zposv_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_zposv_Tile - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization. Tile equivalent of PLASMA_zposv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    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.
    A 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 On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zposv

    PLASMA_zposv_Tile_Async

    PLASMA_cposv_Tile

    PLASMA_dposv_Tile

    PLASMA_sposv_Tile

  int PLASMA_zpotrf_Tile (PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_zpotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite or Hermitian positive definite matrix. Tile equivalent of PLASMA_zpotrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A 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.

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zpotrf

    PLASMA_zpotrf_Tile_Async

    PLASMA_cpotrf_Tile

    PLASMA_dpotrf_Tile

    PLASMA_spotrf_Tile

    PLASMA_zpotrs_Tile

  int PLASMA_zpotri_Tile (PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_zpotri_Tile - Computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by PLASMA_zpotrf. Tile equivalent of PLASMA_zpotri(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A On entry, the triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, as computed by PLASMA_zpotrf. On exit, the upper or lower triangle of the (Hermitian) inverse of A, overwriting the input factor U or L.

Returns:

Return values:
    PLASMA_SUCCESS 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.

See also:
    PLASMA_zpotri

    PLASMA_zpotri_Tile_Async

    PLASMA_cpotri_Tile

    PLASMA_dpotri_Tile

    PLASMA_spotri_Tile

    PLASMA_zpotrf_Tile

  int PLASMA_zpotrs_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_zpotrs_Tile - Solves a system of linear equations using previously computed Cholesky factorization. Tile equivalent of PLASMA_zpotrs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    A The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, computed by PLASMA_zpotrf.
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zpotrs

    PLASMA_zpotrs_Tile_Async

    PLASMA_cpotrs_Tile

    PLASMA_dpotrs_Tile

    PLASMA_spotrs_Tile

    PLASMA_zpotrf_Tile

  int PLASMA_zstedc (PLASMA_enum jobz, int n, double * D, double * E, PLASMA_Complex64_t * Z, int LDZ)
PLASMA_zstedc - Computes all eigenpairs of a symmetric tridiagonal matrix

Parameters:
    jobz Intended usage: = PlasmaIVec: computes eigenpairs of the symmetric tridiagonal matrix = PlasmaVec: computes eigenpairs of the original matrix (not supported now)
    n n specifies the dimension of the original matrix
    D On entry, D contains the diagonal elements of the tridiagonal matrix On exit, D contains the eigenvalues
    E On entry, E contains the extra-diagonal elements of the tridiagonal matrix
    Z On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDZ The leading dimention of the eigenvectors matrix Z. LDZ >= max(1,N).

Returns:

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

See also:
    PLASMA_zstedc

    PLASMA_zstedc_Async

    PLASMA_cstedc

    PLASMA_dstedc

    PLASMA_sstedc

  int PLASMA_zsymm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B, PLASMA_Complex64_t beta, PLASMA_desc * C)
PLASMA_zsymm_Tile - Performs symmetric matrix multiplication. Tile equivalent of PLASMA_zsymm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side Specifies whether the symmetric matrix A appears on the left or right in the operation as follows: = PlasmaLeft: = PlasmaRight:
    uplo Specifies whether the upper or lower triangular part of the symmetric matrix A is to be referenced as follows: = PlasmaLower: Only the lower triangular part of the symmetric matrix A is to be referenced. = PlasmaUpper: Only the upper triangular part of the symmetric matrix A is to be referenced.
    alpha Specifies the scalar alpha.
    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.
    B B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B.
    beta Specifies the scalar beta.
    C C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N updated matrix.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zsymm

    PLASMA_zsymm_Tile_Async

    PLASMA_csymm_Tile

    PLASMA_dsymm_Tile

    PLASMA_ssymm_Tile

  int PLASMA_zsyr2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B, PLASMA_Complex64_t beta, PLASMA_desc * C)
PLASMA_zsyr2k_Tile - Performs symmetric rank k update. Tile equivalent of PLASMA_zsyr2k(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is conjugate transposed.
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    B B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise.
    beta beta specifies the scalar beta
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zsyr2k

    PLASMA_zsyr2k_Tile_Async

    PLASMA_csyr2k_Tile

    PLASMA_dsyr2k_Tile

    PLASMA_ssyr2k_Tile

  int PLASMA_zsyrk_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_Complex64_t beta, PLASMA_desc * C)
PLASMA_zsyrk_Tile - Performs rank k update. Tile equivalent of PLASMA_zsyrk(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored.
    trans Specifies whether the matrix A is transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed.
    alpha alpha specifies the scalar alpha.
    A A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise.
    beta beta specifies the scalar beta
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zsyrk

    PLASMA_zsyrk_Tile_Async

    PLASMA_csyrk_Tile

    PLASMA_dsyrk_Tile

    PLASMA_ssyrk_Tile

  int PLASMA_ztradd_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_Complex64_t beta, PLASMA_desc * B)
PLASMA_ztradd_Tile - Performs a matrix addition similarly to the pztradd() function from the PBLAS library. Tile equivalent of PLASMA_ztradd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo Specifies the shape of A and B matrices: = PlasmaUpperLower: A and B are general matrices. = PlasmaUpper: op(A) and B are upper trapezoidal matrices. = PlasmaLower: op(A) and B are lower trapezoidal matrices.
    trans Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjugate transposed.
    alpha alpha specifies the scalar alpha
    A A is a LDA-by-ka matrix, where ka is N when trans = PlasmaNoTrans, and is M otherwise.
    beta beta specifies the scalar beta
    B B is a LDB-by-N matrix.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_ztradd

    PLASMA_ztradd_Tile_Async

    PLASMA_ctradd_Tile

    PLASMA_dtradd_Tile

    PLASMA_stradd_Tile

  int PLASMA_ztrmm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_ztrmm_Tile - Computes triangular solve. Tile equivalent of PLASMA_ztrmm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B
    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.
    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.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    alpha alpha specifies the scalar alpha.
    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.
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_ztrmm

    PLASMA_ztrmm_Tile_Async

    PLASMA_ctrmm_Tile

    PLASMA_dtrmm_Tile

    PLASMA_strmm_Tile

  int PLASMA_ztrsm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_ztrsm_Tile - Computes triangular solve. Tile equivalent of PLASMA_ztrsm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B
    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.
    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.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    alpha alpha specifies the scalar alpha.
    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.
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_ztrsm

    PLASMA_ztrsm_Tile_Async

    PLASMA_ctrsm_Tile

    PLASMA_dtrsm_Tile

    PLASMA_strsm_Tile

  int PLASMA_ztrsmpl_Tile (PLASMA_desc * A, PLASMA_desc * L, const int * IPIV, PLASMA_desc * B)
PLASMA_ztrsmpl_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.

Parameters:
    A The tile factor L from the factorization, computed by PLASMA_zgetrf_incpiv.
    L Auxiliary factorization data, related to the tile L factor, computed by PLASMA_zgetrf_incpiv.
    IPIV The pivot indices from PLASMA_zgetrf_incpiv (not equivalent to LAPACK).
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_ztrsmpl

    PLASMA_ztrsmpl_Tile_Async

    PLASMA_ctrsmpl_Tile

    PLASMA_dtrsmpl_Tile

    PLASMA_strsmpl_Tile

    PLASMA_zgetrf_incpiv_Tile

  int PLASMA_ztrsmrv_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_ztrsmrv_Tile - Computes triangular solve. Tile equivalent of PLASMA_ztrsmrv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B
    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.
    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.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    alpha alpha specifies the scalar alpha.
    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.
    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.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_ztrsmrv

    PLASMA_ztrsmrv_Tile_Async

    PLASMA_ctrsmrv_Tile

    PLASMA_dtrsmrv_Tile

    PLASMA_strsmrv_Tile

  int PLASMA_ztrtri_Tile (PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc * A)
PLASMA_ztrtri_Tile - Computes the inverse of a complex upper or lower triangular matrix A. Tile equivalent of PLASMA_ztrtri(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    diag = PlasmaNonUnit: A is non-unit triangular; = PlasmaUnit: A us unit triangular.
    A On entry, the triangular matrix A. If UPLO = 'U', 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 = 'L', 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 = 'U', the diagonal elements of A are also not referenced and are assumed to be 1. On exit, the (triangular) inverse of the original matrix, in the same storage format.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    >0 if i, A(i,i) is exactly zero. The triangular matrix is singular and its inverse can not be computed.

See also:
    PLASMA_ztrtri

    PLASMA_ztrtri_Tile_Async

    PLASMA_ctrtri_Tile

    PLASMA_dtrtri_Tile

    PLASMA_strtri_Tile

    PLASMA_zpotri_Tile

  int PLASMA_zunglq_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_zunglq_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_zgelqf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_zgelqf.
    T Auxiliary factorization data, computed by PLASMA_zgelqf.
    Q On exit, the M-by-N matrix Q.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zunglq

    PLASMA_zunglq_Tile_Async

    PLASMA_cunglq_Tile

    PLASMA_dorglq_Tile

    PLASMA_sorglq_Tile

    PLASMA_zgelqf_Tile

  int PLASMA_zungqr_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_zungqr_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_zgeqrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A Details of the QR factorization of the original matrix A as returned by PLASMA_zgeqrf.
    T Auxiliary factorization data, computed by PLASMA_zgeqrf.
    Q On exit, the M-by-N matrix Q.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zungqr

    PLASMA_zungqr_Tile_Async

    PLASMA_cungqr_Tile

    PLASMA_dorgqr_Tile

    PLASMA_sorgqr_Tile

    PLASMA_zgeqrf_Tile

  int PLASMA_zunmlq_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * C)
PLASMA_zunmlq_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_zgelqf_Tile Q is of order M. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side 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 Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjugate transpose, apply Q**H. Currently only PlasmaConjTrans is supported.
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_zgelqf.
    T Auxiliary factorization data, computed by PLASMA_zgelqf.
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zunmlq

    PLASMA_zunmlq_Tile_Async

    PLASMA_cunmlq_Tile

    PLASMA_dormlq_Tile

    PLASMA_sormlq_Tile

    PLASMA_zgelqf_Tile

  int PLASMA_zunmqr_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * C)
PLASMA_zunmqr_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_zgeqrf_Tile Q is of order M. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    side 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 Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjugate transpose, apply Q**H. Currently only PlasmaConjTrans is supported.
    A Details of the QR factorization of the original matrix A as returned by PLASMA_zgeqrf.
    T Auxiliary factorization data, computed by PLASMA_zgeqrf. Can be obtained with PLASMA_Alloc_Workspace_zgeqrf
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_zunmqr

    PLASMA_zunmqr_Tile_Async

    PLASMA_cunmqr_Tile

    PLASMA_dormqr_Tile

    PLASMA_sormqr_Tile

    PLASMA_zgeqrf_Tile

Author

Generated automatically by Doxygen for PLASMA from the source code.