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

🌸 `trevc` — eigenvectors of triangular Schur form, old 💅

okay so bestie, first things first: this is trevc from Library Functions Manual, section 3. she's old. the name literally says "old" — that's not me being shady, that's the actual NAME line. we're looking at the legacy LAPACK-era routine here, and there are four flavours of her: ctrevc, dtrevc, strevc, ztrevc. buckle up 🎀

✨ NAME ✨

trevc — trevc: eigenvectors of triangular Schur form, old

like I said. old. iconic, but old. 👑

✨ SYNOPSIS ✨

🌈 Functions 🌈

subroutine ctrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) — CTREVC
subroutine dtrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info) — DTREVC
subroutine strevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info) — STREVC
subroutine ztrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) — ZTREVC

notice how ctrevc and ztrevc get an extra rwork and the real ones don't? that's not a typo, that's just how she is 💁‍♀️

✨ Detailed Description ✨

it's giving "reference documentation with no chill." scroll down for the good stuff 🫶

✨ Function Documentation ✨

🦋 `subroutine ctrevc` 🦋

subroutine ctrevc (character side, character howmny, logical, dimension( * )
    select, integer n, complex, dimension( ldt, * ) t, integer ldt, complex,
    dimension( ldvl, * ) vl, integer ldvl, complex, dimension( ldvr, * ) vr,
    integer ldvr, integer mm, integer m, complex, dimension( * ) work, real,
    dimension( * ) rwork, integer info)

CTREVC

🎯 Purpose:

okay so CTREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. and where do these come from? matrices of this type are produced by the Schur factorization of a complex general matrix:

A = Q*T*Q**H

as computed by CHSEQR. slay.

bestie, here's the definition. the right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by:

T*x = w*x,     (y**H)*T = w*(y**H)

where y**H denotes the conjugate transpose of the vector y. 🧚

and the eigenvalues? not input to this routine — they're read directly from the diagonal of T. she reads the room, she doesn't get told. 💅

this routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. and if Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. no cap, that's the whole vibe.

🌸 Parameters

SIDE — SIDE is CHARACTER*1. so many choices, bestie:
- = 'R': compute right eigenvectors only;
- = 'L': compute left eigenvectors only;
- = 'B': compute both right and left eigenvectors.
HOWMNY — HOWMNY is CHARACTER*1. this one's the "how do you want 'em" dial:
- = 'A': compute all right and/or left eigenvectors;
- = 'B': compute all right and/or left eigenvectors, backtransformed using the matrices supplied in VR and/or VL;
- = 'S': compute selected right and/or left eigenvectors, as indicated by the logical array SELECT.
SELECT — SELECT is a LOGICAL array, dimension (N). if HOWMNY = 'S', then SELECT specifies the eigenvectors to be computed. the eigenvector corresponding to the j-th eigenvalue is computed if SELECT(j) = .TRUE.. not referenced if HOWMNY = 'A' or 'B' — she simply doesn't look at it, don't take it personally 💀
N — N is INTEGER. the order of the matrix T. N >= 0.
T — T is a COMPLEX array, dimension (LDT,N). the upper triangular matrix T. ⚠️ T is modified, but restored on exit — so she rummages through your closet and puts everything back exactly where she found it. 🫶
LDT — LDT is INTEGER. the leading dimension of the array T. LDT >= max(1,N).
VL — VL is a COMPLEX array, dimension (LDVL,MM).
- on entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must contain an N-by-N matrix Q (usually the unitary matrix Q of Schur vectors returned by CHSEQR).
- on exit, if SIDE = 'L' or 'B', VL contains:
  - if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
  - if HOWMNY = 'B', the matrix Q*Y;
  - if HOWMNY = 'S', the left eigenvectors of T specified by SELECT, stored consecutively in the columns of VL, in the same order as their eigenvalues.
- not referenced if SIDE = 'R'.
LDVL — LDVL is INTEGER. the leading dimension of the array VL. LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N.
VR — VR is a COMPLEX array, dimension (LDVR,MM).
- on entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must contain an N-by-N matrix Q (usually the unitary matrix Q of Schur vectors returned by CHSEQR).
- on exit, if SIDE = 'R' or 'B', VR contains:
  - if HOWMNY = 'A', the matrix X of right eigenvectors of T;
  - if HOWMNY = 'B', the matrix Q*X;
  - if HOWMNY = 'S', the right eigenvectors of T specified by SELECT, stored consecutively in the columns of VR, in the same order as their eigenvalues.
