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

💖 hegv(3) — the `{he,sy}gv` girlies: eig + QR iteration 💖

okay so first things first, bestie: this page lives in the Library Functions Manual, and it's the whole ✨generalized symmetric / Hermitian eigenproblem✨ corner of the world. Two families, four subroutines, one vibe. Let's go 🎀

🌸 NAME 🌸

hegv — literally {he,sy}gv: eig, QR iteration. that's the whole name, no cap.

✨ SYNOPSIS ✨

🫶 Functions

subroutine chegv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork,
    rwork, info)
    CHEGV

subroutine dsygv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork,
    info)
    DSYGV

subroutine ssygv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork,
    info)
    SSYGV

subroutine zhegv (itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork,
    rwork, info)
    ZHEGV

like, four icons in one synopsis block. we love a collective 💅

🌈 Detailed Description 🌈

the original page just drops the heading here and moves right along — no extra prose, minimal queen behaviour 👑. so we go straight to the good stuff.

🔥 Function Documentation 🔥

💜 subroutine `chegv` 💜

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)

CHEGV — the complex one, she's the main character here 🦋

🎀 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 yeah — you hand her a Hermitian A and a Hermitian and positive-definite B, and she gives you back eigenvalues, plus eigenvectors if you ask nicely. the "positive definite" thing on B is not a suggestion btw, it's the vibe check she will absolutely enforce 💀

🧚 Parameters 🧚

ITYPE — integer, and it's literally just "which of the three problems are we solving today":

!> 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 — CHARACTER*1, the "do I want the eigenvectors or not" switch:

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

UPLO — CHARACTER*1, tells her which triangle of A and B you actually filled in:

!> UPLO is 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. and N >= 0, obviously, don't be weird about it 🙈

!> N is INTEGER !> The order of the matrices A and B. N >= 0. !>

A — COMPLEX array, dimension (LDA, N). on entry it's your Hermitian matrix A, and she only reads the triangle you promised her via UPLO:

!> A is COMPLEX array, dimension (LDA, N) !> On entry, the Hermitian matrix A. If UPLO = 'U', the !> leading N-by-N upper triangular part of A contains the !> upper triangular part of the matrix A. If UPLO = 'L', !> the leading N-by-N lower triangular part of A contains !> the lower triangular part of the matrix A. !> !> On exit, if JOBZ = 'V', then if INFO = 0, A contains the !> matrix Z of eigenvectors. The eigenvectors are normalized !> as follows: !> if ITYPE = 1 or 2, Z**H*B*Z = I; !> if ITYPE = 3, Z**H*inv(B)*Z = I. !> If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') !> or the lower triangle (if UPLO='L') of A, including the !> diagonal, is destroyed. !>

⚠️ note the last bit — if you pick JOBZ = 'N', that triangle of A including the diagonal gets yeeted. destroyed. gone. so don't come crying if you needed it, bestie 😭

LDA — integer, the leading dimension of A, and LDA >= max(1,N):

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

B — COMPLEX array, dimension (LDB, N). on entry, the Hermitian positive-definite B (again, just the triangle UPLO says):

!> B is COMPLEX array, dimension (LDB, N) !> On entry, the Hermitian positive definite matrix B. !> If UPLO = 'U', the leading N-by-N upper triangular part of B !> contains the upper triangular part of the matrix B. !> If UPLO = 'L', the leading N-by-N lower triangular part of B !> contains the lower triangular part of the matrix B. !> !> On exit, if INFO <= N, the part of B containing the matrix is !> overwritten by the triangular factor U or L from the Cholesky !> factorization B = U**H*U or B = L*L**H. !>

so B gets rewritten with her Cholesky factor once she's done with it — that's just how she rolls 🍓

LDB — integer, the leading dimension of B, LDB >= max(1,N):

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

W — REAL array, dimension (N). if INFO = 0, these are your eigenvalues, in ascending order — she sorts, you don't have to 💅

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

WORK — COMPLEX array, dimension (MAX(1,LWORK)). and on the way out, if INFO = 0, WORK(1) tells you the optimal LWORK:

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

LWORK — integer, length of WORK. minimum is LWORK >= max(1,2*N-1), but for that optimal-efficiency glow-up you want LWORK >= (NB+1)*N, where NB is the blocksize for CHETRD returned by ILAENV:

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

