doubleGEeigen(3)

📦

version 3.11.0 · 2 versions

3.11.0 · debian bookworm (latest)
3.10.0 · ubuntu jammy

💖 doubleGEeigen(3) 💖

🌸 NAME 🌸

doubleGEeigen — double 💅

okay so bestie, this is the LAPACK manual page for the doubleGEeigen crew. The NAME literally says doubleGEeigen - double. That's the whole name. No cap. 💖

📜 SYNOPSIS 📜

✨ Functions ✨

dgees — computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. 💅

       subroutine dgees (JOBVS, SORT, SELECT, N, A, LDA, SDIM, WR, WI, VS,
           LDVS, WORK, LWORK, BWORK, INFO)

dgeesx — computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. ✨

       subroutine dgeesx (JOBVS, SORT, SELECT, SENSE, N, A, LDA, SDIM, WR, WI,
           VS, LDVS, RCONDE, RCONDV, WORK, LWORK, IWORK, LIWORK, BWORK, INFO)

dgeev — computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices. 🦋

       subroutine dgeev (JOBVL, JOBVR, N, A, LDA, WR, WI, VL, LDVL, VR, LDVR,
           WORK, LWORK, INFO)

dgeevx — computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices. 🌸

       subroutine dgeevx (BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, WR, WI, VL,
           LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM, RCONDE, RCONDV, WORK, LWORK,
           IWORK, INFO)

dgges — computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. 💖

       subroutine dgges (JOBVSL, JOBVSR, SORT, SELCTG, N, A, LDA, B, LDB, SDIM,
           ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK, LWORK, BWORK,
           INFO)

dgges3 — computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices (blocked algorithm). 🔥

       subroutine dgges3 (JOBVSL, JOBVSR, SORT, SELCTG, N, A, LDA, B, LDB,
           SDIM, ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK, LWORK,
           BWORK, INFO)

dggesx — computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. 👑

       subroutine dggesx (JOBVSL, JOBVSR, SORT, SELCTG, SENSE, N, A, LDA, B,
           LDB, SDIM, ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, RCONDE,
           RCONDV, WORK, LWORK, IWORK, LIWORK, BWORK, INFO)

dggev — computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices. 💜

       subroutine dggev (JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, ALPHAI, BETA,
           VL, LDVL, VR, LDVR, WORK, LWORK, INFO)

dggev3 — computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices (blocked algorithm). ⭐

       subroutine dggev3 (JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, ALPHAI,
           BETA, VL, LDVL, VR, LDVR, WORK, LWORK, INFO)

dggevx — computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices. 🌈

       subroutine dggevx (BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, LDB,
           ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR, ILO, IHI, LSCALE, RSCALE,
           ABNRM, BBNRM, RCONDE, RCONDV, WORK, LWORK, IWORK, BWORK, INFO)

✨ Detailed Description ✨

This is the group of double eigenvalue driver functions for GE matrices. That's the vibe. 💅

📚 Function Documentation 📚

🦋 subroutine dgees 🦋

   subroutine dgees (character JOBVS, character SORT, external SELECT, integer
       N, double precision, dimension( lda, * ) A, integer LDA, integer SDIM,
       double precision, dimension( * ) WR, double precision, dimension( * )
       WI, double precision, dimension( ldvs, * ) VS, integer LDVS, double
       precision, dimension( * ) WORK, integer LWORK, logical, dimension( * )
       BWORK, integer INFO)

DGEES computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. 💖

✨ Purpose ✨

DGEES computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**T). slay. ✨

Optionally, it also orders the eigenvalues on the diagonal of the real Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. 💅

A matrix is in real Schur form if it is upper quasi-triangular with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the form

[  a  b  ]
[  c  a  ]

where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc). math bestie. 🧚

🎀 Parameters 🎀

JOBVS — is CHARACTER*1.
- = 'N': Schur vectors are not computed;
- = 'V': Schur vectors are computed. periodt. 💅
SORT — is CHARACTER*1. Specifies whether or not to order the eigenvalues on the diagonal of the Schur form.
- = 'N': Eigenvalues are not ordered;
- = 'S': Eigenvalues are ordered (see SELECT). ✨
SELECT — is a LOGICAL FUNCTION of two DOUBLE PRECISION arguments. SELECT must be declared EXTERNAL in the calling subroutine. If SORT = 'S', SELECT is used to select eigenvalues to sort to the top left of the Schur form. If SORT = 'N', SELECT is not referenced. An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if SELECT(WR(j),WI(j)) is true; i.e., if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. Note that a selected complex eigenvalue may no longer satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since ordering may change the value of complex eigenvalues (especially if the eigenvalue is ill-conditioned); in this case INFO is set to N+2 (see INFO below). 😭
N — is INTEGER. The order of the matrix A. N >= 0. 💖
A — is DOUBLE PRECISION array, dimension (LDA,N). On entry, the N-by-N matrix A. On exit, A has been overwritten by its real Schur form T. 🦋
LDA — is INTEGER. The leading dimension of the array A. LDA >= max(1,N). 🌸
SDIM — is INTEGER. If SORT = 'N', SDIM = 0. If SORT = 'S', SDIM = number of eigenvalues (after sorting) for which SELECT is true. (Complex conjugate pairs for which SELECT is true for either eigenvalue count as 2.) 💅
WR — is DOUBLE PRECISION array, dimension (N). ✨
WI — is DOUBLE PRECISION array, dimension (N). WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues in the same order that they appear on the diagonal of the output Schur form T. Complex conjugate pairs of eigenvalues will appear consecutively with the eigenvalue having the positive imaginary part first. 💜
VS — is DOUBLE PRECISION array, dimension (LDVS,N). If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur vectors. If JOBVS = 'N', VS is not referenced. 👑
LDVS — is INTEGER. The leading dimension of the array VS. LDVS >= 1; if JOBVS = 'V', LDVS >= N. 🌈
WORK — is DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) contains the optimal LWORK. ⭐
LWORK — is INTEGER. The dimension of the array WORK. LWORK >= max(1,3*N). For good performance, LWORK must generally be larger. 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. 🔥
BWORK — is LOGICAL array, dimension (N). Not referenced if SORT = 'N'. 🙈
INFO — is INTEGER.
- = 0: successful exit. 🎀
- < 0: if INFO = -i, the i-th argument had an illegal value. 💀
- > 0: if INFO = i, and i is
  - <= N: the QR algorithm failed to compute all the eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI contain those eigenvalues which have converged; if JOBVS = 'V', VS contains the matrix which reduces A to its partially converged Schur form.
  - = N+1: the eigenvalues could not be reordered because some eigenvalues were too close to separate (the problem is very ill-conditioned);
  - = N+2: after reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues in the Schur form no longer satisfy SELECT=.TRUE. This could also be caused by underflow due to scaling. 😭

👑 Author 👑

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

🦋 subroutine dgeesx 🦋

   subroutine dgeesx (character JOBVS, character SORT, external SELECT,
       character SENSE, integer N, double precision, dimension( lda, * ) A,
       integer LDA, integer SDIM, double precision, dimension( * ) WR, double
       precision, dimension( * ) WI, double precision, dimension( ldvs, * ) VS,
       integer LDVS, double precision RCONDE, double precision RCONDV, double
       precision, dimension( * ) WORK, integer LWORK, integer, dimension( * )
       IWORK, integer LIWORK, logical, dimension( * ) BWORK, integer INFO)

