CGEGV(3)

🦋 CGEGV(3) — like, the deprecated generalized eigenvalue queen 🦋

okay bestie so this page lives in the Library Functions Manual, and it's all about that one file: /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/DEPRECATED/cgegv.f — yes the path literally has DEPRECATED in it, we'll get to that 🙈

---

✨ SYNOPSIS ✨

Functions/Subroutines

subroutine CGEGV (jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl,
    ldvl, vr, ldvr, work, lwork, rwork, info)

CGEGV computes the eigenvalues and, optionally, the left and/or right eigenvectors of a complex matrix pair (A,B). that's the whole vibe 💅

---

🎀 Function/Subroutine Documentation 🎀

subroutine CGEGV (character jobvl, character jobvr, integer n, complex, dimension( lda, * ) a, integer lda, complex, dimension( ldb, * ) b, integer ldb, complex, dimension( * ) alpha, complex, dimension( * ) beta, complex, dimension( ldvl, * ) vl, integer ldvl, complex, dimension( ldvr, * ) vr, integer ldvr, complex, dimension( * ) work, integer lwork, real, dimension( * ) rwork, integer info)

CGEGV computes the eigenvalues and, optionally, the left and/or right eigenvectors of a complex matrix pair (A,B). no cap 🫶

Purpose

!> !> This routine is deprecated and has been replaced by routine CGGEV. !> !> CGEGV computes the eigenvalues and, optionally, the left and/or right !> eigenvectors of a complex matrix pair (A,B). !> Given two square matrices A and B, !> the generalized nonsymmetric eigenvalue problem (GNEP) is to find the !> eigenvalues lambda and corresponding (non-zero) eigenvectors x such !> that !> A*x = lambda*B*x. !> !> An alternate form is to find the eigenvalues mu and corresponding !> eigenvectors y such that !> mu*A*y = B*y. !> !> These two forms are equivalent with mu = 1/lambda and x = y if !> neither lambda nor mu is zero. In order to deal with the case that !> lambda or mu is zero or small, two values alpha and beta are returned !> for each eigenvalue, such that lambda = alpha/beta and !> mu = beta/alpha. !> !> The vectors x and y in the above equations are right eigenvectors of !> the matrix pair (A,B). Vectors u and v satisfying !> u**H*A = lambda*u**H*B or mu*v**H*A = v**H*B !> are left eigenvectors of (A,B). !> !> Note: this routine performs on A and B !>

(the source literally cuts off mid-sentence on that last note — not me, I would NEVER 😭 that's just how it's written in cgegv.f)

so basically: deprecated, replaced by CGGEV, and it's giving "find lambda and x where A*x = lambda*B*x" energy ✨ and the alternate form is mu*A*y = B*y, and the two are equivalent when mu = 1/lambda and x = y and neither is zero. because lambda or mu can be zero or tiny, you get two values alpha and beta per eigenvalue so that lambda = alpha/beta and mu = beta/alpha — clever little icon 👑

---

💖 Parameters 💖

JOBVL

!> JOBVL is CHARACTER*1 !> = 'N': do not compute the left generalized eigenvectors; !> = 'V': compute the left generalized eigenvectors (returned !> in VL). !>

JOBVR

!> JOBVR is CHARACTER*1 !> = 'N': do not compute the right generalized eigenvectors; !> = 'V': compute the right generalized eigenvectors (returned !> in VR). !>

N

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

A

!> A is COMPLEX array, dimension (LDA, N) !> On entry, the matrix A. !> If JOBVL = 'V' or JOBVR = 'V', then on exit A !> contains the Schur form of A from the generalized Schur !> factorization of the pair (A,B) after balancing. If no !> eigenvectors were computed, then only the diagonal elements !> of the Schur form will be correct. See CGGHRD and CHGEQZ !> for details. !>

like, heads up: A gets overwritten on exit, so don't come crying to me when your original matrix is gone 🙈

LDA

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

B

!> B is COMPLEX array, dimension (LDB, N) !> On entry, the matrix B. !> If JOBVL = 'V' or JOBVR = 'V', then on exit B contains the !> upper triangular matrix obtained from B in the generalized !> Schur factorization of the pair (A,B) after balancing. !> If no eigenvectors were computed, then only the diagonal !> elements of B will be correct. See CGGHRD and CHGEQZ for !> details. !>

same deal for B, bestie — she gets rewritten too 💀

LDB

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

ALPHA

!> ALPHA is COMPLEX array, dimension (N) !> The complex scalars alpha that define the eigenvalues of !> GNEP. !>

BETA

!> BETA is COMPLEX array, dimension (N) !> The complex scalars beta that define the eigenvalues of GNEP. !> !> Together, the quantities alpha = ALPHA(j) and beta = BETA(j) !> represent the j-th eigenvalue of the matrix pair (A,B), in !> one of the forms lambda = alpha/beta or mu = beta/alpha. !> Since either lambda or mu may overflow, they should not, !> in general, be computed. !>

