/home/abui...RC/chegv.f(3)

💅 NAME

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/chegv.f — bestie, this is the whole source file path, and yes it's a whole journey. Consider it the origin story ✨ (the manual is the Library Functions Manual, since you asked 🫶).

---

🦋 SYNOPSIS

Functions/Subroutines

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

CHEGV, that's the name, no cap 👑

🌸 Function/Subroutine Documentation

✨ 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 again, iconic 💖

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 — it's computing eigenvalues (and eigenvectors if you want them, no pressure) for a complex generalized Hermitian-definite eigenproblem. Three flavors of the same vibe, listed above. A and B are Hermitian, and B is also positive definite, that part matters a lot 🔥

---

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

An INTEGER that's literally just "which of the three problems are we doing". Pick your fighter: 1, 2, or 3 💅

JOBZ

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

A CHARACTER*1. 'N' = eigenvalues only, minimal effort queen energy. 'V' = eigenvalues and eigenvectors, main character energy 👑

UPLO

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

A CHARACTER*1. 'U' = the upper triangles of A and B are what's stored, 'L' = the lower triangles. Pick one, bestie, the whole routine is built around it 🦋

N

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

INTEGER, the order of A and B. It's gotta be N >= 0. Simple as that ✨

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

COMPLEX array, dimension (LDA, N). On entry it's the Hermitian matrix A — with UPLO = 'U' the leading N-by-N upper triangular part of A holds the upper triangular part of the matrix A, and with 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, normalized like so: if ITYPE = 1 or 2, Z**H*B*Z = I; if ITYPE = 3, Z**H*inv(B)*Z = I.

🫶 Heads up bestie: 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. She ate and left no crumbs 💀

LDA

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

INTEGER, the leading dimension of A. Gotta be LDA >= max(1,N) ⭐

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

COMPLEX array, dimension (LDB, N). On entry, the Hermitian positive definite matrix B — with UPLO = 'U' the leading N-by-N upper triangular part of B holds the upper triangular part of the matrix B, and with 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 gets a whole new look 💅

LDB

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

INTEGER, the leading dimension of B. Gotta be LDB >= max(1,N) ⭐

W

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

REAL array, dimension (N). If INFO = 0, these are the eigenvalues, in ascending order — sorted, tidy, organized, we love to see it 🌸

WORK

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

COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK — she's telling you how much room she really wanted 🎀

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

INTEGER, the length of the WORK array. Minimum is LWORK >= max(1,2*N-1). For optimal efficiency though, you want LWORK >= (NB+1)*N, where NB is the blocksize for CHETRD returned by ILAENV — glow-up math 🔥

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. It's giving "just asking, not committing" 🙈

RWORK

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

REAL array, dimension (max(1, 3*N-2)). That's it. That's her 💜

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

INTEGER, the vibe report:

• = 0: successful exit 🎉
• < 0: if INFO = -i, the i-th argument had an illegal value — check your args bestie 😭
• > 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 💀

---

👑 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 179 of file chegv.f.

---

🌈 Author (again, but the meta one)

Generated automatically by Doxygen for LAPACK from the source code. She was made by a robot, and she's still slaying 🤖💅

---

LAPACK · Version 3.12.0 · /home/abui...RC/chegv.f(3) — and that's the whole page bestie, mwah 🫶💖✨