![]() |
MAGMA
1.6.1
Matrix Algebra for GPU and Multicore Architectures
|
Functions | |
magma_int_t | magma_chegst (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *B, magma_int_t ldb, magma_int_t *info) |
CHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. More... | |
magma_int_t | magma_chegst_gpu (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magma_int_t *info) |
CHEGST_GPU reduces a complex Hermitian-definite generalized eigenproblem to standard form. More... | |
magma_int_t | magma_chegst_m (magma_int_t ngpu, magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *B, magma_int_t ldb, magma_int_t *info) |
CHEGST_M reduces a complex Hermitian-definite generalized eigenproblem to standard form. More... | |
magma_int_t | magma_chetrd (magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, float *d, float *e, magmaFloatComplex *tau, magmaFloatComplex *work, magma_int_t lwork, magma_int_t *info) |
CHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More... | |
magma_int_t | magma_chetrd2_gpu (magma_uplo_t uplo, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, float *d, float *e, magmaFloatComplex *tau, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *work, magma_int_t lwork, magmaFloatComplex_ptr dwork, magma_int_t ldwork, magma_int_t *info) |
CHETRD2_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More... | |
magma_int_t | magma_chetrd_gpu (magma_uplo_t uplo, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, float *d, float *e, magmaFloatComplex *tau, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *work, magma_int_t lwork, magma_int_t *info) |
CHETRD_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More... | |
magma_int_t | magma_chetrd_mgpu (magma_int_t ngpu, magma_int_t nqueue, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, float *d, float *e, magmaFloatComplex *tau, magmaFloatComplex *work, magma_int_t lwork, magma_int_t *info) |
CHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More... | |
magma_int_t | magma_cstedx (magma_range_t range, magma_int_t n, float vl, float vu, magma_int_t il, magma_int_t iu, float *d, float *e, magmaFloatComplex *Z, magma_int_t ldz, float *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magmaFloat_ptr dwork, magma_int_t *info) |
CSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. More... | |
magma_int_t | magma_cstedx_m (magma_int_t ngpu, magma_range_t range, magma_int_t n, float vl, float vu, magma_int_t il, magma_int_t iu, float *d, float *e, magmaFloatComplex *Z, magma_int_t ldz, float *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info) |
CSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. More... | |
magma_int_t | magma_cungtr (magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magmaFloatComplex *work, magma_int_t lwork, magmaFloatComplex *dT, magma_int_t nb, magma_int_t *info) |
CUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: More... | |
magma_int_t | magma_cunmtr (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magmaFloatComplex *C, magma_int_t ldc, magmaFloatComplex *work, magma_int_t lwork, magma_int_t *info) |
CUNMTR overwrites the general complex M-by-N matrix C with. More... | |
magma_int_t | magma_cunmtr_gpu (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex *tau, magmaFloatComplex_ptr dC, magma_int_t lddc, magmaFloatComplex *wA, magma_int_t ldwa, magma_int_t *info) |
CUNMTR overwrites the general complex M-by-N matrix C with. More... | |
magma_int_t | magma_cunmtr_m (magma_int_t ngpu, magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magmaFloatComplex *C, magma_int_t ldc, magmaFloatComplex *work, magma_int_t lwork, magma_int_t *info) |
CUNMTR overwrites the general complex M-by-N matrix C with. More... | |
magma_int_t magma_chegst | ( | magma_int_t | itype, |
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | B, | ||
magma_int_t | ldb, | ||
magma_int_t * | info | ||
) |
CHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form.
If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.
B must have been previously factorized as U**H*U or L*L**H by CPOTRF.
[in] | itype | INTEGER = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H); = 2 or 3: compute U*A*U**H or L**H*A*L. |
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrices A and B. N >= 0. |
[in,out] | A | COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 INFO = 0, the transformed matrix, stored in the same format as A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[in] | B | COMPLEX array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF. |
[in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N). |
[out] | info | INTEGER
|
magma_int_t magma_chegst_gpu | ( | magma_int_t | itype, |
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
magmaFloatComplex_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloatComplex_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_int_t * | info | ||
) |
CHEGST_GPU reduces a complex Hermitian-definite generalized eigenproblem to standard form.
If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.
B must have been previously factorized as U**H*U or L*L**H by CPOTRF.
[in] | itype | INTEGER = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H); = 2 or 3: compute U*A*U**H or L**H*A*L. |
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrices A and B. N >= 0. |
[in,out] | dA | COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 INFO = 0, the transformed matrix, stored in the same format as A. |
[in] | ldda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[in] | dB | COMPLEX array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF. |
[in] | lddb | INTEGER The leading dimension of the array B. LDB >= max(1,N). |
[out] | info | INTEGER
|
magma_int_t magma_chegst_m | ( | magma_int_t | ngpu, |
magma_int_t | itype, | ||
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | B, | ||
magma_int_t | ldb, | ||
magma_int_t * | info | ||
) |
CHEGST_M reduces a complex Hermitian-definite generalized eigenproblem to standard form.
If ITYPE = 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.
B must have been previously factorized as U**H*U or L*L**H by CPOTRF.
[in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0. |
[in] | itype | INTEGER = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H); = 2 or 3: compute U*A*U**H or L**H*A*L. |
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrices A and B. N >= 0. |
[in,out] | A | COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 INFO = 0, the transformed matrix, stored in the same format as A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[in] | B | COMPLEX array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF. |
[in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N). |
[out] | info | INTEGER
|
magma_int_t magma_chetrd | ( | magma_uplo_t | uplo, |
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
float * | d, | ||
float * | e, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magma_int_t * | info | ||
) |
CHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrix A. N >= 0. |
[in,out] | A | COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[out] | d | COMPLEX array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i). |
[out] | e | COMPLEX array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower. |
[out] | tau | COMPLEX array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details). |
[out] | work | (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_chetrd_nb(). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. |
[out] | info | INTEGER
|
If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors
Q = H(n-1) . . . H(2) H(1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).
If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(n-1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).
The contents of A on exit are illustrated by the following examples with n = 5:
if UPLO = MagmaUpper: if UPLO = MagmaLower:
( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )
where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).
magma_int_t magma_chetrd2_gpu | ( | magma_uplo_t | uplo, |
magma_int_t | n, | ||
magmaFloatComplex_ptr | dA, | ||
magma_int_t | ldda, | ||
float * | d, | ||
float * | e, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magmaFloatComplex_ptr | dwork, | ||
magma_int_t | ldwork, | ||
magma_int_t * | info | ||
) |
CHETRD2_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
This version passes a workspace that is used in an optimized GPU matrix-vector product.
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrix A. N >= 0. |
[in,out] | dA | COMPLEX array on the GPU, dimension (LDDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,N). |
[out] | d | COMPLEX array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i). |
[out] | e | COMPLEX array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower. |
[out] | tau | COMPLEX array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details). |
[out] | A | (workspace) COMPLEX array, dimension (LDA,N) On exit the diagonal, the upper part (UPLO=MagmaUpper) or the lower part (UPLO=MagmaLower) are copies of DA |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[out] | work | (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_chetrd_nb(). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. |
[out] | dwork | (workspace) COMPLEX array on the GPU, dim (MAX(1,LDWORK)) |
[in] | ldwork | INTEGER The dimension of the array DWORK. LDWORK >= ldda*ceil(n/64) + 2*ldda*nb, where nb = magma_get_chetrd_nb(n), and 64 is for the blocksize of magmablas_chemv. |
[out] | info | INTEGER
|
If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors
Q = H(n-1) . . . H(2) H(1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).
If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(n-1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).
The contents of A on exit are illustrated by the following examples with n = 5:
if UPLO = MagmaUpper: if UPLO = MagmaLower:
( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )
where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).
magma_int_t magma_chetrd_gpu | ( | magma_uplo_t | uplo, |
magma_int_t | n, | ||
magmaFloatComplex_ptr | dA, | ||
magma_int_t | ldda, | ||
float * | d, | ||
float * | e, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magma_int_t * | info | ||
) |
CHETRD_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrix A. N >= 0. |
[in,out] | dA | COMPLEX array on the GPU, dimension (LDDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,N). |
[out] | d | COMPLEX array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i). |
[out] | e | COMPLEX array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower. |
[out] | tau | COMPLEX array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details). |
[out] | A | (workspace) COMPLEX array, dimension (LDA,N) On exit the diagonal, the upper part (UPLO=MagmaUpper) or the lower part (UPLO=MagmaLower) are copies of DA |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[out] | work | (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_chetrd_nb(). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. |
[out] | info | INTEGER
|
If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors
Q = H(n-1) . . . H(2) H(1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).
If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(n-1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).
The contents of A on exit are illustrated by the following examples with n = 5:
if UPLO = MagmaUpper: if UPLO = MagmaLower:
( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )
where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).
magma_int_t magma_chetrd_mgpu | ( | magma_int_t | ngpu, |
magma_int_t | nqueue, | ||
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
float * | d, | ||
float * | e, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magma_int_t * | info | ||
) |
CHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
[in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0. |
[in] | nqueue | INTEGER The number of GPU streams used for update. 10 >= nqueue > 0. |
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrix A. N >= 0. |
[in,out] | A | COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, 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 = MagmaLower, 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
[out] | d | COMPLEX array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i). |
[out] | e | COMPLEX array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower. |
[out] | tau | COMPLEX array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details). |
[out] | work | (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_chetrd_nb(). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. |
[out] | info | INTEGER
|
If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors
Q = H(n-1) . . . H(2) H(1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).
If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(n-1).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).
The contents of A on exit are illustrated by the following examples with n = 5:
if UPLO = MagmaUpper: if UPLO = MagmaLower:
( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )
where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).
magma_int_t magma_cstedx | ( | magma_range_t | range, |
magma_int_t | n, | ||
float | vl, | ||
float | vu, | ||
magma_int_t | il, | ||
magma_int_t | iu, | ||
float * | d, | ||
float * | e, | ||
magmaFloatComplex * | Z, | ||
magma_int_t | ldz, | ||
float * | rwork, | ||
magma_int_t | lrwork, | ||
magma_int_t * | iwork, | ||
magma_int_t | liwork, | ||
magmaFloat_ptr | dwork, | ||
magma_int_t * | info | ||
) |
CSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.
This code 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. See SLAEX3 for details.
[in] | range | magma_range_t
|
[in] | n | INTEGER The dimension of the symmetric tridiagonal matrix. N >= 0. |
[in] | vl | REAL |
[in] | vu | REAL If RANGE=MagmaRangeV, the lower and upper bounds of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = MagmaRangeAll or MagmaRangeI. |
[in] | il | INTEGER |
[in] | iu | INTEGER If RANGE=MagmaRangeI, 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 = MagmaRangeAll or MagmaRangeV. |
[in,out] | d | REAL array, dimension (N) On entry, the diagonal elements of the tridiagonal matrix. On exit, if INFO = 0, the eigenvalues in ascending order. |
[in,out] | e | REAL array, dimension (N-1) On entry, the subdiagonal elements of the tridiagonal matrix. On exit, E has been destroyed. |
[out] | Z | COMPLEX array, dimension (LDZ,N) On exit, if INFO = 0, Z contains the orthonormal eigenvectors of the symmetric tridiagonal matrix. |
[in] | ldz | INTEGER The leading dimension of the array Z. LDZ >= max(1,N). |
[out] | rwork | (workspace) REAL array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK. |
[in] | lrwork | INTEGER The dimension of the array RWORK. LRWORK >= 1 + 4*N + 2*N**2. Note that if N is less than or equal to the minimum divide size, usually 25, then LRWORK need only be max(1,2*(N-1)). If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA. |
[out] | iwork | (workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK. |
[in] | liwork | INTEGER The dimension of the array IWORK. LIWORK >= 3 + 5*N . Note that if N is less than or equal to the minimum divide size, usually 25, then LIWORK need only be 1. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA. |
dwork | (workspace) REAL array, dimension (3*N*N/2+3*N) | |
[out] | info | INTEGER
|
Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA
magma_int_t magma_cstedx_m | ( | magma_int_t | ngpu, |
magma_range_t | range, | ||
magma_int_t | n, | ||
float | vl, | ||
float | vu, | ||
magma_int_t | il, | ||
magma_int_t | iu, | ||
float * | d, | ||
float * | e, | ||
magmaFloatComplex * | Z, | ||
magma_int_t | ldz, | ||
float * | rwork, | ||
magma_int_t | lrwork, | ||
magma_int_t * | iwork, | ||
magma_int_t | liwork, | ||
magma_int_t * | info | ||
) |
CSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.
This code 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. See SLAEX3 for details.
[in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0. |
[in] | range | magma_range_t
|
[in] | n | INTEGER The dimension of the symmetric tridiagonal matrix. N >= 0. |
[in] | vl | REAL |
[in] | vu | REAL If RANGE=MagmaRangeV, the lower and upper bounds of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = MagmaRangeAll or MagmaRangeI. |
[in] | il | INTEGER |
[in] | iu | INTEGER If RANGE=MagmaRangeI, 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 = MagmaRangeAll or MagmaRangeV. |
[in,out] | d | REAL array, dimension (N) On entry, the diagonal elements of the tridiagonal matrix. On exit, if INFO = 0, the eigenvalues in ascending order. |
[in,out] | e | REAL array, dimension (N-1) On entry, the subdiagonal elements of the tridiagonal matrix. On exit, E has been destroyed. |
[out] | Z | COMPLEX array, dimension (LDZ,N) On exit, if INFO = 0, Z contains the orthonormal eigenvectors of the symmetric tridiagonal matrix. |
[in] | ldz | INTEGER The leading dimension of the array Z. LDZ >= max(1,N). |
[out] | rwork | (workspace) REAL array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK. |
[in] | lrwork | INTEGER The dimension of the array RWORK. LRWORK >= 1 + 4*N + 2*N**2 . Note that if N is less than or equal to the minimum divide size, usually 25, then LRWORK need only be max(1,2*(N-1)). If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA. |
[out] | iwork | (workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK. |
[in] | liwork | INTEGER The dimension of the array IWORK. LIWORK >= 3 + 5*N . Note that if N is less than or equal to the minimum divide size, usually 25, then LIWORK need only be 1. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA. |
[out] | info | INTEGER
|
Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA
magma_int_t magma_cungtr | ( | magma_uplo_t | uplo, |
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magmaFloatComplex * | dT, | ||
magma_int_t | nb, | ||
magma_int_t * | info | ||
) |
CUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD:
if UPLO = MagmaUpper, Q = H(n-1) . . . H(2) H(1),
if UPLO = MagmaLower, Q = H(1) H(2) . . . H(n-1).
[in] | uplo | magma_uplo_t
|
[in] | n | INTEGER The order of the matrix Q. N >= 0. |
[in,out] | A | COMPLEX array, dimension (LDA,N) On entry, the vectors which define the elementary reflectors, as returned by CHETRD. On exit, the N-by-N unitary matrix Q. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= N. |
[in] | tau | COMPLEX array, dimension (N-1) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CHETRD. |
[out] | work | (workspace) COMPLEX array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. LWORK >= N-1. For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. |
[in] | dT | COMPLEX array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i) as returned by magma_chetrd. |
[in] | nb | INTEGER This is the block size used in CHETRD, and correspondingly the size of the T matrices, used in the factorization, and stored in DT. |
[out] | info | INTEGER
|
magma_int_t magma_cunmtr | ( | magma_side_t | side, |
magma_uplo_t | uplo, | ||
magma_trans_t | trans, | ||
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | C, | ||
magma_int_t | ldc, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magma_int_t * | info | ||
) |
CUNMTR overwrites the general complex M-by-N matrix C with.
SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q * C C * Q TRANS = Magma_ConjTrans: Q**H * C C * Q**H
where Q is a complex unitary matrix of order nq, with nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD:
if UPLO = MagmaUpper, Q = H(nq-1) . . . H(2) H(1);
if UPLO = MagmaLower, Q = H(1) H(2) . . . H(nq-1).
[in] | side | magma_side_t
|
[in] | uplo | magma_uplo_t
|
[in] | trans | magma_trans_t
|
[in] | m | INTEGER The number of rows of the matrix C. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix C. N >= 0. |
[in] | A | COMPLEX array, dimension (LDA,M) if SIDE = MagmaLeft (LDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = MagmaLeft; LDA >= max(1,N) if SIDE = MagmaRight. |
[in] | tau | COMPLEX array, dimension (M-1) if SIDE = MagmaLeft (N-1) if SIDE = MagmaRight TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SSYTRD. |
[in,out] | C | COMPLEX array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H * C or C * Q**H or C*Q. |
[in] | ldc | INTEGER The leading dimension of the array C. LDC >= max(1,M). |
[out] | work | (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M). For optimum performance LWORK >= N*NB if SIDE = MagmaLeft, and LWORK >= M*NB if SIDE = MagmaRight, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued. |
[out] | info | INTEGER
|
magma_int_t magma_cunmtr_gpu | ( | magma_side_t | side, |
magma_uplo_t | uplo, | ||
magma_trans_t | trans, | ||
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloatComplex_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex_ptr | dC, | ||
magma_int_t | lddc, | ||
magmaFloatComplex * | wA, | ||
magma_int_t | ldwa, | ||
magma_int_t * | info | ||
) |
CUNMTR overwrites the general complex M-by-N matrix C with.
SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q * C C * Q TRANS = Magma_ConjTrans: Q**H * C C * Q**H
where Q is a complex unitary matrix of order nq, with nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD:
if UPLO = MagmaUpper, Q = H(nq-1) . . . H(2) H(1);
if UPLO = MagmaLower, Q = H(1) H(2) . . . H(nq-1).
[in] | side | magma_side_t
|
[in] | uplo | magma_uplo_t
|
[in] | trans | magma_trans_t
|
[in] | m | INTEGER The number of rows of the matrix C. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix C. N >= 0. |
[in] | dA | COMPLEX array, dimension (LDDA,M) if SIDE = MagmaLeft (LDDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by CHETRD_GPU. On output the diagonal, the subdiagonal and the upper part (UPLO=MagmaLower) or lower part (UPLO=MagmaUpper) are destroyed. |
[in] | ldda | INTEGER The leading dimension of the array DA. LDDA >= max(1,M) if SIDE = MagmaLeft; LDDA >= max(1,N) if SIDE = MagmaRight. |
[in] | tau | COMPLEX array, dimension (M-1) if SIDE = MagmaLeft (N-1) if SIDE = MagmaRight TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by CHETRD. |
[in,out] | dC | COMPLEX array, dimension (LDDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by (Q*C) or (Q**H * C) or (C * Q**H) or (C*Q). |
[in] | lddc | INTEGER The leading dimension of the array C. LDDC >= max(1,M). |
[in] | wA | (workspace) COMPLEX array, dimension (LDWA,M) if SIDE = MagmaLeft (LDWA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by CHETRD_GPU. |
[in] | ldwa | INTEGER The leading dimension of the array wA. LDWA >= max(1,M) if SIDE = MagmaLeft; LDWA >= max(1,N) if SIDE = MagmaRight. |
[out] | info | INTEGER
|
magma_int_t magma_cunmtr_m | ( | magma_int_t | ngpu, |
magma_side_t | side, | ||
magma_uplo_t | uplo, | ||
magma_trans_t | trans, | ||
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | tau, | ||
magmaFloatComplex * | C, | ||
magma_int_t | ldc, | ||
magmaFloatComplex * | work, | ||
magma_int_t | lwork, | ||
magma_int_t * | info | ||
) |
CUNMTR overwrites the general complex M-by-N matrix C with.
SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q * C C * Q TRANS = Magma_ConjTrans: Q**H * C C * Q**H
where Q is a complex unitary matrix of order nq, with nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD:
if UPLO = MagmaUpper, Q = H(nq-1) . . . H(2) H(1);
if UPLO = MagmaLower, Q = H(1) H(2) . . . H(nq-1).
[in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0. |
[in] | side | magma_side_t
|
[in] | uplo | magma_uplo_t
|
[in] | trans | magma_trans_t
|
[in] | m | INTEGER The number of rows of the matrix C. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix C. N >= 0. |
[in] | A | COMPLEX array, dimension (LDA,M) if SIDE = MagmaLeft (LDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = MagmaLeft; LDA >= max(1,N) if SIDE = MagmaRight. |
[in] | tau | COMPLEX array, dimension (M-1) if SIDE = MagmaLeft (N-1) if SIDE = MagmaRight TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SSYTRD. |
[in,out] | C | COMPLEX array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q. |
[in] | ldc | INTEGER The leading dimension of the array C. LDC >= max(1,M). |
[out] | work | (workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK. |
[in] | lwork | INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M). For optimum performance LWORK >= N*NB if SIDE = MagmaLeft, and LWORK >= M*NB if SIDE = MagmaRight, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued. |
[out] | info | INTEGER
|