double(3)

NAME
double - Simple Interface - Double Real

  Functions
int PLASMA_dgeadd (PLASMA_enum trans, int M, int N, double alpha, double *A, int LDA, double beta, double *B, int LDB)
int PLASMA_dgebrd (PLASMA_enum jobq, PLASMA_enum jobp, int M, int N, double *A, int LDA, double *D, double *E, PLASMA_desc *descT, double *Q, int LDQ, double *P, int LDP)
int PLASMA_dgecfi (int m, int n, double *A, PLASMA_enum f_in, int imb, int inb, PLASMA_enum f_out, int omb, int onb)
int PLASMA_dgecfi_Async (int m, int n, double *A, PLASMA_enum f_in, int imb, int inb, PLASMA_enum f_out, int omb, int onb, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgecon (PLASMA_enum norm, int N, double *A, int LDA, double Anorm, double *rcond)
int PLASMA_dgelqf (int M, int N, double *A, int LDA, PLASMA_desc *descT)
int PLASMA_dgelqs (int M, int N, int NRHS, double *A, int LDA, PLASMA_desc *descT, double *B, int LDB)
int PLASMA_dgels (PLASMA_enum trans, int M, int N, int NRHS, double *A, int LDA, PLASMA_desc *descT, double *B, int LDB)
int PLASMA_dgemm (PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, double alpha, double *A, int LDA, double *B, int LDB, double beta, double *C, int LDC)
int PLASMA_dgeqp3 (int M, int N, double *A, int LDA, int *jpvt, double *tau, double *work, double *rwork)
int PLASMA_dgeqrf (int M, int N, double *A, int LDA, PLASMA_desc *descT)
int PLASMA_dgeqrs (int M, int N, int NRHS, double *A, int LDA, PLASMA_desc *descT, double *B, int LDB)
int PLASMA_dgesdd (PLASMA_enum jobu, PLASMA_enum jobvt, int M, int N, double *A, int LDA, double *S, PLASMA_desc *descT, double *U, int LDU, double *VT, int LDVT)
int PLASMA_dgesv (int N, int NRHS, double *A, int LDA, int *IPIV, double *B, int LDB)
int PLASMA_dgesv_incpiv (int N, int NRHS, double *A, int LDA, PLASMA_desc *descL, int *IPIV, double *B, int LDB)
int PLASMA_dgesvd (PLASMA_enum jobu, PLASMA_enum jobvt, int M, int N, double *A, int LDA, double *S, PLASMA_desc *descT, double *U, int LDU, double *VT, int LDVT)
int PLASMA_dgetmi (int m, int n, double *A, PLASMA_enum f_in, int imb, int inb)
int PLASMA_dgetmi_Async (int m, int n, double *A, PLASMA_enum f_in, int mb, int nb, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgetrf (int M, int N, double *A, int LDA, int *IPIV)
int PLASMA_dgetrf_incpiv (int M, int N, double *A, int LDA, PLASMA_desc *descL, int *IPIV)
int PLASMA_dgetrf_nopiv (int M, int N, double *A, int LDA)
int PLASMA_dgetrf_tntpiv (int M, int N, double *A, int LDA, int *IPIV)
int PLASMA_dgetri (int N, double *A, int LDA, int *IPIV)
int PLASMA_dgetrs (PLASMA_enum trans, int N, int NRHS, double *A, int LDA, const int *IPIV, double *B, int LDB)
int PLASMA_dgetrs_incpiv (PLASMA_enum trans, int N, int NRHS, double *A, int LDA, PLASMA_desc *descL, const int *IPIV, double *B, int LDB)
int PLASMA_dlacpy (PLASMA_enum uplo, int M, int N, double *A, int LDA, double *B, int LDB)
double PLASMA_dlange (PLASMA_enum norm, int M, int N, double *A, int LDA)
double PLASMA_dlansy (PLASMA_enum norm, PLASMA_enum uplo, int N, double *A, int LDA)
double PLASMA_dlantr (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, double *A, int LDA)
int PLASMA_dlascal (PLASMA_enum uplo, int M, int N, double alpha, double *A, int LDA)
int PLASMA_dlaset (PLASMA_enum uplo, int M, int N, double alpha, double beta, double *A, int LDA)
int PLASMA_dlaswp (int N, double *A, int LDA, int K1, int K2, const int *IPIV, int INCX)
int PLASMA_dlaswpc (int N, double *A, int LDA, int K1, int K2, const int *IPIV, int INCX)
int PLASMA_dlauum (PLASMA_enum uplo, int N, double *A, int LDA)
int PLASMA_dorglq (int M, int N, int K, double *A, int LDA, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dorgqr (int M, int N, int K, double *A, int LDA, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dormlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, double *A, int LDA, PLASMA_desc *descT, double *C, int LDC)
int PLASMA_dormqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, double *A, int LDA, PLASMA_desc *descT, double *C, int LDC)
int PLASMA_dplgsy (double bump, int N, double *A, int LDA, unsigned long long int seed)
int PLASMA_dplrnt (int M, int N, double *A, int LDA, unsigned long long int seed)
int PLASMA_dpltmg (PLASMA_enum mtxtype, int M, int N, double *A, int LDA, unsigned long long int seed)
int PLASMA_dpocon (PLASMA_enum uplo, int N, double *A, int LDA, double Anorm, double *rcond)
int PLASMA_dposv (PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)
int PLASMA_dpotrf (PLASMA_enum uplo, int N, double *A, int LDA)
int PLASMA_dpotri (PLASMA_enum uplo, int N, double *A, int LDA)
int PLASMA_dpotrs (PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB)
int PLASMA_dsgesv (int N, int NRHS, double *A, int LDA, int *IPIV, double *B, int LDB, double *X, int LDX, int *ITER)
int PLASMA_dsposv (PLASMA_enum uplo, int N, int NRHS, double *A, int LDA, double *B, int LDB, double *X, int LDX, int *ITER)
int PLASMA_dsungesv (PLASMA_enum trans, int N, int NRHS, double *A, int LDA, double *B, int LDB, double *X, int LDX, int *ITER)
int PLASMA_dsyev (PLASMA_enum jobz, PLASMA_enum uplo, int N, double *A, int LDA, double *W, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dsyevd (PLASMA_enum jobz, PLASMA_enum uplo, int N, double *A, int LDA, double *W, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dsyevr (PLASMA_enum jobz, PLASMA_enum range, PLASMA_enum uplo, int N, double *A, int LDA, double vl, double vu, int il, int iu, double abstol, int *nbcomputedeig, double *W, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dsygst (PLASMA_enum itype, PLASMA_enum uplo, int N, double *A, int LDA, double *B, int LDB)
int PLASMA_dsygv (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, int N, double *A, int LDA, double *B, int LDB, double *W, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dsygvd (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, int N, double *A, int LDA, double *B, int LDB, double *W, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dsymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, double alpha, double *A, int LDA, double *B, int LDB, double beta, double *C, int LDC)
int PLASMA_dsyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, double *A, int LDA, double *B, int LDB, double beta, double *C, int LDC)
int PLASMA_dsyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, double *A, int LDA, double beta, double *C, int LDC)
int PLASMA_dsytrd (PLASMA_enum jobz, PLASMA_enum uplo, int N, double *A, int LDA, double *D, double *E, PLASMA_desc *descT, double *Q, int LDQ)
int PLASMA_dtradd (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, double alpha, double *A, int LDA, double beta, double *B, int LDB)
int PLASMA_dtrmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double alpha, double *A, int LDA, double *B, int LDB)
int PLASMA_dtrsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double alpha, double *A, int LDA, double *B, int LDB)
int PLASMA_dtrsmpl (int N, int NRHS, double *A, int LDA, PLASMA_desc *descL, const int *IPIV, double *B, int LDB)
int PLASMA_dtrsmrv (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double alpha, double *A, int LDA, double *B, int LDB)
int PLASMA_dtrtri (PLASMA_enum uplo, PLASMA_enum diag, int N, double *A, int LDA)
int PLASMA_dLapack_to_Tile (double *Af77, int LDA, PLASMA_desc *A)
int PLASMA_dTile_to_Lapack (PLASMA_desc *A, double *Af77, int LDA)

Detailed Description

This is the group of double real functions using the simple user interface.

Function Documentation

  int PLASMA_dgeadd (PLASMA_enum trans, int M, int N, double alpha, double * A, int LDA, double beta, double * B, int LDB)
PLASMA_dgeadd - Performs a matrix addition similarly to the pdgeadd() function from the PBLAS library:

,

where op( X ) is one of

op( X ) = X or op( X ) = X' or op( X ) = g( X' )

alpha and beta are scalars, and A, and B are matrices, with op( A ) and B two m by n matrices.

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.
    M M specifies the number of rows of the matrix op( A ) and of the matrix B. M >= 0.
    N N specifies the number of columns of the matrix op( A ) and of the matrix B. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,K), where K is M when trans = PlasmaNoTrans, and is N when otherwise.
    beta beta specifies the scalar beta
    B B is a LDB-by-N matrix.
    LDB The leading dimension of the array B. LDB >= max(1,M).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_dgeadd_Tile

    PLASMA_cgeadd

    PLASMA_dgeadd

    PLASMA_sgeadd

  int PLASMA_dgebrd (PLASMA_enum jobq, PLASMA_enum jobp, int M, int N, double * A, int LDA, double * D, double * E, PLASMA_desc * descT, double * Q, int LDQ, double * P, int LDP)