👑 and yes — LWORK = -1 is the secret "just tell me how much space you want" handshake. she computes the optimal size, drops it in WORK(1), and XERBLA stays quiet about it, fr fr.

RWORK — REAL array, dimension (max(1, 3*N-2)):

!> RWORK is REAL array, dimension (max(1, 3*N-2)) !>

INFO — integer, the receipts. read them carefully:

!> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: CPOTRF or CHEEV returned an error code: !> <= N: if INFO = i, CHEEV failed to converge; !> i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero; !> > N: if INFO = N + i, for 1 <= i <= N, then the leading !> principal minor of order i of B is not positive. !> The factorization of B could not be completed and !> no eigenvalues or eigenvectors were computed. !>

so: 0 = slay, negative = you passed a bad argument, and > N means the leading principal minor of order i of B is not positive — the factorization couldn't finish and literally nothing got computed. that's the "you said B was positive definite and you lied" error 😭

💫 Author 💫

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

Definition at line 179 of file chegv.f.

⭐ subroutine `dsygv` ⭐

subroutine dsygv (integer itype, character jobz, character uplo, integer n,
    double precision, dimension( lda, * ) a, integer lda, double precision,
    dimension( ldb, * ) b, integer ldb, double precision, dimension( * ) w,
    double precision, dimension( * ) work, integer lwork, integer info)

DSYGV — same energy, but the real symmetric edition. double precision, no complex, no RWORK. she travels light 🦋

🌸 Purpose 🌸

!> !> DSYGV computes all the eigenvalues, and optionally, the eigenvectors !> of a real generalized symmetric-definite eigenproblem, of the form !> A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. !> Here A and B are assumed to be symmetric and B is also !> positive definite. !>

same three problem flavours, except A and B are symmetric here instead of Hermitian, and B still has to be positive definite or she's not doing it 🎀

🌈 Parameters 🌈

ITYPE — integer, pick your problem:

!> 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 — CHARACTER*1:

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

UPLO — CHARACTER*1:

!> UPLO is CHARACTER*1 !> = 'U': Upper triangles of A and B are stored; !> = 'L': Lower triangles of A and B are stored. !>

N — integer, order of A and B, and N >= 0:

!> N is INTEGER !> The order of the matrices A and B. N >= 0. !>

A — DOUBLE PRECISION array, dimension (LDA, N). on entry, the symmetric matrix A (just the UPLO triangle):

!> A is DOUBLE PRECISION array, dimension (LDA, N) !> On entry, the symmetric matrix A. If UPLO = 'U', the !> leading N-by-N upper triangular part of A contains the !> upper triangular part of the matrix A. If UPLO = 'L', !> the leading N-by-N lower triangular part of A contains !> the lower triangular part of the matrix A. !> !> On exit, if JOBZ = 'V', then if INFO = 0, A contains the !> matrix Z of eigenvectors. The eigenvectors are normalized !> as follows: !> if ITYPE = 1 or 2, Z**T*B*Z = I; !> if ITYPE = 3, Z**T*inv(B)*Z = I. !> If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') !> or the lower triangle (if UPLO='L') of A, including the !> diagonal, is destroyed. !>

⚠️ same warning as her sister: JOBZ = 'N' means that triangle of A, diagonal included, is destroyed on exit. no refunds 💀

LDA — integer, leading dimension of A, LDA >= max(1,N):

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

B — DOUBLE PRECISION array, dimension (LDB, N). on entry, the symmetric positive-definite B:

!> B is DOUBLE PRECISION array, dimension (LDB, N) !> On entry, the symmetric positive definite matrix B. !> If UPLO = 'U', the leading N-by-N upper triangular part of B !> contains the upper triangular part of the matrix B. !> If UPLO = 'L', the leading N-by-N lower triangular part of B !> contains the lower triangular part of the matrix B. !> !> On exit, if INFO <= N, the part of B containing the matrix is !> overwritten by the triangular factor U or L from the Cholesky !> factorization B = U**T*U or B = L*L**T. !>

note the transpose, not conjugate-transpose — she's real, that's the whole point 🍓

LDB — integer, leading dimension of B, LDB >= max(1,N):

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

W — DOUBLE PRECISION array, dimension (N). if INFO = 0, eigenvalues in ascending order:

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

WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). on exit, if INFO = 0, WORK(1) returns the optimal LWORK:

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

LWORK — integer. minimum LWORK >= max(1,3*N-1) (yeah, she needs more scratch space than CHEGV), and for optimal efficiency LWORK >= (NB+2)*N, where NB is the blocksize for DSYTRD returned by ILAENV:

!> LWORK is INTEGER !> The length of the array WORK. LWORK >= max(1,3*N-1). !> For optimal efficiency, LWORK >= (NB+2)*N, !> where NB is the blocksize for DSYTRD 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. !>

👑 same LWORK = -1 workspace-query trick: optimal size lands in WORK(1), and XERBLA says nothing about LWORK. iykyk 💅

INFO — integer, the whole receipts section:

!> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: DPOTRF or DSYEV returned an error code: !> <= N: if INFO = i, DSYEV failed to converge; !> i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero; !> > N: if INFO = N + i, for 1 <= i <= N, then the leading !> principal minor of order i of B is not positive. !> The factorization of B could not be completed and !> no eigenvalues or eigenvectors were computed. !>

0 = we ate. negative = bad argument, here's which one. > N = leading principal minor of order i of B isn't positive, factorization bailed, and literally zero eigenvalues/eigenvectors came out. tragic 😭

🫶 Author 🫶

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

Definition at line 173 of file dsygv.f.

💅 `subroutine ssygv` — real symmetric generalized eigenproblem, but make it fashion

subroutine ssygv (integer itype, character jobz, character uplo, integer n,
    real, dimension( lda, * ) a, integer lda, real, dimension( ldb, * ) b,
    integer ldb, real, dimension( * ) w, real, dimension( * ) work, integer
    lwork, integer info)

SSYGV

🎀 Purpose

okay so SSYGV computes all the eigenvalues, and optionally the eigenvectors, of a real generalized symmetric-definite eigenproblem, and it comes in three iconic forms:

A*x=(lambda)*B*x
A*Bx=(lambda)*x
B*A*x=(lambda)*x

Here A and B are assumed to be symmetric, and B is also positive definite. periodt. 💖

✨ Parameters

ITYPE — ITYPE is INTEGER. It 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.
UPLO — UPLO is CHARACTER*1.
- = 'U': Upper triangles of A and B are stored;
- = 'L': Lower triangles of A and B are stored.
N — N is INTEGER. The order of the matrices A and B. N >= 0.
A — A is REAL array, dimension (LDA, N).
- On entry, it's the symmetric matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A.
- On exit, if JOBZ = 'V', then if INFO = 0, A contains the matrix Z of eigenvectors. The eigenvectors are normalized as follows: if ITYPE = 1 or 2, Z**T*B*Z = I; if ITYPE = 3, Z**T*inv(B)*Z = I.
- If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') or the lower triangle (if UPLO='L') of A, including the diagonal, is destroyed. 😭 that's the tea.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,N).
B — B is REAL array, dimension (LDB, N).
- On entry, it's the symmetric positive definite matrix B. If UPLO = 'U', the leading N-by-N upper triangular part of B contains the upper triangular part of the matrix B. If UPLO = 'L', the leading N-by-N lower triangular part of B contains the lower triangular part of the matrix B.
- On exit, if INFO <= N, the part of B containing the matrix is overwritten by the triangular factor U or L from the Cholesky factorization B = U**T*U or B = L*L**T.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
W — W is REAL array, dimension (N). If INFO = 0, the eigenvalues in ascending order. 👑
WORK — WORK is REAL array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — LWORK is INTEGER. The length of the array WORK. LWORK >= max(1,3*N-1). For optimal efficiency, LWORK >= (NB+2)*N, where NB is the blocksize for SSYTRD 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. iykyk 🫶
INFO — INFO is INTEGER.
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
- > 0: SPOTRF or SSYEV returned an error code:
  - <= N: if INFO = i, SSYEV failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero;
  - > N: if INFO = N + i, for 1 <= i <= N, then the leading principal minor of order i of B is not positive. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed.

👑 Author

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

Definition at line 173 of file ssygv.f.

🦋 `subroutine zhegv` — complex Hermitian generalized eigenproblem, serving looks

