complexHEeigen(3)

📦

version 3.11.0 · 2 versions

3.11.0 · debian bookworm (latest)
3.10.0 · ubuntu jammy

✨ NAME ✨

complexHEeigen — complex

Ok so real talk: this is the LAPACK (section 3) page for complexHEeigen, and the one-word vibe of it is literally "complex". That's it. That's the whole NAME line. She's mysterious. 🎀

🌸 SYNOPSIS 🌸

💫 Functions

subroutine cheev (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO) — CHEEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
subroutine cheev_2stage (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO) — CHEEV_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
subroutine cheevd (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO) — CHEEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
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 cheevr (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO) — CHEEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
subroutine cheevr_2stage (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO) — CHEEVR_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
subroutine cheevx (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO) — CHEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
subroutine cheevx_2stage (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO) — CHEEVX_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices
subroutine chegv (ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, RWORK, INFO) — CHEGV
subroutine chegv_2stage (ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, RWORK, INFO) — CHEGV_2STAGE
subroutine chegvd (ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO) — CHEGVD
subroutine chegvx (ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO) — CHEGVX

Here's the same tea, but in actual signature form, so you can copy-paste and go:

subroutine cheev (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO)
subroutine cheev_2stage (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO)
subroutine cheevd (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO)
subroutine cheevd_2stage (JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO)
subroutine cheevr (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO)
subroutine cheevr_2stage (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO)
subroutine cheevx (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO)
subroutine cheevx_2stage (JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO)
subroutine chegv (ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, RWORK, INFO)
subroutine chegv_2stage (ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, RWORK, INFO)
subroutine chegvd (ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO)
subroutine chegvx (ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO)

🦋 Detailed Description 🦋

This is the group of complex eigenvalue driver functions for HE matrices.

No cap. That's the entire description. A whole girlboss squad of drivers, all for HE matrices, all here to hand you eigenvalues and (if you ask nicely) eigenvectors. 👑

🎀 Function Documentation 🎀

💖 subroutine cheev 💖

subroutine cheev (character JOBZ, character UPLO, integer N, complex,
    dimension( lda, * ) A, integer LDA, real, dimension( * ) W, complex,
    dimension( * ) WORK, integer LWORK, real, dimension( * ) RWORK, integer
    INFO)

CHEEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices

Purpose:

CHEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

Parameters

JOBZ — JOBZ is CHARACTER*1
- = 'N': Compute eigenvalues only;
- = 'V': Compute eigenvalues and eigenvectors.
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.

Bestie, hear me: if you're in JOBZ = 'N' mode, part of your A is GONE. It's giving "destroyed", because that's literally what it says. Back your data up before you come for her. 😭

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 length of the array WORK. LWORK >= max(1,2*N-1). For optimal efficiency, LWORK >= (NB+1)*N, where NB is the blocksize for CHETRD returned by ILAENV.

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: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

🌈 subroutine cheev_2stage 🌈

subroutine cheev_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
    INFO)

CHEEV_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices

Purpose:

CHEEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using the 2stage technique for the reduction to tridiagonal.

Parameters

JOBZ — JOBZ is CHARACTER*1
- = 'N': Compute eigenvalues only;
- = 'V': Compute eigenvalues and eigenvectors. Not available in this release.

So like, 'V' is giving "coming soon" energy. It is not available in this release. Do not come for her. 🙈

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.

Same warning, same drama: JOBZ = 'N' means part of A gets obliterated. 💀

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

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: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.

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

ok that's part 1 bestie, keep scrolling, there's more of this squad to meet 💜

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

🌸 `cheevd` — the main character 🎀

subroutine cheevd (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 computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices ✨

💖 Purpose

CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm 👑

The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. (lowkey iconic that they'd work on a Cray but not on some random hex machine, but okay 🦋)

🎀 Parameters

JOBZ — JOBZ is CHARACTER*1
- = 'N': Compute eigenvalues only;
- = 'V': Compute eigenvalues and eigenvectors.
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. 💀 yeah bestie that triangle is gone gone.

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 length of the array WORK.
- If N <= 1, LWORK must be at least 1.
- If JOBZ = 'N' and N > 1, LWORK must be at least N + 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. (workspace query is the move, fr fr ✨)

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

heads up bestie: that INFO > 0 case means it did not converge. Not a vibe. Check your INFO, always. 🙈

🦋 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

👑 `cheevd_2stage` — the sequel, the two-stage era 🎀

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. 😭 (so don't come for it, it's just not here yet)
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. 😤 (yes, you have to ask, no guessing)

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

RWORK — RWORK is REAL array, dimension (LRWORK) On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
LRWORK
LRWORK — INTEGER, the dimension of the RWORK array. size it like this, bestie:
- if N <= 1, then 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.

okay so if LRWORK = -1, that's the ✨workspace query✨ moment: the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, hands them back as the first entries of the WORK, RWORK and IWORK arrays, and XERBLA says nothing about LWORK or LRWORK or LIWORK. not a single peep 🤐

IWORK — INTEGER array, dimension (MAX(1,LIWORK)). on exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. she's a little overachiever fr 💅
LIWORK — INTEGER, the dimension of the IWORK array. here's the tea:
- if N <= 1, then 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.

and if LIWORK = -1, same deal as before — 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. living her quiet life ✨

INFO — INTEGER, the vibe report at the end:
- = 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). it's giving "we tried" 💀

👑 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

💖 subroutine `cheevr` 💖

subroutine cheevr (character JOBZ, character RANGE, character UPLO, integer
    N, complex, dimension( lda, * ) A, integer LDA, real VL, real VU,
    integer IL, integer IU, real ABSTOL, integer M, real, dimension( * ) W,
    complex, dimension( ldz, * ) Z, integer LDZ, integer, dimension( * )
    ISUPPZ, complex, dimension( * ) WORK, integer LWORK, real, dimension( *
    ) RWORK, integer LRWORK, integer, dimension( * ) IWORK, integer LIWORK,
    integer INFO)

CHEEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices 👑

🌸 Purpose:

CHEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various 'good' L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows.

For each unreduced block (submatrix) of T,

Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general.
Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d).
For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy.
For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain.