PLASMA_dgebrd - 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. 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:
    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 N columns of P are returned in array P; = PlasmaNoVec: not referenced.
    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_dgebrd 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:

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

See also:
    PLASMA_dgebrd_Tile

    PLASMA_dgebrd_Tile_Async

    PLASMA_cgebrd

    PLASMA_dgebrd

    PLASMA_sgebrd

  int PLASMA_dgecfi (int m, int n, double * A, PLASMA_enum f_in, int imb, int inb, PLASMA_enum f_out, int omb, int onb)
PLASMA_dgecfi convert the matrice A in place from format f_in to format f_out

Parameters:
    m Number of rows of matrix A
    n Number of columns of matrix A
    A Matrix of size m*n
    f_in Original layout of the matrix A. Must be part of: PlasmaCM: if A is stored in Column Major, PlasmaRM: if A is stored in Row Major, PlasmaCCRB: if A is stored in Column Column Rectangular Block layout, PlasmaCRRB: if A is stored in Column Row Rectangular Block layout, PlasmaRCRB: if A is stored in Row Column Rectangular Block layout, PlasmaRRRB: if A is stored in Row Row Rectangular Block layout; where the first Column/Row stand for the order in which tiles are sorted, and the secon Column/Row stand for the layout inside each tile.
    imb Number of rows of each block in original format
    inb Number of columns of each block in original format
    f_out Format requested for the matrix A. Must be part of (PlasmaCM, PlasmaRM, PlasmaCCRB, PlasmaCRRB, PlasmaRCRB, PlasmaRRRB)
    omb Number of rows of each block in requested format
    onb Number of columns of each block in requested format

Returns:

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

See also:
    PLASMA_dgecfi_Async

  int PLASMA_dgecfi_Async (int m, int n, double * A, PLASMA_enum f_in, int imb, int inb, PLASMA_enum f_out, int omb, int onb, PLASMA_sequence * sequence, PLASMA_request * request)
PLASMA_dgecfi_Async convert the matrice A in place from format f_in to format f_out

Parameters:
    m Number of rows of matrix A
    n Number of columns of matrix A
    A Matrix of size L*m*n
    f_in Original format of the matrix A. Must be part of (PlasmaCM, PlasmaRM, PlasmaCCRB, PlasmaCRRB, PlasmaRCRB, PlasmaRRRB)
    imb Number of rows of each block in original format
    inb Number of columns of each block in original format
    f_out Format requested for the matrix A. Must be part of (PlasmaCM, PlasmaRM, PlasmaCCRB, PlasmaCRRB, PlasmaRCRB, PlasmaRRRB)
    omb Number of rows of each block in requested format
    onb Number of columns of each block in requested format
    sequence Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
    request Identifies this function call (for exception handling purposes).

Returns:

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

See also:
    PLASMA_dgecfi

  int PLASMA_dgecon (PLASMA_enum norm, int N, double * A, int LDA, double Anorm, double * rcond)
PLASMA_dgecon - estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by PLASMA_dgetrf().

An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as

.PP Parameters:
    norm Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm
    N The order of the matrix A. N >= 0.
    A The N-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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_dgecon_Tile

    PLASMA_dgecon_Tile_Async

    PLASMA_cgecon

    PLASMA_dgecon

    PLASMA_sgecon

  int PLASMA_dgelqf (int M, int N, double * A, int LDA, PLASMA_desc * descT)
PLASMA_dgelqf - 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_dgelqs 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_dgelqf_Tile

    PLASMA_dgelqf_Tile_Async

    PLASMA_cgelqf

    PLASMA_dgelqf

    PLASMA_sgelqf

    PLASMA_dgelqs

  int PLASMA_dgelqs (int M, int N, int NRHS, double * A, int LDA, PLASMA_desc * descT, double * B, int LDB)
PLASMA_dgelqs - Compute a minimum-norm solution min || A*X - B || using the LQ factorization A = L*Q computed by PLASMA_dgelqf.

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_dgelqf. Remark: If out-of-place layout translation is used, the matrix A can be considered as input, however if inplace layout translation is enabled, the content of A will be reordered for computation and restored before exiting the function.
    LDA The leading dimension of the array A. LDA >= M.
    descT Auxiliary factorization data, computed by PLASMA_dgelqf.
    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_dgelqs_Tile

    PLASMA_dgelqs_Tile_Async

    PLASMA_cgelqs

    PLASMA_dgelqs

    PLASMA_sgelqs

    PLASMA_dgelqf

  int PLASMA_dgels (PLASMA_enum trans, int M, int N, int NRHS, double * A, int LDA, PLASMA_desc * descT, double * B, int LDB)
PLASMA_dgels - solves overdetermined or underdetermined linear systems involving an M-by-N matrix A using the QR or the LQ factorization of A. It is assumed that A has full rank. The following options are provided:

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

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

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

underdetermined system A * X = B.

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

Parameters:
    trans Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**T. 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_dgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_dgelqf.
    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_dgels_Tile

    PLASMA_dgels_Tile_Async

    PLASMA_cgels

    PLASMA_dgels

    PLASMA_sgels

  int PLASMA_dgemm (PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, double alpha, double * A, int LDA, double * B, int LDB, double beta, double * C, int LDC)
PLASMA_dgemm - Performs one of the matrix-matrix operations

+

where op( X ) is one of

op( X ) = X or op( X ) = X' or op( X ) = g( 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 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.
    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_dgemm_Tile

    PLASMA_cgemm

    PLASMA_dgemm

    PLASMA_sgemm

  int PLASMA_dgeqp3 (int M, int N, double * A, int LDA, int * jpvt, double * tau, double * work, double * rwork)
PLASMA_dgeqp3 - Computes the QR factorization with column pivoting of a complex M-by-N matrix A: A*P = 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).
    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. Uses 1-based indexing for Fortran compatability.
    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
    <0 if -i, the i-th argument had an illegal value

