trevc3(3)

📦
version 3.12.1 · 9 versions
, in arch rolling

✨ NAME ✨

trevc3 — eigenvectors of triangular Schur form, blocked 💅

(and yes bestie, this is the trevc3(3) page, straight out of the Library Functions Manual — we are deep in library-functions territory today 🫶)

🌈 SYNOPSIS 🌈

🎀 Functions

  • subroutine ctrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info) — the complex single-precision one, aka CTREVC3
  • subroutine dtrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info) — the double-precision real one, aka DTREVC3
  • subroutine strevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info) — the single-precision real one, aka STREVC3
  • subroutine ztrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info) — the complex double-precision one, aka ZTREVC3

🦋 Detailed Description

okay so real talk — this whole page is about one job: getting eigenvectors out of a triangular (or quasi-triangular) matrix that's already sitting in Schur form. Every routine down below does the same thing, just for a different flavour of number. Below you'll find the full docs for each one, in order 💖

👑 Function Documentation 👑

🧚 subroutine ctrevc3

subroutine ctrevc3 (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, integer lwork, real, dimension( * ) rwork, integer lrwork, integer info)

💜 CTREVC3

Purpose:

CTREVC3 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 CHSEQR. slay.

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. (yes, it just peeks at the diagonal, iconic behaviour 🎀)

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.

This uses a Level 3 BLAS version of the back transformation. 🔥

🌸 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 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 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 — N is INTEGER The order of the matrix T. N >= 0.
  • T — T is COMPLEX array, dimension (LDT,N) The upper triangular matrix T. ⚠️ T is modified, but restored on exit. (so like, it goes through a phase and then comes back, don't worry 💅)
  • LDT — LDT is INTEGER The leading dimension of the array T. LDT >= max(1,N).
  • VL — VL is 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 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.
  • 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.
  • WORK — WORK is COMPLEX array, dimension (MAX(1,LWORK))
  • LWORK — LWORK is INTEGER The dimension of array WORK. LWORK >= max(1,2*N). For optimum performance, LWORK >= N + 2*N*NB, where NB is the optimal blocksize. 💯
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. (the -1 hack, we love her 🙈)
  • RWORK — RWORK is REAL array, dimension (LRWORK)
  • LRWORK — LRWORK is INTEGER The dimension of array RWORK. LRWORK >= max(1,N).
If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the RWORK array, returns this value as the first entry of the RWORK array, and no error message related to LRWORK is issued by XERBLA.
  • INFO — INFO is INTEGER
    • = 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. 😤

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 242 of file ctrevc3.f. 🎀

🦋 subroutine dtrevc3

subroutine dtrevc3 (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 lwork, integer info)

💜 DTREVC3

Purpose:

DTREVC3 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 DHSEQR.

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

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

where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. (blocks, bestie — real Schur form keeps its 2-by-2s, no cap 🍓)

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.

This uses a Level 3 BLAS version of the back transformation. 🔥

🌸 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

…and that's exactly where part 1 of this page dips out, so hold that thought — SELECT is literally mid-sentence 💅

  • SELECT — a LOGICAL array, dimension (N). Bestie, this is your little checklist of which eigenvectors you actually want 🎀 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 lowkey it tidies up after itself, iconic behavior tbh ✨)
  • N — INTEGER. The order of the matrix T. N >= 0. No cap, but also it can literally be zero, she's flexible 💅
  • T — DOUBLE PRECISION array, dimension (LDT,N). The upper quasi-triangular matrix T in Schur canonical form. This is the main character of the whole situation, fr fr 👑
  • LDT — INTEGER. The leading dimension of the array T. LDT >= max(1,N). Respect the leading dimension or the whole thing gets messy, ngl.
  • VL — DOUBLE PRECISION array, dimension (LDVL,MM). Okay so 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 DHSEQR). 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'. Two columns, one real one imag — she's splitting the vibe across two slots 🦋

  • LDVL — INTEGER. The leading dimension of the array VL. LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N. Conditional requirements, we love a queen with rules 💅
  • 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, the first holding the real part and the second the imaginary part. Not referenced if SIDE = 'L'. Same energy as VL but right-side, obviously 🌸

  • LDVR — INTEGER. The leading dimension of the array VR. LDVR >= 1, and if SIDE = 'R' or 'B', LDVR >= N. Yes the pattern is the pattern, don't come for her 🫶
  • MM — INTEGER. The number of columns in the arrays VL and/or VR. MM >= M. It's the capacity, M is what actually gets used — think of it as the shelf versus what's on the shelf 😭
  • 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. So yeah, complex ones take double the closet space, that's just how it is 💀
  • WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). The scratch space. Give her room to breathe ✨
  • LWORK — INTEGER. The dimension of array WORK. LWORK >= max(1,3*N). For optimum performance, LWORK >= N + 2*N*NB, where NB is the optimal blocksize. Like, the minimum works, but the performance version is serving 🔥

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. It's giving "just tell me how much space you need, I'm not mad" 🙈

  • INFO — INTEGER. The glow-up report card:
    • = 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.

All the academic baddies collaborated on this one, we stan a collective 👑

Further Details:

Okay so the lore: 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" — the original said it like that, I'm not correcting her, she's doing her best 💀)

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|. So the big one gets scaled down to 1, and for complex numbers the "size" is just the two parts added up — that's the whole rule, no cap ✨

Definition at line 235 of file dtrevc3.f.

STREVC3 🌈

subroutine strevc3 (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
    lwork, integer info)

Purpose:

STREVC3 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. So she's the single-precision sibling and she's also booked and busy 💅

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

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

