SRC/slaein.f(3)

📦
version 3.12.1 · 4 versions
, in arch rolling

💅 NAME

SRC/slaein.f — ok so this is the manual page for slaein, and it's literally the file SRC/slaein.f, bestie. That's the whole name section. Short and iconic. ✨

✨ SYNOPSIS

Functions/Subroutines

subroutine slaein (rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb,
    work, eps3, smlnum, bignum, info)

SLAEIN computes a specified right or left eigenvector of an upper Hessenberg matrix by inverse iteration. That's the whole vibe. 🦋

🎀 Function/Subroutine Documentation

subroutine slaein

subroutine slaein (logical rightv, logical noinit, integer n, real,
    dimension( ldh, * ) h, integer ldh, real wr, real wi, real, dimension( *
    ) vr, real, dimension( * ) vi, real, dimension( ldb, * ) b, integer ldb,
    real, dimension( * ) work, real eps3, real smlnum, real bignum, integer
    info)

SLAEIN computes a specified right or left eigenvector of an upper Hessenberg matrix by inverse iteration. No cap, that's what it does. 👑

🔥 Purpose

!>
!> SLAEIN uses inverse iteration to find a right or left eigenvector
!> corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg
!> matrix H.
!>

So like — inverse iteration, one eigenvalue, you pick a side (right or left), and it finds you the eigenvector. Slay. 💅

🧚 Parameters

  • RIGHTV — RIGHTV is LOGICAL. Bestie, pick a side:
!>          RIGHTV is LOGICAL
!>          = .TRUE. : compute right eigenvector;
!>          = .FALSE.: compute left eigenvector.
!>
  • NOINIT — NOINIT is LOGICAL. Are you supplying a starting vector or not, that's the question:
!>          NOINIT is LOGICAL
!>          = .TRUE. : no initial vector supplied in (VR,VI).
!>          = .FALSE.: initial vector supplied in (VR,VI).
!>
  • N — N is INTEGER. The order of the matrix H. And it's gotta be N >= 0, no sneaky negatives. 🌸
!>          N is INTEGER
!>          The order of the matrix H.  N >= 0.
!>
  • H — H is a REAL array, dimension (LDH,N). It's the upper Hessenberg matrix H. main character energy, honestly. ✨
!>          H is REAL array, dimension (LDH,N)
!>          The upper Hessenberg matrix H.
!>
  • LDH — LDH is INTEGER. The leading dimension of the array H, and it must be LDH >= max(1,N). Respect the constraint or don't come to the party. 🙈
!>          LDH is INTEGER
!>          The leading dimension of the array H.  LDH >= max(1,N).
!>
  • WR — WR is REAL. Just vibes here, no extra notes:
!>          WR is REAL
!>
  • WI — WI is REAL. Together with WR it's the real and imaginary part of the eigenvalue of H whose corresponding right or left eigenvector you're computing:
!>          WI is REAL
!>          The real and imaginary parts of the eigenvalue of H whose
!>          corresponding right or left eigenvector is to be computed.
!>
  • VR — VR is a REAL array, dimension (N). Okay this one's a whole essay, so pay attention bestie:
!>          VR is REAL array, dimension (N)
!>

and then:

!>          VI is REAL array, dimension (N)
!>          On entry, if NOINIT = .FALSE. and WI = 0.0, VR must contain
!>          a real starting vector for inverse iteration using the real
!>          eigenvalue WR; if NOINIT = .FALSE. and WI.ne.0.0, VR and VI
!>          must contain the real and imaginary parts of a complex
!>          starting vector for inverse iteration using the complex
!>          eigenvalue (WR,WI); otherwise VR and VI need not be set.
!>          On exit, if WI = 0.0 (real eigenvalue), VR contains the
!>          computed real eigenvector; if WI.ne.0.0 (complex eigenvalue),
!>          VR and VI contain the real and imaginary parts of the
!>          computed complex eigenvector. The eigenvector is normalized
!>          so that the component of largest magnitude has magnitude 1;
!>          here the magnitude of a complex number (x,y) is taken to be
!>          |x| + |y|.
!>          VI is not referenced if WI = 0.0.
!>

(yes, that block is filed under VI below too — it's a joint slay, they share the description 🫶)

  • VI — VI is a REAL array, dimension (N). See the big block right above 👆 — on entry with NOINIT = .FALSE. and WI = 0.0, VR holds a real starting vector; with NOINIT = .FALSE. and WI.ne.0.0, VR and VI hold the real and imaginary parts of a complex starting vector; otherwise VR and VI need not be set. On exit, WI = 0.0 → VR has the computed real eigenvector, WI.ne.0.0 → VR and VI have the real and imaginary parts of the computed complex eigenvector. It's normalized so the component of largest magnitude has magnitude 1, where the magnitude of a complex number (x,y) is |x| + |y|. And VI is not referenced if WI = 0.0. Literally all of it. 💀
  • B — B is a REAL array, dimension (LDB,N). That's it, that's the note:
!>          B is REAL array, dimension (LDB,N)
!>
  • LDB — LDB is INTEGER. The leading dimension of the array B, and it's gotta satisfy LDB >= N+1. ⭐
!>          LDB is INTEGER
!>          The leading dimension of the array B.  LDB >= N+1.
!>
  • WORK — WORK is a REAL array, dimension (N). Doing the work, as the name suggests:
!>          WORK is REAL array, dimension (N)
!>
  • EPS3 — EPS3 is REAL. A small machine-dependent value used to perturb close eigenvalues and to replace zero pivots. It's giving cleanup crew. 🎀
!>          EPS3 is REAL
!>          A small machine-dependent value which is used to perturb
!>          close eigenvalues, and to replace zero pivots.
!>
  • SMLNUM — SMLNUM is REAL. A machine-dependent value close to the underflow threshold:
!>          SMLNUM is REAL
!>          A machine-dependent value close to the underflow threshold.
!>
  • BIGNUM — BIGNUM is REAL. A machine-dependent value close to the overflow threshold. Big number, big name, big energy 🔥
!>          BIGNUM is REAL
!>          A machine-dependent value close to the overflow threshold.
!>
  • INFO — INFO is INTEGER. The vibe check at the end:
!>          INFO is INTEGER
!>          = 0:  successful exit
!>          = 1:  inverse iteration did not converge; VR is set to the
!>                last iterate, and so is VI if WI.ne.0.0.
!>
⚠️ Heads up bestie: if INFO = 1, inverse iteration did not converge — VR gets set to the last iterate, and so does VI if WI.ne.0.0. So it's not a crash, it's just... not converged. Don't @ me. 😭

👑 Author

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

🌈 Definition at line 170 of file slaein.f.

🌸 Author

Generated automatically by Doxygen for LAPACK from the source code.

And that's the page, babe — LAPACK, Version 3.12.0, SRC/slaein.f(3), straight from the source. Go compute an eigenvector and text me when it converges 💖✨🫶

📦 where this page comes from