See also:
    PLASMA_dgeqp3_Tile

    PLASMA_dgeqp3_Tile_Async

    PLASMA_cgeqp3

    PLASMA_dgeqp3

    PLASMA_sgeqp3

  int PLASMA_dgeqrf (int M, int N, double * A, int LDA, PLASMA_desc * descT)
PLASMA_dgeqrf - 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_dgeqrs 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_dgeqrf_Tile

    PLASMA_dgeqrf_Tile_Async

    PLASMA_cgeqrf

    PLASMA_dgeqrf

    PLASMA_sgeqrf

    PLASMA_dgeqrs

  int PLASMA_dgeqrs (int M, int N, int NRHS, double * A, int LDA, PLASMA_desc * descT, double * B, int LDB)
PLASMA_dgeqrs - Compute a minimum-norm solution min || A*X - B || using the QR factorization A = Q*R computed by PLASMA_dgeqrf.

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_dgeqrf. Remark: If out-of-place layout translation is used, the matrix A can be considered as input, however if inplace layout translation is enabled, the content of A will be reordered for computation and restored before exiting the function.
    LDA The leading dimension of the array A. LDA >= M.
    descT Auxiliary factorization data, computed by PLASMA_dgeqrf.
    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_dgeqrs_Tile

    PLASMA_dgeqrs_Tile_Async

    PLASMA_cgeqrs

    PLASMA_dgeqrs

    PLASMA_sgeqrs

    PLASMA_dgeqrf

  int PLASMA_dgesdd (PLASMA_enum jobu, PLASMA_enum jobvt, int M, int N, double * A, int LDA, double * S, PLASMA_desc * descT, double * U, int LDU, double * VT, int LDVT)
PLASMA_dgesdd - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written

 A = U * SIGMA * ugate-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 unitary matrix, and V is an N-by-N unitary 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 VT = V**T, not V.

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.

NOTE that the input parameter of this function differ from the LAPACK DGESDD. We have jobu and jobvt instead of only jobz first to be consistent with DGESVD and second to allow a computation of only U or VT.

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:
    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**T (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 double precision singular values of A, sorted so that S(i) >= S(i+1).
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_dgesdd 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:

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

See also:
    PLASMA_dgesdd_Tile

    PLASMA_dgesdd_Tile_Async

    PLASMA_cgesdd

    PLASMA_dgesdd

    PLASMA_sgesdd

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

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_dgesv_Tile

    PLASMA_dgesv_Tile_Async

    PLASMA_cgesv

    PLASMA_dgesv

    PLASMA_sgesv

  int PLASMA_dgesv_incpiv (int N, int NRHS, double * A, int LDA, PLASMA_desc * descL, int * IPIV, double * B, int LDB)
PLASMA_dgesv_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_dgesv_incpiv_Tile

    PLASMA_dgesv_incpiv_Tile_Async

    PLASMA_cgesv_incpiv

    PLASMA_dgesv_incpiv

    PLASMA_sgesv_incpiv

  int PLASMA_dgesvd (PLASMA_enum jobu, PLASMA_enum jobvt, int M, int N, double * A, int LDA, double * S, PLASMA_desc * descT, double * U, int LDU, double * VT, int LDVT)
PLASMA_dgesvd - 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.

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:
    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**T (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 double precision singular values of A, sorted so that S(i) >= S(i+1).
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_dgesvd 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:

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

See also:
    PLASMA_dgesvd_Tile

    PLASMA_dgesvd_Tile_Async

    PLASMA_cgesvd

    PLASMA_dgesvd

    PLASMA_sgesvd

  int PLASMA_dgetmi (int m, int n, double * A, PLASMA_enum f_in, int imb, int inb)
PLASMA_dgetmi Implementation of inplace transposition based on the GKK algorithm by Gustavson, Karlsson, Kagstrom. This algorithm shift some cycles to transpose the matrix.

Parameters:
    m Number of rows of matrix A
    n Number of columns of matrix A
    A Matrix of size L*m*n.
    f_in Original layout of the matrix A. Must be part of: PlasmaCM: if A is stored in Column Major, PlasmaRM: if A is stored in Row Major, PlasmaCCRB: if A is stored in Column Column Rectangular Block layout, PlasmaCRRB: if A is stored in Column Row Rectangular Block layout, PlasmaRCRB: if A is stored in Row Column Rectangular Block layout, PlasmaRRRB: if A is stored in Row Row Rectangular Block layout; where the first Column/Row stand for the order in which tiles are sorted, and the secon Column/Row stand for the layout inside each tile.
    imb Number of rows of the problem
    inb Number of columns in the problem

Returns:

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

See also:
    PLASMA_dgetmi_Async

  int PLASMA_dgetmi_Async (int m, int n, double * A, PLASMA_enum f_in, int mb, int nb, PLASMA_sequence * sequence, PLASMA_request * request)
PLASMA_dgetmi_Async Implementation of inplace transposition based on the GKK algorithm by Gustavson, Karlsson, Kagstrom. This algorithm shift some cycles to transpose the matrix.

Parameters:
    m Number of rows of matrix A
    n Number of columns of matrix A
    A Matrix of size L*m*n.
    f_in Original format of the matrix A. Must be part of (PlasmaCM, PlasmaRM, PlasmaCCRB, PlasmaCRRB, PlasmaRCRB, PlasmaRRRB)
    mb Number of rows of the problem
    nb Number of columns in the problem
    sequence Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
    request Identifies this function call (for exception handling purposes).

Returns:

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

See also:
    PLASMA_dgetmi

  int PLASMA_dgetrf (int M, int N, double * A, int LDA, int * IPIV)
PLASMA_dgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

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_dgetrf_Tile

    PLASMA_dgetrf_Tile_Async

    PLASMA_cgetrf

    PLASMA_dgetrf

    PLASMA_sgetrf

  int PLASMA_dgetrf_incpiv (int M, int N, double * A, int LDA, PLASMA_desc * descL, int * IPIV)
PLASMA_dgetrf_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_dgetrs_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_dgetrf_incpiv_Tile

    PLASMA_dgetrf_incpiv_Tile_Async

    PLASMA_cgetrf_incpiv

    PLASMA_dgetrf_incpiv

    PLASMA_sgetrf_incpiv

    PLASMA_dgetrs_incpiv

  int PLASMA_dgetrf_nopiv (int M, int N, double * A, int LDA)
PLASMA_dgetrf_nopiv - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm without row pivoting. WARNING: Don't use this function if you are not sure your matrix is diagonal dominant.

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).

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_dgetrf_nopiv_Tile

    PLASMA_dgetrf_nopiv_Tile_Async

    PLASMA_cgetrf_nopiv

    PLASMA_dgetrf_nopiv

    PLASMA_sgetrf_nopiv

  int PLASMA_dgetrf_tntpiv (int M, int N, double * A, int LDA, int * IPIV)
PLASMA_dgetrf_tntpiv - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with tournament pivoting based on LU decomposition at each round.

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_dgetrf

    PLASMA_dgetrf_nopiv

    PLASMA_dgetrf_incpiv

    PLASMA_dgetrf_tntpiv_Tile

    PLASMA_dgetrf_tntpiv_Tile_Async

    PLASMA_cgetrf_tntpiv

    PLASMA_dgetrf_tntpiv

    PLASMA_sgetrf_tntpiv

  int PLASMA_dgetri (int N, double * A, int LDA, int * IPIV)
PLASMA_dgetri - Computes the inverse of a matrix using the LU factorization computed by PLASMA_dgetrf. 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_dgetrf. 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_dgetrf.

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_dgetri_Tile

    PLASMA_dgetri_Tile_Async

    PLASMA_cgetri

    PLASMA_dgetri

    PLASMA_sgetri

    PLASMA_dgetrf

  int PLASMA_dgetrs (PLASMA_enum trans, int N, int NRHS, double * A, int LDA, const int * IPIV, double * B, int LDB)
PLASMA_dgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by PLASMA_dgetrf.

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)
    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_dgetrf. Remark: If out-of-place layout translation is used, the matrix A can be considered as input, however if inplace layout translation is enabled, the content of A will be reordered for computation and restored before exiting the function.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    IPIV The pivot indices from PLASMA_dgetrf.
    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_dgetrs_Tile

    PLASMA_dgetrs_Tile_Async

    PLASMA_cgetrs

    PLASMA_dgetrs

    PLASMA_sgetrs

    PLASMA_dgetrf

  int PLASMA_dgetrs_incpiv (PLASMA_enum trans, int N, int NRHS, double * A, int LDA, PLASMA_desc * descL, const int * IPIV, double * B, int LDB)