DGEESX computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. 💖

✨ Purpose ✨

DGEESX computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**T). iconic. ✨

Optionally, it also orders the eigenvalues on the diagonal of the real Schur form so that selected eigenvalues are at the top left; computes a reciprocal condition number for the average of the selected eigenvalues (RCONDE); and computes a reciprocal condition number for the right invariant subspace corresponding to the selected eigenvalues (RCONDV). The leading columns of Z form an orthonormal basis for this invariant subspace. 💅

For further explanation of the reciprocal condition numbers RCONDE and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where these quantities are called s and sep respectively). 📚

A real matrix is in real Schur form if it's upper quasi-triangular with 1-by-1 and 2-by-2 blocks. The 2-by-2 blocks get standardized into the shape

[  a  b  ]
[  c  a  ]

where b*c < 0. And the eigenvalues of a block like that? They're a +- sqrt(bc). Cute, right? 💅

✨ Parameters ✨

JOBVS — CHARACTER*1. Do we compute Schur vectors or nah?
- = 'N': Schur vectors are not computed;
- = 'V': Schur vectors are computed. 👑
SORT — CHARACTER*1. Tells us whether or not to order the eigenvalues on the diagonal of the Schur form.
- = 'N': eigenvalues are not ordered;
- = 'S': eigenvalues are ordered (see SELECT).
SELECT — a LOGICAL FUNCTION of two DOUBLE PRECISION arguments. Bestie, SELECT must be declared EXTERNAL in the calling subroutine, no cap.
- If SORT = 'S', SELECT is used to select eigenvalues to sort to the top left of the Schur form.
- If SORT = 'N', SELECT is not referenced (it's giving wallflower 🌸).
- An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if SELECT(WR(j),WI(j)) is true; i.e., if either one of a complex conjugate pair of eigenvalues is selected, then both are. Periodt, they're a package deal.
- Heads up though: a selected complex eigenvalue may no longer satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since ordering may change the value of complex eigenvalues (especially if the eigenvalue is ill-conditioned); in this case INFO may be set to N+3 (peep INFO below). 😭
SENSE — CHARACTER*1. Determines which reciprocal condition numbers get computed.
- = 'N': none are computed;
- = 'E': computed for average of selected eigenvalues only;
- = 'V': computed for selected right invariant subspace only;
- = 'B': computed for both.
- If SENSE = 'E', 'V' or 'B', then SORT must equal 'S'. That's the rule, fr fr.
N — INTEGER. The order of the matrix A. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA, N).
- On entry, the N-by-N matrix A.
- On exit, A is overwritten by its real Schur form T. Gone but iconic 💀
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,N).
SDIM — INTEGER.
- If SORT = 'N', SDIM = 0.
- If SORT = 'S', SDIM = number of eigenvalues (after sorting) for which SELECT is true. (Complex conjugate pairs for which SELECT is true for either eigenvalue count as 2. Yes, they count double. Slay.)
WR — DOUBLE PRECISION array, dimension (N).
WI — DOUBLE PRECISION array, dimension (N). WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues, in the same order that they appear on the diagonal of the output Schur form T. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. 💫
VS — DOUBLE PRECISION array, dimension (LDVS,N).
- If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur vectors.
- If JOBVS = 'N', VS is not referenced.
LDVS — INTEGER. The leading dimension of the array VS. LDVS >= 1, and if JOBVS = 'V', LDVS >= N.
RCONDE — DOUBLE PRECISION.
- If SENSE = 'E' or 'B', RCONDE contains the reciprocal condition number for the average of the selected eigenvalues.
- Not referenced if SENSE = 'N' or 'V'.
RCONDV — DOUBLE PRECISION.
- If SENSE = 'V' or 'B', RCONDV contains the reciprocal condition number for the selected right invariant subspace.
- Not referenced if SENSE = 'N' or 'E'.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)).
- On exit, if INFO = 0, WORK(1) returns the optimal LWORK. Bestie it's literally telling you what it wants 🥰
LWORK — INTEGER. The dimension of the array WORK. LWORK >= max(1,3*N).
- Also, if SENSE = 'E' or 'V' or 'B', LWORK >= N+2*SDIM*(N-SDIM), where SDIM is the number of selected eigenvalues computed by this routine. Note that N+2*SDIM*(N-SDIM) <= N+N*N/2. Note also that an error is only returned if LWORK < max(1,3*N), but if SENSE = 'E' or 'V' or 'B' this may not be large enough. 🙈
- For good performance, LWORK must generally be larger. Bigger is better, it's giving main character energy.
- If LWORK = -1, then a workspace query is assumed; the routine only calculates upper bounds on the optimal sizes of the arrays WORK and IWORK, returns these values as the first entries of the WORK and IWORK arrays, and no error messages related to LWORK or LIWORK are issued by XERBLA.
IWORK — INTEGER array, dimension (MAX(1,LIWORK)).
- On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
LIWORK — INTEGER. The dimension of the array IWORK. LIWORK >= 1; if SENSE = 'V' or 'B', LIWORK >= SDIM*(N-SDIM).
- Note that SDIM*(N-SDIM) <= N*N/4. Note also that an error is only returned if LIWORK < 1, but if SENSE = 'V' or 'B' this may not be large enough. 💀
- If LIWORK = -1, then a workspace query is assumed; the routine only calculates upper bounds on the optimal sizes of the arrays WORK and IWORK, returns these values as the first entries of the WORK and IWORK arrays, and no error messages related to LWORK or LIWORK are issued by XERBLA.
BWORK — LOGICAL array, dimension (N). Not referenced if SORT = 'N'.
INFO — INTEGER.
- = 0: successful exit ✨
- < 0: if INFO = -i, the i-th argument had an illegal value. Rude.
- > 0: if INFO = i, and i is
  - <= N: the QR algorithm failed to compute all the eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI contain those eigenvalues which have converged; if JOBVS = 'V', VS contains the transformation which reduces A to its partially converged Schur form.
  - = N+1: the eigenvalues could not be reordered because some eigenvalues were too close to separate (the problem is very ill-conditioned);
  - = N+2: after reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues in the Schur form no longer satisfy SELECT=.TRUE. This could also be caused by underflow due to scaling.

🎀 Author 🎀

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

💖 subroutine dgeev (character JOBVL, character JOBVR, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( * ) WORK, integer LWORK, integer INFO) 💖

DGEEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices. Yes bestie, optionally, we love options.

Purpose:

DGEEV computes, for an N-by-N real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.

The right eigenvector v(j) of A satisfies

A * v(j) = lambda(j) * v(j)

where lambda(j) is its eigenvalue.

The left eigenvector u(j) of A satisfies

u(j)**H * A = lambda(j) * u(j)**H

where u(j)**H denotes the conjugate-transpose of u(j).

The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real. Clean, normalized, demure. 🫶

Parameters