⚠️ real talk: lambda and mu can overflow, so like… don't actually divide them out. just keep alpha and beta around, iykyk 🍓

VL

!> VL is COMPLEX array, dimension (LDVL,N) !> If JOBVL = 'V', the left eigenvectors u(j) are stored !> in the columns of VL, in the same order as their eigenvalues. !> Each eigenvector is scaled so that its largest component has !> abs(real part) + abs(imag. part) = 1, except for eigenvectors !> corresponding to an eigenvalue with alpha = beta = 0, which !> are set to zero. !> Not referenced if JOBVL = 'N'. !>

LDVL

!> LDVL is INTEGER !> The leading dimension of the matrix VL. LDVL >= 1, and !> if JOBVL = 'V', LDVL >= N. !>

VR

!> VR is COMPLEX array, dimension (LDVR,N) !> If JOBVR = 'V', the right eigenvectors x(j) are stored !> in the columns of VR, in the same order as their eigenvalues. !> Each eigenvector is scaled so that its largest component has !> abs(real part) + abs(imag. part) = 1, except for eigenvectors !> corresponding to an eigenvalue with alpha = beta = 0, which !> are set to zero. !> Not referenced if JOBVR = 'N'. !>

LDVR

!> LDVR is INTEGER !> The leading dimension of the matrix VR. LDVR >= 1, and !> if JOBVR = 'V', LDVR >= 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. LWORK >= max(1,2*N). !> For good performance, LWORK must generally be larger. !> To compute the optimal value of LWORK, call ILAENV to get !> blocksizes (for CGEQRF, CUNMQR, and CUNGQR.) Then compute: !> NB -- MAX of the blocksizes for CGEQRF, CUNMQR, and CUNGQR; !> The optimal LWORK is MAX( 2*N, N*(NB+1) ). !> !> 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. !>

so LWORK >= max(1,2*N) is the bare minimum, but for good performance it "must generally be larger" — she's high-maintenance and we respect it 💅 and LWORK = -1 is the little shortcut: workspace query mode, she only computes the optimal size, drops it in WORK(1), and XERBLA stays quiet about it 🎀

RWORK

!> RWORK is REAL array, dimension (8*N) !>

INFO

!> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> =1,...,N: !> The QZ iteration failed. No eigenvectors have been !> calculated, but ALPHA(j) and BETA(j) should be !> correct for j=INFO+1,...,N. !> > N: errors that usually indicate LAPACK problems: !> =N+1: error return from CGGBAL !> =N+2: error return from CGEQRF !> =N+3: error return from CUNMQR !> =N+4: error return from CUNGQR !> =N+5: error return from CGGHRD !> =N+6: error return from CHGEQZ (other than failed !> iteration) !> =N+7: error return from CTGEVC !> =N+8: error return from CGGBAK (computing VL) !> =N+9: error return from CGGBAK (computing VR) !> =N+10: error return from CLASCL (various calls) !>

the whole error decoder ring, bestie 🔥 = 0 slay, < 0 you passed a bad argument, =1,...,N the QZ iteration failed (no eigenvectors, but ALPHA(j) and BETA(j) should still be correct for j=INFO+1,...,N), and > N means "usually LAPACK problems" — the full =N+1 through =N+10 list above is your receipts 💀

---

👑 Author 👑

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

---

🌸 Further Details: 🌸

Balancing

!> !> Balancing !> --------- !> !> This driver calls CGGBAL to both permute and scale rows and columns !> of A and B. The permutations PL and PR are chosen so that PL*A*PR !> and PL*B*R will be upper triangular except for the diagonal blocks !> A(i:j,i:j) and B(i:j,i:j), with i and j as close together as !> possible. The diagonal scaling matrices DL and DR are chosen so !> that the pair DL*PL*A*PR*DR, DL*PL*B*PR*DR have elements close to !> one (except for the elements that start out zero.) !> !> After the eigenvalues and eigenvectors of the balanced matrices !> have been computed, CGGBAK transforms the eigenvectors back to what !> they would have been (in perfect arithmetic) if they had not been !> balanced. !>

(yeah, that's PL*B*R right there in the original — not PL*B*PR. I'm not touching it, not my typo, not my problem 🫶)

Contents of A and B on Exit

!> Contents of A and B on Exit !> -------- -- - --- - -- ---- !> !> If any eigenvectors are computed (either JOBVL='V' or JOBVR='V' or !> both), then on exit the arrays A and B will contain the complex Schur !> form[*] of the versions of A and B. If no eigenvectors !> are computed, then only the diagonal blocks will be correct. !> !> [*] In other words, upper triangular form. !>

and the footnote you needed: [*] = "in other words, upper triangular form" ⭐

---

🧚 Definition 🧚

Definition at line 280 of file cgegv.f. 📍

Author

Generated automatically by Doxygen for LAPACK from the source code.

---

and that's the whole page, bestie 💜 no notes, only alpha/beta ✨

— signed, sealed, delivered by LAPACK, Version 3.12.0, from /home/abui...TED/cgegv.f(3). mwah 🫶🎀