The desired accuracy of the output can be specified by the input parameter ABSTOL.

For more details, see CSTEMR's documentation and:

Inderjit S. Dhillon and Beresford N. Parlett: 'Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices,' Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
Inderjit Dhillon and Beresford Parlett: 'Orthogonal Eigenvectors and Relative Gaps,' SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154.
Inderjit Dhillon: 'A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem', Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997.

Note 1 💅 CHEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made.

⚠️ Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner. no cap, she said what she said 😭

✨ Parameters

JOBZ — CHARACTER*1
- = 'N': Compute eigenvalues only;
- = 'V': Compute eigenvalues and eigenvectors.
RANGE — CHARACTER*1
- = 'A': all eigenvalues will be found.
- = 'V': all eigenvalues in the half-open interval (VL,VU] will be found.
- = 'I': the IL-th through IU-th eigenvalues will be found.

For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and CSTEIN are called

UPLO — CHARACTER*1
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — INTEGER. The order of the matrix A. N >= 0.
A — 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, the lower triangle (if UPLO='L') or the upper triangle (if UPLO='U') of A, including the diagonal, is destroyed 💀 she's gone, bestie.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,N).
VL — REAL. If RANGE='V', the lower bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.
VU — REAL. If RANGE='V', the upper bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.
IL — INTEGER. If RANGE='I', the index of the smallest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.
IU — INTEGER. If RANGE='I', the index of the largest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.
ABSTOL — REAL. The absolute error tolerance for the eigenvalues. An approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b] of width less than or equal to

        ABSTOL + EPS *   max( |a|,|b| ) ,

okay bestie we're back in it — this is the part where the docs get real specific about what comes back out of cheevr and then, plot twist, we meet a whole second subroutine. stay with me, it's giving ✨academic paper energy✨ but I promise it's useful.

See 'Computing Small Singular Values of Bidiagonal Matrices with Guaranteed High Relative Accuracy,' by Demmel and Kahan, LAPACK Working Note #3.

If high relative accuracy is important, set ABSTOL to SLAMCH( 'Safe minimum' ). Doing so will guarantee that eigenvalues are computed to high relative accuracy when possible in future releases. The current code does not make any guarantees about high relative accuracy, but future releases will. See J. Barlow and J. Demmel, 'Computing Accurate Eigensystems of Scaled Diagonally Dominant Matrices', LAPACK Working Note #7, for a discussion of which matrices define their eigenvalues to high relative accuracy.

lowkey the vibe here is: setting ABSTOL that way is a promise for the future, not a promise for right now. read it again if you have to, no cap. 🫶

`M`

M is INTEGER

The total number of eigenvalues found. 0 <= M <= N.

If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.

`W`

W is REAL array, dimension (N)

The first M elements contain the selected eigenvalues in ascending order. ascending, bestie, they come out sorted already 💅

`Z`

Z is COMPLEX array, dimension (LDZ, max(1,M))

If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i).

If JOBZ = 'N', then Z is not referenced.

Note: the user must ensure that at least max(1,M) columns are supplied in the array Z; if RANGE = 'V', the exact value of M is not known in advance and an upper bound must be used.

translation: you gotta over-allocate, because M is a mystery until the routine tells you. it's giving guess the guest list 🎀

`LDZ`

LDZ is INTEGER

The leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', LDZ >= max(1,N).

`ISUPPZ`

ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )

The support of the eigenvectors in Z, i.e., the indices indicating the nonzero elements in Z. The i-th eigenvector is nonzero only in elements ISUPPZ( 2*i-1 ) through ISUPPZ( 2*i ). This is an output of CSTEMR (tridiagonal matrix). The support of the eigenvectors of A is typically 1:N because of the unitary transformations applied by CUNMTR. Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1

screenshot this one: it only works for RANGE = 'A' or 'I', and only when IU - IL = N - 1. periodt. 📸