PLASMA_dgetrs_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_dgetrf_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) = PlasmaTrans: A**T * 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_dgetrf_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_dgetrf_incpiv.
    IPIV The pivot indices from PLASMA_dgetrf_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_dgetrs_incpiv_Tile

    PLASMA_dgetrs_incpiv_Tile_Async

    PLASMA_cgetrs_incpiv

    PLASMA_dgetrs_incpiv

    PLASMA_sgetrs_incpiv

    PLASMA_dgetrf_incpiv

  int PLASMA_dlacpy (PLASMA_enum uplo, int M, int N, double * A, int LDA, double * B, int LDB)
PLASMA_dlacpy 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).

Returns:

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

See also:
    PLASMA_dlacpy_Tile

    PLASMA_dlacpy_Tile_Async

    PLASMA_clacpy

    PLASMA_dlacpy

    PLASMA_slacpy

  double PLASMA_dlange (PLASMA_enum norm, int M, int N, double * A, int LDA)
PLASMA_dlange returns the value

dlange = ( 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).

Returns:

Return values:
    the norm described above.

See also:
    PLASMA_dlange_Tile

    PLASMA_dlange_Tile_Async

    PLASMA_clange

    PLASMA_dlange

    PLASMA_slange

  double PLASMA_dlansy (PLASMA_enum norm, PLASMA_enum uplo, int N, double * A, int LDA)
PLASMA_dlansy returns the value

dlansy = ( 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).

Returns:

Return values:
    the norm described above.

See also:
    PLASMA_dlansy_Tile

    PLASMA_dlansy_Tile_Async

    PLASMA_clansy

    PLASMA_dlansy

    PLASMA_slansy

  double PLASMA_dlantr (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_enum diag, int M, int N, double * A, int LDA)
PLASMA_dlantr returns the value

dlantr = ( 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 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.
    M The number of rows of the matrix A. M >= 0. When M = 0, the returned value is set to zero. If uplo == PlasmaUpper, M <= N.
    N The number of columns of the matrix A. N >= 0. When N = 0, the returned value is set to zero. If uplo == PlasmaLower, N <= M.
    A The M-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,M).

Returns:

Return values:
    the norm described above.

See also:
    PLASMA_dlantr_Tile

    PLASMA_dlantr_Tile_Async

    PLASMA_clantr

    PLASMA_dlantr

    PLASMA_slantr

  int PLASMA_dLapack_to_Tile (double * Af77, int LDA, PLASMA_desc * A)
PLASMA_dLapack_to_Tile - Conversion from LAPACK layout to tile layout. It automatically infers the layout translation mode base on the values of Af77 and A->mat pointers. If (A->mat == Af77 || A->mat == NULL || Af77 == NULL), PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE to do inplace layout translation of the matrix. If (A->mat != Af77 && A->mat != NULL && Af77 != NULL), PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE to do out of place layout translation of the matrix. Both A->mat and Af77 have to be allocated to store the full matrix.

Parameters:
    Af77 LAPACK matrix.
    LDA The leading dimension of the matrix Af77.
    A Descriptor of the PLASMA matrix in tile layout.

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_dLapack_to_Tile_Async

    PLASMA_dTile_to_Lapack

    PLASMA_cLapack_to_Tile

    PLASMA_dLapack_to_Tile

    PLASMA_sLapack_to_Tile

  int PLASMA_dlascal (PLASMA_enum uplo, int M, int N, double alpha, double * A, int LDA)
PLASMA_dlascal - Scales a matrix by the scalar alpha as in ScaLAPACK pdlascal().

,

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.
    M M specifies the number of rows of the matrix A. M >= 0.
    N N specifies the number of columns of the matrix A. N >= 0.
    alpha alpha specifies the scalar alpha
    A A is a LDA-by-N matrix.
    LDA The leading dimension of the array A. LDA >= max(1,M).

Returns:

Return values:
    PLASMA_SUCCESS successful exit

See also:
    PLASMA_dlascal_Tile

    PLASMA_clascal

    PLASMA_dlascal

    PLASMA_slascal

  int PLASMA_dlaset (PLASMA_enum uplo, int M, int N, double alpha, double beta, double * A, int LDA)
PLASMA_dlaset sets all or part of a two-dimensional matrix A.

Parameters:
    uplo Specifies the part of the matrix A to be set. = 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).

Returns:

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

See also:
    PLASMA_dlaset_Tile

    PLASMA_dlaset_Tile_Async

    PLASMA_claset

    PLASMA_dlaset

    PLASMA_slaset

  int PLASMA_dlaswp (int N, double * A, int LDA, int K1, int K2, const int * IPIV, int INCX)
PLASMA_dlaswp - 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_dgetrf.
    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_dgetrf.
    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_dlaswp_Tile

    PLASMA_dlaswp_Tile_Async

    PLASMA_claswp

    PLASMA_dlaswp

    PLASMA_slaswp

    PLASMA_dgetrf

  int PLASMA_dlaswpc (int N, double * A, int LDA, int K1, int K2, const int * IPIV, int INCX)
PLASMA_dlaswpc - 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_dgetrf.
    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_dgetrf.
    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_dlaswpc_Tile

    PLASMA_dlaswpc_Tile_Async

    PLASMA_claswpc

    PLASMA_dlaswpc

    PLASMA_slaswpc

    PLASMA_dgetrf

  int PLASMA_dlauum (PLASMA_enum uplo, int N, double * A, int LDA)
PLASMA_dlauum - 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_dlauum_Tile

    PLASMA_dlauum_Tile_Async

    PLASMA_clauum

    PLASMA_dlauum

    PLASMA_slauum

    PLASMA_dpotri

  int PLASMA_dorglq (int M, int N, int K, double * A, int LDA, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dorglq - 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_dgelqf.

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_dgelqf.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT Auxiliary factorization data, computed by PLASMA_dgelqf.
    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_dorglq_Tile

    PLASMA_dorglq_Tile_Async

    PLASMA_cunglq

    PLASMA_dorglq

    PLASMA_sorglq

    PLASMA_dgelqf

  int PLASMA_dorgqr (int M, int N, int K, double * A, int LDA, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dorgqr - 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_dgeqrf.

Parameters:
    M The number of rows of the matrix Q. M >= 0.
    N The number of columns of the matrix Q. M >= N >= 0.
    K The number of columns of elementary tile reflectors whose product defines the matrix Q. N >= K >= 0.
    A Details of the QR factorization of the original matrix A as returned by PLASMA_dgeqrf, where the K first columns are the reflectors.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    descT Auxiliary factorization data, computed by PLASMA_dgeqrf.
    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_dorgqr_Tile

    PLASMA_dorgqr_Tile_Async

    PLASMA_cungqr

    PLASMA_dorgqr

    PLASMA_sorgqr

    PLASMA_dgeqrf

  int PLASMA_dormlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, double * A, int LDA, PLASMA_desc * descT, double * C, int LDC)
PLASMA_dormlq - Overwrites the general complex M-by-N matrix C with

            SIDE = 'L'     SIDE = 'R'

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

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_dgeqrf. Q is of order M if SIDE = PlasmaLeft and of order N if SIDE = PlasmaRight.

Parameters:
    side Intended usage: = PlasmaLeft: apply Q or Q**T from the left; = PlasmaRight: apply Q or Q**T from the right.
    trans Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaTrans: ugate transpose, apply Q**T.
    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_dgelqf.
    LDA The leading dimension of the array A. LDA >= max(1,K).
    descT Auxiliary factorization data, computed by PLASMA_dgelqf.
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*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_dormlq_Tile

    PLASMA_dormlq_Tile_Async

    PLASMA_cunmlq

    PLASMA_dormlq

    PLASMA_sormlq

    PLASMA_dgelqf

  int PLASMA_dormqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, double * A, int LDA, PLASMA_desc * descT, double * C, int LDC)