JOBVL — CHARACTER*1.
- = 'N': left eigenvectors of A are not computed;
- = 'V': left eigenvectors of A are computed.
JOBVR — CHARACTER*1.
- = 'N': right eigenvectors of A are not computed;
- = 'V': right eigenvectors of A are computed.
N — INTEGER. The order of the matrix A. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,N).
- On entry, the N-by-N matrix A.
- On exit, A has been overwritten. Rip to A, it served 💀
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,N).
WR — DOUBLE PRECISION array, dimension (N).
WI — DOUBLE PRECISION array, dimension (N). WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first. 🌈
VL — DOUBLE PRECISION array, dimension (LDVL,N).
- If JOBVL = 'V', the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues.
- If JOBVL = 'N', VL is not referenced.
- If the j-th eigenvalue is real, then u(j) = VL(:,j), the j-th column of VL.
- If the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and u(j+1) = VL(:,j) - i*VL(:,j+1). The way they pair up... obsessed. 🦋
LDVL — INTEGER. The leading dimension of the array VL. LDVL >= 1; if JOBVL = 'V', LDVL >= N.
VR
VR — DOUBLE PRECISION array, dimension (LDVR,N) — bestie this is where your right eigenvectors live if you asked for them. When JOBVR = 'V', the right eigenvectors v(j) get stacked one after another in the columns of VR, in the exact same order as their eigenvalues. When JOBVR = 'N', VR is not referenced (she's off duty, don't touch her 💅). If the j-th eigenvalue is real, then v(j) = VR(:,j) — literally just the j-th column of VR. And if the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and v(j+1) = VR(:,j) - i*VR(:,j+1) — iconic complex-pair behaviour, the two columns carry the real and imaginary parts together 🦋
LDVR — INTEGER — the leading dimension of the array VR. So like, LDVR >= 1; and if JOBVR = 'V', then LDVR >= N. No shortcuts, queen 👑
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)) — on exit, if INFO = 0, then WORK(1) returns the optimal LWORK. She's the workspace bestie, she holds everything 🌸
LWORK — INTEGER — the dimension of the array WORK. Here's the tea: LWORK >= max(1,3*N), and if JOBVL = 'V' or JOBVR = 'V', then LWORK >= 4*N. And for good performance, LWORK must generally be larger — like, do the most for yourself, ok? ✨

Also, 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. Sneaky little trick but it's legal, no cap 💀

INFO — INTEGER — the receipts 📋
- = 0: successful exit 🎉
- < 0: if INFO = -i, the i-th argument had an illegal value. Not her fault, it's yours 🙈
- > 0: if INFO = i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors have been computed; elements i+1:N of WR and WI contain eigenvalues which have converged. RIP to the ones that didn't make it 😭

💖 Author 💖

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

🦋 subroutine `dgeevx` 🦋

subroutine dgeevx (character BALANC, character JOBVL, character JOBVR,
    character SENSE, integer N, double precision, dimension( lda, * ) A,
    integer LDA, double precision, dimension( * ) WR, double precision,
    dimension( * ) WI, double precision, dimension( ldvl, * ) VL, integer
    LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, integer
    ILO, integer IHI, double precision, dimension( * ) SCALE, double
    precision ABNRM, double precision, dimension( * ) RCONDE, double
    precision, dimension( * ) RCONDV, double precision, dimension( * ) WORK,
    integer LWORK, integer, dimension( * ) IWORK, integer INFO)

DGEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices — she's the deluxe version of the vibe, periodt 👑

✨ Purpose: ✨

DGEEVX computes for an N-by-N real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. Lowkey her whole personality is eigenvalues, highkey she does more 💅

Optionally also, she computes a balancing transformation to improve the conditioning of the eigenvalues and eigenvectors (ILO, IHI, SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues (RCONDE), and reciprocal condition numbers for the right eigenvectors (RCONDV). She's doing the MOST, and we love her for it 🌈

The right eigenvector v(j) of A satisfies:

A * v(j) = lambda(j) * v(j)

where lambda(j) is its eigenvalue. And the left eigenvector u(j) of A satisfies:

u(j)**H * A = lambda(j) * u(j)**H

where u(j)**H denotes the conjugate-transpose of u(j). Left and right, she's ambidextrous fr fr 🫶

The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real. Clean, tidy, iconic ⭐

Now, balancing a matrix — okay so this is a whole thing, let me explain 🎀 — means permuting the rows and columns to make it more nearly upper triangular, and applying a diagonal similarity transformation D * A * D**(-1), where D is a diagonal matrix, to make its rows and columns closer in norm and the condition numbers of its eigenvalues and eigenvectors smaller. The computed reciprocal condition numbers correspond to the balanced matrix. Permuting rows and columns will not change the condition numbers (in exact arithmetic) but diagonal scaling will. For further explanation of balancing, see section 4.10.2 of the LAPACK Users' Guide. Read it bestie, it's giving homework but it's giving ✨knowledge✨

👑 Parameters 👑

BALANC — CHARACTER*1 — indicates how the input matrix should be diagonally scaled and/or permuted to improve the conditioning of its eigenvalues.
- = 'N': Do not diagonally scale or permute; (chill mode, leave her alone)
- = 'P': Perform permutations to make the matrix more nearly upper triangular. Do not diagonally scale;
- = 'S': Diagonally scale the matrix, i.e. replace A by D*A*D**(-1), where D is a diagonal matrix chosen to make the rows and columns of A more equal in norm. Do not permute;
- = 'B': Both diagonally scale and permute A. Go big or go home 💅

Computed reciprocal condition numbers will be for the matrix after balancing and/or permuting. Permuting does not change condition numbers (in exact arithmetic), but balancing does. Important distinction, don't forget it 🧚

JOBVL — CHARACTER*1 —
- = 'N': left eigenvectors of A are not computed;
- = 'V': left eigenvectors of A are computed.

If SENSE = 'E' or 'B', then JOBVL must = 'V'. Non-negotiable bestie, the rules are the rules 🔥

JOBVR — CHARACTER*1 —
- = 'N': right eigenvectors of A are not computed;
- = 'V': right eigenvectors of A are computed.

If SENSE = 'E' or 'B', then JOBVR must = 'V'. Same energy, same rule ✨

SENSE — CHARACTER*1 — determines which reciprocal condition numbers are computed.
- = 'N': None are computed;
- = 'E': Computed for eigenvalues only;
- = 'V': Computed for right eigenvectors only;
- = 'B': Computed for eigenvalues and right eigenvectors.

If SENSE = 'E' or 'B', both left and right eigenvectors must also be computed (JOBVL = 'V' and JOBVR = 'V'). Package deal, no à la carte here 🎀

N — INTEGER — the order of the matrix A. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,N) — on entry, the N-by-N matrix A. On exit, A has been overwritten. If JOBVL = 'V' or JOBVR = 'V', then A contains the real Schur form of the balanced version of the input matrix A. She changed her whole look, and honestly? Ate 🔥
LDA — INTEGER — the leading dimension of the array A. LDA >= max(1,N).
WR — DOUBLE PRECISION array, dimension (N)
WI — DOUBLE PRECISION array, dimension (N) — so WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues will appear consecutively with the eigenvalue having the positive imaginary part first. Order matters, bestie 💜
VL — DOUBLE PRECISION array, dimension (LDVL,N) — if JOBVL = 'V', the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If JOBVL = 'N', VL is not referenced. If the j-th eigenvalue is real, then u(j) = VL(:,j), the j-th column of VL. If the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and u(j+1) = VL(:,j) - i*VL(:,j+1). Same pattern as the right side, she keeps it consistent 💅
LDVL — INTEGER — the leading dimension of the array VL. LDVL >= 1; if JOBVL = 'V', then LDVL >= N.
VR — DOUBLE PRECISION array, dimension (LDVR,N) — if JOBVR = 'V', the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If JOBVR = 'N', VR is not referenced. If the j-th eigenvalue is real, then v(j) = VR(:,j), the j-th column of VR. If the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and v(j+1) = VR(:,j) - i*VR(:,j+1). Mirror mirror on the wall 🪞
LDVR — INTEGER — the leading dimension of the array VR. LDVR >= 1, and if JOBVR = 'V', then LDVR >= N.
ILO — INTEGER
IHI — INTEGER — okay so ILO and IHI are integer values determined when A was balanced. The balanced A(i,j) = 0 if I > J and J = 1,...,ILO-1 or I = IHI+1,...,N. She leaves little zeros behind like breadcrumbs 🍓
SCALE — DOUBLE PRECISION array, dimension (N) — details of the permutations and scaling factors applied when balancing A. If P(j) is the index of the row and column interchanged with row and column j, and D(j) is the scaling factor applied to row and column j, then:

