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

📦 version 3.12.0, in opensuse-leap 16.0

💅 /home/abui...RC/zgeev.f(3) — Library Functions Manual (we're in the LAPACK corner of the man pages, bestie)

okay so first things first: this page lives in the Library Functions Manual section, and it's the glow-up doc for zgeev.f. Yes the "file" is literally a Fortran source file, and yes we're reading its man page like it's a celebrity's wiki. iconic. 🎀

✨ NAME ✨

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/zgeev.f

like. that's the whole name. it's giving "my government name is a build path". no cap, that's genuinely how it's listed, and we respect it. 💜

🦋 SYNOPSIS 🦋

Functions/Subroutines

subroutine ZGEEV (jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work,
    lwork, rwork, info)

ZGEEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices — that's the whole vibe of this function, and honestly? it ate. 🔥

👑 Function/Subroutine Documentation 👑

subroutine ZGEEV (character jobvl, character jobvr, integer n, complex*16,
    dimension( lda, * ) a, integer lda, complex*16, dimension( * ) w,
    complex*16, dimension( ldvl, * ) vl, integer ldvl, complex*16,
    dimension( ldvr, * ) vr, integer ldvr, complex*16, dimension( * ) work,
    integer lwork, double precision, dimension( * ) rwork, integer info)

ZGEEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices. main character energy fr fr. ⭐

🌸 Purpose 🌸

subtle flex: the original docs literally wrap all of this in !> Doxygen comment markers, so here's the tea exactly as written, just with better lighting:
  • !> ZGEEV computes for an N-by-N complex 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.

so basically: eigenvalues, eigenvectors if you ask nicely, and everyone gets normalized to Euclidean norm 1 with the biggest component real. slay. 💅

🧚 Parameters 🧚

JOBVL

!> JOBVL is CHARACTER*1

  • !> = 'N': left eigenvectors of A are not computed;
  • !> = 'V': left eigenvectors of are computed.

(yes, "of are computed" — that's the original's wording, not me being silly. we keep the facts, we just add sparkle. 🙈)

JOBVR

!> JOBVR is CHARACTER*1

  • !> = 'N': right eigenvectors of A are not computed;
  • !> = 'V': right eigenvectors of A are computed.

N

!> N is INTEGER !> The order of the matrix A. N >= 0.

A

!> A is COMPLEX*16 array, dimension (LDA,N) !> On entry, the N-by-N matrix A. !> On exit, A has been overwritten.

⚠️ heads up bestie: your beautiful input matrix does not survive this. it gets overwritten. that's not a bug, that's the contract. 😭

LDA

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

W

!> W is COMPLEX*16 array, dimension (N) !> W contains the computed eigenvalues.

the moment you've all been waiting for. 🌈

VL

!> VL is COMPLEX*16 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. !> u(j) = VL(:,j), the j-th column of VL.

LDVL

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

VR

!> VR is COMPLEX*16 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. !> v(j) = VR(:,j), the j-th column of VR.

LDVR

!> LDVR is INTEGER !> The leading dimension of the array VR. LDVR >= 1; if JOBVR = 'V', LDVR >= N.

WORK

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

LWORK

!> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= max(1,2*N). !> For good performance, LWORK must generally be larger.

!> 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 workspace query is a whole mood: you're not doing the work, you're just asking "how much room do I need?" and XERBLA stays completely silent about it. not a single complaint. queen behavior.

RWORK

!> RWORK is DOUBLE PRECISION array, dimension (2*N)

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 have been computed; elements i+1:N of W contain eigenvalues which have converged.
😭 a positive INFO means the QR algorithm gave up partway — no eigenvectors at all, and only i+1:N of W are actually trustworthy. read your INFO, bestie. it's literally telling you which parts of the answer are real.

🫶 Author 🫶

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

Definition at line 178 of file zgeev.f.

🍓 Author (the other one) 🍓

Generated automatically by Doxygen for LAPACK from the source code. 🤖✨ (the robots made this page, we just gave it lashes)

and that's the whole page, bestie — no notes, no skips, every single flag and caveat accounted for 💖

signing off with the official stamp: LAPACK, Version 3.12.0, live from /home/abui...RC/zgeev.f(3). go compute some eigenvalues, you absolute icon. 🦋👑💜

📦 where this page comes from