`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 >= max(1,2*N).

For optimal efficiency, LWORK >= (NB+1)*N, where NB is the max of the blocksize for CHETRD and for CUNMTR as returned by ILAENV.

💡 the -1 move is the iconic LAPACK trick: ask first, allocate second. she ate and left no crumbs.

`RWORK`

RWORK is REAL array, dimension (MAX(1,LRWORK))

On exit, if INFO = 0, RWORK(1) returns the optimal (and minimal) LRWORK.

`LRWORK`

LRWORK is INTEGER

The length of the array RWORK. LRWORK >= max(1,24*N).

`IWORK`

IWORK is INTEGER array, dimension (MAX(1,LIWORK))

On exit, if INFO = 0, IWORK(1) returns the optimal (and minimal) LIWORK.

`LIWORK`

LIWORK is INTEGER

The dimension of the array IWORK. LIWORK >= max(1,10*N).

three arrays, three -1 queries, one flawless little system. 🦋

`INFO`

INFO is INTEGER

= 0: successful exit 🎉
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: Internal error 💀

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

Inderjit Dhillon, IBM Almaden, USA Osni Marques, LBNL/NERSC, USA Ken Stanley, Computer Science Division, University of California at Berkeley, USA Jason Riedy, Computer Science Division, University of California at Berkeley, USA

🌈 subroutine `cheevr_2stage` 🌈

subroutine cheevr_2stage (character JOBZ, character RANGE, character UPLO,
    integer N, complex, dimension( lda, * ) A, integer LDA, real VL, real
    VU, integer IL, integer IU, real ABSTOL, integer M, real, dimension( * )
    W, complex, dimension( ldz, * ) Z, integer LDZ, integer, dimension( * )
    ISUPPZ, complex, dimension( * ) WORK, integer LWORK, real, dimension( *
    ) RWORK, integer LRWORK, integer, dimension( * ) IWORK, integer LIWORK,
    integer INFO)

CHEEVR_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices

Purpose:

CHEEVR_2STAGE computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using the 2stage technique for the reduction to tridiagonal. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues.

CHEEVR_2STAGE first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR_2STAGE calls CSTEMR to compute eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various 'good' L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows.

For each unreduced block (submatrix) of T,

Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general.
Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d).
For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy.
For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain.

The desired accuracy of the output can be specified by the input parameter ABSTOL.

For more details, see CSTEMR's documentation and:

Inderjit S. Dhillon and Beresford N. Parlett: 'Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices,' Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
Inderjit Dhillon and Beresford Parlett: 'Orthogonal Eigenvectors and Relative Gaps,' SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154.
Inderjit Dhillon: 'A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem', Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997.

Note 1 : CHEEVR_2STAGE calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. CHEEVR_2STAGE calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made.

⚠️ Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner. this is the scary one, bestie — know your environment before you ship it. 😭

Parameters

`JOBZ`

JOBZ is CHARACTER*1

= 'N': Compute eigenvalues only;
= 'V': Compute eigenvalues and eigenvectors. Not available in this release.

not available in this release — so don't come for her, she's just not ready yet 🙈

`RANGE`

RANGE is CHARACTER*1

= 'A': all eigenvalues will be found.
= 'V': all eigenvalues in the half-open interval (VL,VU] will be found.
= 'I': the IL-th through IU-th eigenvalues will be found.

For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and CSTEIN are called

half-open interval (VL,VU] — open on the left, closed on the right, and she will NOT be explaining herself 💅

`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, the lower triangle (if UPLO='L') or the upper triangle (if UPLO='U') of A, including the diagonal, is destroyed.

💀 destroyed. say it with your chest. she is NOT giving your matrix back, she is consuming it. if you need A later, copy it first, no cap.

`LDA`

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,N).

`VL`

VL is REAL. If RANGE='V', this is the lower bound of the interval we're hunting eigenvalues in. VL < VU, no exceptions bestie. Not referenced if RANGE = 'A' or RANGE = 'I' — she's just sitting there, unbothered, not even looked at. 💅

`VU`

VU is REAL. If RANGE='V', it's the upper bound of the interval being searched for eigenvalues. Again: VL < VU. Not referenced if RANGE = 'A' or RANGE = 'I'. 🙈

`IL`

IL is INTEGER. If RANGE='I', this is the index of the smallest eigenvalue to be returned.

1 <= IL <= IU <= N, if N > 0; and IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or RANGE = 'V'.

`IU`

IU is INTEGER. If RANGE='I', it's the index of the largest eigenvalue to be returned.

Same energy as IL: 1 <= IL <= IU <= N, if N > 0; and IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or RANGE = 'V'. ✨

`ABSTOL`

ABSTOL is REAL, and it's the absolute error tolerance for the eigenvalues, okay so listen. An approximate eigenvalue gets accepted as converged when it's determined to lie in an interval [a,b] whose width is less than or equal to

ABSTOL + EPS *   max( |a|,|b| ) ,

where EPS is the machine precision. If ABSTOL is less than or equal to zero, then EPS*|T| is used in its place, where |T| is the 1-norm of the tridiagonal matrix you get by reducing A to tridiagonal form.

See 'Computing Small Singular Values of Bidiagonal Matrices with Guaranteed High Relative Accuracy,' by Demmel and Kahan, LAPACK Working Note #3. 📚

If high relative accuracy is important to you (and honestly, when is it not), set ABSTOL to SLAMCH( 'Safe minimum' ). Doing that guarantees that eigenvalues are computed to high relative accuracy when possible in future releases. Heads up tho: the current code does not make any guarantees about high relative accuracy, but future releases will. See J. Barlow and J. Demmel, 'Computing Accurate Eigensystems of Scaled Diagonally Dominant Matrices', LAPACK Working Note #7, for a whole discussion of which matrices define their eigenvalues to high relative accuracy. 💀

