--- name: "hegv_2stage" section: "3" platform: "linux" package: "lapack-doc" version: "3.12.1-2" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/hegv_2stage" --- # hegv\_2stage(3) {he,sy}gv\_2stage: eig, QR iteration, 2-stage ## NAME hegv\_2stage - {he,sy}gv\_2stage: eig, QR iteration, 2-stage ## SYNOPSIS ### Functions subroutine **chegv\_2stage** (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)\ **CHEGV\_2STAGE** subroutine **dsygv\_2stage** (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)\ **DSYGV\_2STAGE** subroutine **ssygv\_2stage** (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info)\ **SSYGV\_2STAGE** subroutine **zhegv\_2stage** (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info)\ **ZHEGV\_2STAGE** ## Detailed Description ## Function Documentation ### subroutine chegv\_2stage (integer itype, character jobz, character uplo, integer n, complex, dimension( lda, \* ) a, integer lda, complex, dimension( ldb, \* ) b, integer ldb, real, dimension( \* ) w, complex, dimension( \* ) work, integer lwork, real, dimension( \* ) rwork, integer info) **CHEGV\_2STAGE** **Purpose:** ``` !> !> CHEGV_2STAGE computes all the eigenvalues, and optionally, the 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. !> This routine use the 2stage technique for the reduction to tridiagonal !> which showed higher performance on recent architecture and for large !> sizes N>2000. !> ``` **Parameters** *ITYPE* ``` !> ITYPE is INTEGER !> Specifies the problem type to be solved: !> = 1: A*x = (lambda)*B*x !> = 2: A*B*x = (lambda)*x !> = 3: B*A*x = (lambda)*x !> ``` *JOBZ* ``` !> JOBZ is CHARACTER*1 !> = 'N': Compute eigenvalues only; !> = 'V': Compute eigenvalues and eigenvectors. !> Not available in this release. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangles of A and B are stored; !> = 'L': Lower triangles of A and B are stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrices A and B. N >= 0. !> ``` *A* ``` !> A is COMPLEX array, dimension (LDA, N) !> On entry, the Hermitian matrix A. If UPLO = 'U', the !> leading N-by-N upper triangular part of A contains the !> upper triangular part of the matrix A. If UPLO = 'L', !> the leading N-by-N lower triangular part of A contains !> the lower triangular part of the matrix A. !> !> On exit, if JOBZ = 'V', then if INFO = 0, A contains the !> matrix Z of eigenvectors. The eigenvectors are normalized !> as follows: !> if ITYPE = 1 or 2, Z**H*B*Z = I; !> if ITYPE = 3, Z**H*inv(B)*Z = I. !> If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') !> or the lower triangle (if UPLO='L') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *B* ``` !> B is COMPLEX array, dimension (LDB, N) !> On entry, the Hermitian positive definite matrix B. !> If UPLO = 'U', the leading N-by-N upper triangular part of B !> contains the upper triangular part of the matrix B. !> If UPLO = 'L', the leading N-by-N lower triangular part of B !> contains the lower triangular part of the matrix B. !> !> On exit, if INFO <= N, the part of B containing the matrix is !> overwritten by the triangular factor U or L from the Cholesky !> factorization B = U**H*U or B = L*L**H. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *W* ``` !> W is REAL array, dimension (N) !> If INFO = 0, the eigenvalues in ascending order. !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of the array WORK. LWORK >= 1, when N <= 1; !> otherwise !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + N !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + N !> where KD is the blocking size of the reduction, !> FACTOPTNB is the blocking used by the QR or LQ !> algorithm, usually FACTOPTNB=128 is a good choice !> NTHREADS is the number of threads used when !> openMP compilation is enabled, otherwise =1. !> If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available !> !> 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. !> ``` *RWORK* ``` !> RWORK is REAL array, dimension (max(1, 3*N-2)) !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: CPOTRF or CHEEV returned an error code: !> <= N: if INFO = i, CHEEV 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 !> principal minor of order i of B is not positive. !> The factorization of B could not be completed and !> no eigenvalues or eigenvectors were computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Further Details:** ``` !> !> All details about the 2stage techniques are available in: !> !> Azzam Haidar, Hatem Ltaief, and Jack Dongarra. !> Parallel reduction to condensed forms for symmetric eigenvalue problems !> using aggregated fine-grained and memory-aware kernels. In Proceedings !> of 2011 International Conference for High Performance Computing, !> Networking, Storage and Analysis (SC '11), New York, NY, USA, !> Article 8 , 11 pages. !> http://doi.acm.org/10.1145/2063384.2063394 !> !> A. Haidar, J. Kurzak, P. Luszczek, 2013. !> An improved parallel singular value algorithm and its implementation !> for multicore hardware, In Proceedings of 2013 International Conference !> for High Performance Computing, Networking, Storage and Analysis (SC '13). !> Denver, Colorado, USA, 2013. !> Article 90, 12 pages. !> http://doi.acm.org/10.1145/2503210.2503292 !> !> A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra. !> A novel hybrid CPU-GPU generalized eigensolver for electronic structure !> calculations based on fine-grained memory aware tasks. !> International Journal of High Performance Computing Applications. !> Volume 28 Issue 2, Pages 196-209, May 2014. !> http://hpc.sagepub.com/content/28/2/196 !> !> ``` Definition at line **230** of file **chegv\_2stage.f**. ### subroutine dsygv\_2stage (integer itype, character jobz, character uplo, integer n, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( ldb, \* ) b, integer ldb, double precision, dimension( \* ) w, double precision, dimension( \* ) work, integer lwork, integer info) **DSYGV\_2STAGE** **Purpose:** ``` !> !> DSYGV_2STAGE computes all the eigenvalues, and optionally, the eigenvectors !> of a real generalized symmetric-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 symmetric and B is also !> positive definite. !> This routine use the 2stage technique for the reduction to tridiagonal !> which showed higher performance on recent architecture and for large !> sizes N>2000. !> ``` **Parameters** *ITYPE* ``` !> ITYPE is INTEGER !> Specifies the problem type to be solved: !> = 1: A*x = (lambda)*B*x !> = 2: A*B*x = (lambda)*x !> = 3: B*A*x = (lambda)*x !> ``` *JOBZ* ``` !> JOBZ is CHARACTER*1 !> = 'N': Compute eigenvalues only; !> = 'V': Compute eigenvalues and eigenvectors. !> Not available in this release. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangles of A and B are stored; !> = 'L': Lower triangles of A and B are stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrices A and B. N >= 0. !> ``` *A* ``` !> A is DOUBLE PRECISION array, dimension (LDA, N) !> On entry, the symmetric matrix A. If UPLO = 'U', the !> leading N-by-N upper triangular part of A contains the !> upper triangular part of the matrix A. If UPLO = 'L', !> the leading N-by-N lower triangular part of A contains !> the lower triangular part of the matrix A. !> !> On exit, if JOBZ = 'V', then if INFO = 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 = 'N', then on exit the upper triangle (if UPLO='U') !> or the lower triangle (if UPLO='L') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *B* ``` !> B is DOUBLE PRECISION array, dimension (LDB, N) !> On entry, the symmetric positive definite matrix B. !> If UPLO = 'U', the leading N-by-N upper triangular part of B !> contains the upper triangular part of the matrix B. !> If UPLO = 'L', the leading N-by-N lower triangular part of B !> contains the lower triangular part of the matrix B. !> !> On exit, if INFO <= N, the part of B containing the matrix is !> overwritten by the triangular factor U or L from the Cholesky !> factorization B = U**T*U or B = L*L**T. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *W* ``` !> W is DOUBLE PRECISION array, dimension (N) !> If INFO = 0, the eigenvalues in ascending order. !> ``` *WORK* ``` !> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of the array WORK. LWORK >= 1, when N <= 1; !> otherwise !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + 2*N !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + 2*N !> where KD is the blocking size of the reduction, !> FACTOPTNB is the blocking used by the QR or LQ !> algorithm, usually FACTOPTNB=128 is a good choice !> NTHREADS is the number of threads used when !> openMP compilation is enabled, otherwise =1. !> If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available !> !> 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. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: DPOTRF or DSYEV returned an error code: !> <= N: if INFO = i, DSYEV 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 !> principal minor of order i of B is not positive. !> The factorization of B could not be completed and !> no eigenvalues or eigenvectors were computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Further Details:** ``` !> !> All details about the 2stage techniques are available in: !> !> Azzam Haidar, Hatem Ltaief, and Jack Dongarra. !> Parallel reduction to condensed forms for symmetric eigenvalue problems !> using aggregated fine-grained and memory-aware kernels. In Proceedings !> of 2011 International Conference for High Performance Computing, !> Networking, Storage and Analysis (SC '11), New York, NY, USA, !> Article 8 , 11 pages. !> http://doi.acm.org/10.1145/2063384.2063394 !> !> A. Haidar, J. Kurzak, P. Luszczek, 2013. !> An improved parallel singular value algorithm and its implementation !> for multicore hardware, In Proceedings of 2013 International Conference !> for High Performance Computing, Networking, Storage and Analysis (SC '13). !> Denver, Colorado, USA, 2013. !> Article 90, 12 pages. !> http://doi.acm.org/10.1145/2503210.2503292 !> !> A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra. !> A novel hybrid CPU-GPU generalized eigensolver for electronic structure !> calculations based on fine-grained memory aware tasks. !> International Journal of High Performance Computing Applications. !> Volume 28 Issue 2, Pages 196-209, May 2014. !> http://hpc.sagepub.com/content/28/2/196 !> !> ``` Definition at line **224** of file **dsygv\_2stage.f**. ### subroutine ssygv\_2stage (integer itype, character jobz, character uplo, integer n, real, dimension( lda, \* ) a, integer lda, real, dimension( ldb, \* ) b, integer ldb, real, dimension( \* ) w, real, dimension( \* ) work, integer lwork, integer info) **SSYGV\_2STAGE** **Purpose:** ``` !> !> SSYGV_2STAGE computes all the eigenvalues, and optionally, the eigenvectors !> of a real generalized symmetric-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 symmetric and B is also !> positive definite. !> This routine use the 2stage technique for the reduction to tridiagonal !> which showed higher performance on recent architecture and for large !> sizes N>2000. !> ``` **Parameters** *ITYPE* ``` !> ITYPE is INTEGER !> Specifies the problem type to be solved: !> = 1: A*x = (lambda)*B*x !> = 2: A*B*x = (lambda)*x !> = 3: B*A*x = (lambda)*x !> ``` *JOBZ* ``` !> JOBZ is CHARACTER*1 !> = 'N': Compute eigenvalues only; !> = 'V': Compute eigenvalues and eigenvectors. !> Not available in this release. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangles of A and B are stored; !> = 'L': Lower triangles of A and B are stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrices A and B. N >= 0. !> ``` *A* ``` !> A is REAL array, dimension (LDA, N) !> On entry, the symmetric matrix A. If UPLO = 'U', the !> leading N-by-N upper triangular part of A contains the !> upper triangular part of the matrix A. If UPLO = 'L', !> the leading N-by-N lower triangular part of A contains !> the lower triangular part of the matrix A. !> !> On exit, if JOBZ = 'V', then if INFO = 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 = 'N', then on exit the upper triangle (if UPLO='U') !> or the lower triangle (if UPLO='L') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *B* ``` !> B is REAL array, dimension (LDB, N) !> On entry, the symmetric positive definite matrix B. !> If UPLO = 'U', the leading N-by-N upper triangular part of B !> contains the upper triangular part of the matrix B. !> If UPLO = 'L', the leading N-by-N lower triangular part of B !> contains the lower triangular part of the matrix B. !> !> On exit, if INFO <= N, the part of B containing the matrix is !> overwritten by the triangular factor U or L from the Cholesky !> factorization B = U**T*U or B = L*L**T. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *W* ``` !> W is REAL array, dimension (N) !> If INFO = 0, the eigenvalues in ascending order. !> ``` *WORK* ``` !> WORK is REAL array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of the array WORK. LWORK >= 1, when N <= 1; !> otherwise !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + 2*N !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + 2*N !> where KD is the blocking size of the reduction, !> FACTOPTNB is the blocking used by the QR or LQ !> algorithm, usually FACTOPTNB=128 is a good choice !> NTHREADS is the number of threads used when !> openMP compilation is enabled, otherwise =1. !> If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available !> !> 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. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: SPOTRF or SSYEV returned an error code: !> <= N: if INFO = i, SSYEV 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 !> principal minor of order i of B is not positive. !> The factorization of B could not be completed and !> no eigenvalues or eigenvectors were computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Further Details:** ``` !> !> All details about the 2stage techniques are available in: !> !> Azzam Haidar, Hatem Ltaief, and Jack Dongarra. !> Parallel reduction to condensed forms for symmetric eigenvalue problems !> using aggregated fine-grained and memory-aware kernels. In Proceedings !> of 2011 International Conference for High Performance Computing, !> Networking, Storage and Analysis (SC '11), New York, NY, USA, !> Article 8 , 11 pages. !> http://doi.acm.org/10.1145/2063384.2063394 !> !> A. Haidar, J. Kurzak, P. Luszczek, 2013. !> An improved parallel singular value algorithm and its implementation !> for multicore hardware, In Proceedings of 2013 International Conference !> for High Performance Computing, Networking, Storage and Analysis (SC '13). !> Denver, Colorado, USA, 2013. !> Article 90, 12 pages. !> http://doi.acm.org/10.1145/2503210.2503292 !> !> A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra. !> A novel hybrid CPU-GPU generalized eigensolver for electronic structure !> calculations based on fine-grained memory aware tasks. !> International Journal of High Performance Computing Applications. !> Volume 28 Issue 2, Pages 196-209, May 2014. !> http://hpc.sagepub.com/content/28/2/196 !> !> ``` Definition at line **224** of file **ssygv\_2stage.f**. ### subroutine zhegv\_2stage (integer itype, character jobz, character uplo, integer n, complex\*16, dimension( lda, \* ) a, integer lda, complex\*16, dimension( ldb, \* ) b, integer ldb, double precision, dimension( \* ) w, complex\*16, dimension( \* ) work, integer lwork, double precision, dimension( \* ) rwork, integer info) **ZHEGV\_2STAGE** **Purpose:** ``` !> !> ZHEGV_2STAGE computes all the eigenvalues, and optionally, the 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. !> This routine use the 2stage technique for the reduction to tridiagonal !> which showed higher performance on recent architecture and for large !> sizes N>2000. !> ``` **Parameters** *ITYPE* ``` !> ITYPE is INTEGER !> Specifies the problem type to be solved: !> = 1: A*x = (lambda)*B*x !> = 2: A*B*x = (lambda)*x !> = 3: B*A*x = (lambda)*x !> ``` *JOBZ* ``` !> JOBZ is CHARACTER*1 !> = 'N': Compute eigenvalues only; !> = 'V': Compute eigenvalues and eigenvectors. !> Not available in this release. !> ``` *UPLO* ``` !> UPLO is CHARACTER*1 !> = 'U': Upper triangles of A and B are stored; !> = 'L': Lower triangles of A and B are stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrices A and B. N >= 0. !> ``` *A* ``` !> A is COMPLEX*16 array, dimension (LDA, N) !> On entry, the Hermitian matrix A. If UPLO = 'U', the !> leading N-by-N upper triangular part of A contains the !> upper triangular part of the matrix A. If UPLO = 'L', !> the leading N-by-N lower triangular part of A contains !> the lower triangular part of the matrix A. !> !> On exit, if JOBZ = 'V', then if INFO = 0, A contains the !> matrix Z of eigenvectors. The eigenvectors are normalized !> as follows: !> if ITYPE = 1 or 2, Z**H*B*Z = I; !> if ITYPE = 3, Z**H*inv(B)*Z = I. !> If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') !> or the lower triangle (if UPLO='L') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *B* ``` !> B is COMPLEX*16 array, dimension (LDB, N) !> On entry, the Hermitian positive definite matrix B. !> If UPLO = 'U', the leading N-by-N upper triangular part of B !> contains the upper triangular part of the matrix B. !> If UPLO = 'L', the leading N-by-N lower triangular part of B !> contains the lower triangular part of the matrix B. !> !> On exit, if INFO <= N, the part of B containing the matrix is !> overwritten by the triangular factor U or L from the Cholesky !> factorization B = U**H*U or B = L*L**H. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *W* ``` !> W is DOUBLE PRECISION array, dimension (N) !> If INFO = 0, the eigenvalues in ascending order. !> ``` *WORK* ``` !> WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The length of the array WORK. LWORK >= 1, when N <= 1; !> otherwise !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + N !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + N !> where KD is the blocking size of the reduction, !> FACTOPTNB is the blocking used by the QR or LQ !> algorithm, usually FACTOPTNB=128 is a good choice !> NTHREADS is the number of threads used when !> openMP compilation is enabled, otherwise =1. !> If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available !> !> 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. !> ``` *RWORK* ``` !> RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2)) !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: ZPOTRF or ZHEEV returned an error code: !> <= N: if INFO = i, ZHEEV 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 !> principal minor of order i of B is not positive. !> The factorization of B could not be completed and !> no eigenvalues or eigenvectors were computed. !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Further Details:** ``` !> !> All details about the 2stage techniques are available in: !> !> Azzam Haidar, Hatem Ltaief, and Jack Dongarra. !> Parallel reduction to condensed forms for symmetric eigenvalue problems !> using aggregated fine-grained and memory-aware kernels. In Proceedings !> of 2011 International Conference for High Performance Computing, !> Networking, Storage and Analysis (SC '11), New York, NY, USA, !> Article 8 , 11 pages. !> http://doi.acm.org/10.1145/2063384.2063394 !> !> A. Haidar, J. Kurzak, P. Luszczek, 2013. !> An improved parallel singular value algorithm and its implementation !> for multicore hardware, In Proceedings of 2013 International Conference !> for High Performance Computing, Networking, Storage and Analysis (SC '13). !> Denver, Colorado, USA, 2013. !> Article 90, 12 pages. !> http://doi.acm.org/10.1145/2503210.2503292 !> !> A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra. !> A novel hybrid CPU-GPU generalized eigensolver for electronic structure !> calculations based on fine-grained memory aware tasks. !> International Journal of High Performance Computing Applications. !> Volume 28 Issue 2, Pages 196-209, May 2014. !> http://hpc.sagepub.com/content/28/2/196 !> !> ``` Definition at line **230** of file **zhegv\_2stage.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.