- not referenced if SIDE = 'L'.
LDVR — LDVR is INTEGER. the leading dimension of the array VR. LDVR >= 1, and if SIDE = 'R' or 'B'; LDVR >= N. (yes, that semicolon is in the original, she's quirky like that 🙈)
MM — MM is INTEGER. the number of columns in the arrays VL and/or VR. MM >= M.
M — M is INTEGER. the number of columns in the arrays VL and/or VR actually used to store the eigenvectors. if HOWMNY = 'A' or 'B', M is set to N. each selected eigenvector occupies one column. one girl, one column, periodt. ✨
WORK — WORK is a COMPLEX array, dimension (2*N). that's right, two times N, don't skimp.
RWORK — RWORK is a REAL array, dimension (N).
INFO — INFO is INTEGER:
- = 0: successful exit 🎉
- < 0: if INFO = -i, the i-th argument had an illegal value. so if you see INFO = -3, bestie, argument 3 is the problem and she's calling it out 💀

👑 Author

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

the whole group chat contributed, honestly.

🔥 Further Details:

the algorithm used in this program is basically backward (forward) substitution, with scaling to make the the code robust against possible overflow. (yes, "the the" — she said it twice, we're leaving it, it's part of the lore 💅)
each eigenvector is normalized so that the element of largest magnitude has magnitude 1; here the magnitude of a complex number (x,y) is taken to be |x| + |y|.

that's not a typo either — |x| + |y|, not the usual square-root situation. she does her own thing and honestly? it works. ⭐

Definition at line 216 of file ctrevc.f.

🧚 `subroutine dtrevc` 🧚

subroutine dtrevc (character side, character howmny, logical, dimension( * )
    select, integer n, double precision, dimension( ldt, * ) t, integer ldt,
    double precision, dimension( ldvl, * ) vl, integer ldvl, double
    precision, dimension( ldvr, * ) vr, integer ldvr, integer mm, integer m,
    double precision, dimension( * ) work, integer info)

DTREVC

🎯 Purpose:

DTREVC computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. yes — quasi-triangular, she's got 2×2 blocks on the diagonal, it's a whole thing. 🌀

matrices of this type are produced by the Schur factorization of a real general matrix:

A = Q*T*Q**T

as computed by DHSEQR. note the Q**T, not Q**H — real girl behaviour.

the right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by:

T*x = w*x,     (y**H)*T = w*(y**H)

where y**H denotes the conjugate transpose of y. 🦋

the eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T.

this routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. if Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. (unitary in the complex version, orthogonal here — she's not swapping those, okay? 💜)

🌸 Parameters

SIDE — SIDE is CHARACTER*1:
- = 'R': compute right eigenvectors only;
- = 'L': compute left eigenvectors only;
- = 'B': compute both right and left eigenvectors.
HOWMNY — HOWMNY is CHARACTER*1:
- = 'A': compute all right and/or left eigenvectors;
- = 'B': compute all right and/or left eigenvectors, backtransformed by the matrices in VR and/or VL;
- = 'S': compute selected right and/or left eigenvectors, as indicated by the logical array SELECT.
SELECT — SELECT is a LOGICAL array, dimension (N). if HOWMNY = 'S', SELECT specifies the eigenvectors to be computed. but here's the extra lore for the real version, bestie, pay attention: 🚨
- if w(j) is a real eigenvalue, the corresponding real eigenvector is computed if SELECT(j) is .TRUE..
- if w(j) and w(j+1) are the real and imaginary parts of a complex eigenvalue, the corresponding complex eigenvector is computed if either SELECT(j) or SELECT(j+1) is .TRUE., and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to .FALSE.. she picks a winner and it's j. main character energy. 👑
- not referenced if HOWMNY = 'A' or 'B'.
N — N is INTEGER. the order of the matrix T. N >= 0.
T — T is a DOUBLE PRECISION array, dimension (LDT,N). the upper quasi-triangular matrix T in Schur canonical form.
LDT — LDT is INTEGER. the leading dimension of the array T. LDT >= max(1,N).
VL — (okay bestie this is exactly where part 1 runs out 😭 the tea on VL continues in the next part 💅)
VL — DOUBLE PRECISION array, dimension (LDVL,MM). Ok so picture this: on entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', then VL has to already contain an N-by-N matrix Q (usually the orthogonal matrix Q of Schur vectors that DHSEQR handed back to you). On exit, if SIDE = 'L' or 'B', VL contains:
- if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
- if HOWMNY = 'B', the matrix Q*Y;
- if HOWMNY = 'S', the left eigenvectors of T specified by SELECT, stored consecutively in the columns of VL, in the same order as their eigenvalues.

A complex eigenvector corresponding to a complex eigenvalue is stored in two consecutive columns — first column = the real part, second = the imaginary part. Two slots, one vibe 💅 Not referenced if SIDE = 'R'.

LDVL — INTEGER. The leading dimension of the array VL. LDVL >= 1, and if SIDE = 'L' or 'B', then LDVL >= N. Gen Z translation: don't lowball this number, the Fortran will not forgive you 🫶
VR — DOUBLE PRECISION array, dimension (LDVR,MM). On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must contain an N-by-N matrix Q (usually the orthogonal matrix Q of Schur vectors returned by DHSEQR). On exit, if SIDE = 'R' or 'B', VR contains:
- if HOWMNY = 'A', the matrix X of right eigenvectors of T;
- if HOWMNY = 'B', the matrix Q*X;
- if HOWMNY = 'S', the right eigenvectors of T specified by SELECT, stored consecutively in the columns of VR, in the same order as their eigenvalues.

A complex eigenvector corresponding to a complex eigenvalue is stored in two consecutive columns — first column holds the real part and the second the imaginary part. Not referenced if SIDE = 'L'. Yes bestie, VL and VR are literally the same paragraph with the letters swapped. Iconic symmetry, no notes ✨

LDVR — INTEGER. The leading dimension of the array VR. LDVR >= 1, and if SIDE = 'R' or 'B', then LDVR >= N.
MM — INTEGER. The number of columns in the arrays VL and/or VR. MM >= M. You bring the venue size, the routine tells you how many eigenvectors actually showed up 🎀
M — INTEGER. The number of columns in the arrays VL and/or VR that are actually used to store the eigenvectors. If HOWMNY = 'A' or 'B', M is set to N. Each selected real eigenvector occupies one column and each selected complex eigenvector occupies two columns. Complex ones take up two seats, fr fr 😭
WORK — DOUBLE PRECISION array, dimension (3*N). Scratch space, don't touch it, it's doing its job 🧚
INFO — INTEGER. The receipts:
- = 0: successful exit 🌈
- < 0: if INFO = -i, the i-th argument had an illegal value somebody passed something cursed, go check argument number -INFO 💀

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Further Details:

The algorithm used in this program is basically backward (forward) substitution, with scaling to make the the code robust against possible overflow. (Yes, "the the" is in the source. We are leaving it exactly as-is, because accuracy is the assignment 💅)

Each eigenvector is normalized so that the element of largest magnitude has magnitude 1; here the magnitude of a complex number (x,y) is taken to be |x| + |y|. That's the 1-norm vibe check, not the fancy Euclidean one — noted, memorized, moving on ✨

Definition at line 220 of file dtrevc.f.

🦋 and now… the single-precision sibling: `strevc` 🦋

subroutine strevc (character side, character howmny, logical, dimension( * )
 select, integer n, real, dimension( ldt, * ) t, integer ldt, real,
 dimension( ldvl, * ) vl, integer ldvl, real, dimension( ldvr, * ) vr,
 integer ldvr, integer mm, integer m, real, dimension( * ) work, integer
 info)

STREVC

✨ Purpose

STREVC computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by SHSEQR. Same deal as before, just REAL instead of DOUBLE PRECISION — the ✨budget✨ version, but make no mistake, she's still main character 🌸

The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by:

T*x = w*x,     (y**H)*T = w*(y**H)

where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine — they're read directly from the diagonal blocks of T. No, you don't hand her the eigenvalues. She reads them off the diagonal herself, iykyk 👑

This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. The way that one routine can just hand you eigenvectors of A without ever seeing A… obsessed 🫶

💖 Parameters

SIDE — CHARACTER*1. Which side are we doing, bestie?
- = 'R': compute right eigenvectors only;
- = 'L': compute left eigenvectors only;
- = 'B': compute both right and left eigenvectors.
HOWMNY — CHARACTER*1. How many, and do we backtransform?
- = 'A': compute all right and/or left eigenvectors;
- = 'B': compute all right and/or left eigenvectors, backtransformed by the matrices in VR and/or VL;
- = 'S': compute selected right and/or left eigenvectors, as indicated by the logical array SELECT.
SELECT — LOGICAL array, dimension (N). If HOWMNY = 'S', SELECT specifies the eigenvectors to be computed. If w(j) is a real eigenvalue, the corresponding real eigenvector is computed if SELECT(j) is .TRUE.. If w(j) and w(j+1) are the real and imaginary parts of a complex eigenvalue, the corresponding complex eigenvector is computed if either SELECT(j) or SELECT(j+1) is .TRUE., and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to .FALSE.. Not referenced if HOWMNY = 'A' or 'B'. So if you flag either half of a complex pair, she takes the pair — and then quietly tidies up your flags for you. Mother behavior 💅
N — INTEGER. The order of the matrix T. N >= 0.
T — REAL array, dimension (LDT,N). The upper quasi-triangular matrix T in Schur canonical form. Quasi-triangular = the diagonal may have lil 2-by-2 blocks chilling in it for complex eigenvalue pairs. That's just how she rolls ✨
LDT — INTEGER. The leading dimension of the array T. LDT >= max(1,N). Note the max(1,N) — she's being polite about the N = 0 case 🫶
VL — REAL array, dimension (LDVL,MM). On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must contain an N-by-N matrix Q (usually the orthogonal matrix Q of Schur vectors returned by SHSEQR). On exit, if SIDE = 'L' or 'B', VL contains:
- if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
- if HOWMNY = 'B', the matrix Q*Y;
- if HOWMNY = 'S', the left eigenvectors of T specified by SELECT, stored consecutively in the columns of VL, in the same order as their eigenvalues.

A complex eigenvector corresponding to a complex eigenvalue is stored in two consecutive columns, the first holding the real part, and the second the imaginary part. Not referenced if SIDE = 'R'.

LDVL — INTEGER. The leading dimension of the array VL. LDVL >= 1, and if SIDE = 'L' or 'B', then LDVL >= N.
VR — REAL array, dimension (LDVR,MM). On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must contain an N-by-N matrix Q (usually the orthogonal matrix Q of Schur vectors returned by SHSEQR). On exit, if SIDE = 'R' or 'B', VR contains:
- if HOWMNY = 'A', the matrix X of right eigenvectors of T;
- if HOWMNY = 'B', the matrix Q*X;
- if HOWMNY = 'S', the right eigenvectors of T specified by SELECT, stored consecutively in the columns of VR, in the same order as their eigenvalues.

A complex eigenvector corresponding to a complex eigenvalue is stored in two consecutive columns, the first holding the real part and the second the imaginary part. Not referenced if SIDE = 'L'.

LDVR — INTEGER. The leading dimension of the array VR. LDVR >= 1, and if SIDE = 'R' or 'B', then LDVR >= N.
MM — INTEGER. The number of columns in the arrays VL and/or VR. MM >= M.
M — INTEGER. The number of columns in the arrays VL and/or VR actually used to store the eigenvectors. If HOWMNY = 'A' or 'B', M is set to N. Each selected real eigenvector occupies one column and each selected complex eigenvector occupies two columns.
WORK — REAL array, dimension (3*N). Three times N of scratch space, same deal, hands off 🌈
INFO — INTEGER. The verdict:
- = 0: successful exit 🎀
- < 0: if INFO = -i, the i-th argument had an illegal value argument -INFO said something out of pocket, go apologize to it 💀

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Further Details:

The algorithm used in this program is basically backward (forward) substitution, with scaling to make the the code robust against possible overflow. (That double "the the" again — she's a family trait at this point. Preserved word for word, no cap 😭)

Each eigenvector is normalized so that the element of largest magnitude has magnitude 1; here the magnitude of a complex number (x,y) is taken to be |x| + |y|. Max element gets magnitude 1, complex magnitude is |x| + |y|. Same normalization energy as her double-precision sister, and tbh it ate 🔥

Definition at line 220 of file strevc.f.

okay so here's the exact signature for ztrevc, bestie — don't touch a character:

   subroutine ztrevc (character side, character howmny, logical, dimension( * )
       select, integer n, complex*16, dimension( ldt, * ) t, integer ldt,
       complex*16, dimension( ldvl, * ) vl, integer ldvl, complex*16,
       dimension( ldvr, * ) vr, integer ldvr, integer mm, integer m,
       complex*16, dimension( * ) work, double precision, dimension( * ) rwork,
       integer info)

💫 `ZTREVC` 💫

Purpose:

ZTREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by ZHSEQR.

The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by:

T*x = w*x,     (y**H)*T = w*(y**H)

where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T.

This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. iconic behavior, honestly. ✨

🌸 Parameters

SIDE — CHARACTER*1. Tells us which side's eigenvectors we're grabbing:
- 'R': compute right eigenvectors only;
- 'L': compute left eigenvectors only;
- 'B': compute both right and left eigenvectors.
HOWMNY — CHARACTER*1. Controls how many and which eigenvectors:
- 'A': compute all right and/or left eigenvectors;
- 'B': compute all right and/or left eigenvectors, backtransformed using the matrices supplied in VR and/or VL;
- 'S': compute selected right and/or left eigenvectors, as indicated by the logical array SELECT.
SELECT — LOGICAL array, dimension (N). If HOWMNY = 'S', SELECT specifies the eigenvectors to be computed. The eigenvector corresponding to the j-th eigenvalue is computed if SELECT(j) = .TRUE.. Not referenced if HOWMNY = 'A' or 'B'.
N — INTEGER. The order of the matrix T. N >= 0.
T — COMPLEX*16 array, dimension (LDT,N). The upper triangular matrix T. T is modified, but restored on exit. no cap, it puts itself back.
LDT — INTEGER. The leading dimension of the array T. LDT >= max(1,N).
VL — COMPLEX*16 array, dimension (LDVL,MM). On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must contain an N-by-N matrix Q (usually the unitary matrix Q of Schur vectors returned by ZHSEQR). On exit, if SIDE = 'L' or 'B', VL contains:
- if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
- if HOWMNY = 'B', the matrix Q*Y;
- if HOWMNY = 'S', the left eigenvectors of T specified by SELECT, stored consecutively in the columns of VL, in the same order as their eigenvalues.

Not referenced if SIDE = 'R'.

LDVL — INTEGER. The leading dimension of the array VL. LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N.
VR — COMPLEX*16 array, dimension (LDVR,MM). On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must contain an N-by-N matrix Q (usually the unitary matrix Q of Schur vectors returned by ZHSEQR). On exit, if SIDE = 'R' or 'B', VR contains:
- if HOWMNY = 'A', the matrix X of right eigenvectors of T;
- if HOWMNY = 'B', the matrix Q*X;
- if HOWMNY = 'S', the right eigenvectors of T specified by SELECT, stored consecutively in the columns of VR, in the same order as their eigenvalues.

Not referenced if SIDE = 'L'.

LDVR — INTEGER. The leading dimension of the array VR. LDVR >= 1, and if SIDE = 'R' or 'B'; LDVR >= N.
MM — INTEGER. The number of columns in the arrays VL and/or VR. MM >= M.
M — INTEGER. The number of columns in the arrays VL and/or VR actually used to store the eigenvectors. If HOWMNY = 'A' or 'B', M is set to N. Each selected eigenvector occupies one column.
WORK — COMPLEX*16 array, dimension (2*N).
RWORK — DOUBLE PRECISION array, dimension (N).
INFO — INTEGER. The vibe check:
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value

👑 Author

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

🔍 Further Details

The algorithm used in this program is basically backward (forward) substitution, with scaling to make the the code robust against possible overflow. yes, “the the” is literally in the source — leaving it exactly as found, bestie. 💅

Each eigenvector is normalized so that the element of largest magnitude has magnitude 1; here the magnitude of a complex number (x,y) is taken to be |x| + |y|.

Definition at line 216 of file ztrevc.f.

🤖 Author

Generated automatically by Doxygen for LAPACK from the source code.

and that's the whole page, bestie 💖 the footer at the very bottom says LAPACK Version 3.12.0 and trevc(3) — no date shown, just the version and the page name. periodt. ✨🫶

📦 where this page comes from

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

trevc(3)

🌸 trevc — eigenvectors of triangular Schur form, old 💅

✨ NAME ✨

✨ SYNOPSIS ✨

🌈 Functions 🌈

✨ Detailed Description ✨

✨ Function Documentation ✨

🦋 subroutine ctrevc 🦋

🎯 Purpose:

🌸 Parameters

👑 Author

🔥 Further Details:

🧚 subroutine dtrevc 🧚

🎯 Purpose:

🌸 Parameters

Author

Further Details:

🦋 and now… the single-precision sibling: strevc 🦋

✨ Purpose

💖 Parameters

Author

Further Details:

💫 ZTREVC 💫

🌸 Parameters

👑 Author

🔍 Further Details

🤖 Author

🌸 `trevc` — eigenvectors of triangular Schur form, old 💅

🦋 `subroutine ctrevc` 🦋

🧚 `subroutine dtrevc` 🧚

🦋 and now… the single-precision sibling: `strevc` 🦋

💫 `ZTREVC` 💫