float_Tile(3)

NAME
float_Tile - Advanced Interface: Synchronous - Single Real

  Functions
int PLASMA_sgeadd_Tile (PLASMA_enum trans, float alpha, PLASMA_desc *A, float beta, PLASMA_desc *B)
int PLASMA_sgebrd_Tile (PLASMA_enum jobq, PLASMA_enum jobp, PLASMA_desc *A, float *D, float *E, PLASMA_desc *T, float *Q, int LDQ, float *P, int LDP)
int PLASMA_sgecon_Tile (PLASMA_enum norm, PLASMA_desc *A, float Anorm, float *rcond)
int PLASMA_sgelqf_Tile (PLASMA_desc *A, PLASMA_desc *T)
int PLASMA_sgelqs_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
int PLASMA_sgels_Tile (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
int PLASMA_sgemm_Tile (PLASMA_enum transA, PLASMA_enum transB, float alpha, PLASMA_desc *A, PLASMA_desc *B, float beta, PLASMA_desc *C)
int PLASMA_sgeqp3_Tile (PLASMA_desc *A, int *jpvt, float *tau, float *work, float *rwork)
int PLASMA_sgeqrf_Tile (PLASMA_desc *A, PLASMA_desc *T)
int PLASMA_sgeqrs_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B)
int PLASMA_sgesdd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, float *S, PLASMA_desc *T, float *U, int LDU, float *VT, int LDVT)
int PLASMA_sgesv_Tile (PLASMA_desc *A, int *IPIV, PLASMA_desc *B)
int PLASMA_sgesv_incpiv_Tile (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B)
int PLASMA_sgesvd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, float *S, PLASMA_desc *T, float *U, int LDU, float *VT, int LDVT)
int PLASMA_sgetrf_Tile (PLASMA_desc *A, int *IPIV)
int PLASMA_sgetrf_incpiv_Tile (PLASMA_desc *A, PLASMA_desc *L, int *IPIV)
int PLASMA_sgetrf_nopiv_Tile (PLASMA_desc *A)
int PLASMA_sgetrf_tntpiv_Tile (PLASMA_desc *A, int *IPIV)
int PLASMA_sgetri_Tile (PLASMA_desc *A, int *IPIV)
int PLASMA_sgetrs_Tile (PLASMA_enum trans, PLASMA_desc *A, const int *IPIV, PLASMA_desc *B)
int PLASMA_sgetrs_incpiv_Tile (PLASMA_desc *A, PLASMA_desc *L, const int *IPIV, PLASMA_desc *B)
int PLASMA_slacpy_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
float PLASMA_slange_Tile (PLASMA_enum norm, PLASMA_desc *A)
float PLASMA_slansy_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc *A)
float PLASMA_slantr_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc *A)
int PLASMA_slascal_Tile (PLASMA_enum uplo, float alpha, PLASMA_desc *A)
int PLASMA_slaset_Tile (PLASMA_enum uplo, float alpha, float beta, PLASMA_desc *A)
int PLASMA_slaswp_Tile (PLASMA_desc *A, int K1, int K2, const int *IPIV, int INCX)
int PLASMA_slaswpc_Tile (PLASMA_desc *A, int K1, int K2, const int *IPIV, int INCX)
int PLASMA_slauum_Tile (PLASMA_enum uplo, PLASMA_desc *A)
int PLASMA_sorglq_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_sorgqr_Tile (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_sormlq_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *C)
int PLASMA_sormqr_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *C)
int PLASMA_splgsy_Tile (float bump, PLASMA_desc *A, unsigned long long int seed)
int PLASMA_splrnt_Tile (PLASMA_desc *A, unsigned long long int seed)
int PLASMA_spltmg_Tile (PLASMA_enum mtxtype, PLASMA_desc *A, unsigned long long int seed)
int PLASMA_spocon_Tile (PLASMA_enum uplo, PLASMA_desc *A, float Anorm, float *rcond)
int PLASMA_sposv_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_spotrf_Tile (PLASMA_enum uplo, PLASMA_desc *A)
int PLASMA_spotri_Tile (PLASMA_enum uplo, PLASMA_desc *A)
int PLASMA_spotrs_Tile (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_sstedc (PLASMA_enum jobz, int n, float *D, float *E, float *Z, int LDZ)
int PLASMA_ssyev_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, float *W, PLASMA_desc *T, float *Q, int LDQ)
int PLASMA_ssyevd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, float *W, PLASMA_desc *T, float *Q, int LDQ)
int PLASMA_ssyevr_Tile (PLASMA_enum jobz, PLASMA_enum range, PLASMA_enum uplo, PLASMA_desc *A, float vl, float vu, int il, int iu, float abstol, int *nbcomputedeig, float *W, PLASMA_desc *T, float *Q, int LDQ)
int PLASMA_ssygst_Tile (PLASMA_enum itype, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_ssygv_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, float *W, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_ssygvd_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, float *W, PLASMA_desc *T, PLASMA_desc *Q)
int PLASMA_ssymm_Tile (PLASMA_enum side, PLASMA_enum uplo, float alpha, PLASMA_desc *A, PLASMA_desc *B, float beta, PLASMA_desc *C)
int PLASMA_ssyr2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc *A, PLASMA_desc *B, float beta, PLASMA_desc *C)
int PLASMA_ssyrk_Tile (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc *A, float beta, PLASMA_desc *C)
int PLASMA_ssytrd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, float *D, float *E, PLASMA_desc *T, float *Q, int LDQ)
int PLASMA_stradd_Tile (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc *A, float beta, PLASMA_desc *B)
int PLASMA_strmm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, float alpha, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_strsm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, float alpha, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_strsmpl_Tile (PLASMA_desc *A, PLASMA_desc *L, const int *IPIV, PLASMA_desc *B)
int PLASMA_strsmrv_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, float alpha, PLASMA_desc *A, PLASMA_desc *B)
int PLASMA_strtri_Tile (PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc *A)