PLASMA_dormqr - Overwrites the general complex M-by-N matrix C with

            SIDE = 'L'     SIDE = 'R'

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

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_dgeqrf. Q is of order M if SIDE = PlasmaLeft and of order N if SIDE = PlasmaRight.

Parameters:
    side Intended usage: = PlasmaLeft: apply Q or Q**T from the left; = PlasmaRight: apply Q or Q**T from the right.
    trans Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaTrans: ugate transpose, apply Q**T.
    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_dgeqrf.
    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_dgeqrf.
    C On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*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_dormqr_Tile

    PLASMA_dormqr_Tile_Async

    PLASMA_cormqr

    PLASMA_dormqr

    PLASMA_sormqr

    PLASMA_dgeqrf

  int PLASMA_dplgsy (double bump, int N, double * A, int LDA, unsigned long long int seed)
PLASMA_dplgsy - 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_dplgsy_Tile

    PLASMA_dplgsy_Tile_Async

    PLASMA_cplgsy

    PLASMA_dplgsy

    PLASMA_splgsy

    PLASMA_dplrnt

    PLASMA_dplgsy

  int PLASMA_dplrnt (int M, int N, double * A, int LDA, unsigned long long int seed)
PLASMA_dplrnt - 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_dplrnt_Tile

    PLASMA_dplrnt_Tile_Async

    PLASMA_cplrnt

    PLASMA_dplrnt

    PLASMA_splrnt

    PLASMA_dplgsy

    PLASMA_dplgsy

  int PLASMA_dpltmg (PLASMA_enum mtxtype, int M, int N, double * A, int LDA, unsigned long long int seed)
PLASMA_dpltmg - Generate a test matrix by tiles.

Parameters:
    mtxtype
    •   PlasmaMatrixCauchy: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1019317
    Cauchy matrix