SCALE(J) = P(J),    for J = 1,...,ILO-1
         = D(J),    for J = ILO,...,IHI
         = P(J)     for J = IHI+1,...,N.

The order in which the interchanges are made is N to IHI+1, then 1 to ILO-1. Note the order, bestie, it's lowkey important 🙈

ABNRM — DOUBLE PRECISION — the one-norm of the balanced matrix (the maximum of the sum of absolute values of elements of any column).
RCONDE — DOUBLE PRECISION array, dimension (N) — RCONDE(j) is the reciprocal condition number of the j-th eigenvalue.
RCONDV — DOUBLE PRECISION array, dimension (N) — RCONDV(j) is the reciprocal condition number of the j-th right eigenvector.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)) — on exit, if INFO = 0, then WORK(1) returns the optimal LWORK. Same deal as before, she's the workspace 💖
LWORK — INTEGER — the dimension of the array WORK. If SENSE = 'N' or 'E', then LWORK >= max(1,2*N), and if JOBVL = 'V' or JOBVR = 'V', then LWORK >= 3*N. If SENSE = 'V' or 'B', then LWORK >= N*(N+6). For good performance, LWORK must generally be larger. Give her room to breathe, she deserves it 🌸

okay so if LWORK = -1, that's the workspace-query vibe: the routine only calculates the optimal size of the WORK array, returns that value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 💅 no notes, no yelling.

IWORK — IWORK is INTEGER array, dimension (2*N-2). If SENSE = 'N' or 'E', it's just not referenced. 🙈
INFO — INFO is INTEGER:
- = 0: successful exit ✨
- < 0: if INFO = -i, the i-th argument had an illegal value 💀
- > 0: if INFO = i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors or condition numbers have been computed; elements 1:ILO-1 and i+1:N of WR and WI contain eigenvalues which have converged.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

subroutine `dgges`

subroutine dgges (character JOBVSL, character JOBVSR, character SORT,
    external SELCTG, integer N, double precision, dimension( lda, * ) A,
    integer LDA, double precision, dimension( ldb, * ) B, integer LDB,
    integer SDIM, double precision, dimension( * ) ALPHAR, double precision,
    dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double
    precision, dimension( ldvsl, * ) VSL, integer LDVSL, double precision,
    dimension( ldvsr, * ) VSR, integer LDVSR, double precision, dimension( *
    ) WORK, integer LWORK, logical, dimension( * ) BWORK, integer INFO)

DGGES computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices. 👑

Purpose

DGGES computes, for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), and optionally the left and/or right matrices of Schur vectors (VSL and VSR). Bestie, that gives you the generalized Schur factorization:

         (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )

Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). 🦋

(If you only need the generalized eigenvalues, use the driver DGGEV instead, which is faster. Not me giving you the shortcut — but yes, do that. 🏃‍♀️)

A generalized eigenvalue for a pair of matrices (A,B) is a scalar w, or a ratio alpha/beta = w, such that A - w*B is singular. It's usually represented as the pair (alpha,beta), because there's a reasonable interpretation for beta=0 or both being zero. 🌈

A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. The 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S get 'standardized' by making the corresponding elements of T have the form:

        [  a  0  ]
        [  0  b  ]

and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues. 😌 iconic behavior, honestly.

Parameters

JOBVSL — JOBVSL is CHARACTER*1
- = 'N': do not compute the left Schur vectors;
- = 'V': compute the left Schur vectors.
JOBVSR — JOBVSR is CHARACTER*1
- = 'N': do not compute the right Schur vectors;
- = 'V': compute the right Schur vectors.
SORT — SORT is CHARACTER*1. Specifies whether or not to order the eigenvalues on the diagonal of the generalized Schur form.
- = 'N': Eigenvalues are not ordered;
- = 'S': Eigenvalues are ordered (see SELCTG);
SELCTG — SELCTG is a LOGICAL FUNCTION of three DOUBLE PRECISION arguments. SELCTG must be declared EXTERNAL in the calling subroutine. If SORT = 'N', SELCTG is not referenced. If SORT = 'S', SELCTG is used to select eigenvalues to sort to the top left of the Schur form. An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. 👯

Note that in the ill-conditioned case, a selected complex eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) = .TRUE. after ordering. INFO is to be set to N+2 in this case. 😭

N — N is INTEGER. The order of the matrices A, B, VSL, and VSR. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA, N). On entry, the first of the pair of matrices. On exit, A has been overwritten by its generalized Schur form S. 💫
LDA — LDA is INTEGER. The leading dimension of A. LDA >= max(1,N).
B — B is DOUBLE PRECISION array, dimension (LDB, N). On entry, the second of the pair of matrices. On exit, B has been overwritten by its generalized Schur form T. 💫
LDB — LDB is INTEGER. The leading dimension of B. LDB >= max(1,N).
SDIM — SDIM is INTEGER. If SORT = 'N', SDIM = 0. If SORT = 'S', SDIM = number of eigenvalues (after sorting) for which SELCTG is true. (Complex conjugate pairs for which SELCTG is true for either eigenvalue count as 2.) ✌️
ALPHAR — ALPHAR is DOUBLE PRECISION array, dimension (N)
ALPHAI — ALPHAI is DOUBLE PRECISION array, dimension (N)
BETA — BETA is DOUBLE PRECISION array, dimension (N). On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will be the generalized eigenvalues. ALPHAR(j) + ALPHAI(j)*i, and BETA(j), j=1,...,N are the diagonals of the complex Schur form (S,T) that would result if the 2-by-2 diagonal blocks of the real Schur form of (A,B) were further reduced to triangular form using 2-by-2 complex unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is real; if positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) negative. 🎀

Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) may easily over- or underflow, and BETA(j) may even be zero. So like… the user should avoid naively computing the ratio. fr fr. However, ALPHAR and ALPHAI will be always less than and usually comparable with norm(A) in magnitude, and BETA always less than and usually comparable with norm(B).

VSL — VSL is DOUBLE PRECISION array, dimension (LDVSL,N). If JOBVSL = 'V', VSL will contain the left Schur vectors. Not referenced if JOBVSL = 'N'.
LDVSL — LDVSL is INTEGER. The leading dimension of the matrix VSL. LDVSL >=1, and if JOBVSL = 'V', LDVSL >= N.
VSR — VSR is DOUBLE PRECISION array, dimension (LDVSR,N). If JOBVSR = 'V', VSR will contain the right Schur vectors. Not referenced if JOBVSR = 'N'.
LDVSR — LDVSR is INTEGER. The leading dimension of the matrix VSR. LDVSR >= 1, and if JOBVSR = 'V', LDVSR >= N.
WORK — WORK is DOUBLE PRECISION 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 = 0, LWORK >= 1, else LWORK >= 8*N+16. For good performance, LWORK must generally be larger.

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.

