|
PLASMA
2.4.5
PLASMA - Parallel Linear Algebra for Scalable Multi-core Architectures
|
|
PLASMA
2.4.5
PLASMA - Parallel Linear Algebra for Scalable Multi-core Architectures
|
This is the group of single real functions using the advanced synchronous interface.
| int PLASMA_sgebrd_Tile | ( | PLASMA_enum | jobu, |
| PLASMA_enum | jobvt, | ||
| PLASMA_desc * | A, | ||
| float * | D, | ||
| float * | E, | ||
| PLASMA_desc * | U, | ||
| PLASMA_desc * | VT, | ||
| PLASMA_desc * | T | ||
| ) |
PLASMA_sgebrd_Tile - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. Tile equivalent of PLASMA_sgebrd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | jobu | Specifies options for computing all or part of the matrix U. Intended usage: = PlasmaVec: all M columns of U are returned in array U; = PlasmaNoVec: no columns of U (no left singular vectors) are computed. |
| [in] | jobvt | Specifies options for computing all or part of the matrix V**T. Intended usage: = PlasmaVec: all M columns of U are returned in array U; = PlasmaNoVec: no columns of U (no left singular vectors) are computed. |
| [in,out] | A | On entry, the M-by-N matrix A. On exit, if JOBU = 'O', A is overwritten with the first min(m,n) columns of U (the left singular vectors, stored columnwise); if JOBVT = 'O', A is overwritten with the first min(m,n) rows of V**T (the right singular vectors, stored rowwise); if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A are destroyed. |
| [out] | S | The singular values of A, sorted so that S(i) >= S(i+1). |
| [out] | U | (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'. If JOBU = 'A', U contains the M-by-M unitary matrix U; if JOBU = 'S', U contains the first min(m,n) columns of U (the left singular vectors, stored columnwise); if JOBU = 'N' or 'O', U is not referenced. |
| [out] | 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. |
| [out] | T | On exit, auxiliary factorization data. |
Definition at line 333 of file sgebrd.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgebrd_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgelqf_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | T | ||
| ) |
PLASMA_sgelqf_Tile - Computes the tile LQ factorization of a matrix. Tile equivalent of PLASMA_sgelqf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | 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. |
| [out] | T | On exit, auxiliary factorization data, required by PLASMA_sgelqs to solve the system of equations. |
| PLASMA_SUCCESS | successful exit |
Definition at line 187 of file sgelqf.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgelqf_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgelqs_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | T, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgelqs_Tile - Computes a minimum-norm solution using previously computed LQ factorization. Tile equivalent of PLASMA_sgelqs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf. |
| [in] | T | Auxiliary factorization data, computed by PLASMA_sgelqf. |
| [in,out] | B | On entry, the M-by-NRHS right hand side matrix B. On exit, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 207 of file sgelqs.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgelqs_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgels_Tile | ( | PLASMA_enum | trans, |
| PLASMA_desc * | A, | ||
| PLASMA_desc * | T, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgels_Tile - Solves overdetermined or underdetermined linear system of equations using the tile QR or the tile LQ factorization. Tile equivalent of PLASMA_sgels(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | trans | Intended usage: = PlasmaNoTrans: the linear system involves A; = PlasmaTrans: the linear system involves A**T. Currently only PlasmaNoTrans is supported. |
| [in,out] | A | On entry, the M-by-N matrix A. On exit, if M >= N, A is overwritten by details of its QR factorization as returned by PLASMA_sgeqrf; if M < N, A is overwritten by details of its LQ factorization as returned by PLASMA_sgelqf. |
| [out] | T | On exit, auxiliary factorization data. |
| [in,out] | 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; |
Definition at line 267 of file sgels.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgels_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgemm_Tile | ( | PLASMA_enum | transA, |
| PLASMA_enum | transB, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B, | ||
| float | beta, | ||
| PLASMA_desc * | C | ||
| ) |
PLASMA_sgemm_Tile - Performs matrix multiplication. Tile equivalent of PLASMA_sgemm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | 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. |
| [in] | 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. |
| [in] | alpha | alpha specifies the scalar alpha |
| [in] | A | A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise. |
| [in] | B | B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise. |
| [in] | beta | beta specifies the scalar beta |
| [in,out] | 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 ) |
| PLASMA_SUCCESS | successful exit |
Definition at line 264 of file sgemm.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgemm_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgeqrf_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | T | ||
| ) |
PLASMA_sgeqrf_Tile - Computes the tile QR factorization of a matrix. Tile equivalent of PLASMA_sgeqrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | 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. |
| [out] | T | On exit, auxiliary factorization data, required by PLASMA_sgeqrs to solve the system of equations. |
| PLASMA_SUCCESS | successful exit |
Definition at line 186 of file sgeqrf.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgeqrf_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgeqrs_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | T, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgeqrs_Tile - Computes a minimum-norm solution using the tile QR factorization. Tile equivalent of PLASMA_sgeqrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | A | Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf. |
| [in] | T | Auxiliary factorization data, computed by PLASMA_sgeqrf. |
| [in,out] | B | On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 206 of file sgeqrs.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgeqrs_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgesv_incpiv_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | L, | ||
| int * | IPIV, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgesv_incpiv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of PLASMA_sgetrf_incpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | A | On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK). |
| [in,out] | L | On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations. |
| [out] | IPIV | On exit, the pivot indices that define the permutations (not equivalent to LAPACK). |
| [in,out] | B | On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed. |
Definition at line 203 of file sgesv_incpiv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgesv_incpiv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgesv_Tile | ( | PLASMA_desc * | A, |
| int * | IPIV, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgesv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of PLASMA_sgetrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | A | On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization. |
| [out] | IPIV | On exit, the pivot indices that define the permutations. |
| [in,out] | B | On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed. |
Definition at line 187 of file sgesv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgesv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgesvd_Tile | ( | PLASMA_enum | jobu, |
| PLASMA_enum | jobvt, | ||
| PLASMA_desc * | A, | ||
| float * | S, | ||
| PLASMA_desc * | U, | ||
| PLASMA_desc * | VT, | ||
| PLASMA_desc * | T | ||
| ) |
PLASMA_sgesvd_Tile - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. Tile equivalent of PLASMA_sgesvd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | jobu | Specifies options for computing all or part of the matrix U. Intended usage: = PlasmaVec: all M columns of U are returned in array U; = PlasmaNoVec: no columns of U (no left singular vectors) are computed. |
| [in] | jobvt | Specifies options for computing all or part of the matrix V**T. Intended usage: = PlasmaVec: all M columns of U are returned in array U; = PlasmaNoVec: no columns of U (no left singular vectors) are computed. |
| [in,out] | A | On entry, the M-by-N matrix A. On exit, if JOBU = 'O', A is overwritten with the first min(m,n) columns of U (the left singular vectors, stored columnwise); if JOBVT = 'O', A is overwritten with the first min(m,n) rows of V**T (the right singular vectors, stored rowwise); if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A are destroyed. |
| [out] | S | The singular values of A, sorted so that S(i) >= S(i+1). |
| [out] | U | (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'. If JOBU = 'A', U contains the M-by-M unitary matrix U; if JOBU = 'S', U contains the first min(m,n) columns of U (the left singular vectors, stored columnwise); if JOBU = 'N' or 'O', U is not referenced. |
| [out] | 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. |
| [out] | T | On exit, auxiliary factorization data. |
Definition at line 333 of file sgesvd.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgesvd_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgetrf_incpiv_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | L, | ||
| int * | IPIV | ||
| ) |
PLASMA_sgetrf_incpiv_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_sgetrf_incpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | A | On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. |
| [out] | L | On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_sgetrs_incpiv to solve the system of equations. |
| [out] | IPIV | The pivot indices that define the permutations (not equivalent to LAPACK). |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations. |
Definition at line 184 of file sgetrf_incpiv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgetrf_incpiv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgetrf_Tile | ( | PLASMA_desc * | A, |
| int * | IPIV | ||
| ) |
PLASMA_sgetrf_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of PLASMA_sgetrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | A | On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization. |
| [out] | L | On exit, auxiliary factorization data, related to the tile L factor, required by PLASMA_sgetrs to solve the system of equations. |
| [out] | IPIV | The pivot indices that define the permutations (not equivalent to LAPACK). |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations. |
Definition at line 189 of file sgetrf.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgetrf_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgetri_Tile | ( | PLASMA_desc * | A, |
| int * | IPIV | ||
| ) |
PLASMA_sgetri_Tile - Computes the inverse of a matrix using the LU factorization computed by PLASMA_sgetrf. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). Tile equivalent of PLASMA_sgetri(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in,out] | A | On entry, the triangular factor L or U from the factorization A = P*L*U as computed by PLASMA_sgetrf. On exit, if return value = 0, the inverse of the original matrix A. |
| [in] | IPIV | The pivot indices that define the permutations as returned by PLASMA_sgetrf. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, the (i,i) element of the factor U is exactly zero; The matrix is singular and its inverse could not be computed. |
Definition at line 175 of file sgetri.c.
References PLASMA_Alloc_Workspace_sgetri_Tile_Async(), plasma_context_self(), plasma_desc_mat_free(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgetri_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgetrs_incpiv_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | L, | ||
| int * | IPIV, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgetrs_incpiv_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of PLASMA_sgetrs_incpiv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | The tile factors L and U from the factorization, computed by PLASMA_sgetrf_incpiv. |
| [in] | L | Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf_incpiv. |
| [in] | IPIV | The pivot indices from PLASMA_sgetrf_incpiv (not equivalent to LAPACK). |
| [in,out] | B | On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 206 of file sgetrs_incpiv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgetrs_incpiv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sgetrs_Tile | ( | PLASMA_enum | trans, |
| PLASMA_desc * | A, | ||
| int * | IPIV, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sgetrs_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of PLASMA_sgetrs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | 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) |
| [in] | A | The tile factors L and U from the factorization, computed by PLASMA_sgetrf. |
| [in] | IPIV | The pivot indices from PLASMA_sgetrf. |
| [in,out] | B | On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 199 of file sgetrs.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sgetrs_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_slacpy_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_slacpy_Tile - Tile equivalent of PLASMA_slacpy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | 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 |
| [in] | 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. |
| [out] | B | The M-by-N matrix B. On exit, B = A in the locations specified by UPLO. |
| PLASMA_SUCCESS | successful exit |
Definition at line 183 of file slacpy.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_slacpy_Tile_Async(), and PLASMA_SUCCESS.
| float PLASMA_slange_Tile | ( | PLASMA_enum | norm, |
| PLASMA_desc * | A, | ||
| float * | work | ||
| ) |
PLASMA_slange_Tile - Tile equivalent of PLASMA_slange(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | norm | = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm |
| [in] | 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. |
| [in] | work | real array of dimension (MAX(1,LWORK)), where LWORK >= M when NORM = PlasmaInfNorm; otherwise, WORK is not referenced. |
| PLASMA_SUCCESS | successful exit |
Definition at line 193 of file slange.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), and PLASMA_slange_Tile_Async().
| float PLASMA_slansy_Tile | ( | PLASMA_enum | norm, |
| PLASMA_enum | uplo, | ||
| PLASMA_desc * | A, | ||
| float * | work | ||
| ) |
PLASMA_slansy_Tile - Tile equivalent of PLASMA_slansy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | norm | = PlasmaMaxNorm: Max norm = PlasmaOneNorm: One norm = PlasmaInfNorm: Infinity norm = PlasmaFrobeniusNorm: Frobenius norm |
| [in] | uplo | = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | 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. |
| [in] | work | real array of dimension PLASMA_SIZE is PLASMA_STATIC_SCHEDULING is used, and NULL otherwise. |
| PLASMA_SUCCESS | successful exit |
Definition at line 195 of file slansy.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), and PLASMA_slansy_Tile_Async().
| int PLASMA_slaset_Tile | ( | PLASMA_enum | uplo, |
| float | alpha, | ||
| float | beta, | ||
| PLASMA_desc * | A | ||
| ) |
PLASMA_slaset_Tile - Tile equivalent of PLASMA_slaset(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | 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 |
| [in,out] | 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) |
| PLASMA_SUCCESS | successful exit |
Definition at line 172 of file slaset.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_slaset_Tile_Async(), and PLASMA_SUCCESS.
| int PLASMA_slaswp_Tile | ( | PLASMA_desc * | A, |
| int | K1, | ||
| int | K2, | ||
| int * | IPIV, | ||
| int | INCX | ||
| ) |
PLASMA_slaswp_Tile - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. Tile equivalent of PLASMA_slaswp(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | The tile factors L and U from the factorization, computed by PLASMA_sgetrf. |
| [in] | K1 | The first element of IPIV for which a row interchange will be done. |
| [in] | K2 | The last element of IPIV for which a row interchange will be done. |
| [in] | IPIV | The pivot indices from PLASMA_sgetrf. |
| [in] | INCX | The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order. |
| PLASMA_SUCCESS | successful exit |
Definition at line 176 of file slaswp.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_slaswp_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_slaswpc_Tile | ( | PLASMA_desc * | A, |
| int | K1, | ||
| int | K2, | ||
| int * | IPIV, | ||
| int | INCX | ||
| ) |
PLASMA_slaswpc_Tile - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. Tile equivalent of PLASMA_slaswpc(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | The tile factors L and U from the factorization, computed by PLASMA_sgetrf. |
| [in] | K1 | The first element of IPIV for which a row interchange will be done. |
| [in] | K2 | The last element of IPIV for which a row interchange will be done. |
| [in] | IPIV | The pivot indices from PLASMA_sgetrf. |
| [in] | INCX | The increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order. |
| PLASMA_SUCCESS | successful exit |
Definition at line 176 of file slaswpc.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_slaswpc_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_slauum_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_desc * | A | ||
| ) |
PLASMA_slauum_Tile - Computes the product U * U' or L' * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. Tile equivalent of PLASMA_slauum(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | 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. |
| PLASMA_SUCCESS | successful exit |
Definition at line 172 of file slauum.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_slauum_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sorglq_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | T, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sorglq_Tile - Generates an M-by-N matrix Q with orthonormal rows, which is defined as the first M rows of a product of the elementary reflectors returned by PLASMA_sgelqf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf. |
| [in] | T | Auxiliary factorization data, computed by PLASMA_sgelqf. |
| [out] | B | On exit, the M-by-N matrix Q. |
| PLASMA_SUCCESS | successful exit |
Definition at line 202 of file sorglq.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sorglq_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sorgqr_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | T, | ||
| PLASMA_desc * | Q | ||
| ) |
PLASMA_sorgqr_Tile - Generates an M-by-N matrix Q with orthonormal columns, which is defined as the first N columns of a product of the elementary reflectors returned by PLASMA_sgeqrf. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf. |
| [in] | T | Auxiliary factorization data, computed by PLASMA_sgeqrf. |
| [out] | Q | On exit, the M-by-N matrix Q. |
| PLASMA_SUCCESS | successful exit |
Definition at line 200 of file sorgqr.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sorgqr_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sormlq_Tile | ( | PLASMA_enum | side, |
| PLASMA_enum | trans, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | T, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sormlq_Tile - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal matrix (unitary in the complex case) defined as the product of elementary reflectors returned by PLASMA_sgelqf_Tile Q is of order M. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | side | Intended usage: = PlasmaLeft: apply Q or Q**T from the left; = PlasmaRight: apply Q or Q**T from the right. Currently only PlasmaLeft is supported. |
| [in] | trans | Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaTrans: ugate transpose, apply Q**T. Currently only PlasmaTrans is supported. |
| [in] | A | Details of the LQ factorization of the original matrix A as returned by PLASMA_sgelqf. |
| [in] | T | Auxiliary factorization data, computed by PLASMA_sgelqf. |
| [in,out] | B | On entry, the M-by-N matrix B. On exit, B is overwritten by Q*B or Q**T*B. |
| PLASMA_SUCCESS | successful exit |
Definition at line 247 of file sormlq.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sormlq_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sormqr_Tile | ( | PLASMA_enum | side, |
| PLASMA_enum | trans, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | T, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sormqr_Tile - overwrites the general M-by-N matrix C with Q*C, where Q is an orthogonal matrix (unitary in the complex case) defined as the product of elementary reflectors returned by PLASMA_sgeqrf_Tile Q is of order M. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | side | Intended usage: = PlasmaLeft: apply Q or Q**T from the left; = PlasmaRight: apply Q or Q**T from the right. Currently only PlasmaLeft is supported. |
| [in] | trans | Intended usage: = PlasmaNoTrans: no transpose, apply Q; = PlasmaTrans: ugate transpose, apply Q**T. Currently only PlasmaTrans is supported. |
| [in] | A | Details of the QR factorization of the original matrix A as returned by PLASMA_sgeqrf. |
| [in] | T | Auxiliary factorization data, computed by PLASMA_sgeqrf. |
| [in,out] | B | On entry, the M-by-N matrix B. On exit, B is overwritten by Q*B or Q**T*B. |
| PLASMA_SUCCESS | successful exit |
Definition at line 250 of file sormqr.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sormqr_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_splgsy_Tile | ( | float | bump, |
| PLASMA_desc * | A, | ||
| unsigned long long int | seed | ||
| ) |
PLASMA_splgsy_Tile - Generate a random hermitian matrix by tiles. Tile equivalent of PLASMA_splgsy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | bump | The value to add to the diagonal to be sure to have a positive definite matrix. |
| [in] | A | On exit, The random hermitian matrix A generated. |
| [in] | seed | The seed used in the random generation. |
| PLASMA_SUCCESS | successful exit |
Definition at line 153 of file splgsy.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_splgsy_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_splrnt_Tile | ( | PLASMA_desc * | A, |
| unsigned long long int | seed | ||
| ) |
PLASMA_splrnt_Tile - Generate a random matrix by tiles. Tile equivalent of PLASMA_splrnt(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | On exit, The random matrix A generated. |
| [in] | seed | The seed used in the random generation. |
| PLASMA_SUCCESS | successful exit |
Definition at line 151 of file splrnt.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_splrnt_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_sposv_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_sposv_Tile - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization. Tile equivalent of PLASMA_sposv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in,out] | 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. |
| [in,out] | B | On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. |
Definition at line 212 of file sposv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_sposv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_spotrf_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_desc * | A | ||
| ) |
PLASMA_spotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite or Hermitian positive definite matrix. Tile equivalent of PLASMA_spotrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | 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. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. |
Definition at line 183 of file spotrf.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_spotrf_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_spotri_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_desc * | A | ||
| ) |
PLASMA_spotri_Tile - Computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by PLASMA_spotrf. Tile equivalent of PLASMA_spotri(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | A | On entry, the triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PLASMA_spotrf. On exit, the upper or lower triangle of the (Hermitian) inverse of A, overwriting the input factor U or L. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. |
Definition at line 172 of file spotri.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_spotri_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_spotrs_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_spotrs_Tile - Solves a system of linear equations using previously computed Cholesky factorization. Tile equivalent of PLASMA_spotrs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | A | The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, computed by PLASMA_spotrf. |
| [in,out] | B | On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 187 of file spotrs.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_spotrs_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssyev_Tile | ( | PLASMA_enum | jobz, |
| PLASMA_enum | uplo, | ||
| PLASMA_desc * | A, | ||
| float * | W, | ||
| PLASMA_desc * | T, | ||
| PLASMA_desc * | Q | ||
| ) |
PLASMA_ssyev_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.
Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | jobz | Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors. PlasmaVec is NOT supported. |
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in,out] | A | On entry, the symmetric (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if jobz = PlasmaVec, then if return value = 0, A contains the orthonormal eigenvectors of the matrix A. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.* |
| [out] | W | On exit, if info = 0, the eigenvalues. |
| [in,out] | T | On entry, descriptor as return by PLASMA_Alloc_Workspace_ssyev On exit, contains auxiliary factorization data. |
| [out] | Q | On exit, if jobz = PlasmaVec and info = 0, the eigenvectors. |
| 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. |
Definition at line 274 of file ssyev.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssyev_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssygst_Tile | ( | PLASMA_enum | itype, |
| PLASMA_enum | uplo, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_ssygst_Tile - reduces a complex Hermitian-definite generalized eigenproblem to standard form. If PlasmaItype == 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T) If PlasmaItype == 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by PLASMA_SPOTRF. ONLY PlasmaItype == 1 and PlasmaLower supported! Tile equivalent of PLASMA_ssygst(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | PlasmaItype | Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x Currently only PlasmaItype == 1 is supported. |
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. Currently only PlasmaLower is supported. |
| [in,out] | 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. |
| [in,out] | B | On entry, the triangular factor from the Cholesky factorization of B, as returned by PLASMA_SPOTRF. |
| PLASMA_SUCCESS | successful exit |
| <0 | if -i, the i-th argument had an illegal value |
Definition at line 233 of file ssygst.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssygst_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssygv_Tile | ( | PLASMA_enum | itype, |
| PLASMA_enum | jobz, | ||
| PLASMA_enum | uplo, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B, | ||
| float * | W, | ||
| PLASMA_desc * | T, | ||
| PLASMA_desc * | Q | ||
| ) |
PLASMA_ssygv_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem of the form: A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.
Tile equivalent of PLASMA_ssygv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | PlasmaItype | Intended usage: = 1: A*x=(lambda)*B*x = 2: A*Bx=(lambda)*x = 3: B*A*x=(lambda)*x |
| [in] | jobz | Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors. Currently only PlasmaVec is NOT supported. |
| [in] | 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. |
| [in] | N | The order of the matrix A. N >= 0. |
| [in,out] | 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. |
| [in] | LDA | The leading dimension of the array A. LDA >= max(1,N). |
| [in,out] | 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. |
| [in] | LDB | The leading dimension of the array B. LDA >= max(1,N). |
| [in,out] | T | On entry, descriptor as return by PLASMA_Alloc_Workspace_ssygv On exit, contains auxiliary factorization data. |
| [out] | W | On exit, if info = 0, the eigenvalues. |
| [out] | Q | On exit, if jobz = PlasmaVec and info = 0, the eigenvectors. |
| PLASMA_SUCCESS | successful exit |
| <0 | if -i, the i-th argument had an illegal value |
| <=N | if INFO = i, plasma_ssygv failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. |
| >N | if INFO = N + i, for 1 <= i <= N, then the leading minor of order i of B is not positive definite. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed. |
Definition at line 369 of file ssygv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssygv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssymm_Tile | ( | PLASMA_enum | side, |
| PLASMA_enum | uplo, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B, | ||
| float | beta, | ||
| PLASMA_desc * | C | ||
| ) |
PLASMA_ssymm_Tile - Performs symmetric matrix multiplication. Tile equivalent of PLASMA_ssymm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | side | Specifies whether the symmetric matrix A appears on the left or right in the operation as follows: = PlasmaLeft:
|
| [in] | 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. |
| [in] | alpha | Specifies the scalar alpha. |
| [in] | A | A is a LDA-by-ka matrix, where ka is M when side = PlasmaLeft, and is N otherwise. Only the uplo triangular part is referenced. |
| [in] | B | B is a LDB-by-N matrix, where the leading M-by-N part of the array B must contain the matrix B. |
| [in] | beta | Specifies the scalar beta. |
| [in,out] | C | C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N updated matrix. |
| PLASMA_SUCCESS | successful exit |
Definition at line 254 of file ssymm.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssymm_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssyr2k_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_enum | trans, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B, | ||
| float | beta, | ||
| PLASMA_desc * | C | ||
| ) |
PLASMA_ssyr2k_Tile - Performs symmetric rank k update. Tile equivalent of PLASMA_ssyr2k(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored. |
| [in] | trans | Specifies whether the matrix A is transposed or ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is ugate transposed. |
| [in] | alpha | alpha specifies the scalar alpha. |
| [in] | A | A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise. |
| [in] | B | B is a LDB-by-kb matrix, where kb is K when trans = PlasmaNoTrans, and is N otherwise. |
| [in] | beta | beta specifies the scalar beta |
| [in,out] | C | C is a LDC-by-N matrix. On exit, the array uplo part of the matrix is overwritten by the uplo part of the updated matrix. |
| PLASMA_SUCCESS | successful exit |
Definition at line 250 of file ssyr2k.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssyr2k_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssyrk_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_enum | trans, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| float | beta, | ||
| PLASMA_desc * | C | ||
| ) |
PLASMA_ssyrk_Tile - Performs rank k update. Tile equivalent of PLASMA_ssyrk(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of C is stored; = PlasmaLower: Lower triangle of C is stored. |
| [in] | trans | Specifies whether the matrix A is transposed or ugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed. |
| [in] | alpha | alpha specifies the scalar alpha. |
| [in] | A | A is a LDA-by-ka matrix, where ka is K when trans = PlasmaNoTrans, and is N otherwise. |
| [in] | beta | beta specifies the scalar beta |
| [in,out] | C | C is a LDC-by-N matrix. On exit, the array uplo part of the matrix is overwritten by the uplo part of the updated matrix. |
| PLASMA_SUCCESS | successful exit |
Definition at line 227 of file ssyrk.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssyrk_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_ssytrd_Tile | ( | PLASMA_enum | jobz, |
| PLASMA_enum | uplo, | ||
| PLASMA_desc * | A, | ||
| float * | D, | ||
| float * | E, | ||
| PLASMA_desc * | T, | ||
| PLASMA_desc * | Q | ||
| ) |
PLASMA_ssytrd_Tile - reduces a complex Hermitian matrix A to real symmetric tridiagonal form S using a two-stage approach First stage: reduction to band tridiagonal form (unitary Q1); Second stage: reduction from band to tridiagonal form (unitary Q2). Let Q = Q1 * Q2 be the global unitary transformation; Q**T * A * Q = S. Tile equivalent of PLASMA_ssytrd(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | jobz | Intended usage: = PlasmaNoVec: computes eigenvalues only; = PlasmaVec: computes eigenvalues and eigenvectors. PlasmaVec is NOT supported. |
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in,out] | A | On entry, the symmetric (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if jobz = PlasmaVec, then if return value = 0, A contains the orthonormal eigenvectors of the matrix A. If jobz = PlasmaNoVec, then on exit the lower triangle (if uplo = PlasmaLower) or the upper triangle (if uplo = PlasmaUpper) of A, including the diagonal, is destroyed.* |
| [out] | D | On exit, the diagonal elements of the tridiagonal matrix: D(i) = A(i,i). |
| [out] | 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. |
| [out] | T | On exit, auxiliary factorization data. |
| [out] | Q | On exit, if jobz = PlasmaVec and info = 0, the eigenvectors. |
| 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. |
Definition at line 279 of file ssytrd.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_ssytrd_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_strmm_Tile | ( | PLASMA_enum | side, |
| PLASMA_enum | uplo, | ||
| PLASMA_enum | transA, | ||
| PLASMA_enum | diag, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_strmm_Tile - Computes triangular solve. Tile equivalent of PLASMA_strmm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | side | Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B |
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | 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. |
| [in] | diag | Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. |
| [in] | alpha | alpha specifies the scalar alpha. |
| [in] | A | The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. |
| [in,out] | B | On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 249 of file strmm.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_strmm_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_strsm_Tile | ( | PLASMA_enum | side, |
| PLASMA_enum | uplo, | ||
| PLASMA_enum | transA, | ||
| PLASMA_enum | diag, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_strsm_Tile - Computes triangular solve. Tile equivalent of PLASMA_strsm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | side | Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B |
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | 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. |
| [in] | diag | Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. |
| [in] | alpha | alpha specifies the scalar alpha. |
| [in] | A | The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. |
| [in,out] | B | On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 249 of file strsm.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_strsm_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_strsmpl_Tile | ( | PLASMA_desc * | A, |
| PLASMA_desc * | L, | ||
| int * | IPIV, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_strsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | A | The tile factor L from the factorization, computed by PLASMA_sgetrf_incpiv. |
| [in] | L | Auxiliary factorization data, related to the tile L factor, computed by PLASMA_sgetrf_incpiv. |
| [in] | IPIV | The pivot indices from PLASMA_sgetrf_incpiv (not equivalent to LAPACK). |
| [in,out] | B | On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 191 of file strsmpl.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_strsmpl_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_strsmrv_Tile | ( | PLASMA_enum | side, |
| PLASMA_enum | uplo, | ||
| PLASMA_enum | transA, | ||
| PLASMA_enum | diag, | ||
| float | alpha, | ||
| PLASMA_desc * | A, | ||
| PLASMA_desc * | B | ||
| ) |
PLASMA_strsmrv_Tile - Computes triangular solve. Tile equivalent of PLASMA_strsmrv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | side | Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B |
| [in] | uplo | Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | 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. |
| [in] | diag | Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit. |
| [in] | alpha | alpha specifies the scalar alpha. |
| [in] | A | The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1. |
| [in,out] | B | On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X. |
| PLASMA_SUCCESS | successful exit |
Definition at line 249 of file strsmrv.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_strsmrv_Tile_Async(), and plasma_sequence_t::status.
| int PLASMA_strtri_Tile | ( | PLASMA_enum | uplo, |
| PLASMA_enum | diag, | ||
| PLASMA_desc * | A | ||
| ) |
PLASMA_strtri_Tile - Computes the inverse of a complex upper or lower triangular matrix A. Tile equivalent of PLASMA_strtri(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.
| [in] | uplo | = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored. |
| [in] | diag | = PlasmaNonUnit: A is non-unit triangular; = PlasmaUnit: A us unit triangular. |
| [in] | 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. |
| PLASMA_SUCCESS | successful exit |
| >0 | if i, A(i,i) is exactly zero. The triangular matrix is singular and its inverse can not be computed. |
Definition at line 191 of file strtri.c.
References plasma_context_self(), plasma_dynamic_sync, PLASMA_ERR_NOT_INITIALIZED, plasma_fatal_error(), PLASMA_REQUEST_INITIALIZER, plasma_sequence_create(), plasma_sequence_destroy(), PLASMA_strtri_Tile_Async(), and plasma_sequence_t::status.
1.8.1 
![\[ C = \alpha \times A \times B + \beta \times C \]](form_1.png)
![\[ C = \alpha \times B \times A + \beta \times C \]](form_2.png)