`M`

M is INTEGER. It's the total number of eigenvalues found. 0 <= M <= N.

If RANGE = 'A', then M = N, and if RANGE = 'I', then M = IU-IL+1. Math is mathing. 🧮

`W`

W is a REAL array, dimension (N). The first M elements contain the selected eigenvalues, in ascending order. Sorted and slaying. 👑

`Z`

Z is a COMPLEX array, dimension (LDZ, max(1,M)). If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced, she's off the clock. 🙅

Note: the user must ensure that at least max(1,M) columns are supplied in the array Z; if RANGE = 'V', the exact value of M is not known in advance and an upper bound must be used. So like, budget generously bestie.

`LDZ`

LDZ is INTEGER — the leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', then LDZ >= max(1,N). Don't skimp. 🎀

`ISUPPZ`

ISUPPZ is an INTEGER array, dimension ( 2*max(1,M) ). It's the support of the eigenvectors in Z, i.e. the indices indicating the nonzero elements in Z. The i-th eigenvector is nonzero only in elements ISUPPZ( 2*i-1 ) through ISUPPZ( 2*i ). This is an output of CSTEMR (tridiagonal matrix). The support of the eigenvectors of A is typically 1:N because of the unitary transformations applied by CUNMTR.

Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1. ✨

`WORK`

WORK is a COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. She tells you what she needs. 🫶

`LWORK`

LWORK is INTEGER — the dimension of the array WORK.

If JOBZ = 'N' and N > 1, LWORK must be queried.