BWORK — BWORK is LOGICAL array, dimension (N). Not referenced if SORT = '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. (A,B) are not in Schur form, but ALPHAR(j), ALPHAI(j), and BETA(j) should be correct for j=INFO+1,...,N.
- > N:
  - =N+1: other than QZ iteration failed in DHGEQZ.
  - =N+2: after reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues in the Generalized Schur form no longer satisfy SELCTG=.TRUE. This could also be caused due to scaling.
  - =N+3: reordering failed in DTGSEN.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

subroutine `dgges3`

subroutine dgges3 (character JOBVSL, character JOBVSR, character SORT,
    external SELCTG, integer N, double precision, dimension( lda, * ) A,
    integer LDA, double precision, dimension( ldb, * ) B, integer LDB,
    integer SDIM, double precision, dimension( * ) ALPHAR, double precision,
    dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double
    precision, dimension( ldvsl, * ) VSL, integer LDVSL, double precision,
    dimension( ldvsr, * ) VSR, integer LDVSR, double precision, dimension( *
    ) WORK, integer LWORK, logical, dimension( * ) BWORK, integer INFO)

DGGES3 computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices (blocked algorithm). same energy, but blocked. ✨

Purpose

DGGES3 computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization

         (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )

Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). ✨

(If only the generalized eigenvalues are needed, use the driver DGGEV instead, which is faster.)

A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), because there's a reasonable interpretation for beta=0 or for both being zero. 💅

A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. The 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S will be 'standardized' by making the corresponding elements of T have the form:

[  a  0  ]
[  0  b  ]

and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues. 🦋

🎀 Parameters 🎀

JOBVSL — it's a CHARACTER*1, bestie. = 'N': do not compute the left Schur vectors. = 'V': compute the left Schur vectors. That's the whole vibe check. 💖
JOBVSR — also CHARACTER*1. = 'N': do not compute the right Schur vectors. = 'V': compute the right Schur vectors. Same energy, other side. ✨
SORT — CHARACTER*1. This one decides whether or not to order the eigenvalues on the diagonal of the generalized Schur form. = 'N': eigenvalues are not ordered. = 'S': eigenvalues are ordered (see SELCTG). 👑
SELCTG — SELCTG is a LOGICAL FUNCTION of three DOUBLE PRECISION arguments. SELCTG must be declared EXTERNAL in the calling subroutine — no cap, don't skip this. If SORT = 'N', then SELCTG is not referenced at all. If SORT = 'S', then SELCTG is used to select eigenvalues to sort to the top left of the Schur form. An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either one of a complex conjugate pair of eigenvalues is selected, then both complex eigenvalues are selected. 🫶

⚠️ heads up: in the ill-conditioned case, a selected complex eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j), BETA(j)) = .TRUE. after ordering. In that case INFO is to be set to N+2.

N — INTEGER. The order of the matrices A, B, VSL, and VSR. Constraint: N >= 0. 💜
A — DOUBLE PRECISION array, dimension (LDA, N). On entry, the first of the pair of matrices. On exit, A has been overwritten by its generalized Schur form S. (Gone, replaced, glow-up complete. ✨)
LDA — INTEGER. The leading dimension of A. LDA >= max(1,N).
B — DOUBLE PRECISION array, dimension (LDB, N). On entry, the second of the pair of matrices. On exit, B has been overwritten by its generalized Schur form T. 💫
LDB — INTEGER. The leading dimension of B. LDB >= max(1,N).
SDIM — INTEGER. If SORT = 'N', then SDIM = 0. If SORT = 'S', then SDIM = the number of eigenvalues (after sorting) for which SELCTG is true. (Complex conjugate pairs for which SELCTG is true for either eigenvalue count as 2.) 🍓
ALPHAR — DOUBLE PRECISION array, dimension (N). 🌸
ALPHAI — DOUBLE PRECISION array, dimension (N). 🌸
BETA — DOUBLE PRECISION array, dimension (N). On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will be the generalized eigenvalues. ALPHAR(j) + ALPHAI(j)*i, and BETA(j),j=1,...,N are the diagonals of the complex Schur form (S,T) that would result if the 2-by-2 diagonal blocks of the real Schur form of (A,B) were further reduced to triangular form using 2-by-2 complex unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is real; if positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) negative.

⚠️ note, bestie: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) may easily over- or underflow, and BETA(j) may even be zero. So please avoid naively computing the ratio — that's a trap, fr fr. ALPHAR and ALPHAI will always be less than and usually comparable with norm(A) in magnitude, and BETA always less than and usually comparable with norm(B).

VSL — DOUBLE PRECISION array, dimension (LDVSL,N). If JOBVSL = 'V', VSL will contain the left Schur vectors. Not referenced if JOBVSL = 'N'. 🎀
LDVSL — INTEGER. The leading dimension of the matrix VSL. LDVSL >=1, and if JOBVSL = 'V', LDVSL >= N.
VSR — DOUBLE PRECISION array, dimension (LDVSR,N). If JOBVSR = 'V', VSR will contain the right Schur vectors. Not referenced if JOBVSR = 'N'. 🎀
LDVSR — INTEGER. The leading dimension of the matrix VSR. LDVSR >= 1, and if JOBVSR = 'V', LDVSR >= N.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. 🔥
LWORK — INTEGER. The dimension of the array WORK. 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. Sneaky but valid. 😌
BWORK — LOGICAL array, dimension (N). Not referenced if SORT = 'N'.
INFO — INTEGER. The receipts: 🧾
- = 0: successful exit. slay.
- < 0: if INFO = -i, the i-th argument had an illegal value.
- = 1,...,N: the QZ iteration failed. (A,B) are not in Schur form, but ALPHAR(j), ALPHAI(j), and BETA(j) should be correct for j=INFO+1,...,N.
- > N:
  - =N+1: other than QZ iteration failed in DLAQZ0.
  - =N+2: after reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues in the Generalized Schur form no longer satisfy SELCTG=.TRUE. This could also be caused due to scaling.
  - =N+3: reordering failed in DTGSEN.

👑 Author 👑

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

🦋 subroutine dggesx (character JOBVSL, character JOBVSR, character SORT, external SELCTG, character SENSE, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, integer SDIM, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( ldvsl, * ) VSL, integer LDVSL, double precision, dimension( ldvsr, * ) VSR, integer LDVSR, double precision, dimension( 2 ) RCONDE, double precision, dimension( 2 ) RCONDV, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, logical, dimension( * ) BWORK, integer INFO) 🦋

DGGESX computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices

💖 Purpose 💖

DGGESX computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the real Schur form (S,T), and, optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization

(A,B) = ( (VSL) S (VSR)**T, (VSL) T (VSR)**T )

Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T; computes a reciprocal condition number for the average of the selected eigenvalues (RCONDE); and computes a reciprocal condition number for the right and left deflating subspaces corresponding to the selected eigenvalues (RCONDV). The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). ✨

A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there's a reasonable interpretation for beta=0 or for both being zero. 💅

[  a  0  ]
[  0  b  ]

and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues. 🦋

🎀 Parameters 🎀

