--- name: "heevd_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/heevd_2stage" --- # heevd\_2stage(3) {he,sy}evd\_2stage: eig, divide and conquer ## NAME heevd\_2stage - {he,sy}evd\_2stage: eig, divide and conquer ## SYNOPSIS ### Functions subroutine **cheevd\_2stage** (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)\ **CHEEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices** subroutine **dsyevd\_2stage** (jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)\ **DSYEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices** subroutine **ssyevd\_2stage** (jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info)\ **SSYEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices** subroutine **zheevd\_2stage** (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info)\ **ZHEEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices** ## Detailed Description ## Function Documentation ### subroutine cheevd\_2stage (character jobz, character uplo, integer n, complex, dimension( lda, \* ) a, integer lda, real, dimension( \* ) w, complex, dimension( \* ) work, integer lwork, real, dimension( \* ) rwork, integer lrwork, integer, dimension( \* ) iwork, integer liwork, integer info) **CHEEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices** **Purpose:** ``` !> !> CHEEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a !> complex Hermitian matrix A using the 2stage technique for !> the reduction to tridiagonal. If eigenvectors are desired, it uses a !> divide and conquer algorithm. !> !> ``` **Parameters** *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 triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. 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 !> orthonormal eigenvectors of the matrix A. !> If JOBZ = 'N', then on exit the lower triangle (if UPLO='L') !> or the upper triangle (if UPLO='U') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= 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 dimension of the array WORK. !> If N <= 1, LWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + N+1 !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + N+1 !> 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 at least 2*N + N**2 !> !> If LWORK = -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. !> ``` *RWORK* ``` !> RWORK is REAL array, !> dimension (LRWORK) !> On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK. !> ``` *LRWORK* ``` !> LRWORK is INTEGER !> The dimension of the array RWORK. !> If N <= 1, LRWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LRWORK must be at least N. !> If JOBZ = 'V' and N > 1, LRWORK must be at least !> 1 + 5*N + 2*N**2. !> !> 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. !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (MAX(1,LIWORK)) !> On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. !> ``` *LIWORK* ``` !> LIWORK is INTEGER !> The dimension of the array IWORK. !> If N <= 1, LIWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LIWORK must be at least 1. !> If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N. !> !> 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. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i and JOBZ = 'N', then the algorithm failed !> to converge; i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero; !> if INFO = i and JOBZ = 'V', then the algorithm failed !> to compute an eigenvalue while working on the submatrix !> lying in rows and columns INFO/(N+1) through !> mod(INFO,N+1). !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Further Details:** Modified description of INFO. Sven, 16 Feb 05. **Contributors:** Jeff Rutter, Computer Science Division, University of California at Berkeley, USA **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 **245** of file **cheevd\_2stage.f**. ### subroutine dsyevd\_2stage (character jobz, character uplo, integer n, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( \* ) w, double precision, dimension( \* ) work, integer lwork, integer, dimension( \* ) iwork, integer liwork, integer info) **DSYEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices** **Purpose:** ``` !> !> DSYEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a !> real symmetric matrix A using the 2stage technique for !> the reduction to tridiagonal. If eigenvectors are desired, it uses a !> divide and conquer algorithm. !> !> ``` **Parameters** *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 triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. 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 !> orthonormal eigenvectors of the matrix A. !> If JOBZ = 'N', then on exit the lower triangle (if UPLO='L') !> or the upper triangle (if UPLO='U') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= 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 (LWORK) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> If N <= 1, LWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + 2*N+1 !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + 2*N+1 !> 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 at least !> 1 + 6*N + 2*N**2. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal sizes of the WORK and IWORK !> arrays, returns these values as the first entries of the WORK !> and IWORK arrays, and no error message related to LWORK or !> LIWORK is issued by XERBLA. !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (MAX(1,LIWORK)) !> On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. !> ``` *LIWORK* ``` !> LIWORK is INTEGER !> The dimension of the array IWORK. !> If N <= 1, LIWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LIWORK must be at least 1. !> If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N. !> !> If LIWORK = -1, then a workspace query is assumed; the !> routine only calculates the optimal sizes of the WORK and !> IWORK arrays, returns these values as the first entries of !> the WORK and IWORK arrays, and no error message related to !> LWORK or LIWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i and JOBZ = 'N', then the algorithm failed !> to converge; i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero; !> if INFO = i and JOBZ = 'V', then the algorithm failed !> to compute an eigenvalue while working on the submatrix !> lying in rows and columns INFO/(N+1) through !> mod(INFO,N+1). !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Contributors:** Jeff Rutter, Computer Science Division, University of California at Berkeley, USA \ \ Modified by Francoise Tisseur, University of Tennessee \ \ Modified description of INFO. Sven, 16 Feb 05. \ **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 **219** of file **dsyevd\_2stage.f**. ### subroutine ssyevd\_2stage (character jobz, character uplo, integer n, real, dimension( lda, \* ) a, integer lda, real, dimension( \* ) w, real, dimension( \* ) work, integer lwork, integer, dimension( \* ) iwork, integer liwork, integer info) **SSYEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices** **Purpose:** ``` !> !> SSYEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a !> real symmetric matrix A using the 2stage technique for !> the reduction to tridiagonal. If eigenvectors are desired, it uses a !> divide and conquer algorithm. !> !> ``` **Parameters** *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 triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. 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 !> orthonormal eigenvectors of the matrix A. !> If JOBZ = 'N', then on exit the lower triangle (if UPLO='L') !> or the upper triangle (if UPLO='U') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *W* ``` !> W is REAL array, dimension (N) !> If INFO = 0, the eigenvalues in ascending order. !> ``` *WORK* ``` !> WORK is REAL array, !> dimension (LWORK) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> If N <= 1, LWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + 2*N+1 !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + 2*N+1 !> 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 at least !> 1 + 6*N + 2*N**2. !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal sizes of the WORK and IWORK !> arrays, returns these values as the first entries of the WORK !> and IWORK arrays, and no error message related to LWORK or !> LIWORK is issued by XERBLA. !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (MAX(1,LIWORK)) !> On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. !> ``` *LIWORK* ``` !> LIWORK is INTEGER !> The dimension of the array IWORK. !> If N <= 1, LIWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LIWORK must be at least 1. !> If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N. !> !> If LIWORK = -1, then a workspace query is assumed; the !> routine only calculates the optimal sizes of the WORK and !> IWORK arrays, returns these values as the first entries of !> the WORK and IWORK arrays, and no error message related to !> LWORK or LIWORK is issued by XERBLA. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i and JOBZ = 'N', then the algorithm failed !> to converge; i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero; !> if INFO = i and JOBZ = 'V', then the algorithm failed !> to compute an eigenvalue while working on the submatrix !> lying in rows and columns INFO/(N+1) through !> mod(INFO,N+1). !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Contributors:** Jeff Rutter, Computer Science Division, University of California at Berkeley, USA \ \ Modified by Francoise Tisseur, University of Tennessee \ \ Modified description of INFO. Sven, 16 Feb 05. \ **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 **219** of file **ssyevd\_2stage.f**. ### subroutine zheevd\_2stage (character jobz, character uplo, integer n, complex\*16, dimension( lda, \* ) a, integer lda, double precision, dimension( \* ) w, complex\*16, dimension( \* ) work, integer lwork, double precision, dimension( \* ) rwork, integer lrwork, integer, dimension( \* ) iwork, integer liwork, integer info) **ZHEEVD\_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices** **Purpose:** ``` !> !> ZHEEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a !> complex Hermitian matrix A using the 2stage technique for !> the reduction to tridiagonal. If eigenvectors are desired, it uses a !> divide and conquer algorithm. !> !> ``` **Parameters** *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 triangle of A is stored; !> = 'L': Lower triangle of A is stored. !> ``` *N* ``` !> N is INTEGER !> The order of the matrix A. 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 !> orthonormal eigenvectors of the matrix A. !> If JOBZ = 'N', then on exit the lower triangle (if UPLO='L') !> or the upper triangle (if UPLO='U') of A, including the !> diagonal, is destroyed. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= 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 dimension of the array WORK. !> If N <= 1, LWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LWORK must be queried. !> LWORK = MAX(1, dimension) where !> dimension = max(stage1,stage2) + (KD+1)*N + N+1 !> = N*KD + N*max(KD+1,FACTOPTNB) !> + max(2*KD*KD, KD*NTHREADS) !> + (KD+1)*N + N+1 !> 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 at least 2*N + N**2 !> !> If LWORK = -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. !> ``` *RWORK* ``` !> RWORK is DOUBLE PRECISION array, !> dimension (LRWORK) !> On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK. !> ``` *LRWORK* ``` !> LRWORK is INTEGER !> The dimension of the array RWORK. !> If N <= 1, LRWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LRWORK must be at least N. !> If JOBZ = 'V' and N > 1, LRWORK must be at least !> 1 + 5*N + 2*N**2. !> !> 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. !> ``` *IWORK* ``` !> IWORK is INTEGER array, dimension (MAX(1,LIWORK)) !> On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. !> ``` *LIWORK* ``` !> LIWORK is INTEGER !> The dimension of the array IWORK. !> If N <= 1, LIWORK must be at least 1. !> If JOBZ = 'N' and N > 1, LIWORK must be at least 1. !> If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N. !> !> 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. !> ``` *INFO* ``` !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i and JOBZ = 'N', then the algorithm failed !> to converge; i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero; !> if INFO = i and JOBZ = 'V', then the algorithm failed !> to compute an eigenvalue while working on the submatrix !> lying in rows and columns INFO/(N+1) through !> mod(INFO,N+1). !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. **Further Details:** Modified description of INFO. Sven, 16 Feb 05. **Contributors:** Jeff Rutter, Computer Science Division, University of California at Berkeley, USA **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 **245** of file **zheevd\_2stage.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.