LWORK = MAX(1, 26*N, 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. 😭

`RWORK`

RWORK is a REAL array, dimension (MAX(1,LRWORK)). On exit, if INFO = 0, RWORK(1) returns the optimal (and minimal) LRWORK. 🌸

`LRWORK`

LRWORK is INTEGER — the length of the array RWORK. LRWORK >= max(1,24*N).

`IWORK`

IWORK is an INTEGER array, dimension (MAX(1,LIWORK)). On exit, if INFO = 0, IWORK(1) returns the optimal (and minimal) LIWORK. 💖

`LIWORK`

LIWORK is INTEGER — the dimension of the array IWORK. LIWORK >= max(1,10*N).

`INFO`

INFO is INTEGER, and this is the vibe check at the end:

= 0: successful exit ✨
< 0: if INFO = -i, the i-th argument had an illegal value 💀
> 0: Internal error 😭

Author 🫶

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors 💜

Inderjit Dhillon, IBM Almaden, USA
Osni Marques, LBNL/NERSC, USA
Ken Stanley, Computer Science Division, University of California at Berkeley, USA
Jason Riedy, 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

`subroutine cheevx` 👑

subroutine cheevx (character JOBZ, character RANGE, character UPLO, integer
    N, complex, dimension( lda, * ) A, integer LDA, real VL, real VU,
    integer IL, integer IU, real ABSTOL, integer M, real, dimension( * ) W,
    complex, dimension( ldz, * ) Z, integer LDZ, complex, dimension( * )
    WORK, integer LWORK, real, dimension( * ) RWORK, integer, dimension( * )
    IWORK, integer, dimension( * ) IFAIL, integer INFO)

CHEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices. 🦋

Purpose ✨

CHEEVX computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Pick your fighter. 💅

Parameters

`JOBZ`

JOBZ is CHARACTER*1:

= 'N': Compute eigenvalues only;
= 'V': Compute eigenvalues and eigenvectors.

`RANGE`

RANGE is CHARACTER*1:

= 'A': all eigenvalues will be found.
= 'V': all eigenvalues in the half-open interval (VL,VU] will be found.
= 'I': the IL-th through IU-th eigenvalues will be found.

`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 (COMPLEX array, dimension (LDA, N))

Okay so on entry, A is your Hermitian matrix A, bestie. 💖 If UPLO = 'U', the leading N-by-N upper triangular part of A holds the upper triangular part of the matrix A. If UPLO = 'L', the leading N-by-N lower triangular part of A holds the lower triangular part of the matrix A.

And on exit? 😭 The lower triangle (if UPLO='L') or the upper triangle (if UPLO='U') of A, including the diagonal, is destroyed. She's gone. Do not come back for her. If you needed that matrix, you should've kept a copy, no cap.

LDA

LDA is INTEGER. It's the leading dimension of the array A. LDA >= max(1,N). That's the vibe check it has to pass. ✨

VL

VL is REAL. If RANGE='V', this is the lower bound of the interval to be searched for eigenvalues, and VL < VU. Not referenced if RANGE = 'A' or 'I' — so it's just sitting there minding its business. 🦋

VU

VU is REAL. If RANGE='V', this is the upper bound of the interval to be searched for eigenvalues, and VL < VU. Not referenced if RANGE = 'A' or 'I'. Matching set with VL, iconic. 💅

IL

IL is INTEGER. If RANGE='I', it's the index of the smallest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; and IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.

IU

IU is INTEGER. If RANGE='I', it's the index of the largest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; and IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.

ABSTOL

ABSTOL is REAL — the absolute error tolerance for the eigenvalues. An approximate eigenvalue gets accepted as converged when it's determined to lie in an interval [a,b] of width less than or equal to

ABSTOL + EPS *   max( |a|,|b| ) ,

where EPS is the machine precision. If ABSTOL is less than or equal to zero, then EPS*|T| will be used in its place, where |T| is the 1-norm of the tridiagonal matrix you get by reducing A to tridiagonal form.

Bestie, listen: eigenvalues will be computed most accurately when ABSTOL is set to twice the underflow threshold 2*SLAMCH('S'), not zero. And if this routine comes back with INFO>0, meaning some eigenvectors did not converge, try setting ABSTOL to 2*SLAMCH('S'). That's the fix, periodt. 🔥

Also see 'Computing Small Singular Values of Bidiagonal Matrices with Guaranteed High Relative Accuracy,' by Demmel and Kahan, LAPACK Working Note #3. Academic queen behavior. 👑

M

M is INTEGER — the total number of eigenvalues found. 0 <= M <= N. If RANGE = 'A', then M = N, and if RANGE = 'I', then M = IU-IL+1. Math is mathing. ✨

W

W is REAL array, dimension (N). On a normal exit, the first M elements contain the selected eigenvalues in ascending order. Sorted, organized, main character energy. 🌸

Z

Z is COMPLEX array, dimension (LDZ, max(1,M)). If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i).

If an eigenvector fails to converge, then that column of Z contains the latest approximation to the eigenvector, and the index of the eigenvector is returned in IFAIL. Close enough, bestie, we tried. 🫶

If JOBZ = 'N', then Z is not referenced. Not even looked at.

Note: the user must ensure that at least max(1,M) columns are supplied in the array Z; if RANGE = 'V', the exact value of M is not known in advance and an upper bound must be used. So like, over-provision. Don't be stingy. 💀

LDZ

LDZ is INTEGER — the leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', then LDZ >= max(1,N).

WORK

WORK is COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, then WORK(1) returns the optimal LWORK. She's telling you what she really needed. 🙈

LWORK

LWORK is INTEGER — the length of the array WORK. LWORK >= 1, when N <= 1; otherwise 2*N.

For optimal efficiency, LWORK >= (NB+1)*N, where NB is the max of the blocksize for CHETRD and for CUNMTR as returned by ILAENV. Efficiency queen. ✨

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. Sneaky little shortcut, iykyk. 💅

RWORK

RWORK is REAL array, dimension (7*N).

IWORK

IWORK is INTEGER array, dimension (5*N).

IFAIL

IFAIL is INTEGER array, dimension (N). If JOBZ = 'V', then if INFO = 0, the first M elements of IFAIL are zero. If INFO > 0, then IFAIL contains the indices of the eigenvectors that failed to converge. If JOBZ = 'N', then IFAIL is not referenced. Not invited to the party. 🎀

INFO

INFO is INTEGER:

= 0:  successful exit
< 0:  if INFO = -i, the i-th argument had an illegal value
> 0:  if INFO = i, then i eigenvectors failed to converge.
      Their indices are stored in array IFAIL.

So yeah — negative INFO means argument -i was illegal (you fed her something she couldn't work with 😭), and positive INFO means i eigenvectors just refused to converge and their indices are chillin' in IFAIL. 🦋

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

`cheevx_2stage` 🌈

subroutine cheevx_2stage (character JOBZ, character RANGE, character UPLO,
    integer N, complex, dimension( lda, * ) A, integer LDA, real VL, real
    VU, integer IL, integer IU, real ABSTOL, integer M, real, dimension( * )
    W, complex, dimension( ldz, * ) Z, integer LDZ, complex, dimension( * )
    WORK, integer LWORK, real, dimension( * ) RWORK, integer, dimension( * )
    IWORK, integer, dimension( * ) IFAIL, integer INFO)

CHEEVX_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices. 💖

Purpose:

CHEEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors
of a complex Hermitian matrix A using the 2stage technique for
the reduction to tridiagonal.  Eigenvalues and eigenvectors can
be selected by specifying either a range of values or a range of
indices for the desired eigenvalues.

Two-stage technique, bestie — that's the whole glow-up. ✨

Parameters

JOBZ

JOBZ is CHARACTER*1

= 'N': Compute eigenvalues only;
= 'V': Compute eigenvalues and eigenvectors. Not available in this release.

Careful! The 'V' option is not available in this release. So don't @ me when it doesn't work. 💀

RANGE

RANGE is CHARACTER*1

= 'A': all eigenvalues will be found.
= 'V': all eigenvalues in the half-open interval (VL,VU] will be found.
= 'I': the IL-th through IU-th eigenvalues will be found.

Pick your fighter. 🎀

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, the lower triangle (if UPLO='L') or the upper triangle (if UPLO='U') of A, including the diagonal, is destroyed. Same story as before, bestie — she's gone. 😭

LDA

LDA is INTEGER — the leading dimension of the array A. LDA >= max(1,N).

VL

VL is REAL. If RANGE='V', the lower bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.

VU

VU is REAL. If RANGE='V', the upper bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.

IL

IL is INTEGER. If RANGE='I', the index of the smallest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.

IU

IU is INTEGER. If RANGE='I', the index of the largest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.

ABSTOL

ABSTOL is REAL — the absolute error tolerance for the eigenvalues. An approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b] of width less than or equal to

ABSTOL + EPS *   max( |a|,|b| ) ,

Again for the people in the back: eigenvalues will be computed most accurately when ABSTOL is set to twice the underflow threshold 2*SLAMCH('S'), not zero. If this routine returns with INFO>0, indicating that some eigenvectors did not converge, try setting ABSTOL to 2*SLAMCH('S'). 🔥

See 'Computing Small Singular Values of Bidiagonal Matrices with Guaranteed High Relative Accuracy,' by Demmel and Kahan, LAPACK Working Note #3.

M

M is INTEGER — the total number of eigenvalues found. 0 <= M <= N. If RANGE = 'A', then M = N, and if RANGE = 'I', then M = IU-IL+1.

W

W is REAL array, dimension (N). On normal exit, the first M elements contain the selected eigenvalues in ascending order. 🌸

Z

Z — a COMPLEX array, dimension (LDZ, max(1,M)), bestie listen up 💅 If JOBZ = 'V', then when INFO = 0, the first M columns of Z hold the orthonormal eigenvectors of the matrix A that go with the selected eigenvalues — and the i-th column of Z is the eigenvector for W(i). If some eigenvector just refuses to converge, that column of Z gets the latest approximation instead, and its index shows up in IFAIL. If JOBZ = 'N', then Z is literally not referenced, it's giving background character.

Note: you (yes you) have to make sure at least max(1,M) columns are supplied in the array Z; and if RANGE = 'V', the exact value of M is not known in advance so you gotta use an upper bound. No cap.

LDZ — INTEGER, the leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', then LDZ >= max(1,N). Respect the minimum, it's the rule. ✨
WORK — COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, then WORK(1) returns the optimal LWORK. Iconic little self-reporting behaviour honestly.
LWORK — 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, 8*N, 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 — and 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 🫠 (it said what it said).

RWORK — REAL array, dimension (7*N).
IWORK — INTEGER array, dimension (5*N).
IFAIL — INTEGER array, dimension (N). If JOBZ = 'V', then if INFO = 0, the first M elements of IFAIL are zero. If INFO > 0, then IFAIL contains the indices of the eigenvectors that failed to converge. If JOBZ = 'N', then IFAIL is not referenced. It's the receipts column fr.
INFO — INTEGER
- = 0: successful exit 🌈
- < 0: if INFO = -i, the i-th argument had an illegal value 💀
- > 0: if INFO = i, then i eigenvectors failed to converge. Their indices are stored in array IFAIL.

👑 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:

💖 CHEGV — the main character subroutine

subroutine chegv (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)

✨ Purpose:

CHEGV 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. So like, the well-behaved situation, we love that for us 🎀

🌸 Parameters

ITYPE — 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 — CHARACTER*1
- = 'N': Compute eigenvalues only;
- = 'V': Compute eigenvalues and eigenvectors.
UPLO — CHARACTER*1
- = 'U': Upper triangles of A and B are stored;
- = 'L': Lower triangles of A and B are stored.
N — INTEGER, the order of the matrices A and B. N >= 0.
A — COMPLEX array, dimension (LDA, N).

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 😭 sorry bestie, that data's gone gone.

LDA — INTEGER, the leading dimension of the array A. LDA >= max(1,N).
B — 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. Glow-up arc, honestly 💅

LDB — INTEGER, the leading dimension of the array B. LDB >= max(1,N).
W — REAL array, dimension (N). If INFO = 0, the eigenvalues in ascending order. Sorted, as they should be, periodt.
WORK — COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — INTEGER, the length of the array WORK. LWORK >= max(1,2*N-1).

For optimal efficiency, LWORK >= (NB+1)*N, where NB is the blocksize for CHETRD returned by ILAENV.

RWORK — REAL array, dimension (max(1, 3*N-2)).
INFO — 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 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 💀💀

👑 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

🦋 CHEGV_2STAGE — the glow-up version

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)

✨ 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 uses the 2stage technique for the reduction to tridiagonal, which showed higher performance on recent architecture and for large sizes N>2000. She's the upgraded girlie, she performs 💅🔥

🌸 Parameters

ITYPE — 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 — CHARACTER*1
- = 'N': Compute eigenvalues only;
- = 'V': Compute eigenvalues and eigenvectors. Not available in this release. 🙈 (it's coming, it's just not here yet)
UPLO —

`UPLO`

okay so UPLO is CHARACTER*1, and it's literally just the "which half of the matrix did you actually bother to fill in" switch 💅

= 'U': the upper triangles of A and B are stored;
= 'L': the lower triangles of A and B are stored.

`N`

N is INTEGER. it's the order of the matrices A and B, bestie. and the vibe check is strict here: N >= 0. that's it, that's the rule. periodt. 💅

`A`

A is COMPLEX array, dimension (LDA, N).

On entry, it's your Hermitian matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of A holds the upper triangular part of the matrix A. If UPLO = 'L', the leading N-by-N lower triangular part of A holds 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. like, gone gone. no cap 😭

`LDA`

LDA is INTEGER. it's the leading dimension of the array A, and LDA >= max(1,N). that's the whole assignment, she's simple, she's iconic. ✨

`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 holds the upper triangular part of the matrix B. If UPLO = 'L', the leading N-by-N lower triangular part of B holds the lower triangular part of the matrix B.

On exit, if INFO <= N, the part of B containing the matrix gets overwritten by the triangular factor U or L from the Cholesky factorization B = U**H*U or B = L*L**H. she ate and left no crumbs fr fr.

`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, these are your eigenvalues in ascending order 🌈.

`WORK`

WORK is COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. she's reporting back bestie 🫶

`LWORK`

LWORK is INTEGER. it's 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), and 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 🙈

`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 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. yeah. that's the worst-case scenario bestie 😭

👑 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

subroutine chegvd (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 LRWORK, integer,
    dimension( * ) IWORK, integer LIWORK, integer INFO)

💖 CHEGVD 💖

🎯 Purpose: 🎯

CHEGVD 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. If eigenvectors are desired, it uses a divide and conquer algorithm ✨.

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

✨ 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. main character energy fr 🔥

`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 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. she's not coming back bestie 😭

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

If N <= 1, LWORK >= 1.
If JOBZ = 'N' and N > 1, LWORK >= N + 1.
If JOBZ = 'V' and N > 1, LWORK >= 2*N + N**2.

`RWORK`

RWORK is REAL array, dimension (MAX(1,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 >= 1.
If JOBZ = 'N' and N > 1, LRWORK >= N.
If JOBZ = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.

If LRWORK = -1, bestie, we're in workspace query mode ✨ — the routine ONLY figures out the optimal sizes of the WORK, RWORK and IWORK arrays, hands them back to you as the first entries of the WORK, RWORK and IWORK arrays, and XERBLA will NOT be sending any angry messages about LWORK or LRWORK or LIWORK. Periodt.

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 >= 1.
If JOBZ = 'N' and N > 1, LIWORK >= 1.
If JOBZ = 'V' and N > 1, LIWORK >= 3 + 5*N.

INFO

INFO is INTEGER

= 0: successful exit 🎉
< 0: if INFO = -i, the i-th argument had an illegal value 💀
> 0: CPOTRF or CHEEVD returned an error code:
- <= N: 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);
- > 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. 🚫

👑 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

🔍 Further Details:

Modified so that no backsubstitution is performed if CHEEVD fails to converge (NEIG in old code could be greater than N causing out of bounds reference to A — reported by Ralf Meyer). Also corrected the description of INFO and the test on ITYPE. Sven, 16 Feb 05.

🫶 Contributors:

Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

🌸 subroutine chegvx (integer ITYPE, character JOBZ, character RANGE, character UPLO, integer N, complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB, real VL, real VU, integer IL, integer IU, real ABSTOL, integer M, real, dimension( * ) W, complex, dimension( ldz, * ) Z, integer LDZ, complex, dimension( * ) WORK, integer LWORK, real, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer, dimension( * ) IFAIL, integer INFO)

CHEGVX

Purpose:

CHEGVX computes selected 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. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. 💅

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

RANGE

RANGE is CHARACTER*1

= 'A': all eigenvalues will be found.
= 'V': all eigenvalues in the half-open interval (VL,VU] will be found.
= 'I': the IL-th through IU-th eigenvalues will be found.

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, the lower triangle (if UPLO='L') or the upper triangle (if UPLO='U') of A, including the diagonal, is destroyed. 😭 (gone, reduced to atoms)

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

VL

VL is REAL

If RANGE='V', the lower bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.

VU

VU is REAL

If RANGE='V', the upper bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.

IL

IL is INTEGER

If RANGE='I', the index of the smallest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.

IU

IU is INTEGER

If RANGE='I', the index of the largest eigenvalue to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = 'A' or 'V'.

ABSTOL

ABSTOL is REAL The absolute error tolerance for the eigenvalues. An approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b] of width less than or equal to

ABSTOL + EPS *   max( |a|,|b| ) ,

where EPS is the machine precision. If ABSTOL is less than or equal to zero, then EPS*|T| will be used in its place, where |T| is the 1-norm of the tridiagonal matrix obtained by reducing C to tridiagonal form, where C is the symmetric matrix of the standard symmetric problem to which the generalized problem is transformed.

Eigenvalues will be computed most accurately when ABSTOL is set to twice the underflow threshold 2*SLAMCH('S'), not zero. If this routine returns with INFO>0, indicating that some eigenvectors did not converge, try setting ABSTOL to 2*SLAMCH('S').

M

M is INTEGER The total number of eigenvalues found. 0 <= M <= N. If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.

W

W is REAL array, dimension (N) The first M elements contain the selected eigenvalues in ascending order.

Z

Z is COMPLEX array, dimension (LDZ, max(1,M)) If JOBZ = 'N', then Z is not referenced. If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). 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 an eigenvector fails to converge, then that column of Z contains the latest approximation to the eigenvector, and the index of the eigenvector is returned in IFAIL. Note: the user must ensure that at least max(1,M) columns are supplied in the array Z; if RANGE = 'V', the exact value of M is not known in advance and an upper bound must be used. 🙈 (yes bestie, you have to guess an upper bound, it's giving chaotic)

LDZ

LDZ is INTEGER The leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', LDZ >= max(1,N).

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 >= max(1,2*N). For optimal efficiency, LWORK >= (NB+1)*N, where NB is the blocksize for CHETRD returned by ILAENV.

RWORK

RWORK is REAL array, dimension (7*N)

IWORK

IWORK is INTEGER array, dimension (5*N)

IFAIL

IFAIL is INTEGER array, dimension (N) If JOBZ = 'V', then if INFO = 0, the first M elements of IFAIL are zero. If INFO > 0, then IFAIL contains the indices of the eigenvectors that failed to converge. If JOBZ = 'N', then IFAIL is not referenced.

INFO

INFO is INTEGER, and bestie she is the receipts section — she tells you what actually went down:
- = 0 — successful exit. slay. we love a clean run. ✨
- < 0 — if INFO = -i, then the i-th argument had an illegal value. so like… you handed her something cursed and she's telling you exactly which one. 😭
- > 0 — CPOTRF or CHEEVX returned an error code, and here's where it gets specific:
  - <= N — if INFO = i, CHEEVX failed to converge. literally i eigenvectors failed to converge, and their indices are stored in array IFAIL. she keeps the list, she doesn't gatekeep. 💅
  - > 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. that's a full stop, no crumbs, nothing came out. 💀

ok real talk though — that second bullet is the one that ends the whole vibe. B not being positive definite means the factorization just cannot finish, and you get zero eigenvalues and zero eigenvectors. not "some", not "partial", none. so if you see INFO > N, that's your sign to go check B, not to sit there refreshing like it's gonna change. 🙈

👑 Author 👑

ok so this was a whole group project and honestly iconic of them:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

🫶 Contributors: 🫶

Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

🦋 Author 🦋

Generated automatically by Doxygen for LAPACK from the source code.

like… no human wrote this bit, a robot did, and she ate. 🤖✨

and that's a wrap on complexHEeigen(3), bestie!! 🌸 this lil' page came from LAPACK Version 3.11.0, dated Sun Nov 27 2022 — so go forth, check your INFO, respect the positive-definiteness of B, and may all your eigenvectors converge on the first try. mwah. 💖🎀🦋

📦 where this page comes from

debian bookworm: liblapack-doc 3.11.0-2 · BSD-3-Clause
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

complexHEeigen(3)

✨ NAME ✨

🌸 SYNOPSIS 🌸

💫 Functions

🦋 Detailed Description 🦋

🎀 Function Documentation 🎀

💖 subroutine cheev 💖

Purpose:

Parameters

Author

🌈 subroutine cheev_2stage 🌈

Purpose:

Parameters

Author

Further Details:

🌸 cheevd — the main character 🎀

💖 Purpose

🎀 Parameters

🦋 Author

✨ Further Details:

🌈 Contributors:

👑 cheevd_2stage — the sequel, the two-stage era 🎀

💖 Purpose

🎀 Parameters

👑 Author

🌈 Further Details:

🎀 Contributors:

🦋 Further Details:

💖 subroutine cheevr 💖

🌸 Purpose:

✨ Parameters

M

W

Z

LDZ

ISUPPZ

WORK

LWORK

RWORK

LRWORK

IWORK

LIWORK

INFO

Author

Contributors:

🌈 subroutine cheevr_2stage 🌈

Purpose:

Parameters

JOBZ

RANGE

UPLO

N

A

LDA

VL

VL

VU

IL

IU

ABSTOL

M

W

Z

LDZ

ISUPPZ

WORK

LWORK

RWORK

LRWORK

IWORK

LIWORK

INFO

Author 🫶

Contributors 💜

Further Details 🌈

subroutine cheevx 👑

Purpose ✨

Parameters

JOBZ

RANGE

🌸 `cheevd` — the main character 🎀

👑 `cheevd_2stage` — the sequel, the two-stage era 🎀

💖 subroutine `cheevr` 💖

`M`

`W`

`Z`

`LDZ`

`ISUPPZ`

`WORK`

`LWORK`

`RWORK`

`LRWORK`

`IWORK`

`LIWORK`

`INFO`

🌈 subroutine `cheevr_2stage` 🌈

`JOBZ`

`RANGE`

`UPLO`

`N`

`A`

`LDA`

`VL`

`VL`

`VU`

`IL`

`IU`

`ABSTOL`

`M`

`W`

`Z`

`LDZ`

`ISUPPZ`

`WORK`

`LWORK`

`RWORK`

`LRWORK`

`IWORK`

`LIWORK`

`INFO`

`subroutine cheevx` 👑

`JOBZ`

`RANGE`

`UPLO`

`N`

`A`

`cheevx_2stage` 🌈

`UPLO`

`N`

`A`

`LDA`

`B`

`LDB`

`W`

`WORK`

`LWORK`

`RWORK`

`INFO`

`ITYPE`

`JOBZ`

`UPLO`

`N`

`A`

`LDA`

`B`

`LDB`

`W`

`WORK`

`LWORK`

`RWORK`

`LRWORK`