JOBVSL — CHARACTER*1. = 'N': do not compute the left Schur vectors. = 'V': compute the left Schur vectors. 💖
JOBVSR — CHARACTER*1. = 'N': do not compute the right Schur vectors. = 'V': compute the right Schur vectors. ✨
SORT —
SORT — CHARACTER*1. Tells the routine whether or not it should reorder the eigenvalues sitting on the diagonal of the generalized Schur form. Options are:
- 'N': nope, eigenvalues are not ordered.
- 'S': yep, eigenvalues are ordered (peep SELCTG for the deets).
SELCTG — a LOGICAL FUNCTION that takes three DOUBLE PRECISION arguments. You must declare it EXTERNAL in the subroutine that's calling this. If SORT = 'N', SELCTG isn't even looked at. If SORT = 'S', it's the little judge that picks which eigenvalues get sorted up to the top left of the Schur form. An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected when SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true — meaning if either one of a complex conjugate pair gets selected, then both complex eigenvalues get selected, no splitting them up. 💅

Heads up bestie: a selected complex eigenvalue might not satisfy SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) = .TRUE. anymore after ordering, because ordering can literally change the value of complex eigenvalues (especially if the eigenvalue is ill-conditioned). When that happens, INFO gets set to N+3. Not a vibe. 😭

SENSE — CHARACTER*1. Decides which reciprocal condition numbers get computed:
- 'N': none, we're not doing that today.
- 'E': computed for the average of selected eigenvalues only.
- 'V': computed for the selected deflating subspaces only.
- 'B': computed for both. Iconic, we love a completionist. ✨

If SENSE = 'E', 'V', or 'B', then SORT must equal 'S'. No exceptions, fr fr.

N — INTEGER. The order of the matrices A, B, VSL, and VSR. Constraint: N >= 0.
A — DOUBLE PRECISION array, dimension (LDA, N). On entry, it's the first of the pair of matrices. On exit, A has been overwritten by its generalized Schur form S. Gone, replaced, glow-up complete. 🦋
LDA — INTEGER. The leading dimension of A. Constraint: LDA >= max(1,N).
B — DOUBLE PRECISION array, dimension (LDB, N). On entry, the second of the pair of matrices. On exit, B has been overwritten by its generalized Schur form T.
LDB — INTEGER. The leading dimension of B. Constraint: LDB >= max(1,N).
SDIM — INTEGER. If SORT = 'N', then SDIM = 0. If SORT = 'S', then SDIM = the number of eigenvalues (after sorting) for which SELCTG is true. And btw, complex conjugate pairs where SELCTG is true for either eigenvalue count as 2. Double the girls, double the count. 👑
ALPHAR — DOUBLE PRECISION array, dimension (N).
ALPHAI — DOUBLE PRECISION array, dimension (N).
BETA — DOUBLE PRECISION array, dimension (N).

On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will be the generalized eigenvalues. ALPHAR(j) + ALPHAI(j)*i and BETA(j), j=1,...,N are the diagonals of the complex Schur form (S,T) that would result if the 2-by-2 diagonal blocks of the real Schur form of (A,B) were further reduced to triangular form using 2-by-2 complex unitary transformations. If ALPHAI(j) is zero, then the j-th eigenvalue is real; if it's positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) negative.

Note, and this one matters: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) may easily over- or underflow, and BETA(j) may even be zero. So the user should avoid naively computing the ratio. However — ALPHAR and ALPHAI will always be less than and usually comparable with norm(A) in magnitude, and BETA is always less than and usually comparable with norm(B). So like, respect the pair, don't just divide. 🙈

VSL — DOUBLE PRECISION array, dimension (LDVSL,N). If JOBVSL = 'V', VSL will contain the left Schur vectors. Not referenced if JOBVSL = 'N'.
LDVSL — INTEGER. The leading dimension of the matrix VSL. LDVSL >= 1, and if JOBVSL = 'V', then LDVSL >= N.
VSR — DOUBLE PRECISION array, dimension (LDVSR,N). If JOBVSR = 'V', VSR will contain the right Schur vectors. Not referenced if JOBVSR = 'N'.
LDVSR — INTEGER. The leading dimension of the matrix VSR. LDVSR >= 1, and if JOBVSR = 'V', then LDVSR >= N.
RCONDE — DOUBLE PRECISION array, dimension ( 2 ). If SENSE = 'E' or 'B', then RCONDE(1) and RCONDE(2) contain the reciprocal condition numbers for the average of the selected eigenvalues. Not referenced if SENSE = 'N' or 'V'.
RCONDV — DOUBLE PRECISION array, dimension ( 2 ). If SENSE = 'V' or 'B', then RCONDV(1) and RCONDV(2) contain the reciprocal condition numbers for the selected deflating subspaces. Not referenced if SENSE = 'N' or 'E'.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — INTEGER. The dimension of the array WORK.

If N = 0, LWORK >= 1, else if SENSE = 'E', 'V', or 'B': LWORK >= max( 8*N, 6*N+16, 2*SDIM*(N-SDIM) ), else LWORK >= max( 8*N, 6*N+16 ).

Note that 2*SDIM*(N-SDIM) <= N*N/2. Also note that an error is only returned if LWORK < max( 8*N, 6*N+16), but if SENSE = 'E' or 'V' or 'B' this may not be large enough. Slightly chaotic, but that's the rule. 💀

If LWORK = -1, then a workspace query is assumed; the routine only calculates the bound on the optimal size of the WORK array and the minimum size of the IWORK array, 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.

IWORK — INTEGER array, dimension (MAX(1,LIWORK)). On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK.
LIWORK — INTEGER. The dimension of the array IWORK.

If SENSE = 'N' or N = 0, LIWORK >= 1, otherwise LIWORK >= N+6.

If LIWORK = -1, then a workspace query is assumed; the routine only calculates the bound on the optimal size of the WORK array and the minimum size of the IWORK array, 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.

BWORK — LOGICAL array, dimension (N). Not referenced if SORT = 'N'.
INFO — INTEGER. The receipts:
- = 0: successful exit. We ate. 🎀
- < 0: if INFO = -i, the i-th argument had an illegal value.
- = 1,...,N: The QZ iteration failed. (A,B) are not in Schur form, but ALPHAR(j), ALPHAI(j), and BETA(j) should be correct for j=INFO+1,...,N.
- > N:
  - =N+1: other than QZ iteration failed in DHGEQZ
  - =N+2: after reordering, roundoff changed values of some complex eigenvalues so that leading eigenvalues in the Generalized Schur form no longer satisfy SELCTG=.TRUE.. This could also be caused due to scaling.
  - =N+3: reordering failed in DTGSEN.

👑 Author 👑

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

🦋 Further Details 🦋

An approximate (asymptotic) bound on the average absolute error of the selected eigenvalues is

EPS * norm((A, B)) / RCONDE( 1 ).

An approximate (asymptotic) bound on the maximum angular error in the computed deflating subspaces is

EPS * norm((A, B)) / RCONDV( 2 ).

See LAPACK User's Guide, section 4.11 for more information. 📚

🌟 subroutine `dggev` 🌟

subroutine dggev (character JOBVL, character JOBVR, integer N, double
    precision, dimension( lda, * ) A, integer LDA, double precision,
    dimension( ldb, * ) B, integer LDB, double precision, dimension( * )
    ALPHAR, double precision, dimension( * ) ALPHAI, double precision,
    dimension( * ) BETA, double precision, dimension( ldvl, * ) VL, integer
    LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double
    precision, dimension( * ) WORK, integer LWORK, integer INFO)

DGGEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices

🎯 Purpose 🎯

DGGEV computes, for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. Bestie it does the whole thing. 🔥

