hbevd(3)

📦

version 3.12.1 · 9 versions

3.12.1 · arch rolling (latest)
3.12.0 · opensuse-leap 16.0
3.12.1 · ubuntu stonking
3.12.1 · ubuntu questing
3.12.0 · ubuntu noble
3.12.0 · ubuntu noble
3.12.0 · centos-stream 10, fedora 43, fedora 44
3.12.1 · ubuntu resolute
3.12.1 · debian trixie

🦋 hbevd — eig, divide and conquer 🦋

okay so this is hbevd(3) from the Library Functions Manual, and bestie, it's a whole family of subroutines — hb and sb, real and complex, all doing the eigen-thing the fancy divide-and-conquer way. Buckle up 💖

✨ NAME ✨

hbevd — {hb,sb}evd: eig, divide and conquer

✨ SYNOPSIS ✨

🎀 Functions

subroutine chbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) CHBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices
subroutine dsbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) DSBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices
subroutine ssbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) SSBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices
subroutine zhbevd (jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) ZHBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices

🌸 Detailed Description 🌸

(no body here, it's literally just vibes and a heading — the real tea is in Function Documentation below 👇)

👑 Function Documentation 👑

🌈 `subroutine chbevd (character jobz, character uplo, integer n, integer kd, complex, dimension( ldab, * ) ab, integer ldab, real, dimension( * ) w, complex, dimension( ldz, * ) z, integer ldz, complex, dimension( * ) work, integer lwork, real, dimension( * ) rwork, integer lrwork, integer, dimension( * ) iwork, integer liwork, integer info)`

CHBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices

Purpose:

!>
!> CHBEVD computes all the eigenvalues and, optionally, eigenvectors of
!> a complex Hermitian band matrix A.  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.
!>

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

KD

!>          KD is INTEGER
!>          The number of superdiagonals of the matrix A if UPLO = 'U',
!>          or the number of subdiagonals if UPLO = 'L'.  KD >= 0.
!>

AB

!>          AB is COMPLEX array, dimension (LDAB, N)
!>          On entry, the upper or lower triangle of the Hermitian band
!>          matrix A, stored in the first KD+1 rows of the array.  The
!>          j-th column of A is stored in the j-th column of the array AB
!>          as follows:
!>          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
!>          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
!>
!>          On exit, AB is overwritten by values generated during the
!>          reduction to tridiagonal form.  If UPLO = 'U', the first
!>          superdiagonal and the diagonal of the tridiagonal matrix T
!>          are returned in rows KD and KD+1 of AB, and if UPLO = 'L',
!>          the diagonal and first subdiagonal of T are returned in the
!>          first two rows of AB.
!>

LDAB

!>          LDAB is INTEGER
!>          The leading dimension of the array AB.  LDAB >= KD + 1.
!>

W

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

Z

!>          Z is COMPLEX array, dimension (LDZ, N)
!>          If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
!>          eigenvectors of the matrix A, with the i-th column of Z
!>          holding the eigenvector associated with W(i).
!>          If JOBZ = 'N', then Z is not referenced.
!>

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 dimension 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.
!>          If JOBZ = 'V' and N > 1, LWORK must be at least 2*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 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 array IWORK.
!>          If JOBZ = 'N' or 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, 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.

Definition at line 207 of file chbevd.f.

🌈 `subroutine dsbevd (character jobz, character uplo, integer n, integer kd, double precision, dimension( ldab, * ) ab, integer ldab, double precision, dimension( * ) w, double precision, dimension( ldz, * ) z, integer ldz, double precision, dimension( * ) work, integer lwork, integer, dimension( * ) iwork, integer liwork, integer info)`

DSBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices

Purpose:

!>
!> DSBEVD computes all the eigenvalues and, optionally, eigenvectors of
!> a real symmetric band matrix A. 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.
!>

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

KD

!>          KD is INTEGER
!>          The number of superdiagonals of the matrix A if UPLO = 'U',
!>          or the number of subdiagonals if UPLO = 'L'.  KD >= 0.
!>

AB

!>          AB is DOUBLE PRECISION array, dimension (LDAB, N)
!>          On entry, the upper or lower triangle of the symmetric band
!>          matrix A, stored in the first KD+1 rows of the array.  The
!>          j-th column of A is stored in the j-th column of the array AB
!>          as follows:
!>          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
!>          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
!>
!>          On exit, AB is overwritten by values generated during the
!>          reduction to tridiagonal form.  If UPLO = 'U', the first
!>          superdiagonal and the diagonal of the tridiagonal matrix T
!>          are returned in rows KD and KD+1 of AB, and if UPLO = 'L',
!>          the diagonal and first subdiagonal of T are returned in the
!>          first two rows of AB.
!>

LDAB

!>          LDAB is INTEGER
!>          The leading dimension of the array AB.  LDAB >= KD + 1.
!>

W

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

Z

!>          Z is DOUBLE PRECISION array, dimension (LDZ, N)
!>          If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
!>          eigenvectors of the matrix A, with the i-th column of Z
!>          holding the eigenvector associated with W(i).
!>          If JOBZ = 'N', then Z is not referenced.
!>

LDZ

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

WORK

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

LWORK — …
LWORK — okay so this is an INTEGER, and it’s literally the dimension of the WORK array. Bestie, the rules are: IF N <= 1, LWORK must be at least 1. If JOBZ = 'N' and N > 2, LWORK must be at least 2*N. If JOBZ = 'V' and N > 2, LWORK must be at least ( 1 + 5*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. iykyk ✨

IWORK — IWORK is an INTEGER array, dimension (MAX(1,LIWORK)). On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. slay 💅
LIWORK — LIWORK is an INTEGER. It’s the dimension of the array IWORK. If JOBZ = 'N' or N <= 1, LIWORK must be at least 1. If JOBZ = 'V' and N > 2, 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. no cap 🦋

INFO — INFO is an 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. periodt 💀

👑 Author 👑

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

Definition at line 185 of file dsbevd.f.

🌟 subroutine `ssbevd` 🌟

subroutine ssbevd (character jobz, character uplo, integer n, integer kd,
    real, dimension( ldab, * ) ab, integer ldab, real, dimension( * ) w,
    real, dimension( ldz, * ) z, integer ldz, real, dimension( * ) work,
    integer lwork, integer, dimension( * ) iwork, integer liwork, integer
    info)

SSBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices. it’s giving main character energy 👑

💖 Purpose 💖

SSBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. obsessed ✨

🎀 Parameters 🎀

JOBZ — JOBZ is CHARACTER*1. = 'N': Compute eigenvalues only; = 'V': Compute eigenvalues and eigenvectors. simple as that 💅
UPLO — UPLO is CHARACTER*1. = 'U': Upper triangle of A is stored; = 'L': Lower triangle of A is stored. choose your fighter 🦋
N — N is INTEGER. The order of the matrix A. N >= 0. math girlie 🎀
KD — KD is INTEGER. The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. lowkey important ✨
AB — AB is REAL array, dimension (LDAB, N). On entry, the upper or lower triangle of the symmetric band matrix A, stored in the first KD+1 rows of the array. The j-th column of A is stored in the j-th column of the array AB as follows:

if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

On exit, AB is overwritten by values generated during the reduction to tridiagonal form. If UPLO = 'U', the first superdiagonal and the diagonal of the tridiagonal matrix T are returned in rows KD and KD+1 of AB, and if UPLO = 'L', the diagonal and first subdiagonal of T are returned in the first two rows of AB. the way that works 😭

LDAB — LDAB is INTEGER. The leading dimension of the array AB. LDAB >= KD + 1. respect the dimension 💅
W — W is REAL array, dimension (N). If INFO = 0, the eigenvalues in ascending order. in order, bestie ✨
Z — Z is REAL array, dimension (LDZ, N). If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal eigenvectors of the matrix A, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced. not me ignoring Z when JOBZ is N 🙈
LDZ — LDZ is INTEGER. The leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', LDZ >= max(1,N). rules are rules 🎀
WORK — WORK is REAL array, dimension (LWORK). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. workspace icon 💅
LWORK — LWORK is INTEGER. The dimension of the array WORK. IF N <= 1, LWORK must be at least 1. If JOBZ = 'N' and N > 2, LWORK must be at least 2*N. If JOBZ = 'V' and N > 2, LWORK must be at least ( 1 + 5*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. workspace query slay 🌈

IWORK — IWORK is INTEGER array, dimension (MAX(1,LIWORK)). On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. int array realness ✨
LIWORK — LIWORK is INTEGER. The dimension of the array IWORK. If JOBZ = 'N' or N <= 1, LIWORK must be at least 1. If JOBZ = 'V' and N > 2, 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. same vibe, different array 🦋

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. convergence drama 💀

👑 Author 👑

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

Definition at line 185 of file ssbevd.f.

🌈 subroutine `zhbevd` 🌈

subroutine zhbevd (character jobz, character uplo, integer n, integer kd,
    complex*16, dimension( ldab, * ) ab, integer ldab, double precision,
    dimension( * ) w, complex*16, dimension( ldz, * ) z, integer ldz,
    complex*16, dimension( * ) work, integer lwork, double precision,
    dimension( * ) rwork, integer lrwork, integer, dimension( * ) iwork,
    integer liwork, integer info)

ZHBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices. complex Hermitian band matrix? she ate 👑

💖 Purpose 💖

ZHBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. divide and conquer queen ✨

🎀 Parameters 🎀

JOBZ — JOBZ is CHARACTER*1. = 'N': Compute eigenvalues only; = 'V': Compute eigenvalues and eigenvectors. pick your path 💅
UPLO — UPLO is CHARACTER*1. = 'U': Upper triangle of A is stored; = 'L': Lower triangle of A is stored. upper or lower, no in-between 🦋
N — N is INTEGER. The order of the matrix A. N >= 0. size queen 🎀
KD — KD is INTEGER. The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. diagonal count, bestie ✨
AB — AB is COMPLEX*16 array, dimension (LDAB, N). On entry, the upper or lower triangle of the Hermitian band matrix A, stored in the first KD+1 rows of the array. The j-th column of A is stored in the j-th column of the array AB as follows:

if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

LDAB — LDAB is INTEGER. The leading dimension of the array AB. LDAB >= KD + 1. leading dimension realness 💅
W — W is DOUBLE PRECISION array, dimension (N). If INFO = 0, the eigenvalues in ascending order. ascending, always ✨
Z — Z is COMPLEX*16 array, dimension (LDZ, N). If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal eigenvectors of the matrix A, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced. Z said not today when JOBZ is N 🙈
LDZ — LDZ is INTEGER. The leading dimension of the array Z. LDZ >= 1, and if JOBZ = 'V', LDZ >= max(1,N). dimension check, slay 🎀
WORK — WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. complex workspace vibes 💅
LWORK —
LWORK — LWORK is INTEGER, and it’s the dimension of the array WORK, bestie. The requirements are giving very specific:
- If N <= 1, LWORK must be at least 1.
- If JOBZ = 'N' and N > 1, LWORK must be at least N.
- If JOBZ = 'V' and N > 1, LWORK must be at least 2*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. Very “ask first, allocate later” of it ✨
RWORK — RWORK is DOUBLE PRECISION array, dimension (LRWORK). On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK. Bestie said “report back with the optimal number” 💅
LRWORK — LRWORK is INTEGER, and it’s the dimension of array RWORK. The rules are:
- 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 vibe, different array 🫶
IWORK — IWORK is INTEGER array, dimension (MAX(1,LIWORK)). On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. It’s the integer-array bestie, keeping receipts 📝
LIWORK — LIWORK is INTEGER, and it’s the dimension of array IWORK. The checklist:
- If JOBZ = 'N' or 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. Query mode stays iconic 💖
INFO — INFO is INTEGER. Here’s the status tea:
- = 0: successful exit. We love a clean win 🌈
- < 0: if INFO = -i, the i-th argument had an illegal value. Not the argument doing illegal stuff 😭
- > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. Convergence said “not today,” and that’s a real warning, bestie 💀

✨ AUTHOR ✨

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

Definition at line 207 of file zhbevd.f.

🦋 AUTHOR (DOXYGEN EDITION) 🦋

Generated automatically by Doxygen for LAPACK from the source code. Doxygen really said “I’ll document it so you don’t have to” ✨

Sign-off time, bestie: this page is from LAPACK Version 3.12.0, and the page name is hbevd(3). The footer date wasn’t included in the footer text provided, so I’m not inventing one — no fake calendar energy here, periodt 💜 🎀

📦 where this page comes from

arch rolling: lapack-doc 3.12.1-2 · custom
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms

hbevd(3)

🦋 hbevd — eig, divide and conquer 🦋

✨ NAME ✨

✨ SYNOPSIS ✨

🎀 Functions

🌸 Detailed Description 🌸

👑 Function Documentation 👑

Purpose:

Parameters 🫶

Author 💜

Purpose:

Parameters 🫶

👑 Author 👑

🌟 subroutine ssbevd 🌟

💖 Purpose 💖

🎀 Parameters 🎀

👑 Author 👑

🌈 subroutine zhbevd 🌈

💖 Purpose 💖

🎀 Parameters 🎀

✨ AUTHOR ✨

🦋 AUTHOR (DOXYGEN EDITION) 🦋

🌟 subroutine `ssbevd` 🌟

🌈 subroutine `zhbevd` 🌈