SLAEIN(3)

📦 version 3.12.0, in opensuse-leap 16.0

💅 slaein.f(3) — a LAPACK library functions manual moment

okay so this is a LAPACK manpage, bestie, from the Library Functions Manual corner of the universe, and it's about /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/slaein.f — yes that's the whole entire path, it's giving "I was generated by a build system and I'm proud of it" 💀

✨ NAME ✨

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/slaein.f — literally the file, that's the name, no cap, the whole path is the name 🫶

🌸 SYNOPSIS 🌸

Functions/Subroutines

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

so SLAEIN computes a specified right or left eigenvector of an upper Hessenberg matrix by inverse iteration. iconic behaviour tbh 👑

🦋 Function/Subroutine Documentation 🦋

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. main character energy, honestly ✨

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

like, that's the whole vibe: inverse iteration, eigenvalue (WR,WI), real upper Hessenberg matrix H. periodt 💜

🌈 Parameters 🌈

  • RIGHTV
!>          RIGHTV is LOGICAL
!>          = .TRUE. : compute right eigenvector;
!>          = .FALSE.: compute left eigenvector.
!>

so <mint>.TRUE.</mint> = right eigenvector, <mint>.FALSE.</mint> = left eigenvector. pick your fighter 🫶

  • NOINIT
!>          NOINIT is LOGICAL
!>          = .TRUE. : no initial vector supplied in (VR,VI).
!>          = .FALSE.: initial vector supplied in (VR,VI).
!>

<mint>.TRUE.</mint> means you're not supplying a starting vector in (VR,VI), <mint>.FALSE.</mint> means you are. k byeee 🙈

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

order of H, and it's gotta satisfy N >= 0. zero is allowed, we love an inclusive queen 💅

  • H
!>          H is REAL array, dimension (LDH,N)
!>          The upper Hessenberg matrix H.
!>

the actual upper Hessenberg matrix, REAL array, dimension (LDH,N) — she's the moment 🔥

  • LDH
!>          LDH is INTEGER
!>          The leading dimension of the array H.  LDH >= max(1,N).
!>

leading dimension of H, must be LDH >= max(1,N) ⭐

  • WR
!>          WR is REAL
!>

just a REAL. that's it. that's the whole entry. she said minimalism 💀

  • WI
!>          WI is REAL
!>          The real and imaginary parts of the eigenvalue of H whose
!>          corresponding right or left eigenvector is to be computed.
!>

so WR + WI together are the real and imaginary parts of the eigenvalue of H whose right-or-left eigenvector we're computing. the way that works is so cute 🎀

  • VR
!>          VR is REAL array, dimension (N)
!>

REAL array, dimension (N). and also ⬇️

  • VI
!>          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.
!>

okay this one is a whole saga, let me break it down 💀

on entry:

  • if NOINIT = .FALSE. and WI = 0.0, then VR must contain a real starting vector for inverse iteration using the real eigenvalue WR
  • if NOINIT = .FALSE. and WI.ne.0.0, then 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| — yes, that's the definition, don't come for her 🫶

and <yellow>VI is not referenced if WI = 0.0</yellow> — noted, bestie, she simply doesn't get invited to that party 😭

  • B
!>          B is REAL array, dimension (LDB,N)
!>

REAL array, dimension (LDB,N). short and sweet 🌸

  • LDB
!>          LDB is INTEGER
!>          The leading dimension of the array B.  LDB >= N+1.
!>

leading dimension of B, and the rule is LDB >= N+1 — note the +1, it's not a typo, don't @ me 💅

  • WORK
!>          WORK is REAL array, dimension (N)
!>

REAL array, dimension (N). she works, hence the name 💀

  • EPS3
!>          EPS3 is REAL
!>          A small machine-dependent value which is used to perturb
!>          close eigenvalues, and to replace zero pivots.
!>

small machine-dependent value, used to perturb close eigenvalues and to replace zero pivots ✨

  • SMLNUM
!>          SMLNUM is REAL
!>          A machine-dependent value close to the underflow threshold.
!>

machine-dependent value close to the underflow threshold. underflow threshold, got it 🐛

  • BIGNUM
!>          BIGNUM is REAL
!>          A machine-dependent value close to the overflow threshold.
!>

same but big: machine-dependent value close to the overflow threshold 🔥

  • INFO
!>          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.
!>

the vibe check at the end:

  • = 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 😭
ngl, INFO = 1 is the "we tried, bestie" exit code. the results you get are the last iterate, not a converged answer. don't pretend otherwise 💀

🧚 Author 🧚

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

⭐ Definition at line 170 of file slaein.f. ⭐

like, line 170, in slaein.f, exactly as stated 🎀

💖 Author 💖

Generated automatically by Doxygen for LAPACK from the source code. so nobody hand-wrote this, a robot did, and honestly? she ate 🤖✨

and that's the whole page, bestie — LAPACK, Version 3.12.0, and the footer says /home/abui...RC/slaein.f(3), so there's your source/version and your date-shaped sign-off. mwah 💋🫶💜

📦 where this page comes from