A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambda*B is singular. It's usually represented as the pair (alpha,beta), because there's a reasonable interpretation for beta=0, and even for both being zero. Slay, edge cases handled.

The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies

                 A * v(j) = lambda(j) * B * v(j).

The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies

                 u(j)**H * A  = lambda(j) * u(j)**H * B .

where u(j)**H is the conjugate-transpose of u(j). Conjugate-transpose, not just transpose, don't play yourself. 💅

📋 Parameters 📋

JOBVL — CHARACTER*1.
- 'N': do not compute the left generalized eigenvectors;
- 'V': compute the left generalized eigenvectors.
JOBVR — CHARACTER*1.
- 'N': do not compute the right generalized eigenvectors;
- 'V': compute the right generalized eigenvectors.
N — INTEGER. The order of the matrices A, B, VL, and VR. Constraint: N >= 0.
A
A — a DOUBLE PRECISION array, dimension (LDA, N). On entry it's the matrix A from your pair (A,B). On exit, bestie… it's been overwritten. Gone. Different girl now 💅
LDA — INTEGER. The leading dimension of A. Rule of the land: LDA >= max(1,N).
B — a DOUBLE PRECISION array, dimension (LDB, N). On entry it's the matrix B from your pair (A,B). On exit, also overwritten 🫠
LDB — INTEGER. The leading dimension of B. LDB >= max(1,N), no exceptions.
ALPHAR — a DOUBLE PRECISION array, dimension (N).
ALPHAI — a DOUBLE PRECISION array, dimension (N).
BETA — a DOUBLE PRECISION array, dimension (N). On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will be the generalized eigenvalues ✨ If ALPHAI(j) is zero then the j-th eigenvalue is real, periodt. If it's positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) negative. Iconic pairing behavior honestly.

Heads up bestie: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) may easily over- or underflow, and BETA(j) may even be zero. So do not go naively computing the ratio alpha/beta, I am begging 😭 That said — ALPHAR and ALPHAI will always be less than, and usually comparable with, norm(A) in magnitude, and BETA always less than and usually comparable with norm(B). So the pieces are chill even when the ratio isn't.

VL — a DOUBLE PRECISION array, dimension (LDVL,N). If JOBVL = 'V', the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If the j-th eigenvalue is real, then u(j) = VL(:,j), the j-th column of VL. If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1). Each eigenvector is scaled so the largest component has abs(real part)+abs(imag. part)=1. Not referenced if JOBVL = 'N' — she simply doesn't get invited.
LDVL — INTEGER. The leading dimension of the matrix VL. LDVL >= 1, and if JOBVL = 'V', then LDVL >= N.
VR — a DOUBLE PRECISION array, dimension (LDVR,N). If JOBVR = 'V', the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If the j-th eigenvalue is real, then v(j) = VR(:,j), the j-th column of VR. If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1). Each eigenvector is scaled so the largest component has abs(real part)+abs(imag. part)=1. Not referenced if JOBVR = 'N'.
LDVR — INTEGER. The leading dimension of the matrix VR. LDVR >= 1, and if JOBVR = 'V', then LDVR >= N.
WORK — a DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, then WORK(1) returns the optimal LWORK 🫶
LWORK — INTEGER. The dimension of the array WORK. LWORK >= max(1,8*N). And for good performance, LWORK must generally be larger. Yes, larger. She's hungry for workspace 🍓

INFO — 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 ALPHAR(j), ALPHAI(j), and BETA(j) should be correct for j=INFO+1,...,N.
- > N: =N+1: other than QZ iteration failed in DHGEQZ. =N+2: error return from DTGEVC.

✨ Author ✨

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

🦋 subroutine dggev3 🦋

subroutine dggev3 (character JOBVL, character JOBVR, integer N, double
    precision, dimension( lda, * ) A, integer LDA, double precision,
    dimension( ldb, * ) B, integer LDB, double precision, dimension( * )
    ALPHAR, double precision, dimension( * ) ALPHAI, double precision,
    dimension( * ) BETA, double precision, dimension( ldvl, * ) VL, integer
    LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double
    precision, dimension( * ) WORK, integer LWORK, integer INFO)

DGGEV3 computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices (blocked algorithm) 🔥

Purpose ✨

DGGEV3 computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. Yes, this is the blocked-algorithm sibling, and she's serving the exact same energy 👑

A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambda*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. Not me being dramatic about zero, it's just literally true 💀

The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies

                 A * v(j) = lambda(j) * B * v(j).

The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies

                 u(j)**H * A  = lambda(j) * u(j)**H * B .

where u(j)**H is the conjugate-transpose of u(j). Conjugate-transpose is the glow-up, iykyk 💅

Parameters 🎀

JOBVL — CHARACTER*1.
- = 'N': do not compute the left generalized eigenvectors;
- = 'V': compute the left generalized eigenvectors.
JOBVR — CHARACTER*1.
- = 'N': do not compute the right generalized eigenvectors;
- = 'V': compute the right generalized eigenvectors.
N — INTEGER. The order of the matrices A, B, VL, and VR. N >= 0.
A — a DOUBLE PRECISION array, dimension (LDA, N). On entry, the matrix A in the pair (A,B). On exit, A has been overwritten. She served her purpose and left 🫡
LDA — INTEGER. The leading dimension of A. LDA >= max(1,N).
B — a DOUBLE PRECISION array, dimension (LDB, N). On entry, the matrix B in the pair (A,B). On exit, B has been overwritten.
LDB — INTEGER. The leading dimension of B. LDB >= max(1,N).
ALPHAR — a DOUBLE PRECISION array, dimension (N).
ALPHAI — a DOUBLE PRECISION array, dimension (N).
BETA — a DOUBLE PRECISION array, dimension (N). On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will be the generalized eigenvalues ✨ If ALPHAI(j) is zero, then the j-th eigenvalue is real; if positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) negative.

Same warning as before, and it still matters: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) may easily over- or underflow, and BETA(j) may even be zero. So the user should avoid naively computing the ratio alpha/beta, fr fr 😭 However, ALPHAR and ALPHAI will be always less than and usually comparable with norm(A) in magnitude, and BETA always less than and usually comparable with norm(B).

VL — a DOUBLE PRECISION array, dimension (LDVL,N). If JOBVL = 'V', the left eigenvectors u(j) are stored one after another in the columns of VL, in the same order as their eigenvalues. If the j-th eigenvalue is real, then u(j) = VL(:,j), the j-th column of VL. If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1). Each eigenvector is scaled so the largest component has abs(real part)+abs(imag. part)=1. Not referenced if JOBVL = 'N'.
LDVL — INTEGER. The leading dimension of the matrix VL. LDVL >= 1, and if JOBVL = 'V', then LDVL >= N.
VR — a DOUBLE PRECISION array, dimension (LDVR,N). If JOBVR = 'V', the right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If the j-th eigenvalue is real, then v(j) = VR(:,j), the j-th column of VR. If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1). Each eigenvector is scaled so the largest component has abs(real part)+abs(imag. part)=1. Not referenced if JOBVR = 'N'.
LDVR — INTEGER. The leading dimension of the matrix VR. LDVR >= 1, and if JOBVR = 'V', then LDVR >= N.
WORK — a DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, then WORK(1) returns the optimal LWORK 🫶
LWORK — INTEGER.

INFO — 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 ALPHAR(j), ALPHAI(j), and BETA(j) should be correct for j=INFO+1,...,N.
- > N: =N+1: other than QZ iteration failed in DLAQZ0. =N+2: error return from DTGEVC.

