SRC/zlaqz2.f(3)

📦
version 3.12.1 · 3 versions
, in arch rolling

💅 SRC/zlaqz2.f(3) — the zlaqz2 glow-up 🦋

okay bestie, so this is a page from the LAPACK manual — section 3, SRC/zlaqz2.f, like the file itself. it's a Fortran thing. it's giving numerical linear algebra and honestly? iconic. let's get into it ✨

✨ NAME ✨

SRC/zlaqz2.f — that's literally it, that's the name, she's self-titled 💅

🌸 SYNOPSIS 🌸

Functions/Subroutines

  • recursive subroutine zlaqz2 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alpha, beta, qc, ldqc, zc, ldzc, work, lwork, rwork, rec, info) — also known as ZLAQZ2 👑

🎀 Function/Subroutine Documentation 🎀

recursive subroutine zlaqz2

so the full signature, no cap, is:

recursive subroutine zlaqz2 (logical, intent(in) ilschur, logical,
    intent(in) ilq, logical, intent(in) ilz, integer, intent(in) n, integer,
    intent(in) ilo, integer, intent(in) ihi, integer, intent(in) nw,
    complex*16, dimension( lda, * ), intent(inout) a, integer, intent(in)
    lda, complex*16, dimension( ldb, * ), intent(inout) b, integer,
    intent(in) ldb, complex*16, dimension( ldq,         * ), intent(inout)
    q, integer, intent(in) ldq, complex*16, dimension( ldz, * ),
    intent(inout) z, integer, intent(in) ldz, integer, intent(out) ns,
    integer, intent(out) nd, complex*16, dimension( * ), intent(inout)
    alpha, complex*16, dimension( * ), intent(inout) beta, complex*16,
    dimension( ldqc, * ) qc, integer, intent(in) ldqc, complex*16,
    dimension( ldzc, * ) zc, integer, intent(in) ldzc, complex*16,
    dimension( * ) work, integer, intent(in) lwork, double precision,
    dimension( * ) rwork, integer, intent(in) rec, integer, intent(out)
    info)

ZLAQZ2 🔥

💖 Purpose 💖

!> !> ZLAQZ2 performs AED !>

that's the whole purpose, bestie. AED. she does AED. that's her job and she ate 💀✨

🌈 Parameters 🌈

okay here's the full cast, no skips, we're doing all of them 🫶

ILSCHUR

!> ILSCHUR is LOGICAL !> Determines whether or not to update the full Schur form !>

ILQ

!> ILQ is LOGICAL !> Determines whether or not to update the matrix Q !>

ILZ

!> ILZ is LOGICAL !> Determines whether or not to update the matrix Z !>

N

!> N is INTEGER !> The order of the matrices A, B, Q, and Z. N >= 0. !>

ILO

!> ILO is INTEGER !>

IHI

!> IHI is INTEGER !> ILO and IHI mark the rows and columns of (A,B) which !> are to be normalized !>

NW

!> NW is INTEGER !> The desired size of the deflation window. !>

A

!> A is COMPLEX*16 array, dimension (LDA, N) !>

LDA

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

B

!> B is COMPLEX*16 array, dimension (LDB, N) !>

LDB

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

Q

!> Q is COMPLEX*16 array, dimension (LDQ, N) !>

LDQ

!> LDQ is INTEGER !>

Z

!> Z is COMPLEX*16 array, dimension (LDZ, N) !>

LDZ

!> LDZ is INTEGER !>

NS

!> NS is INTEGER !> The number of unconverged eigenvalues available to !> use as shifts. !>

ND

!> ND is INTEGER !> The number of converged eigenvalues found. !>

ALPHA

!> ALPHA is COMPLEX*16 array, dimension (N) !> Each scalar alpha defining an eigenvalue !> of GNEP. !>

BETA

!> BETA is COMPLEX*16 array, dimension (N) !> The scalars beta that define the eigenvalues of GNEP. !> Together, the quantities alpha = ALPHA(j) and !> beta = BETA(j) represent the j-th eigenvalue of the matrix !> pair (A,B), in one of the forms lambda = alpha/beta or !> mu = beta/alpha. Since either lambda or mu may overflow, !> they should not, in general, be computed. !>
⚠️ real talk bestie: either lambda or mu may overflow, so like… don't just casually compute them, okay? that's the warning, i'm just relaying it 💀

QC

!> QC is COMPLEX*16 array, dimension (LDQC, NW) !>

LDQC

!> LDQC is INTEGER !>

ZC

!> ZC is COMPLEX*16 array, dimension (LDZC, NW) !>

LDZC

!> LDZ is INTEGER !>

(no i did not typo that — the original literally says LDZC is documented as LDZ is INTEGER, and i'm keeping it exactly as written 🙈)

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,N). !> !> 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. !>

so LWORK = -1 is the little "just tell me how much space i need" mode, and XERBLA stays quiet about it 🎀

RWORK

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

REC

!> REC is INTEGER !> REC indicates the current recursion level. Should be set !> to 0 on first call. !>

first call? set it to 0. that's the vibe check ✅

INFO

!> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !>
  • 0 → slayed, successful exit 🎉
  • < 0 → if INFO = -i, the i-th argument had an illegal value 😭

👑 Author 👑

Thijs Steel, KU Leuven — we stan 💜

🦋 Date 🦋

May 2020 🌸

Definition at line 230 of file zlaqz2.f. 📍

🍓 Author (the meta one) 🍓

Generated automatically by Doxygen for LAPACK from the source code. (yes, the docs have an author section that says the docs were generated. recursive, just like the subroutine. main character energy fr fr ✨)

and that's the whole page bestie, every last parameter, no cap 🫶💖

LAPACK — Version 3.12.0 — SRC/zlaqz2.f(3) ⭐ sign-off time: docs generated by Doxygen for LAPACK, version 3.12.0, page SRC/zlaqz2.f(3) — go forth and perform AED, icon 💅🎀

📦 where this page comes from