Detailed Description

This is the group of single real functions using the advanced synchronous interface.

Function Documentation

  int PLASMA_sgeadd_Tile (PLASMA_enum trans, float alpha, PLASMA_desc * A, float beta, PLASMA_desc * B)
PLASMA_sgeadd_Tile - Performs a matrix addition similarly to the psgeadd() function from the PBLAS library. Tile equivalent of PLASMA_sgeadd(). 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 ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaTrans: A is ugate 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_sgeadd

    PLASMA_sgeadd_Tile_Async

    PLASMA_cgeadd_Tile

    PLASMA_dgeadd_Tile

    PLASMA_sgeadd_Tile

  int PLASMA_sgebrd_Tile (PLASMA_enum jobq, PLASMA_enum jobp, PLASMA_desc * A, float * D, float * E, PLASMA_desc * T, float * Q, int LDQ, float * P, int LDP)
PLASMA_sgebrd_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**T * 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_sgebrd(). 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**T. 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 real array containing the diagonal elements of the bidiagonal matrix B: D(i) = A(i,i). Dimension (min(M,N)).
    E The real 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_sgebrd

    PLASMA_sgebrd_Tile_Async

    PLASMA_cgebrd_Tile

    PLASMA_dgebrd_Tile

    PLASMA_sgebrd_Tile

  int PLASMA_sgecon_Tile (PLASMA_enum norm, PLASMA_desc * A, float Anorm, float * rcond)
PLASMA_sgecon_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_sgecon(). 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_sgecon

    PLASMA_sgecon_Tile_Async

    PLASMA_cgecon_Tile

    PLASMA_dgecon_Tile

    PLASMA_sgecon_Tile

  int PLASMA_sgelqf_Tile (PLASMA_desc * A, PLASMA_desc * T)
PLASMA_sgelqf_Tile - Computes the tile LQ factorization of a matrix. Tile equivalent of PLASMA_sgelqf(). 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_sgelqs to solve the system of equations.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_sgelqf

    PLASMA_sgelqf_Tile_Async

    PLASMA_cgelqf_Tile

    PLASMA_dgelqf_Tile

    PLASMA_sgelqf_Tile

    PLASMA_sgelqs_Tile

  int PLASMA_sgelqs_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B)
PLASMA_sgelqs_Tile - Computes a minimum-norm solution using previously computed LQ factorization. Tile equivalent of PLASMA_sgelqs(). 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_sgelqf.
    T Auxiliary factorization data, computed by PLASMA_sgelqf.
    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_sgelqs

    PLASMA_sgelqs_Tile_Async

    PLASMA_cgelqs_Tile

    PLASMA_dgelqs_Tile

    PLASMA_sgelqs_Tile

    PLASMA_sgelqf_Tile

  int PLASMA_sgels_Tile (PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B)