Returns an n-by-n matrix C such that, C(i,j) = 1/(i + j).
•   PlasmaMatrixChebvand: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999859
Vandermonde-like matrix for the Chebyshev polynomials
Produces the (primal) Chebyshev Vandermonde matrix based on the vector of points p, which define where the Chebyshev polynomial is calculated.
If seed != 0, C(i,j) = Ti – 1(p(j)) where Ti – 1 is the Chebyshev polynomial of degree i – 1, and p is a vector of N equally spaced points on the interval [0,1].
•   PlasmaMatrixCircul: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999880
Circulant matrix
A circulant matrix has the property that each row is obtained from the previous one by cyclically permuting the entries one step forward. It is a special Toeplitz matrix in which the diagonals 'wrap around.'
The eigensystem of C (n-by-n) is known explicitly: If t is an nth root of unity, then the inner product of v and w = [1 t t2 ... t(n – 1)] is an eigenvalue of C and w(n:-1:1) is an eigenvector, where v is the first column of C.
•   PlasmaMatrixCompan: See http://www.mathworks.fr/fr/help/matlab/ref/compan.html
Companion matrix
A = compan(u) returns the corresponding companion matrix whose first row is -u(2:n)/u(1), where u is a vector of polynomial coefficients. The eigenvalues of compan(u) are the roots of the polynomial.
•   PlasmaMatrixCondex: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999898 gallery('condex',n,4,100)
Returns a 'counter-example' matrix to a condition estimator. It has order n and scalar parameter theta (default 100).
LAPACK (RCOND): It is the inverse of this matrix that is a counter-example.
•   PlasmaMatrixDemmel: See [1] J. Demmel, Applied Numerical Linear Algebra, SIAM, Philadelphia, 1997
Returns a matrix defined by: A = D * ( I + 1e-7* rand(n)), where D = diag(10^{14*(0:n-1)/n})
•   PlasmaMatrixDorr: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999936
Diagonally dominant, ill-conditioned, tridiagonal matrix
Returns the n-by-n matrix, row diagonally dominant, tridiagonal matrix that is ill-conditioned for small nonnegative values of theta. The default value of theta is 0.01. The Dorr matrix itself is the same as gallery('tridiag',c,d,e).
•   PlasmaMatrixFiedler: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999960
Fiedler matrix of size n-by-n is defined throug a random vector c of size n, such that each element is equal to abs(n(i)-n(j)).
Matrix A has a dominant positive eigenvalue and all the other eigenvalues are negative.
Explicit formulas for inv(A) and det(A) are given in [Todd, J., Basic Numerical Mathematics, Vol. 2: Numerical Algebra, Birkhauser, Basel, and Academic Press, New York, 1977, p. 159] and attributed to Fiedler. These indicate that inv(A) is tridiagonal except for nonzero (1,n) and (n,1) elements.
•   PlasmaMatrixFoster: See [1] L. V. Foster, Gaussian Elimination with Partial Pivoting Can Fail in Practice, SIAM J. Matrix Anal. Appl., 15 (1994), pp. 1354-1362.
[2] L. V. Foster, The growth factor and efficiency of Gaussian elimination with rook pivoting, J. Comput. Appl. Math., 86 (1997), pp. 177-194
A pathological case for LU with gaussian elimination.
•   PlasmaMatrixHadamard: See http://www.mathworks.fr/fr/help/matlab/ref/hadamard.html
Initialize the tile A to create the Hadamard matrix of order gN.
Hadamard matrices are matrices of 1's and -1's whose columns are orthogonal,
H'*H = gN*I
where [gN gN]=size(H) and I = eye(gN,gN) ,.
They have applications in several different areas, including combinatorics, signal processing, and numerical analysis.
An n-by-n Hadamard matrix with n > 2 exists only if rem(n,4) = 0. This function handles only the cases where n is a power of 2.
•   PlasmaMatrixHankel: See http://en.wikipedia.org/wiki/Hankel_matrix
Hankel matrix
In linear algebra, a Hankel matrix (or catalecticant matrix), named after Hermann Hankel, is a square matrix with constant skew-diagonals (positive sloping diagonals), e.g.:
g \ b & c & d & e & f \ c & d & e & f & g \ d & e & f & g & h \ e & f & g & h & i \ \nd{bmatrix} ].
A(i,j) = A(i-1,j+1)
•   PlasmaMatrixHilb: See http://www.mathworks.fr/fr/help/matlab/ref/hilb.html
Hilbert Matrix
The Hilbert matrix is a notable example of a poorly conditioned matrix. The elements of the Hilbert matrices are: H(i,j) = 1/(i * + j – 1).
•   PlasmaMatrixHouse: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-999993
Householder matrix
Generates a random column vector of size M, and returns the housholder matrix H = eye(n,n) - beta*v*v' that satisfies the relationship
H*x = -sign(x(1))*norm(x)*e1
where e1 is the first column of eye(n,n). Note that if x is complex, then sign(x) exp(i*arg(x)) (which equals x./abs(x) when x is nonzero).
•   PlasmaMatrixInvhess: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000000
Inverse of an upper Hessenberg matrix
A = gallery('invhess',x,y), where x is a length n vector and y is a length n-1 vector, returns the matrix whose lower triangle agrees with that of ones(n,1)*x' and whose strict upper triangle agrees with that of [1 y]*ones(1,n).
The matrix is nonsingular if x(1) ~= 0 and x(i+1) ~= y(i) for all i, and its inverse is an upper Hessenberg matrix. Argument y defaults to -x(1:n-1).
If x is a scalar, invhess(x) is the same as invhess(1:x).
Here: gallery('invhess', gM)
•   PlasmaMatrixKms: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000026
Kac-Murdock-Szego Toeplitz matrix
Returns the n-by-n Kac-Murdock-Szego Toeplitz matrix such that A(i,j) = rho^(abs(i-j)), for real rho.
For complex rho, the same formula holds except that elements below the diagonal are ugated. rho defaults to 0.5.
The KMS matrix A has these properties:
•   An LDL' factorization with L inv(gallery('triw',n,-rho,1))', and D(i,i) (1-abs(rho)^2)*eye(n), except D(1,1) = 1.
•   Positive definite if and only if 0 < abs(rho) < 1.
•   The inverse inv(A) is tridiagonal.Symmetric Hankel matrix
In this function, rho is set to 0.5 and cannot be changed.
•   PlasmaMatrixLangou: Generates a pathological case for LU with gaussian elimination.
Returns a random matrix on which, the columns from N/4 to N/2 are scaled down by eps. These matrices fails on LU with partial pivoting, but Hybrid LU-QR algorithms manage to recover the scaled down columns.
•   PlasmaMatrixLehmer: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000049
Symmetric positive definite matrix
Returns the symmetric positive definite n-by-n matrix such that A(i,j) = i/j for j >= i.
The Lehmer matrix A has these properties:
•   A is totally nonnegative.
•   The inverse inv(A) is tridiagonal and explicitly known.
•   The order n <= cond(A) <= 4*n*n.Matrix associated with the Riemann hypothesis
•   PlasmaMatrixLotkin: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000062
Lotkin matrix
Returns the Hilbert matrix with its first row altered to all ones. The Lotkin matrix A is nonsymmetric, ill-conditioned, and has many negative eigenvalues of small magnitude. Its inverse has integer entries and is known explicitly.
•   PlasmaMatrixMinij: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000066
Symmetric positive definite matrix
Returns the n-by-n symmetric positive definite matrix with A(i,j) = min(i,j).
The minij matrix has these properties:
•   The inverse inv(A) is tridiagonal and equal to -1 times the second difference matrix, except its (n,n) element is 1.
•   Givens' matrix, 2*A-ones(size(A)), has tridiagonal inverse and eigenvalues 0.5*sec((2*r-1)*pi/(4*n))^2, where r=1:n.
•   (n+1)*ones(size(A))-A has elements that are max(i,j) and a tridiagonal inverse.
•   PlasmaMatrixMoler: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000074
Symmetric positive definite matrix
Returns the symmetric positive definite n-by-n matrix U'*U, where U = gallery('triw',n,alpha).
For the default alpha = -1, A(i,j) = min(i,j)-2, and A(i,i) = i. One of the eigenvalues of A is small.
•   PlasmaMatrixOrthog: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000083
Orthogonal and nearly orthogonal matrices
Returns the matrix Q of order n, such that: Q(i,j) = sqrt(2/(n+1)) * sin(i*j*pi/(n+1))
Symmetric eigenvector matrix for second difference matrix.
•   PlasmaMatrixParter: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000116
Toeplitz matrix with singular values near pi. Returns the tile A, such that the elment of the matrix are 1/(i-j+0.5).
C is a Cauchy matrix and a Toeplitz matrix. Most of the singular values of C are very close to pi.
•   PlasmaMatrixRandom: Random matrix with values between -0.5 and 0.5.
•   PlasmaMatrixRiemann: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000232
Matrix associated with the Riemann hypothesis
Returns an n-by-n matrix for which the Riemann hypothesis is true if and only if for every eps > 0.
The Riemann matrix is defined by:
A = B(2:n+1,2:n+1)
where B(i,j) = i-1 if i divides j, and B(i,j) = -1 otherwise.
The Riemann matrix has these properties:
•   Each eigenvalue e(i) satisfies abs(e(i)) <= m-1/m, where m = n+1.
•   i <= e(i) <= i+1 with at most m-sqrt(m) exceptions.
•   All integers in the interval (m/3, m/2] are eigenvalues.
•   PlasmaMatrixRis: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000243
Symmetric Hankel matrix Returns a symmetric gN-by-gN Hankel matrix with elements.
A(i,j) = 0.5/(n-i-j+1.5)
The eigenvalues of A cluster around π/2 and –π/2. This matrix was invented by F.N. Ris.
•   PlasmaMatrixToeppd: See http://www.mathworks.fr/fr/help/matlab/ref/gallery.html#f84-1000272
A toeppd matrix is an n-by-n symmetric, positive semi-definite (SPD) Toeplitz matrix composed of the sum of m rank 2 (or, for certain theta, rank 1) SPD Toeplitz matrices. Specifically,
T = w(1)*T(theta(1)) + ... + w(m)*T(theta(m))
where T(theta(k)) has (i,j) element cos(2*pi*theta(k)*(i-j)).
In this matrix generation: w = rand(m,1), and theta = rand(m,1).
•   PlasmaMatrixWilkinson: See http://www.mathworks.fr/fr/help/matlab/ref/wilkinson.html
Wilkinson's eigenvalue test matrix
Returns one of J. H. Wilkinson's eigenvalue test matrices. It is a symmetric, tridiagonal matrix with pairs of nearly, but not exactly, equal eigenvalues.
•   PlasmaMatrixWright: See [3] S. J. Wright, A collection of problems for which Gaussian elimination with partial pivoting is unstable, SIAM J. SCI. STATIST. COMPUT., 14 (1993), pp. 231-238.
A pathological case for LU with gaussian elimination.
Parameters:
    M The number of rows of A.
    N The order of the matrix A. N >= 0.
    A On exit, The 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_dpltmg_Tile
    PLASMA_dpltmg_Tile_Async
    PLASMA_cpltmg
    PLASMA_dpltmg
    PLASMA_spltmg

  int PLASMA_dpocon (PLASMA_enum uplo, int N, double * A, int LDA, double Anorm, double * rcond)
PLASMA_dpocon - estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by PLASMA_dpotrf().
An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as
.PP 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 The N-by-N matrix A.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    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_dpocon_Tile
    PLASMA_dpocon_Tile_Async
    PLASMA_cpocon
    PLASMA_dpocon
    PLASMA_spocon

  int PLASMA_dposv (PLASMA_enum uplo, int N, int NRHS, double * A, int LDA, double * B, int LDB)