where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. So she doesn't need you to hand her the eigenvalues, she finds them herself. independent queen behavior 👑

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.

This uses a Level 3 BLAS version of the back transformation. Level 3 BLAS is the fast one, we love efficiency 🚀

Parameters

  • SIDE — CHARACTER*1. Which side are we serving today:
    • = 'R': compute right eigenvectors only;
    • = 'L': compute left eigenvectors only;
    • = 'B': compute both right and left eigenvectors.

Choose your fighter, or honestly just pick 'B' and get both 🫶

  • HOWMNY — CHARACTER*1. The how-many switch, and there are exactly three modes:
    • = '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.

A, B, or S — all, backtransformed, or selected. Periodt ✨

  • 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'. Also note she does her own cleanup on exit, which is honestly so considerate of her 🎀
  • N — INTEGER. The order of the matrix T. N >= 0. Zero is allowed, she's not gonna judge.
  • T — REAL array, dimension (LDT,N). The upper quasi-triangular matrix T in Schur canonical form. The moment, the icon, the legend 👑
  • LDT — INTEGER. The leading dimension of the array T. LDT >= max(1,N). Yes the same rule as before, because math is consistent like that 💅
  • 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'. Two columns again, real then imag, we been knew 🦋

  • LDVL — INTEGER. The leading dimension of the array VL. LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N. Conditional constraint, she's conditional about it 💜
  • 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'. Mirror image of VL, matching set, so cute 🌸

  • LDVR —
  • LDVR — INTEGER, the leading dimension of the array VR. Rules: LDVR >= 1, and if SIDE = 'R' or 'B', then LDVR >= N. ✨
  • MM — INTEGER, the number of columns in the arrays VL and/or VR. Bestie, MM >= M. That's the whole vibe. 💅
  • M — INTEGER, the number of columns in VL and/or VR that are actually used to store the eigenvectors (the real ones, not the wishful ones). If HOWMNY = 'A' or 'B', then M is set to N. And the counting tea ☕: each selected real eigenvector occupies one column, and each selected complex eigenvector occupies two columns. Not me stressing about column budget 😭
  • WORK — REAL array, dimension (MAX(1,LWORK)). That's it, that's the whole description. 🫶
  • LWORK — INTEGER, the dimension of array WORK. So LWORK >= max(1,3*N). For optimum performance tho (highkey worth it), LWORK >= N + 2*N*NB, where NB is the optimal blocksize. 🔥

And the iconic little trick: 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. No cap, it's just asking for the size, it's not doing the math. 🎀

  • INFO — INTEGER, the receipts:
    • = 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", she said it, we're keeping it, it's canon 🎀)

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 norm they're using — |x| + |y|, not the fancy Euclidean one. Note it, bestie. 📝

Definition at line 235 of file strevc3.f.

🦋 subroutine ztrevc3

Ok so now we're in the complex girlie era and she is serving. Signature, exactly as written:

subroutine ztrevc3 (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, integer lwork, double precision,
dimension( * ) rwork, integer lrwork, integer info)

ZTREVC3 👑

✨ Purpose:

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

So like, ZHSEQR hands you T, and this routine does the eigenvector thing. Chain of command, iykyk. 💅

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.

Read that again, bestie — the eigenvalues are not input to this routine. They're literally just sitting on the diagonal of T the whole time. Main character energy 🎀

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.
This uses a Level 3 BLAS version of the back transformation.

Level 3 BLAS back transformation — she's fast and she's pretty. Obsessed. 🔥

🎀 Parameters

  • SIDE — CHARACTER*1, choose your fighter:
    • = 'R': compute right eigenvectors only;
    • = 'L': compute left eigenvectors only;
    • = 'B': compute both right and left eigenvectors. 🫶
  • HOWMNY — CHARACTER*1, the "how much" knob:
    • = '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. Heads up ⚠️: T is modified, but restored on exit. So she rummages through your matrix and puts everything back exactly where she found it. Iconic, honestly. ✨
  • 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. Same deal as before, the budget must cover it. 💅
  • 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. And note the complex version is simpler 👀: each selected eigenvector occupies one column. (No "two columns" drama here — that was the real-valued strevc3 flex.)
  • WORK — COMPLEX*16 array, dimension (MAX(1,LWORK)).
  • LWORK — INTEGER, the dimension of array WORK. So LWORK >= max(1,2*N). For optimum performance, LWORK >= N + 2*N*NB, where NB is the optimal blocksize. 🔥

And again, the classic: if LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. 🎀

  • RWORK — DOUBLE PRECISION array, dimension (LRWORK). Yes she brought her real-valued friend along, that's solidarity. 🌸
  • LRWORK — INTEGER, the dimension of array RWORK. LRWORK >= max(1,N).

Same query energy, second round: if LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the RWORK array, returns this value as the first entry of the RWORK array, and no error message related to LRWORK is issued by XERBLA. 🫶

  • INFO — INTEGER:
    • = 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.

(again with the "the the" — she's consistent, we respect it 🎀)

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

So big-element-goes-to-1, and the complex magnitude is |x| + |y|, not the hypotenuse. Keep that in your notes, bestie. 📝

Definition at line 242 of file ztrevc3.f.

⭐ Author

Generated automatically by Doxygen for LAPACK from the source code.

<a rainbow>and that's the whole page, bestie!!</a> 🦋✨ this lil masterpiece is stamped LAPACK, Version 3.12.0, and the page tag is trevc3(3) — go forth and compute your eigenvectors, u got this 💖👑

📦 where this page comes from