PLASMA_sgels_Tile - Solves overdetermined or underdetermined linear system of equations using the tile QR or the tile LQ factorization. Tile equivalent of PLASMA_sgels(). 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; = PlasmaTrans: the linear system involves A**T. 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_sgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_sgelqf.
    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_sgels

    PLASMA_sgels_Tile_Async

    PLASMA_cgels_Tile

    PLASMA_dgels_Tile

    PLASMA_sgels_Tile

  int PLASMA_sgemm_Tile (PLASMA_enum transA, PLASMA_enum transB, float alpha, PLASMA_desc * A, PLASMA_desc * B, float beta, PLASMA_desc * C)
PLASMA_sgemm_Tile - Performs matrix multiplication. Tile equivalent of PLASMA_sgemm(). 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 ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaTrans: A is ugate transposed.
    transB Specifies whether the matrix B is transposed, not transposed or ugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaTrans: B is ugate 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_sgemm

    PLASMA_sgemm_Tile_Async

    PLASMA_cgemm_Tile

    PLASMA_dgemm_Tile

    PLASMA_sgemm_Tile

  int PLASMA_sgeqp3_Tile (PLASMA_desc * A, int * jpvt, float * tau, float * work, float * rwork)
PLASMA_sgeqp3_Tile - Computes the tile QR factorization with column pivoting of a matrix. Tile equivalent of PLASMA_sgeqp3(). 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_sgeqp3

    PLASMA_sgeqp3_Tile_Async

    PLASMA_cgeqp3_Tile

    PLASMA_dgeqp3_Tile

    PLASMA_sgeqp3_Tile

  int PLASMA_sgeqrf_Tile (PLASMA_desc * A, PLASMA_desc * T)
PLASMA_sgeqrf_Tile - Computes the tile QR factorization of a matrix. Tile equivalent of PLASMA_sgeqrf(). 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_sgeqrs to solve the system of equations.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_sgeqrf

    PLASMA_sgeqrf_Tile_Async

    PLASMA_cgeqrf_Tile

    PLASMA_dgeqrf_Tile

    PLASMA_sgeqrf_Tile

    PLASMA_sgeqrs_Tile

  int PLASMA_sgeqrs_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * B)
PLASMA_sgeqrs_Tile - Computes a minimum-norm solution using the tile QR factorization. Tile equivalent of PLASMA_sgeqrf(). 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_sgeqrf.
    T Auxiliary factorization data, computed by PLASMA_sgeqrf.
    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_sgeqrs

    PLASMA_sgeqrs_Tile_Async

    PLASMA_cgeqrs_Tile

    PLASMA_dgeqrs_Tile

    PLASMA_sgeqrs_Tile

    PLASMA_sgeqrf_Tile

  int PLASMA_sgesdd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc * A, float * S, PLASMA_desc * T, float * U, int LDU, float * VT, int LDVT)