✨ Author ✨

Univ. of Tennessee

Univ. of California Berkeley

ILO — an INTEGER. It's half of a lil duo with IHI, bestie, and the glow-up explanation lives right below 👇
IHI — also an INTEGER. So ILO and IHI are these two integer values such that, on exit, A(i,j) = 0 and B(i,j) = 0 whenever i > j and j = 1,...,ILO-1 or i = IHI+1,...,N. Basically the corners got zeroed out ✨ And if BALANC = 'N' or 'S', then ILO = 1 and IHI = N. Simple as that 💅
LSCALE — DOUBLE PRECISION array, dimension (N). This one's the receipts for everything that happened to the left side of A and B 📝 If PL(j) is the index of the row interchanged with row j, and DL(j) is the scaling factor applied to row j, then:

LSCALE(j) = PL(j)  for j = 1,...,ILO-1
          = DL(j)  for j = ILO,...,IHI
          = PL(j)  for j = IHI+1,...,N.

And the order the interchanges go down is N to IHI+1, then 1 to ILO-1. Noted, no cap 🫶

RSCALE — DOUBLE PRECISION array, dimension (N). Same energy, but for the right side of A and B 🦋 If PR(j) is the index of the column interchanged with column j, and DR(j) is the scaling factor applied to column j, then:

RSCALE(j) = PR(j)  for j = 1,...,ILO-1
          = DR(j)  for j = ILO,...,IHI
          = PR(j)  for j = IHI+1,...,N

And the order here? Also N to IHI+1, then 1 to ILO-1. Matching set, iconic 👑

ABNRM — DOUBLE PRECISION. It's the one-norm of the balanced matrix A. That's it, that's the whole vibe ⭐
BBNRM — DOUBLE PRECISION. The one-norm of the balanced matrix B. Sibling behavior, love that for them 🌸
RCONDE — DOUBLE PRECISION array, dimension (N). If SENSE = 'E' or 'B', this holds the reciprocal condition numbers of the eigenvalues, stored in consecutive elements of the array. For a complex conjugate pair of eigenvalues, two consecutive elements of RCONDE get set to the same value. So RCONDE(j), RCONDV(j), and the j-th columns of VL and VR all correspond to the j-th eigenpair — they're a package deal, fr fr 🎀 And if SENSE = 'N or 'V', RCONDE is not referenced. (Yes, the original says 'N with a missing closing quote, and I am faithfully preserving that typo because the facts don't change, only the vibes 💀)
RCONDV — DOUBLE PRECISION array, dimension (N). If SENSE = 'V' or 'B', this is the estimated reciprocal condition numbers of the eigenvectors, stored in consecutive elements of the array. For a complex eigenvector, two consecutive elements of RCONDV get set to the same value. And if the eigenvalues can't be reordered to compute RCONDV(j), then RCONDV(j) is set to 0 — which can only happen when the true value would've been super tiny anyway, so it's giving "we tried our best" 😭 If SENSE = 'N' or 'E', RCONDV is not referenced.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, then WORK(1) returns the optimal LWORK. The little peek into what you should have asked for 👀
LWORK — INTEGER. The dimension of the array WORK. So like, the rules:
- LWORK >= max(1,2*N).
- If BALANC = 'S' or 'B', or JOBVL = 'V', or JOBVR = 'V', then LWORK >= max(1,6*N).
- If SENSE = 'E' or 'B', then LWORK >= max(1,10*N).
- If SENSE = 'V' or 'B', then LWORK >= 2*N*N+8*N+16.
LWORK — INTEGER</p>. And bestie, listen: the dimension of the array WORK.
- If SENSE = 'N', then LWORK >= max(1,2*N).
- otherwise LWORK >= max(1,4*N).

But like, if LWORK = -1, then a workspace query is assumed — the routine only figures out the optimal size of the WORK array, hands that value back as the first entry of WORK, and no error message related to LWORK is issued by XERBLA. It's giving "just asking, not committing." 💅

IWORK — INTEGER array, dimension (N+6).

If SENSE = 'E', IWORK is not referenced. It's literally not invited to the party. 🙈

BWORK — LOGICAL array, dimension (N).

If SENSE = 'N', BWORK is not referenced either. Two arrays sitting at home. 💀

INFO — 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 ALPHAR(j), ALPHAI(j), and BETA(j)
should be correct for j=INFO+1,...,N.

> N: =N+1: other than QZ iteration failed in DHGEQZ. =N+2: error return from DTGEVC.

👑 Author

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

🔍 Further Details

Okay so here's the tea on balancing, because it's actually kind of iconic. Balancing a matrix pair (A,B) includes, first, permuting rows and columns to isolate eigenvalues, and second, applying diagonal similarity transformation to the rows and columns to make the rows and columns as close in norm as possible. The computed reciprocal condition numbers correspond to the balanced matrix. Permuting rows and columns will not change the condition numbers (in exact arithmetic) but diagonal scaling will. For further explanation of balancing, see section 4.11.1.2 of LAPACK Users' Guide. 📖

An approximate error bound on the chordal distance between the i-th computed generalized eigenvalue w and the corresponding exact eigenvalue lambda is

chord(w, lambda) <= EPS * norm(ABNRM, BBNRM) / RCONDE(I)

An approximate error bound for the angle between the i-th computed eigenvector VL(i) or VR(i) is given by

EPS * norm(ABNRM, BBNRM) / DIF(i).

For further explanation of the reciprocal condition numbers RCONDE and RCONDV, see section 4.11 of LAPACK Users' Guide. No cap, the Users' Guide really said "read me." 🫶

🌈 Author

Generated automatically by Doxygen for LAPACK from the source code. The robot wrote this one, not a human, and honestly? Slay. 🤖✨

And that's the whole page, bestie! 💖 This was LAPACK Version 3.11.0, dated Sun Nov 27 2022, and it's the doubleGEeigen(3) manpage — you ate that, fr fr. Now go compute some generalized eigenvalues and be the main character of your own linear algebra journey. Periodt. 👑🌸

📦 where this page comes from

debian bookworm: liblapack-doc 3.11.0-2 · BSD-3-Clause
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

doubleGEeigen(3)

💖 doubleGEeigen(3) 💖

🌸 NAME 🌸

📜 SYNOPSIS 📜

✨ Functions ✨

✨ Detailed Description ✨

📚 Function Documentation 📚

🦋 subroutine dgees 🦋

✨ Purpose ✨

🎀 Parameters 🎀

👑 Author 👑

🦋 subroutine dgeesx 🦋

✨ Purpose ✨

✨ Parameters ✨

🎀 Author 🎀

Purpose:

Parameters

💖 Author 💖

🦋 subroutine dgeevx 🦋

✨ Purpose: ✨

👑 Parameters 👑

Author

subroutine dgges

Purpose

Parameters

Author

subroutine dgges3

Purpose

🎀 Parameters 🎀

👑 Author 👑

💖 Purpose 💖

🎀 Parameters 🎀

👑 Author 👑

🦋 Further Details 🦋

🌟 subroutine dggev 🌟

🎯 Purpose 🎯

📋 Parameters 📋

✨ Author ✨

🦋 subroutine dggev3 🦋

Purpose ✨

Parameters 🎀

✨ Author ✨

👑 Author

🔍 Further Details

🌈 Author

🦋 subroutine `dgeevx` 🦋

subroutine `dgges`

subroutine `dgges3`

🌟 subroutine `dggev` 🌟