Simple Interface - Single Complex(3)

NAME
Simple Interface - Single Complex -

  Functions/Subroutines
int PLASMA_cgebrd (int M, int N, PLASMA_Complex32_t *A, int LDA, float *D, float *E, PLASMA_desc *descT)
int LAPACK_GLOBAL (clacn2, CLACN2)
int PLASMA_cgelqf (int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT)
int PLASMA_cgelqs (int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cgels (PLASMA_enum trans, int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cgemm (PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_cgeqrf (int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT)
int PLASMA_cgeqrs (int M, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cgesv (int N, int NRHS, PLASMA_Complex32_t *A, int LDA, int *IPIV, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cgesv_incpiv (int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descL, int *IPIV, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cgesvd (PLASMA_enum jobu, PLASMA_enum jobvt, int M, int N, PLASMA_Complex32_t *A, int LDA, float *S, PLASMA_Complex32_t *U, int LDU, PLASMA_Complex32_t *VT, int LDVT, PLASMA_desc *descT)
int PLASMA_cgetrf (int M, int N, PLASMA_Complex32_t *A, int LDA, int *IPIV)
int PLASMA_cgetrf_incpiv (int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descL, int *IPIV)
int PLASMA_cgetri (int N, PLASMA_Complex32_t *A, int LDA, int *IPIV)
int PLASMA_cgetrs (PLASMA_enum trans, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, int *IPIV, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cgetrs_incpiv (PLASMA_enum trans, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descL, int *IPIV, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cheev (PLASMA_enum jobz, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_cheevd (PLASMA_enum jobz, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_chegst (PLASMA_enum itype, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
int PLASMA_chegv (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_chegvd (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_chemm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_cher2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, float beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_cherk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, float alpha, PLASMA_Complex32_t *A, int LDA, float beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_chetrd (PLASMA_enum jobz, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, float *D, float *E, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_clacpy (PLASMA_enum uplo, int M, int N, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
float PLASMA_clange (PLASMA_enum norm, int M, int N, PLASMA_Complex32_t *A, int LDA, float *work)
float PLASMA_clanhe (PLASMA_enum norm, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, float *work)
float PLASMA_clansy (PLASMA_enum norm, PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA, float *work)
int PLASMA_claset (PLASMA_enum uplo, int M, int N, PLASMA_Complex32_t alpha, PLASMA_Complex32_t beta, PLASMA_Complex32_t *A, int LDA)
int PLASMA_claswp (int N, PLASMA_Complex32_t *A, int LDA, int K1, int K2, int *IPIV, int INCX)
int PLASMA_claswpc (int N, PLASMA_Complex32_t *A, int LDA, int K1, int K2, int *IPIV, int INCX)
int PLASMA_clauum (PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA)
int PLASMA_cplghe (float bump, int N, PLASMA_Complex32_t *A, int LDA, unsigned long long int seed)
int PLASMA_cplgsy (PLASMA_Complex32_t bump, int N, PLASMA_Complex32_t *A, int LDA, unsigned long long int seed)
int PLASMA_cplrnt (int M, int N, PLASMA_Complex32_t *A, int LDA, unsigned long long int seed)
int PLASMA_cposv (PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
int PLASMA_cpotrf (PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA)
int PLASMA_cpotri (PLASMA_enum uplo, int N, PLASMA_Complex32_t *A, int LDA)
int PLASMA_cpotrs (PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
int PLASMA_csymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_csyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_csyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t beta, PLASMA_Complex32_t *C, int LDC)
int PLASMA_ctrmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
int PLASMA_ctrsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
int PLASMA_ctrsmpl (int N, int NRHS, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descL, int *IPIV, PLASMA_Complex32_t *B, int LDB)
int PLASMA_ctrsmrv (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex32_t alpha, PLASMA_Complex32_t *A, int LDA, PLASMA_Complex32_t *B, int LDB)
int PLASMA_ctrtri (PLASMA_enum uplo, PLASMA_enum diag, int N, PLASMA_Complex32_t *A, int LDA)
int PLASMA_cunglq (int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_cungqr (int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *Q, int LDQ)
int PLASMA_cunmlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *C, int LDC)
int PLASMA_cunmqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex32_t *A, int LDA, PLASMA_desc *descT, PLASMA_Complex32_t *C, int LDC)
int PLASMA_cLapack_to_Tile (PLASMA_Complex32_t *Af77, int LDA, PLASMA_desc *A)
int PLASMA_cTile_to_Lapack (PLASMA_desc *A, PLASMA_Complex32_t *Af77, int LDA)

Detailed Description

This is the group of single complex functions using the simple user interface.

Function/Subroutine Documentation

  int PLASMA_cgebrd (intM, intN, PLASMA_Complex32_t *A, intLDA, float *D, float *E, PLASMA_desc *descT)
PLASMA_cgebrd - 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. Not LAPACK Compliant for now! Note: T is incomplete and contains only the block reflectors of the first stage. Therefore, Q and P can not be built completely.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    D On exit, the diagonal elements of the bidiagonal matrix: D(i) = A(i,i). Dimension (min(M,N)).
    E On exit, the off-diagonal elements of the bidiagonal matrix: 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).
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_cgesvd On exit, contains auxiliary factorization data.

Returns:

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

See Also:
    PLASMA_cgebrd_Tile

    PLASMA_cgebrd_Tile_Async

    PLASMA_cgebrd

    PLASMA_dgebrd

    PLASMA_sgebrd

  int PLASMA_cgelqf (intM, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT)
PLASMA_cgelqf - Computes the tile LQ factorization of a complex M-by-N matrix A: A = L * Q.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT On exit, auxiliary factorization data, required by PLASMA_cgelqs to solve the system of equations.

Returns:

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

See Also:
    PLASMA_cgelqf_Tile

    PLASMA_cgelqf_Tile_Async

    PLASMA_cgelqf

    PLASMA_dgelqf

    PLASMA_sgelqf

    PLASMA_cgelqs

  int PLASMA_cgelqs (intM, intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *B, intLDB)
PLASMA_cgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_cgelqf.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= M >= 0.
    NRHS The number of columns of B. NRHS >= 0.
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.
    LDA The leading dimension of the array A. LDA >= M.
    descT Auxiliary factorization data, computed by PLASMA_cgelqf.
    B On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X.
    LDB The leading dimension of the array B. LDB >= N.

Returns:

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

See Also:
    PLASMA_cgelqs_Tile

    PLASMA_cgelqs_Tile_Async

    PLASMA_cgelqs

    PLASMA_dgelqs

    PLASMA_sgelqs

    PLASMA_cgelqf

  int PLASMA_cgels (PLASMA_enumtrans, intM, intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *B, intLDB)
PLASMA_cgels - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

trans = PlasmaNoTrans and M >= N: find the least squares solution of an overdetermined

system, i.e., solve the least squares problem: minimize || B - A*X ||.

trans = PlasmaNoTrans and M < N: find the minimum norm solution of an underdetermined

system A * X = B.

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

Parameters:
    trans Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaConjTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported.
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
    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_cgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_cgelqf.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT 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;
    LDB The leading dimension of the array B. LDB >= MAX(1,M,N).

Returns:

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

See Also:
    PLASMA_cgels_Tile

    PLASMA_cgels_Tile_Async

    PLASMA_cgels

    PLASMA_dgels

    PLASMA_sgels

  int PLASMA_cgemm (PLASMA_enumtransA, PLASMA_enumtransB, intM, intN, intK, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, PLASMA_Complex32_tbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_cgemm - Performs one of the matrix-matrix operations

+

where op( X ) is one of

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

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

Parameters:
    transA Specifies whether the matrix A is transposed, not transposed or conjfugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjfugate transposed.
    transB Specifies whether the matrix B is transposed, not transposed or conjfugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaConjTrans: B is conjfugate transposed.
    M M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0.
    N N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0.
    K K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    B B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise.
    LDB The leading dimension of the array B. LDB >= max(1,N).
    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 )
    LDC The leading dimension of the array C. LDC >= max(1,M).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_cgemm_Tile

    PLASMA_cgemm

    PLASMA_dgemm

    PLASMA_sgemm

  int PLASMA_cgeqrf (intM, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT)
PLASMA_cgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT On exit, auxiliary factorization data, required by PLASMA_cgeqrs to solve the system of equations.

Returns:

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

See Also:
    PLASMA_cgeqrf_Tile

    PLASMA_cgeqrf_Tile_Async

    PLASMA_cgeqrf

    PLASMA_dgeqrf

    PLASMA_sgeqrf

    PLASMA_cgeqrs

  int PLASMA_cgeqrs (intM, intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *B, intLDB)
PLASMA_cgeqrs - Compute a minimum-norm solution min || A*X - B || using the RQ factorization A = R*Q computed by PLASMA_cgeqrf.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= M >= 0.
    NRHS The number of columns of B. NRHS >= 0.
    A Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.
    LDA The leading dimension of the array A. LDA >= M.
    descT Auxiliary factorization data, computed by PLASMA_cgeqrf.
    B On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_cgeqrs_Tile

    PLASMA_cgeqrs_Tile_Async

    PLASMA_cgeqrs

    PLASMA_dgeqrs

    PLASMA_sgeqrs

    PLASMA_cgeqrf

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

Parameters:
    N The number of linear equations, i.e., the order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    A On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.

See Also:
    PLASMA_cgesv_Tile

    PLASMA_cgesv_Tile_Async

    PLASMA_cgesv

    PLASMA_dgesv

    PLASMA_sgesv

  int PLASMA_cgesv_incpiv (intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descL, int *IPIV, PLASMA_Complex32_t *B, intLDB)
PLASMA_cgesv_incpiv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B.

Parameters:
    N The number of linear equations, i.e., the order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    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).
    LDA The leading dimension of the array A. LDA >= max(1,N).
    descL 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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.

See Also:
    PLASMA_cgesv_incpiv_Tile

    PLASMA_cgesv_incpiv_Tile_Async

    PLASMA_cgesv_incpiv

    PLASMA_dgesv_incpiv

    PLASMA_sgesv_incpiv

  int PLASMA_cgesvd (PLASMA_enumjobu, PLASMA_enumjobvt, intM, intN, PLASMA_Complex32_t *A, intLDA, float *S, PLASMA_Complex32_t *U, intLDU, PLASMA_Complex32_t *VT, intLDVT, PLASMA_desc *descT)
PLASMA_cgesvd - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written

 A = U * SIGMA * transpose(V)

where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A.

Note that the routine returns V**T, not V. Not LAPACK Compliant for now! Note: Only PlasmaNoVec supported!

Parameters:
    jobu Specifies options for computing all or part of the matrix U. Intended usage: = PlasmaVec: all M columns of U are returned in array U; = PlasmaNoVec: no columns of U (no left singular vectors) are computed. Note: Only PlasmaNoVec supported!
    jobvt Specifies options for computing all or part of the matrix V**H. Intended usage: = PlasmaVec: all M columns of U are returned in array U; = PlasmaNoVec: no columns of U (no left singular vectors) are computed. Note: Only PlasmaNoVec supported!
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    S The real singular values of A, sorted so that S(i) >= S(i+1).
    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).
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_cgesvd On exit, contains auxiliary factorization data.

Returns:

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

See Also:
    PLASMA_cgesvd_Tile

    PLASMA_cgesvd_Tile_Async

    PLASMA_cgesvd

    PLASMA_dgesvd

    PLASMA_sgesvd

  int PLASMA_cgetrf (intM, intN, PLASMA_Complex32_t *A, intLDA, int *IPIV)
PLASMA_cgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    IPIV The pivot indices that define the permutations.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

See Also:
    PLASMA_cgetrf_Tile

    PLASMA_cgetrf_Tile_Async

    PLASMA_cgetrf

    PLASMA_dgetrf

    PLASMA_sgetrf

  int PLASMA_cgetrf_incpiv (intM, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descL, int *IPIV)
PLASMA_cgetrf_incpiv - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

Parameters:
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    A On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descL On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_cgetrs_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, the i-th argument had an illegal value
    >0 if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

See Also:
    PLASMA_cgetrf_incpiv_Tile

    PLASMA_cgetrf_incpiv_Tile_Async

    PLASMA_cgetrf_incpiv

    PLASMA_dgetrf_incpiv

    PLASMA_sgetrf_incpiv

    PLASMA_cgetrs_incpiv

  int PLASMA_cgetri (intN, PLASMA_Complex32_t *A, intLDA, int *IPIV)
PLASMA_cgetri - Computes the inverse of a matrix using the LU factorization computed by PLASMA_cgetrf. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

Parameters:
    N The order of the matrix A. N >= 0.
    A On entry, the triangular factor L or U from the factorization A = P*L*U as computed by PLASMA_cgetrf. On exit, if return value = 0, the inverse of the original matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    IPIV The pivot indices that define the permutations as returned by PLASMA_cgetrf.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >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_cgetri_Tile

    PLASMA_cgetri_Tile_Async

    PLASMA_cgetri

    PLASMA_dgetri

    PLASMA_sgetri

    PLASMA_cgetrf

  int PLASMA_cgetrs (PLASMA_enumtrans, intN, intNRHS, PLASMA_Complex32_t *A, intLDA, int *IPIV, PLASMA_Complex32_t *B, intLDB)
PLASMA_cgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_cgetrf.

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)
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    A The tile factors L and U from the factorization, computed by PLASMA_cgetrf.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    IPIV The pivot indices from PLASMA_cgetrf.
    B On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

Returns:
    <0 if -i, the i-th argument had an illegal value

See Also:
    PLASMA_cgetrs_Tile

    PLASMA_cgetrs_Tile_Async

    PLASMA_cgetrs

    PLASMA_dgetrs

    PLASMA_sgetrs

    PLASMA_cgetrf

  int PLASMA_cgetrs_incpiv (PLASMA_enumtrans, intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descL, int *IPIV, PLASMA_Complex32_t *B, intLDB)
PLASMA_cgetrs_incpiv - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_cgetrf_incpiv.

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) Currently only PlasmaNoTrans is supported.
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    A The tile factors L and U from the factorization, computed by PLASMA_cgetrf_incpiv.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    descL Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf_incpiv.
    IPIV The pivot indices from PLASMA_cgetrf_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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

Returns:
    <0 if -i, the i-th argument had an illegal value

See Also:
    PLASMA_cgetrs_incpiv_Tile

    PLASMA_cgetrs_incpiv_Tile_Async

    PLASMA_cgetrs_incpiv

    PLASMA_dgetrs_incpiv

    PLASMA_sgetrs_incpiv

    PLASMA_cgetrf_incpiv

  int PLASMA_cheev (PLASMA_enumjobz, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_cheev - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. The matrix A is preliminary reduced to tridiagonal form using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

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.
    N The order of the matrix A. N >= 0.
    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, the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    W On exit, if info = 0, the eigenvalues.
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_cheev On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimension of the array 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_cheev_Tile

    PLASMA_cheev_Tile_Async

    PLASMA_cheev

    PLASMA_dsyev

    PLASMA_ssyev

  int PLASMA_cheevd (PLASMA_enumjobz, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_cheevd - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. The matrix A is preliminary reduced to tridiagonal form using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

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.
    N The order of the matrix A. N >= 0.
    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, the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    W On exit, if info = 0, the eigenvalues.
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_cheevd On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimension of the array 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_cheevd_Tile

    PLASMA_cheevd_Tile_Async

    PLASMA_cheevd

    PLASMA_dsyev

    PLASMA_ssyev

  int PLASMA_chegst (PLASMA_enumitype, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB)
PLASMA_chegst - 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_CPOTRF.

Parameters:
    itype Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x
    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.
    N The order of the matrices A and B. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    B On entry, the triangular factor from the Cholesky factorization of B, as returned by PLASMA_CPOTRF.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_chegst_Tile

    PLASMA_chegst_Tile_Async

    PLASMA_chegst

    PLASMA_dsygst

    PLASMA_ssygst

  int PLASMA_chegv (PLASMA_enumitype, PLASMA_enumjobz, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_chegv - 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.

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.
    N The order of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDA >= max(1,N).
    W On exit, if info = 0, the eigenvalues.
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_chegv On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimension of Q.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    <=N if INFO = i, plasma_chegv 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_chegv_Tile

    PLASMA_chegv_Tile_Async

    PLASMA_chegv

    PLASMA_dsygv

    PLASMA_ssygv

  int PLASMA_chegvd (PLASMA_enumitype, PLASMA_enumjobz, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, float *W, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_chegvd - 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.

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.
    N The order of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDA >= max(1,N).
    W On exit, if info = 0, the eigenvalues.
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_chegvd On exit, contains auxiliary factorization data.
    Q On exit, if jobz = PlasmaVec and info = 0, the eigenvectors.
    LDQ The leading dimension of Q.

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    <=N if INFO = i, plasma_chegvd 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_chegvd_Tile

    PLASMA_chegvd_Tile_Async

    PLASMA_chegvd

    PLASMA_dsygvd

    PLASMA_ssygvd

  int PLASMA_chemm (PLASMA_enumside, PLASMA_enumuplo, intM, intN, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, PLASMA_Complex32_tbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_chemm - Performs one of the matrix-matrix operations

.PP or

.PP where alpha and beta are scalars, A is an hermitian matrix and B and C are m by n matrices.

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.
    M Specifies the number of rows of the matrix C. M >= 0.
    N Specifies the number of columns of the matrix C. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,ka).
    B B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B.
    LDB The leading dimension of the array B. LDB >= max(1,M).
    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.
    LDC The leading dimension of the array C. LDC >= max(1,M).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_chemm_Tile

    PLASMA_chemm

    PLASMA_dhemm

    PLASMA_shemm

  int PLASMA_cher2k (PLASMA_enumuplo, PLASMA_enumtrans, intN, intK, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, floatbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_cher2k - Performs one of the hermitian rank 2k operations

+ conjfg( lpha ) [ op( B ) imes conjfg( op( A )' )] + ts op( B ) ] + conjfg( lpha ) [ conjfg( op( B )' ) imes op( A ) ] +

where op( X ) is one of

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

where alpha and beta are real scalars, C is an n-by-n symmetric matrix and A and B are an n-by-k matrices the first case and k-by-n matrices in the second case.

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 conjfugate transposed: = PlasmaNoTrans: + conjfg( lpha ) [ op( B ) imes conjfg( op( A )' )] + ts op( B ) ] + conjfg( lpha ) [ conjfg( op( B )' ) imes op( A ) ] +
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the A and B matrices with trans = PlasmaNoTrans. K specifies the number of rows of the A and B matrices with trans = PlasmaTrans.
    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.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ), otherwise LDA must be at least max( 1, K ).
    B B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise.
    LDB The leading dimension of the array B. LDB must be at least max( 1, N ), otherwise LDB must be at least max( 1, K ).
    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.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_cher2k_Tile

    PLASMA_cher2k

    PLASMA_dher2k

    PLASMA_sher2k

  int PLASMA_cherk (PLASMA_enumuplo, PLASMA_enumtrans, intN, intK, floatalpha, PLASMA_Complex32_t *A, intLDA, floatbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_cherk - Performs one of the hermitian rank k operations

+

where op( X ) is one of

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

where alpha and beta are real scalars, C is an n-by-n hermitian matrix and A is an n-by-k matrix in the first case and a k-by-n matrix in the second case.

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 conjfugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaConjTrans: A is conjfugate transposed.
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the matrix op( A ).
    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.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ) if trans == PlasmaNoTrans, otherwise LDA must be at least max( 1, K ).
    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.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_cherk_Tile

    PLASMA_cherk

    PLASMA_dherk

    PLASMA_sherk

  int PLASMA_chetrd (PLASMA_enumjobz, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, float *D, float *E, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_chetrd - 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.

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.
    N The order of the matrix A. N >= 0.
    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, the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_chetrd On exit, contains 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_chetrd_Tile

    PLASMA_chetrd_Tile_Async

    PLASMA_chetrd

    PLASMA_dsytrd

    PLASMA_ssytrd

  int PLASMA_clacpy (PLASMA_enumuplo, intM, intN, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB)
PLASMA_clacpy copies all or part of a two-dimensional matrix A to another matrix B

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
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    B The M-by-N matrix B. On exit, B = A in the locations specified by UPLO.
    LDB The leading dimension of the array B. LDB >= max(1,M).

See Also:
    PLASMA_clacpy_Tile

    PLASMA_clacpy_Tile_Async

    PLASMA_clacpy

    PLASMA_dlacpy

    PLASMA_slacpy

  float PLASMA_clange (PLASMA_enumnorm, intM, intN, PLASMA_Complex32_t *A, intLDA, float *work)
PLASMA_clange returns the value

clange = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm

where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

Parameters:
    norm = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm
    M The number of rows of the matrix A. M >= 0. When M = 0, the returned value is set to zero.
    N The number of columns of the matrix A. N >= 0. When N = 0, the returned value is set to zero.
    A The M-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    work real array of dimension (MAX(1,LWORK)), where LWORK >= M when NORM = PlasmaInfNorm; otherwise, WORK is not referenced.

Returns:

Return values:
    the norm described above.

See Also:
    PLASMA_clange_Tile

    PLASMA_clange_Tile_Async

    PLASMA_clange

    PLASMA_dlange

    PLASMA_slange

  float PLASMA_clanhe (PLASMA_enumnorm, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, float *work)
PLASMA_clanhe returns the value

clanhe = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm

where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

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.
    N The number of columns/rows of the matrix A. N >= 0. When N = 0, the returned value is set to zero.
    A The N-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    work real array of dimension PLASMA_SIZE is PLASMA_STATIC_SCHEDULING is used, and NULL otherwise.

Returns:

Return values:
    the norm described above.

See Also:
    PLASMA_clanhe_Tile

    PLASMA_clanhe_Tile_Async

    PLASMA_clanhe

    PLASMA_dlanhe

    PLASMA_slanhe

  float PLASMA_clansy (PLASMA_enumnorm, PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA, float *work)
PLASMA_clansy returns the value

clansy = ( max(abs(A(i,j))), NORM = PlasmaMaxNorm ( ( norm1(A), NORM = PlasmaOneNorm ( ( normI(A), NORM = PlasmaInfNorm ( ( normF(A), NORM = PlasmaFrobeniusNorm

where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

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.
    N The number of columns/rows of the matrix A. N >= 0. When N = 0, the returned value is set to zero.
    A The N-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    work real array of dimension PLASMA_SIZE is PLASMA_STATIC_SCHEDULING is used, and NULL otherwise.

Returns:

Return values:
    the norm described above.

See Also:
    PLASMA_clansy_Tile

    PLASMA_clansy_Tile_Async

    PLASMA_clansy

    PLASMA_dlansy

    PLASMA_slansy

  int PLASMA_cLapack_to_Tile (PLASMA_Complex32_t *Af77, intLDA, PLASMA_desc *A)
PLASMA_cLapack_to_Tile - Conversion from LAPACK layout to tile layout.

Parameters:
    Af77 LAPACK matrix.
    LDA The leading dimension of the matrix Af77.
    A Descriptor of the PLASMA matrix in tile layout. If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE, A->mat is not used and set to Af77 when returns, else if PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE, A->mat has to be allocated before.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_cLapack_to_Tile_Async

    PLASMA_cTile_to_Lapack

    PLASMA_cLapack_to_Tile

    PLASMA_dLapack_to_Tile

    PLASMA_sLapack_to_Tile

  int PLASMA_claset (PLASMA_enumuplo, intM, intN, PLASMA_Complex32_talpha, PLASMA_Complex32_tbeta, PLASMA_Complex32_t *A, intLDA)
PLASMA_claset copies all or part of a two-dimensional matrix A to another matrix B

Parameters:
    uplo Specifies the part of the matrix A to be copied to B. = PlasmaUpperLower: All the matrix A = PlasmaUpper: Upper triangular part is set. The lower triangle is unchanged. = PlasmaLower: Lower triangular part is set. The upper triangle is unchange.
    M The number of rows of the matrix A. M >= 0.
    N The number of columns of the matrix A. N >= 0.
    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)
    LDA The leading dimension of the array A. LDA >= max(1,M).

See Also:
    PLASMA_claset_Tile

    PLASMA_claset_Tile_Async

    PLASMA_claset

    PLASMA_dlaset

    PLASMA_slaset

  int PLASMA_claswp (intN, PLASMA_Complex32_t *A, intLDA, intK1, intK2, int *IPIV, intINCX)
PLASMA_claswp - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Parameters:
    N The order of the matrix A. N >= 0.
    A The tile factors L and U from the factorization, computed by PLASMA_cgetrf.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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_cgetrf.
    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

Returns:
    <0 if -i, the i-th argument had an illegal value

See Also:
    PLASMA_claswp_Tile

    PLASMA_claswp_Tile_Async

    PLASMA_claswp

    PLASMA_dlaswp

    PLASMA_slaswp

    PLASMA_cgetrf

  int PLASMA_claswpc (intN, PLASMA_Complex32_t *A, intLDA, intK1, intK2, int *IPIV, intINCX)
PLASMA_claswpc - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.

Parameters:
    N The order of the matrix A. N >= 0.
    A The tile factors L and U from the factorization, computed by PLASMA_cgetrf.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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_cgetrf.
    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

Returns:
    <0 if -i, the i-th argument had an illegal value

See Also:
    PLASMA_claswpc_Tile

    PLASMA_claswpc_Tile_Async

    PLASMA_claswpc

    PLASMA_dlaswpc

    PLASMA_slaswpc

    PLASMA_cgetrf

  int PLASMA_clauum (PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA)
PLASMA_clauum - 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.

If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the triangular factor U or L. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).

Returns:

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

See Also:
    PLASMA_clauum_Tile

    PLASMA_clauum_Tile_Async

    PLASMA_clauum

    PLASMA_dlauum

    PLASMA_slauum

    PLASMA_cpotri

  int PLASMA_cplghe (floatbump, intN, PLASMA_Complex32_t *A, intLDA, unsigned long long intseed)
PLASMA_cplghe - Generate a random hermitian matrix by tiles.

Parameters:
    bump The value to add to the diagonal to be sure to have a positive definite matrix.
    N The order of the matrix A. N >= 0.
    A On exit, The random hermitian matrix A generated.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    seed The seed used in the random generation.

Returns:

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

See Also:
    PLASMA_cplghe_Tile

    PLASMA_cplghe_Tile_Async

    PLASMA_cplghe

    PLASMA_dplghe

    PLASMA_splghe

    PLASMA_cplrnt

    PLASMA_cplgsy

  int PLASMA_cplgsy (PLASMA_Complex32_tbump, intN, PLASMA_Complex32_t *A, intLDA, unsigned long long intseed)
PLASMA_cplgsy - Generate a random hermitian matrix by tiles.

Parameters:
    bump The value to add to the diagonal to be sure to have a positive definite matrix.
    N The order of the matrix A. N >= 0.
    A On exit, The random hermitian matrix A generated.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    seed The seed used in the random generation.

Returns:

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

See Also:
    PLASMA_cplgsy_Tile

    PLASMA_cplgsy_Tile_Async

    PLASMA_cplgsy

    PLASMA_dplgsy

    PLASMA_splgsy

    PLASMA_cplrnt

    PLASMA_cplgsy

  int PLASMA_cplrnt (intM, intN, PLASMA_Complex32_t *A, intLDA, unsigned long long intseed)
PLASMA_cplrnt - Generate a random matrix by tiles.

Parameters:
    M The number of rows of A.
    N The order of the matrix A. N >= 0.
    A On exit, The random matrix A generated.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    seed The seed used in the random generation.

Returns:

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

See Also:
    PLASMA_cplrnt_Tile

    PLASMA_cplrnt_Tile_Async

    PLASMA_cplrnt

    PLASMA_dplrnt

    PLASMA_splrnt

    PLASMA_cplghe

    PLASMA_cplgsy

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

A = _{L imes L^H, if uplo = PlasmaLower}^{U^H imes U, if uplo = PlasmaUpper} ].PP where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

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.
    N The number of linear equations, i.e., the order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

See Also:
    PLASMA_cposv_Tile

    PLASMA_cposv_Tile_Async

    PLASMA_cposv

    PLASMA_dposv

    PLASMA_sposv

  int PLASMA_cpotrf (PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA)
PLASMA_cpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

A = _{L imes L^H, if uplo = PlasmaLower}^{U^H imes U, if uplo = PlasmaUpper} ].PP where U is an upper triangular matrix and L is a lower triangular matrix.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

See Also:
    PLASMA_cpotrf_Tile

    PLASMA_cpotrf_Tile_Async

    PLASMA_cpotrf

    PLASMA_dpotrf

    PLASMA_spotrf

    PLASMA_cpotrs

  int PLASMA_cpotri (PLASMA_enumuplo, intN, PLASMA_Complex32_t *A, intLDA)
PLASMA_cpotri - 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_cpotrf.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A. N >= 0.
    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_cpotrf. On exit, the upper or lower triangle of the (Hermitian) inverse of A, overwriting the input factor U or L.
    LDA The leading dimension of the array A. LDA >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, the (i,i) element of the factor U or L is zero, and the inverse could not be computed.

See Also:
    PLASMA_cpotri_Tile

    PLASMA_cpotri_Tile_Async

    PLASMA_cpotri

    PLASMA_dpotri

    PLASMA_spotri

    PLASMA_cpotrf

  int PLASMA_cpotrs (PLASMA_enumuplo, intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB)
PLASMA_cpotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by PLASMA_cpotrf.

Parameters:
    uplo = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    A The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, computed by PLASMA_cpotrf.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_cpotrs_Tile

    PLASMA_cpotrs_Tile_Async

    PLASMA_cpotrs

    PLASMA_dpotrs

    PLASMA_spotrs

    PLASMA_cpotrf

  int PLASMA_csymm (PLASMA_enumside, PLASMA_enumuplo, intM, intN, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, PLASMA_Complex32_tbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_csymm - Performs one of the matrix-matrix operations

.PP or

.PP where alpha and beta are scalars, A is an symmetric matrix and B and C are m by n matrices.

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.
    M Specifies the number of rows of the matrix C. M >= 0.
    N Specifies the number of columns of the matrix C. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,ka).
    B B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B.
    LDB The leading dimension of the array B. LDB >= max(1,M).
    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.
    LDC The leading dimension of the array C. LDC >= max(1,M).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_csymm_Tile

    PLASMA_csymm

    PLASMA_dsymm

    PLASMA_ssymm

  int PLASMA_csyr2k (PLASMA_enumuplo, PLASMA_enumtrans, intN, intK, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB, PLASMA_Complex32_tbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_csyr2k - Performs one of the symmetric rank 2k operations

+ lpha [ op( B ) imes conjfg( op( A )' )] + ts op( B ) ] + lpha [ conjfg( op( B )' ) imes op( A ) ] +

where op( X ) is one of

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

where alpha and beta are real scalars, C is an n-by-n symmetric matrix and A and B are an n-by-k matrices the first case and k-by-n matrices in the second case.

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 conjfugate transposed: = PlasmaNoTrans: + lpha [ op( B ) imes conjfg( op( A )' )] + ts op( B ) ] + lpha [ conjfg( op( B )' ) imes op( A ) ] +
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the A and B matrices with trans = PlasmaNoTrans. K specifies the number of rows of the A and B matrices with trans = PlasmaTrans.
    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.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ), otherwise LDA must be at least max( 1, K ).
    B B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise.
    LDB The leading dimension of the array B. LDB must be at least max( 1, N ), otherwise LDB must be at least max( 1, K ).
    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.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_csyr2k_Tile

    PLASMA_csyr2k

    PLASMA_dsyr2k

    PLASMA_ssyr2k

  int PLASMA_csyrk (PLASMA_enumuplo, PLASMA_enumtrans, intN, intK, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_tbeta, PLASMA_Complex32_t *C, intLDC)
PLASMA_csyrk - Performs one of the hermitian rank k operations

+

where op( X ) is one of

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

where alpha and beta are real scalars, C is an n-by-n hermitian matrix and A is an n-by-k matrix in the first case and a k-by-n matrix in the second case.

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 conjfugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans : A is transposed.
    N N specifies the order of the matrix C. N must be at least zero.
    K K specifies the number of columns of the matrix op( A ).
    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.
    LDA The leading dimension of the array A. LDA must be at least max( 1, N ) if trans == PlasmaNoTrans, otherwise LDA must be at least max( 1, K ).
    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.
    LDC The leading dimension of the array C. LDC >= max( 1, N ).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_csyrk_Tile

    PLASMA_csyrk

    PLASMA_dsyrk

    PLASMA_ssyrk

  int PLASMA_cTile_to_Lapack (PLASMA_desc *A, PLASMA_Complex32_t *Af77, intLDA)
PLASMA_Tile_to_Lapack - Conversion from tile layout to LAPACK layout.

Parameters:
    A Descriptor of the PLASMA matrix in tile layout.
    Af77 LAPACK matrix. If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE, Af77 has to be A->mat, else if PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE, Af77 has to be allocated before.
    LDA The leading dimension of the matrix Af77.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See Also:
    PLASMA_cTile_to_Lapack_Async

    PLASMA_cLapack_to_Tile

    PLASMA_cTile_to_Lapack

    PLASMA_dTile_to_Lapack

    PLASMA_sTile_to_Lapack

  int PLASMA_ctrmm (PLASMA_enumside, PLASMA_enumuplo, PLASMA_enumtransA, PLASMA_enumdiag, intN, intNRHS, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB)
PLASMA_ctrmm - Computes B = alpha*op( A )*B or B = alpha*B*op( A ).

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 conjfugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjfugate transposed.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_ctrmm_Tile

    PLASMA_ctrmm_Tile_Async

    PLASMA_ctrmm

    PLASMA_dtrmm

    PLASMA_strmm

  int PLASMA_ctrsm (PLASMA_enumside, PLASMA_enumuplo, PLASMA_enumtransA, PLASMA_enumdiag, intN, intNRHS, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB)
PLASMA_ctrsm - Computes triangular solve A*X = B or X*A = B.

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 conjfugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjfugate transposed.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_ctrsm_Tile

    PLASMA_ctrsm_Tile_Async

    PLASMA_ctrsm

    PLASMA_dtrsm

    PLASMA_strsm

  int PLASMA_ctrsmpl (intN, intNRHS, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descL, int *IPIV, PLASMA_Complex32_t *B, intLDB)
PLASMA_ctrsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.

Parameters:
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    A The tile factor L from the factorization, computed by PLASMA_cgetrf_incpiv.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    descL Auxiliary factorization data, related to the tile L factor, computed by PLASMA_cgetrf_incpiv.
    IPIV The pivot indices from PLASMA_cgetrf_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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_ctrsmpl_Tile

    PLASMA_ctrsmpl_Tile_Async

    PLASMA_ctrsmpl

    PLASMA_dtrsmpl

    PLASMA_strsmpl

    PLASMA_cgetrf_incpiv

  int PLASMA_ctrsmrv (PLASMA_enumside, PLASMA_enumuplo, PLASMA_enumtransA, PLASMA_enumdiag, intN, intNRHS, PLASMA_Complex32_talpha, PLASMA_Complex32_t *A, intLDA, PLASMA_Complex32_t *B, intLDB)
PLASMA_ctrsmrv - Computes triangular solve A*X = B or X*A = B.

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 conjfugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjfugate transposed.
    diag Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
    N The order of the matrix A. N >= 0.
    NRHS The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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.
    LDB The leading dimension of the array B. LDB >= max(1,N).

Returns:

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

See Also:
    PLASMA_ctrsmrv_Tile

    PLASMA_ctrsmrv_Tile_Async

    PLASMA_ctrsmrv

    PLASMA_dtrsmrv

    PLASMA_strsmrv

  int PLASMA_ctrtri (PLASMA_enumuplo, PLASMA_enumdiag, intN, PLASMA_Complex32_t *A, intLDA)
PLASMA_ctrtri - Computes the inverse of a complex upper or lower triangular matrix A.

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 is unit triangular.
    N The order of the matrix A. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,N).

Returns:

Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
    >0 if i, A(i,i) is exactly zero. The triangular matrix is singular and its inverse can not be computed.

See Also:
    PLASMA_ctrtri_Tile

    PLASMA_ctrtri_Tile_Async

    PLASMA_ctrtri

    PLASMA_dtrtri

    PLASMA_strtri

    PLASMA_cpotri

  int PLASMA_cunglq (intM, intN, intK, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_cunglq - Generates an M-by-N matrix Q with orthonormal rows, which is defined as the first M rows of a product of the elementary reflectors returned by PLASMA_cgelqf.

Parameters:
    M The number of rows of the matrix Q. M >= 0.
    N The number of columns of the matrix Q. N >= M.
    K The number of rows of elementary tile reflectors whose product defines the matrix Q. M >= K >= 0.
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT Auxiliary factorization data, computed by PLASMA_cgelqf.
    Q On exit, the M-by-N matrix Q.
    LDQ The leading dimension of the array Q. LDQ >= max(1,M).

Returns:

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

See Also:
    PLASMA_cunglq_Tile

    PLASMA_cunglq_Tile_Async

    PLASMA_cunglq

    PLASMA_dorglq

    PLASMA_sorglq

    PLASMA_cgelqf

  int PLASMA_cungqr (intM, intN, intK, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *Q, intLDQ)
PLASMA_cungqr - Generates an M-by-N matrix Q with orthonormal columns, which is defined as the first N columns of a product of the elementary reflectors returned by PLASMA_cgeqrf.

Parameters:
    M The number of rows of the matrix Q. M >= 0.
    N The number of columns of the matrix Q. N >= M.
    K The number of columns of elementary tile reflectors whose product defines the matrix Q. M >= K >= 0.
    A Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT Auxiliary factorization data, computed by PLASMA_cgeqrf.
    Q On exit, the M-by-N matrix Q.
    LDQ The leading dimension of the array Q. LDQ >= max(1,M).

Returns:

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

See Also:
    PLASMA_cungqr_Tile

    PLASMA_cungqr_Tile_Async

    PLASMA_cungqr

    PLASMA_dorgqr

    PLASMA_sorgqr

    PLASMA_cgeqrf

  int PLASMA_cunmlq (PLASMA_enumside, PLASMA_enumtrans, intM, intN, intK, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *C, intLDC)
PLASMA_cunmlq - Overwrites the general complex M-by-N matrix C with

            SIDE = 'L'     SIDE = 'R'

 TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H

where Q is a complex unitary matrix defined as the product of k elementary reflectors

  Q = H(1) H(2) . . . H(k)

as returned by PLASMA_cgeqrf. Q is of order M if SIDE = PlasmaLeft and of order N if SIDE = PlasmaRight.

Parameters:
    side Intended usage: = PlasmaLeft: apply Q or Q**H from the left; = PlasmaRight: apply Q or Q**H from the right.
    trans Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjfugate transpose, apply Q**H.
    M The number of rows of the matrix C. M >= 0.
    N The number of columns of the matrix C. N >= 0.
    K The number of rows of elementary tile reflectors whose product defines the matrix Q. If side == PlasmaLeft, M >= K >= 0. If side == PlasmaRight, N >= K >= 0.
    A Details of the LQ factorization of the original matrix A as returned by PLASMA_cgelqf.
    LDA The leading dimension of the array A. LDA >= max(1,K).
    descT Auxiliary factorization data, computed by PLASMA_cgelqf.
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C.
    LDC The leading dimension of the array C. LDC >= max(1,M).

Returns:

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

See Also:
    PLASMA_cunmlq_Tile

    PLASMA_cunmlq_Tile_Async

    PLASMA_cunmlq

    PLASMA_dormlq

    PLASMA_sormlq

    PLASMA_cgelqf

  int PLASMA_cunmqr (PLASMA_enumside, PLASMA_enumtrans, intM, intN, intK, PLASMA_Complex32_t *A, intLDA, PLASMA_desc *descT, PLASMA_Complex32_t *C, intLDC)
PLASMA_cunmqr - Overwrites the general complex M-by-N matrix C with

            SIDE = 'L'     SIDE = 'R'

 TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H

where Q is a complex unitary matrix defined as the product of k elementary reflectors

  Q = H(1) H(2) . . . H(k)

as returned by PLASMA_cgeqrf. Q is of order M if SIDE = PlasmaLeft and of order N if SIDE = PlasmaRight.

Parameters:
    side Intended usage: = PlasmaLeft: apply Q or Q**H from the left; = PlasmaRight: apply Q or Q**H from the right.
    trans Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaConjTrans: conjfugate transpose, apply Q**H.
    M The number of rows of the matrix C. M >= 0.
    N The number of columns of the matrix C. N >= 0.
    K The number of elementary reflectors whose product defines the matrix Q. If side == PlasmaLeft, M >= K >= 0. If side == PlasmaRight, N >= K >= 0.
    A Details of the QR factorization of the original matrix A as returned by PLASMA_cgeqrf.
    LDA The leading dimension of the array A. If side == PlasmaLeft, LDA >= max(1,M). If side == PlasmaRight, LDA >= max(1,N).
    descT Auxiliary factorization data, computed by PLASMA_cgeqrf.
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C.
    LDC The leading dimension of the array C. LDC >= max(1,M).

Returns:

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

See Also:
    PLASMA_cunmqr_Tile

    PLASMA_cunmqr_Tile_Async

    PLASMA_cunmqr

    PLASMA_dormqr

    PLASMA_sormqr

    PLASMA_cgeqrf

Author

Generated automatically by Doxygen for PLASMA from the source code.