PLASMA_sgesdd_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_sgesdd(). 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**T. Intended usage: = PlasmaVec = 'A'(lapack): all N rows of V**T are returned in the array VT; = PlasmaNoVec = 'N': no rows of V**T (no right singular vectors) are computed. = PlasmaSVec = 'S': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array VT; NOT SUPPORTTED YET = PlasmaOVec = 'O': the first min(m,n) rows of V**T (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**T (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_sgesdd 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**T; if JOBVT = 'S', VT contains the first min(m,n) rows of V**T (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_sgesdd

    PLASMA_sgesdd_Tile_Async

    PLASMA_cgesdd_Tile

    PLASMA_dgesdd_Tile

    PLASMA_sgesdd_Tile

  int PLASMA_sgesv_incpiv_Tile (PLASMA_desc * A, PLASMA_desc * L, int * IPIV, PLASMA_desc * B)
PLASMA_sgesv_incpiv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of PLASMA_sgetrf_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_sgesv_incpiv

    PLASMA_sgesv_incpiv_Tile_Async

    PLASMA_cgesv_incpiv_Tile

    PLASMA_dgesv_incpiv_Tile

    PLASMA_sgesv_incpiv_Tile

    PLASMA_scgesv_Tile

  int PLASMA_sgesv_Tile (PLASMA_desc * A, int * IPIV, PLASMA_desc * B)
PLASMA_sgesv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of PLASMA_sgesv(). 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_sgesv

    PLASMA_sgesv_Tile_Async

    PLASMA_cgesv_Tile

    PLASMA_dgesv_Tile

    PLASMA_sgesv_Tile

    PLASMA_scgesv_Tile

  int PLASMA_sgesvd_Tile (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc * A, float * S, PLASMA_desc * T, float * U, int LDU, float * VT, int LDVT)
PLASMA_sgesvd_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_sgesvd(). 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**T. Intended usage: = PlasmaVec = 'A'(lapack): all N rows of V**T are returned in the array VT; = PlasmaNoVec = 'N': no rows of V**T (no right singular vectors) are computed. = PlasmaSVec = 'S': the first min(m,n) rows of V**T (the right singular vectors) are returned in the array VT; NOT SUPPORTTED YET = PlasmaOVec = 'O': the first min(m,n) rows of V**T (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**T (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_sgesvd 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**T; if JOBVT = 'S', VT contains the first min(m,n) rows of V**T (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_sgesvd

    PLASMA_sgesvd_Tile_Async

    PLASMA_cgesvd_Tile

    PLASMA_dgesvd_Tile

    PLASMA_sgesvd_Tile

  int PLASMA_sgetrf_incpiv_Tile (PLASMA_desc * A, PLASMA_desc * L, int * IPIV)
PLASMA_sgetrf_incpiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_sgetrf_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_sgetrs_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_sgetrf_incpiv

    PLASMA_sgetrf_incpiv_Tile_Async

    PLASMA_cgetrf_incpiv_Tile

    PLASMA_dgetrf_incpiv_Tile

    PLASMA_sgetrf_incpiv_Tile

    PLASMA_sgetrs_incpiv_Tile

  int PLASMA_sgetrf_nopiv_Tile (PLASMA_desc * A)
PLASMA_sgetrf_nopiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_sgetrf_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_sgetrf_nopiv

    PLASMA_sgetrf_nopiv_Tile_Async

    PLASMA_cgetrf_nopiv_Tile

    PLASMA_dgetrf_nopiv_Tile

    PLASMA_sgetrf_nopiv_Tile

    PLASMA_sgetrs_Tile

  int PLASMA_sgetrf_Tile (PLASMA_desc * A, int * IPIV)
PLASMA_sgetrf_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_sgetrf(). 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_sgetrf

    PLASMA_sgetrf_Tile_Async

    PLASMA_cgetrf_Tile

    PLASMA_dgetrf_Tile

    PLASMA_sgetrf_Tile

    PLASMA_sgetrs_Tile

  int PLASMA_sgetrf_tntpiv_Tile (PLASMA_desc * A, int * IPIV)
PLASMA_sgetrf_tntpiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_sgetrf_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_sgetrf_tntpiv

    PLASMA_sgetrf_tntpiv_Tile_Async

    PLASMA_cgetrf_tntpiv_Tile

    PLASMA_dgetrf_tntpiv_Tile

    PLASMA_sgetrf_tntpiv_Tile

  int PLASMA_sgetri_Tile (PLASMA_desc * A, int * IPIV)
PLASMA_sgetri_Tile - Computes the inverse of a matrix using the LU factorization computed by PLASMA_sgetrf. 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_sgetri(). 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_sgetrf. 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_sgetrf.

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_sgetri

    PLASMA_sgetri_Tile_Async

    PLASMA_cgetri_Tile

    PLASMA_dgetri_Tile

    PLASMA_sgetri_Tile

    PLASMA_sgetrf_Tile

  int PLASMA_sgetrs_incpiv_Tile (PLASMA_desc * A, PLASMA_desc * L, const int * IPIV, PLASMA_desc * B)
PLASMA_sgetrs_incpiv_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of PLASMA_sgetrs_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_sgetrf_incpiv.
    L Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf_incpiv.
    IPIV The pivot indices from PLASMA_sgetrf_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_sgetrs_incpiv

    PLASMA_sgetrs_incpiv_Tile_Async

    PLASMA_cgetrs_incpiv_Tile

    PLASMA_dgetrs_incpiv_Tile

    PLASMA_sgetrs_incpiv_Tile

    PLASMA_sgetrf_incpiv_Tile

  int PLASMA_sgetrs_Tile (PLASMA_enum trans, PLASMA_desc * A, const int * IPIV, PLASMA_desc * B)
PLASMA_sgetrs_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of PLASMA_sgetrs(). 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) = PlasmaTrans: A**T * X = B (Conjugate transpose)
    A The tile factors L and U from the factorization, computed by PLASMA_sgetrf.
    IPIV The pivot indices from PLASMA_sgetrf.
    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_sgetrs

    PLASMA_sgetrs_Tile_Async

    PLASMA_cgetrs_Tile

    PLASMA_dgetrs_Tile

    PLASMA_sgetrs_Tile

    PLASMA_sgetrf_Tile

  int PLASMA_slacpy_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_slacpy_Tile - Tile equivalent of PLASMA_slacpy(). 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_slacpy

    PLASMA_slacpy_Tile_Async

    PLASMA_clacpy_Tile

    PLASMA_dlacpy_Tile

    PLASMA_slacpy_Tile

  float PLASMA_slange_Tile (PLASMA_enum norm, PLASMA_desc * A)
PLASMA_slange_Tile - Tile equivalent of PLASMA_slange(). 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_slange

    PLASMA_slange_Tile_Async

    PLASMA_clange_Tile

    PLASMA_dlange_Tile

    PLASMA_slange_Tile

  float PLASMA_slansy_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_slansy_Tile - Tile equivalent of PLASMA_slansy(). 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_slansy

    PLASMA_slansy_Tile_Async

    PLASMA_clansy_Tile

    PLASMA_dlansy_Tile

    PLASMA_slansy_Tile

  float PLASMA_slantr_Tile (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc * A)
PLASMA_slantr_Tile - Tile equivalent of PLASMA_slantr(). 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_slantr

    PLASMA_slantr_Tile_Async

    PLASMA_clantr_Tile

    PLASMA_dlantr_Tile

    PLASMA_slantr_Tile

  int PLASMA_slascal_Tile (PLASMA_enum uplo, float alpha, PLASMA_desc * A)
PLASMA_slascal_Tile - Scales a matrix by the scalar alpha as in ScaLAPACK pslascal().

,

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_slascal

    PLASMA_slascal_Tile_Async

    PLASMA_clascal_Tile

    PLASMA_dlascal_Tile

    PLASMA_slascal_Tile

  int PLASMA_slaset_Tile (PLASMA_enum uplo, float alpha, float beta, PLASMA_desc * A)
PLASMA_slaset_Tile - Tile equivalent of PLASMA_slaset(). 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_slaset

    PLASMA_slaset_Tile_Async

    PLASMA_claset_Tile

    PLASMA_slaset_Tile

    PLASMA_slaset_Tile

  int PLASMA_slaswp_Tile (PLASMA_desc * A, int K1, int K2, const int * IPIV, int INCX)
PLASMA_slaswp_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_slaswp(). 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_sgetrf.
    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_sgetrf.
    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_slaswp

    PLASMA_slaswp_Tile_Async

    PLASMA_claswp_Tile

    PLASMA_dlaswp_Tile

    PLASMA_slaswp_Tile

    PLASMA_sgetrf_Tile

  int PLASMA_slaswpc_Tile (PLASMA_desc * A, int K1, int K2, const int * IPIV, int INCX)
PLASMA_slaswpc_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_slaswpc(). 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_sgetrf.
    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_sgetrf.
    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_slaswpc

    PLASMA_slaswpc_Tile_Async

    PLASMA_claswpc_Tile

    PLASMA_dlaswpc_Tile

    PLASMA_slaswpc_Tile

    PLASMA_sgetrf_Tile

  int PLASMA_slauum_Tile (PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_slauum_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_slauum(). 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_slauum

    PLASMA_slauum_Tile_Async

    PLASMA_clauum_Tile

    PLASMA_dlauum_Tile

    PLASMA_slauum_Tile

    PLASMA_spotri_Tile

  int PLASMA_sorglq_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_sorglq_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_sgelqf. 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_sgelqf.
    T Auxiliary factorization data, computed by PLASMA_sgelqf.
    Q On exit, the M-by-N matrix Q.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_sorglq

    PLASMA_sorglq_Tile_Async

    PLASMA_cunglq_Tile

    PLASMA_dorglq_Tile

    PLASMA_sorglq_Tile

    PLASMA_sgelqf_Tile

  int PLASMA_sorgqr_Tile (PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_sorgqr_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_sgeqrf. 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_sgeqrf.
    T Auxiliary factorization data, computed by PLASMA_sgeqrf.
    Q On exit, the M-by-N matrix Q.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_sorgqr

    PLASMA_sorgqr_Tile_Async

    PLASMA_cungqr_Tile

    PLASMA_dorgqr_Tile

    PLASMA_sorgqr_Tile

    PLASMA_sgeqrf_Tile

  int PLASMA_sormlq_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * C)
PLASMA_sormlq_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_sgelqf_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**T from the left; = PlasmaRight: apply Q or Q**T from the right. Currently only PlasmaLeft is supported.
    trans Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaTrans: ugate transpose, apply Q**T. Currently only PlasmaTrans is supported.
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf.
    T Auxiliary factorization data, computed by PLASMA_sgelqf.
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_sormlq

    PLASMA_sormlq_Tile_Async

    PLASMA_cunmlq_Tile

    PLASMA_dormlq_Tile

    PLASMA_sormlq_Tile

    PLASMA_sgelqf_Tile

  int PLASMA_sormqr_Tile (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc * A, PLASMA_desc * T, PLASMA_desc * C)
PLASMA_sormqr_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_sgeqrf_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**T from the left; = PlasmaRight: apply Q or Q**T from the right. Currently only PlasmaLeft is supported.
    trans Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaTrans: ugate transpose, apply Q**T. Currently only PlasmaTrans is supported.
    A Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf.
    T Auxiliary factorization data, computed by PLASMA_sgeqrf. Can be obtained with PLASMA_Alloc_Workspace_sgeqrf
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_sormqr

    PLASMA_sormqr_Tile_Async

    PLASMA_cormqr_Tile

    PLASMA_dormqr_Tile

    PLASMA_sormqr_Tile

    PLASMA_sgeqrf_Tile

  int PLASMA_splgsy_Tile (float bump, PLASMA_desc * A, unsigned long long int seed)
PLASMA_splgsy_Tile - Generate a random hermitian matrix by tiles. Tile equivalent of PLASMA_splgsy(). 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_splgsy

    PLASMA_splgsy_Tile_Async

    PLASMA_cplgsy_Tile

    PLASMA_dplgsy_Tile

    PLASMA_splgsy_Tile

    PLASMA_splrnt_Tile

    PLASMA_splgsy_Tile

  int PLASMA_splrnt_Tile (PLASMA_desc * A, unsigned long long int seed)
PLASMA_splrnt_Tile - Generate a random matrix by tiles. Tile equivalent of PLASMA_splrnt(). 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_splrnt

    PLASMA_splrnt_Tile_Async

    PLASMA_cplrnt_Tile

    PLASMA_dplrnt_Tile

    PLASMA_splrnt_Tile

    PLASMA_splgsy_Tile

    PLASMA_splgsy_Tile

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

Parameters:
    mtxtype See PLASMA_spltmg()
    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_spltmg

    PLASMA_spltmg_Tile_Async

    PLASMA_cpltmg_Tile

    PLASMA_dpltmg_Tile

    PLASMA_spltmg_Tile

  int PLASMA_spocon_Tile (PLASMA_enum uplo, PLASMA_desc * A, float Anorm, float * rcond)
PLASMA_spocon_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_spocon(). 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_spocon

    PLASMA_spocon_Tile_Async

    PLASMA_cpocon_Tile

    PLASMA_dpocon_Tile

    PLASMA_spocon_Tile

  int PLASMA_sposv_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_sposv_Tile - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization. Tile equivalent of PLASMA_sposv(). 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**T*U or A = L*L**T.
    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_sposv

    PLASMA_sposv_Tile_Async

    PLASMA_cposv_Tile

    PLASMA_dposv_Tile

    PLASMA_sposv_Tile

  int PLASMA_spotrf_Tile (PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_spotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite or Hermitian positive definite matrix. Tile equivalent of PLASMA_spotrf(). 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**T*U or A = L*L**T.

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_spotrf

    PLASMA_spotrf_Tile_Async

    PLASMA_cpotrf_Tile

    PLASMA_dpotrf_Tile

    PLASMA_spotrf_Tile

    PLASMA_spotrs_Tile

  int PLASMA_spotri_Tile (PLASMA_enum uplo, PLASMA_desc * A)
PLASMA_spotri_Tile - Computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by PLASMA_spotrf. Tile equivalent of PLASMA_spotri(). 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**T*U or A = L*L**T, as computed by PLASMA_spotrf. 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_spotri

    PLASMA_spotri_Tile_Async

    PLASMA_cpotri_Tile

    PLASMA_dpotri_Tile

    PLASMA_spotri_Tile

    PLASMA_spotrf_Tile

  int PLASMA_spotrs_Tile (PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_spotrs_Tile - Solves a system of linear equations using previously computed Cholesky factorization. Tile equivalent of PLASMA_spotrs(). 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**T*U or A = L*L**T, computed by PLASMA_spotrf.
    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_spotrs

    PLASMA_spotrs_Tile_Async

    PLASMA_cpotrs_Tile

    PLASMA_dpotrs_Tile

    PLASMA_spotrs_Tile

    PLASMA_spotrf_Tile

  int PLASMA_sstedc (PLASMA_enum jobz, int n, float * D, float * E, float * Z, int LDZ)
PLASMA_sstedc - 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_sstedc

    PLASMA_sstedc_Async

    PLASMA_cstedc

    PLASMA_sstedc

    PLASMA_sstedc

  int PLASMA_ssyev_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, float * W, PLASMA_desc * T, float * Q, int LDQ)
PLASMA_ssyev_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_ssyev 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_ssyev_Tile

    PLASMA_ssyev_Tile_Async

    PLASMA_cheev

    PLASMA_dsyev

    PLASMA_ssyev

  int PLASMA_ssyevd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, float * W, PLASMA_desc * T, float * Q, int LDQ)
PLASMA_ssyevd_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_ssyevd 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_ssyevd_Tile

    PLASMA_ssyevd_Tile_Async

    PLASMA_cheevd

    PLASMA_dsyev

    PLASMA_ssyev

  int PLASMA_ssyevr_Tile (PLASMA_enum jobz, PLASMA_enum range, PLASMA_enum uplo, PLASMA_desc * A, float vl, float vu, int il, int iu, float abstol, int * nbcomputedeig, float * W, PLASMA_desc * T, float * Q, int LDQ)
PLASMA_ssyevr_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 SLAMCH( '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_ssyevr 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_ssyevr_Tile

    PLASMA_ssyevr_Tile_Async

    PLASMA_cheevr

    PLASMA_dsyevr

    PLASMA_ssyevr

  int PLASMA_ssygst_Tile (PLASMA_enum itype, PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_ssygst_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**T)*A*inv(U) or inv(L)*A*inv(L**T) 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**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by PLASMA_SPOTRF. ONLY PlasmaItype == 1 and PlasmaLower supported! Tile equivalent of PLASMA_ssygst(). 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_SPOTRF.

Returns:

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

See also:
    PLASMA_ssygst

    PLASMA_ssygst_Tile_Async

    PLASMA_chegst_Tile

    PLASMA_dsygst_Tile

    PLASMA_ssygst_Tile

    PLASMA_ssygst_Tile

  int PLASMA_ssygv_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B, float * W, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_ssygv_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_ssygv(). 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**T*B*Z = I; if ITYPE = 3, Z**T*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**T*U or B = L*L**T.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_ssygv 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_ssygv 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_ssygv

    PLASMA_ssygv_Tile_Async

    PLASMA_chegv_Tile

    PLASMA_dsygv_Tile

    PLASMA_ssygv_Tile

  int PLASMA_ssygvd_Tile (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, PLASMA_desc * B, float * W, PLASMA_desc * T, PLASMA_desc * Q)
PLASMA_ssygvd_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_ssygvd(). 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**T*B*Z = I; if ITYPE = 3, Z**T*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**T*U or B = L*L**T.
    T On entry, descriptor as return by PLASMA_Alloc_Workspace_ssygvd 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_ssygvd 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_ssygvd

    PLASMA_ssygvd_Tile_Async

    PLASMA_chegvd_Tile

    PLASMA_dsygvd_Tile

    PLASMA_ssygvd_Tile

  int PLASMA_ssymm_Tile (PLASMA_enum side, PLASMA_enum uplo, float alpha, PLASMA_desc * A, PLASMA_desc * B, float beta, PLASMA_desc * C)
PLASMA_ssymm_Tile - Performs symmetric matrix multiplication. Tile equivalent of PLASMA_ssymm(). 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_ssymm

    PLASMA_ssymm_Tile_Async

    PLASMA_csymm_Tile

    PLASMA_dsymm_Tile

    PLASMA_ssymm_Tile

  int PLASMA_ssyr2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc * A, PLASMA_desc * B, float beta, PLASMA_desc * C)
PLASMA_ssyr2k_Tile - Performs symmetric rank k update. Tile equivalent of PLASMA_ssyr2k(). 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 ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is ugate 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_ssyr2k

    PLASMA_ssyr2k_Tile_Async

    PLASMA_csyr2k_Tile

    PLASMA_dsyr2k_Tile

    PLASMA_ssyr2k_Tile

  int PLASMA_ssyrk_Tile (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc * A, float beta, PLASMA_desc * C)
PLASMA_ssyrk_Tile - Performs rank k update. Tile equivalent of PLASMA_ssyrk(). 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 ugate 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_ssyrk

    PLASMA_ssyrk_Tile_Async

    PLASMA_csyrk_Tile

    PLASMA_dsyrk_Tile

    PLASMA_ssyrk_Tile

  int PLASMA_ssytrd_Tile (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc * A, float * D, float * E, PLASMA_desc * T, float * Q, int LDQ)
PLASMA_ssytrd_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**T * A * Q = S. Tile equivalent of PLASMA_ssytrd(). 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_ssytrd

    PLASMA_ssytrd_Tile_Async

    PLASMA_chetrd_Tile

    PLASMA_dsytrd_Tile

    PLASMA_ssytrd_Tile

    PLASMA_ssytrd_Tile

  int PLASMA_stradd_Tile (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc * A, float beta, PLASMA_desc * B)
PLASMA_stradd_Tile - Performs a matrix addition similarly to the pstradd() function from the PBLAS library. Tile equivalent of PLASMA_stradd(). 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 ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaTrans: A is ugate 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_stradd

    PLASMA_stradd_Tile_Async

    PLASMA_ctradd_Tile

    PLASMA_dtradd_Tile

    PLASMA_stradd_Tile

  int PLASMA_strmm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, float alpha, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_strmm_Tile - Computes triangular solve. Tile equivalent of PLASMA_strmm(). 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 ugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is ugate 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_strmm

    PLASMA_strmm_Tile_Async

    PLASMA_ctrmm_Tile

    PLASMA_dtrmm_Tile

    PLASMA_strmm_Tile

  int PLASMA_strsm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, float alpha, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_strsm_Tile - Computes triangular solve. Tile equivalent of PLASMA_strsm(). 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 ugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is ugate 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_strsm

    PLASMA_strsm_Tile_Async

    PLASMA_ctrsm_Tile

    PLASMA_dtrsm_Tile

    PLASMA_strsm_Tile

  int PLASMA_strsmpl_Tile (PLASMA_desc * A, PLASMA_desc * L, const int * IPIV, PLASMA_desc * B)
PLASMA_strsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:
    A The tile factor L from the factorization, computed by PLASMA_sgetrf_incpiv.
    L Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf_incpiv.
    IPIV The pivot indices from PLASMA_sgetrf_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_strsmpl

    PLASMA_strsmpl_Tile_Async

    PLASMA_ctrsmpl_Tile

    PLASMA_dtrsmpl_Tile

    PLASMA_strsmpl_Tile

    PLASMA_sgetrf_incpiv_Tile

  int PLASMA_strsmrv_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, float alpha, PLASMA_desc * A, PLASMA_desc * B)
PLASMA_strsmrv_Tile - Computes triangular solve. Tile equivalent of PLASMA_strsmrv(). 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 ugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaTrans: A is ugate 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_strsmrv

    PLASMA_strsmrv_Tile_Async

    PLASMA_ctrsmrv_Tile

    PLASMA_dtrsmrv_Tile

    PLASMA_strsmrv_Tile

  int PLASMA_strtri_Tile (PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc * A)
PLASMA_strtri_Tile - Computes the inverse of a complex upper or lower triangular matrix A. Tile equivalent of PLASMA_strtri(). 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_strtri

    PLASMA_strtri_Tile_Async

    PLASMA_ctrtri_Tile

    PLASMA_dtrtri_Tile

    PLASMA_strtri_Tile

    PLASMA_spotri_Tile

Author

Generated automatically by Doxygen for PLASMA from the source code.