SRC/zheevd.f(3)

💜 SRC/zheevd.f 💜

okay so this is a page from the Library Functions Manual — it's the LAPACK docs for zheevd, and bestie, it's giving main character energy in the eigenvalue world 🎀

---

✨ NAME ✨

SRC/zheevd.f — no cap, that's literally the whole name, it's a Fortran source file and it's iconic for it 💅

---

🌸 SYNOPSIS 🌸

🦋 Functions/Subroutines

subroutine zheevd (jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork,
    iwork, liwork, info)

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

🎀 Function/Subroutine Documentation

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

💖 Purpose:

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

like, it gets all the eigenvalues (not just some, she's thorough 👑), and if you want eigenvectors too she'll hand those over as well — via a divide and conquer algorithm, which is lowkey the cool way to do it.

---

🌈 Parameters 🌈

• JOBZ — a CHARACTER*1, the "what do you actually want from me" switch 💅

!>          JOBZ is CHARACTER*1
!>          = 'N':  Compute eigenvalues only;
!>          = 'V':  Compute eigenvalues and eigenvectors.
!>

• UPLO — a CHARACTER*1, tells her which triangle of A you actually filled in 🫶

!>          UPLO is CHARACTER*1
!>          = 'U':  Upper triangle of A is stored;
!>          = 'L':  Lower triangle of A is stored.
!>

• N — an INTEGER, the order of the matrix A. Constraint: N >= 0 ⭐

!>          N is INTEGER
!>          The order of the matrix A.  N >= 0.
!>

• A — COMPLEX*16 array, dimension (LDA, N). the moment ✨

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

real talk: if JOBZ = 'N', part of A gets destroyed on exit — the lower triangle (if UPLO='L') or the upper triangle (if UPLO='U'), diagonal included. so don't come crying to her if you needed that data, she warned you 😭

• LDA — an INTEGER, the leading dimension of the array A. Constraint: LDA >= max(1,N) 🦋

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

• W — DOUBLE PRECISION array, dimension (N). If INFO = 0, this is where the eigenvalues land, in ascending order 👑

!>          W is DOUBLE PRECISION array, dimension (N)
!>          If INFO = 0, the eigenvalues in ascending order.
!>

• WORK — COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK 🌸

!>          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
!>

• LWORK — an INTEGER, the length of the array WORK. bestie, the minimums are specific:

!>          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 mode: pass LWORK = -1 and she won't actually do the math — she just crunches the optimal sizes of WORK, RWORK and IWORK, drops them into the first entries of those arrays, and XERBLA stays completely quiet, no error message about LWORK or LRWORK or LIWORK. very demure, very mindful 💅

• RWORK — DOUBLE PRECISION array, dimension (MAX(1,LRWORK)). On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK 🎀

!>          RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))
!>          On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
!>

• LRWORK — an INTEGER, the dimension of the array RWORK:

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

same workspace-query deal as above — LRWORK = -1 means sizes only, no math, no XERBLA complaints ✨

• IWORK — INTEGER array, dimension (MAX(1,LIWORK)). On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK 💜

!>          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
!>          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
!>

• LIWORK — an INTEGER, the dimension of the array IWORK:

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

and yes, LIWORK = -1 is the third flavour of the exact same workspace query — sizes only, zero XERBLA drama 🌈

• INFO — an INTEGER, the vibe report card at the end 📋

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

so like, 0 = slay, we did it. negative = you passed her a bad argument (the i-th one, specifically 🙈). positive = the algorithm didn't converge, and the exact meaning depends on JOBZ, so read the block above carefully, it's literally spelled out 💀

---

👑 Author 👑

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

🧚 Further Details:

Modified description of INFO. Sven, 16 Feb 05. (shoutout Sven, he tweaked the INFO description 🫶)

🍓 Contributors:

Jeff Rutter, Computer Science Division, University of California at Berkeley, USA ✨

Definition at line 196 of file zheevd.f. 📍

---

⭐ Author ⭐

Generated automatically by Doxygen for LAPACK from the source code. (the robot did the typing, she just did the math 💅)

---

LAPACK · Version 3.12.0 · SRC/zheevd.f(3) — okay that's the whole page bestie, go forth and diagonalize, iykyk 🦋💖🎀