PLASMA_dposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
A = _{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**T*U or A = L*L**T.
    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_dposv_Tile
    PLASMA_dposv_Tile_Async
    PLASMA_cposv
    PLASMA_dposv
    PLASMA_sposv

  int PLASMA_dpotrf (PLASMA_enum uplo, int N, double * A, int LDA)
PLASMA_dpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form
A = _{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**T*U or A = L*L**T.
    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_dpotrf_Tile
    PLASMA_dpotrf_Tile_Async
    PLASMA_cpotrf
    PLASMA_dpotrf
    PLASMA_spotrf
    PLASMA_dpotrs

  int PLASMA_dpotri (PLASMA_enum uplo, int N, double * A, int LDA)
PLASMA_dpotri - 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_dpotrf.
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**T*U or A = L*L**T, as computed by PLASMA_dpotrf. 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_dpotri_Tile
    PLASMA_dpotri_Tile_Async
    PLASMA_cpotri
    PLASMA_dpotri
    PLASMA_spotri
    PLASMA_dpotrf

  int PLASMA_dpotrs (PLASMA_enum uplo, int N, int NRHS, double * A, int LDA, double * B, int LDB)
PLASMA_dpotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by PLASMA_dpotrf.
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**T*U or A = L*L**T, computed by PLASMA_dpotrf. Remark: If out-of-place layout translation is used, the matrix A can be considered as input, however if inplace layout translation is enabled, the content of A will be reordered for computation and restored before exiting the function.
    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_dpotrs_Tile
    PLASMA_dpotrs_Tile_Async
    PLASMA_cpotrs
    PLASMA_dpotrs
    PLASMA_spotrs
    PLASMA_dpotrf

  int PLASMA_dsgesv (int N, int NRHS, double * A, int LDA, int * IPIV, double * B, int LDB, double * X, int LDX, int * ITER)
PLASMA_dsgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
PLASMA_dsgesv first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.
The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.
The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where:
•   ITER is the number of the current iteration in the iterative refinement process
•   RNRM is the infinity-norm of the residual
•   XNRM is the infinity-norm of the solution
•   ANRM is the infinity-operator-norm of the matrix A
•   EPS is the machine epsilon returned by DLAMCH('Epsilon').
Actually, in its current state (PLASMA 2.1.0), the test is slightly relaxed.
The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
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 The N-by-N coefficient matrix A. This matrix is not modified.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    IPIV On exit, the pivot indices that define the permutations.
    B The N-by-NRHS matrix of right hand side matrix B.
    LDB The leading dimension of the array B. LDB >= max(1,N).
    X If return value = 0, the N-by-NRHS solution matrix X.
    LDX The leading dimension of the array B. LDX >= max(1,N).
    ITER The number of the current iteration in the iterative refinement process
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_dsgesv_Tile
    PLASMA_dsgesv_Tile_Async
    PLASMA_dsgesv
    PLASMA_dgesv

  int PLASMA_dsposv (PLASMA_enum uplo, int N, int NRHS, double * A, int LDA, double * B, int LDB, double * X, int LDX, int * ITER)
PLASMA_dsposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
A = U**H * U, if uplo = PlasmaUpper, or A = L * L**H, if uplo = PlasmaLower,
where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
PLASMA_dsposv first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.
The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.
The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where:
•   ITER is the number of the current iteration in the iterative refinement process
•   RNRM is the infinity-norm of the residual
•   XNRM is the infinity-norm of the solution
•   ANRM is the infinity-operator-norm of the matrix A
•   EPS is the machine epsilon returned by DLAMCH('Epsilon').
Actually, in its current state (PLASMA 2.1.0), the test is slightly relaxed.
The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
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 The N-by-N symmetric positive definite (or Hermitian) coefficient matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. This matrix is not modified.
    LDA The leading dimension of the array A. LDA >= max(1,N).
    B The N-by-NRHS matrix of right hand side matrix B.
    LDB The leading dimension of the array B. LDB >= max(1,N).
    X If return value = 0, the N-by-NRHS solution matrix X.
    LDX The leading dimension of the array B. LDX >= max(1,N).
    ITER The number of the current iteration in the iterative refinement process
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_dsposv_Tile
    PLASMA_dsposv_Tile_Async
    PLASMA_dsposv
    PLASMA_dposv

  int PLASMA_dsungesv (PLASMA_enum trans, int N, int NRHS, double * A, int LDA, double * B, int LDB, double * X, int LDX, int * ITER)
PLASMA_dsungesv - 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.
PLASMA_dsungesv first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve.
The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement.
The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < N*XNRM*ANRM*EPS*BWDMAX where:
•   ITER is the number of the current iteration in the iterative refinement process
•   RNRM is the infinity-norm of the residual
•   XNRM is the infinity-norm of the solution
•   ANRM is the infinity-operator-norm of the matrix A
•   EPS is the machine epsilon returned by DLAMCH('Epsilon').
Actually, in its current state (PLASMA 2.1.0), the test is slightly relaxed.
The values ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
We follow Bjorck's algorithm proposed in 'Iterative Refinement of Linear
 Least Squares solutions I', BIT, 7:257-278, 1967.4
Parameters:
    trans Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**H. Currently only PlasmaNoTrans is supported.
    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 The M-by-N matrix A. This matrix is not modified.
    LDA The leading dimension of the array A. LDA >= max(1,M).
    B The M-by-NRHS matrix B of right hand side vectors, stored columnwise. Not modified.
    LDB The leading dimension of the array B. LDB >= MAX(1,M,N).
    X If return value = 0, 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;
    LDX The leading dimension of the array B. LDB >= MAX(1,M,N).
    ITER The number of the current iteration in the iterative refinement process
Returns:
Return values:
    PLASMA_SUCCESS successful exit
    <0 if -i, the i-th argument had an illegal value
See also:
    PLASMA_dsungesv_Tile
    PLASMA_dsungesv_Tile_Async
    PLASMA_dsungesv
    PLASMA_dgels

  int PLASMA_dsyev (PLASMA_enum jobz, PLASMA_enum uplo, int N, double * A, int LDA, double * W, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dsyev - 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_dsyev 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_dsyev_Tile
    PLASMA_dsyev_Tile_Async
    PLASMA_cheev
    PLASMA_dsyev
    PLASMA_ssyev

  int PLASMA_dsyevd (PLASMA_enum jobz, PLASMA_enum uplo, int N, double * A, int LDA, double * W, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dsyevd - 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_dsyevd 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_dsyevd_Tile
    PLASMA_dsyevd_Tile_Async
    PLASMA_cheevd
    PLASMA_dsyev
    PLASMA_ssyev

  int PLASMA_dsyevr (PLASMA_enum jobz, PLASMA_enum range, PLASMA_enum uplo, int N, double * A, int LDA, double vl, double vu, int il, int iu, double abstol, int * nbcomputedeig, double * W, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dsyevr - 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.
    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.
    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).
    vl see vu.
    vu If RANGE=PlasmaVec, the lower and upper bounds of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = PlasmaAllVec or PlasmaIvec.
    il see iu.
    iu If RANGE=PlasmaIvec, the indices (in ascending order) of the smallest and largest eigenvalues to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = PlasmaAllVec or PlasmaVec.
    abstol The absolute error tolerance for the eigenvalues. An approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b] of width less than or equal to
        ABSTOL + EPS *   max( |a|,|b| ) ,
where EPS is the machine precision. If ABSTOL is less than or equal to zero, then EPS*|T| will be used in its place, where |T| is the 1-norm of the tridiagonal matrix obtained by reducing A to tridiagonal form.
See 'Computing Small Singular Values of Bidiagonal Matrices
         with Guaranteed High Relative Accuracy,' by Demmel and Kahan, LAPACK Working Note #3.
If high relative accuracy is important, set ABSTOL to DLAMCH( 'Safe minimum' ). Doing so will guarantee that eigenvalues are computed to high relative accuracy when possible in future releases. The current code does not make any guarantees about high relative accuracy, but furutre releases will. See J. Barlow and J. Demmel, 'Computing Accurate Eigensystems of Scaled Diagonally
         Dominant Matrices', LAPACK Working Note #7, for a discussion of which matrices define their eigenvalues to high relative accuracy. (hard set to use tryrac=1).
Parameters:
    nbcomputedeig The total number of eigenvalues found. 0 <= M <= N. If RANGE = PlasmaAllVec, M = N, and if RANGE = PlasmaIvec, M = IU-IL+1.
    W On exit, if info = 0, the eigenvalues.
    descT On entry, descriptor as return by PLASMA_Alloc_Workspace_dsyevr 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_dsyevr_Tile
    PLASMA_dsyevr_Tile_Async
    PLASMA_cheevr
    PLASMA_dsyevr
    PLASMA_ssyevr

  int PLASMA_dsygst (PLASMA_enum itype, PLASMA_enum uplo, int N, double * A, int LDA, double * B, int LDB)
PLASMA_dsygst - 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_DPOTRF.
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_DPOTRF.
    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_dsygst_Tile
    PLASMA_dsygst_Tile_Async
    PLASMA_chegst
    PLASMA_dsygst
    PLASMA_ssygst

  int PLASMA_dsygv (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, int N, double * A, int LDA, double * B, int LDB, double * W, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dsygv - 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**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.
    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**T*U or B = L*L**T.
    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_dsygv 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_dsygv 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_dsygv_Tile
    PLASMA_dsygv_Tile_Async
    PLASMA_chegv
    PLASMA_dsygv
    PLASMA_ssygv

  int PLASMA_dsygvd (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, int N, double * A, int LDA, double * B, int LDB, double * W, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dsygvd - 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**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.
    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**T*U or B = L*L**T.
    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_dsygvd 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_dsygvd 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_dsygvd_Tile
    PLASMA_dsygvd_Tile_Async
    PLASMA_chegvd
    PLASMA_dsygvd
    PLASMA_ssygvd

  int PLASMA_dsymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, double alpha, double * A, int LDA, double * B, int LDB, double beta, double * C, int LDC)
PLASMA_dsymm - 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_dsymm_Tile
    PLASMA_csymm
    PLASMA_dsymm
    PLASMA_ssymm

  int PLASMA_dsyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, double * A, int LDA, double * B, int LDB, double beta, double * C, int LDC)
PLASMA_dsyr2k - Performs one of the symmetric rank 2k operations
+ lpha [ op( B ) imes g( op( A )' )] + ts op( B ) ] + lpha [ g( op( B )' ) imes op( A ) ] +
where op( X ) is one of
op( X ) = X or op( X ) = g( 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 ugate transposed: = PlasmaNoTrans: + lpha [ op( B ) imes g( op( A )' )] + ts op( B ) ] + lpha [ g( 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_dsyr2k_Tile
    PLASMA_dsyr2k_Tile_Async
    PLASMA_csyr2k
    PLASMA_dsyr2k
    PLASMA_ssyr2k

  int PLASMA_dsyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, double * A, int LDA, double beta, double * C, int LDC)
PLASMA_dsyrk - Performs one of the hermitian rank k operations
+
where op( X ) is one of
op( X ) = X or op( X ) = g( 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 ugate 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_dsyrk_Tile
    PLASMA_dsyrk_Tile_Async
    PLASMA_csyrk
    PLASMA_dsyrk
    PLASMA_ssyrk

  int PLASMA_dsytrd (PLASMA_enum jobz, PLASMA_enum uplo, int N, double * A, int LDA, double * D, double * E, PLASMA_desc * descT, double * Q, int LDQ)
PLASMA_dsytrd - 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.
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_dsytrd 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_dsytrd_Tile
    PLASMA_dsytrd_Tile_Async
    PLASMA_chetrd
    PLASMA_dsytrd
    PLASMA_ssytrd

  int PLASMA_dTile_to_Lapack (PLASMA_desc * A, double * Af77, int LDA)
PLASMA_Tile_to_Lapack - Conversion from tile layout to LAPACK layout. It automatically infers the layout translation mode base on the values of Af77 and A->mat pointers. If (A->mat == Af77 || A->mat == NULL || Af77 == NULL), PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE to do inplace layout translation of the matrix. If (A->mat != Af77 && A->mat != NULL && Af77 != NULL), PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE to do out of place layout translation of the matrix. Both A->mat and Af77 have to be allocated to store the full matrix.
Parameters:
    A Descriptor of the PLASMA matrix in tile layout.
    Af77 LAPACK matrix.
    LDA The leading dimension of the matrix Af77.
Returns:
Return values:
    PLASMA_SUCCESS successful exit
See also:
    PLASMA_dTile_to_Lapack_Async
    PLASMA_dLapack_to_Tile
    PLASMA_cTile_to_Lapack
    PLASMA_dTile_to_Lapack
    PLASMA_sTile_to_Lapack

  int PLASMA_dtradd (PLASMA_enum uplo, PLASMA_enum trans, int M, int N, double alpha, double * A, int LDA, double beta, double * B, int LDB)
PLASMA_dtradd - Performs a matrix addition similarly to the pdtradd() function from the PBLAS library:
,
where op( X ) is one of
op( X ) = X or op( X ) = X' or op( X ) = g( X' )
alpha and beta are scalars, and A, and B are two trapezoidal matrices, with op( A ) and B two m by n matrices.
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.
    M M specifies the number of rows of the matrix op( A ) and of the matrix B. M >= 0.
    N N specifies the number of columns of the matrix op( A ) and of the matrix B. N >= 0.
    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.
    LDA The leading dimension of the array A. LDA >= max(1,K), where K is M when trans = PlasmaNoTrans, and is N when otherwise.
    beta beta specifies the scalar beta
    B B is a LDB-by-N matrix.
    LDB The leading dimension of the array B. LDB >= max(1,M).
Returns:
Return values:
    PLASMA_SUCCESS successful exit
See also:
    PLASMA_dtradd_Tile
    PLASMA_ctradd
    PLASMA_dtradd
    PLASMA_stradd

  int PLASMA_dtrmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double alpha, double * A, int LDA, double * B, int LDB)
PLASMA_dtrmm - 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: alpha*op( A )*B = PlasmaRight: alpha*B*op( A )
    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.
    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_dtrmm_Tile
    PLASMA_dtrmm_Tile_Async
    PLASMA_ctrmm
    PLASMA_dtrmm
    PLASMA_strmm

  int PLASMA_dtrsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double alpha, double * A, int LDA, double * B, int LDB)
PLASMA_dtrsm - 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 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.
    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_dtrsm_Tile
    PLASMA_dtrsm_Tile_Async
    PLASMA_ctrsm
    PLASMA_dtrsm
    PLASMA_strsm

  int PLASMA_dtrsmpl (int N, int NRHS, double * A, int LDA, PLASMA_desc * descL, const int * IPIV, double * B, int LDB)
PLASMA_dtrsmpl - 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_dgetrf_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_dgetrf_incpiv.
    IPIV The pivot indices from PLASMA_dgetrf_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_dtrsmpl_Tile
    PLASMA_dtrsmpl_Tile_Async
    PLASMA_ctrsmpl
    PLASMA_dtrsmpl
    PLASMA_strsmpl
    PLASMA_dgetrf_incpiv

  int PLASMA_dtrsmrv (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, double alpha, double * A, int LDA, double * B, int LDB)
PLASMA_dtrsmrv - 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 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.
    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_dtrsmrv_Tile
    PLASMA_dtrsmrv_Tile_Async
    PLASMA_ctrsmrv
    PLASMA_dtrsmrv
    PLASMA_strsmrv

  int PLASMA_dtrtri (PLASMA_enum uplo, PLASMA_enum diag, int N, double * A, int LDA)
PLASMA_dtrtri - 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_dtrtri_Tile
    PLASMA_dtrtri_Tile_Async
    PLASMA_ctrtri
    PLASMA_dtrtri
    PLASMA_strtri
    PLASMA_dpotri

Author
Generated automatically by Doxygen for PLASMA from the source code.