subroutine zhegv (integer itype, character jobz, character uplo, integer n,
    complex*16, dimension( lda, * ) a, integer lda, complex*16, dimension(
    ldb, * ) b, integer ldb, double precision, dimension( * ) w, complex*16,
    dimension( * ) work, integer lwork, double precision, dimension( * )
    rwork, integer info)

ZHEGV

🎯 Purpose

bestie, ZHEGV computes all the eigenvalues, and optionally the eigenvectors, of a complex generalized Hermitian-definite eigenproblem, in one of these three forms:

A*x=(lambda)*B*x
A*Bx=(lambda)*x
B*A*x=(lambda)*x

Here A and B are assumed to be Hermitian, and B is also positive definite. no cap. 💜

🌸 Parameters

ITYPE — ITYPE is INTEGER. It 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.
UPLO — UPLO is CHARACTER*1.
- = 'U': Upper triangles of A and B are stored;
- = 'L': Lower triangles of A and B are stored.
N — N is INTEGER. The order of the matrices A and B. N >= 0.
A — A is COMPLEX*16 array, dimension (LDA, N).
- On entry, it's the Hermitian matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A.
- On exit, if JOBZ = 'V', then if INFO = 0, A contains the matrix Z of eigenvectors. The eigenvectors are normalized as follows: if ITYPE = 1 or 2, Z**H*B*Z = I; if ITYPE = 3, Z**H*inv(B)*Z = I.
- If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') or the lower triangle (if UPLO='L') of A, including the diagonal, is destroyed. yep, she's gone 💀
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,N).
B — B is COMPLEX*16 array, dimension (LDB, N).
- On entry, it's the Hermitian positive definite matrix B. If UPLO = 'U', the leading N-by-N upper triangular part of B contains the upper triangular part of the matrix B. If UPLO = 'L', the leading N-by-N lower triangular part of B contains the lower triangular part of the matrix B.
- On exit, if INFO <= N, the part of B containing the matrix is overwritten by the triangular factor U or L from the Cholesky factorization B = U**H*U or B = L*L**H.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
W — W is DOUBLE PRECISION array, dimension (N). If INFO = 0, the eigenvalues in ascending order.
WORK — WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — LWORK is INTEGER. The length of the array WORK. LWORK >= max(1,2*N-1). For optimal efficiency, LWORK >= (NB+1)*N, where NB is the blocksize for ZHETRD 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 DOUBLE PRECISION array, dimension (max(1, 3*N-2)).
INFO — INFO is INTEGER.
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
- > 0: ZPOTRF or ZHEEV returned an error code:
  - <= N: if INFO = i, ZHEEV failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero;
  - > N: if INFO = N + i, for 1 <= i <= N, then the leading principal minor of order i of B is not positive. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed.

👑 Author

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

Definition at line 179 of file zhegv.f.

🫶 Author

Generated automatically by Doxygen for LAPACK from the source code.

And that's the footer tea, bestie: source/version says LAPACK Version 3.12.0, and this page is hegv(3) — the footer line shown doesn't give a separate date, so that's all the metadata we've got. bye bestie 💖✨

📦 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

hegv(3)

💖 hegv(3) — the {he,sy}gv girlies: eig + QR iteration 💖

🌸 NAME 🌸

✨ SYNOPSIS ✨

🫶 Functions

🌈 Detailed Description 🌈

🔥 Function Documentation 🔥

💜 subroutine chegv 💜

🎀 Purpose 🎀

🧚 Parameters 🧚

💫 Author 💫

⭐ subroutine dsygv ⭐

🌸 Purpose 🌸

🌈 Parameters 🌈

🫶 Author 🫶

💅 subroutine ssygv — real symmetric generalized eigenproblem, but make it fashion

🎀 Purpose

✨ Parameters

👑 Author

🦋 subroutine zhegv — complex Hermitian generalized eigenproblem, serving looks

🎯 Purpose

🌸 Parameters

👑 Author

🫶 Author

💖 hegv(3) — the `{he,sy}gv` girlies: eig + QR iteration 💖

💜 subroutine `chegv` 💜

⭐ subroutine `dsygv` ⭐

💅 `subroutine ssygv` — real symmetric generalized eigenproblem, but make it fashion

🦋 `subroutine zhegv` — complex Hermitian generalized eigenproblem, serving looks