SRC/dorgbr.f(3)

💅 SRC/dorgbr.f — from the LAPACK Library Functions Manual ✨

okay bestie, buckle up, because this is the glow-up of dorgbr 🦋 — a Fortran subroutine that's been serving realness in the LAPACK manual (that's the Library Functions Manual, iykyk).

---

✨ SYNOPSIS ✨

🎀 Functions/Subroutines

• subroutine dorgbr (vect, m, n, k, a, lda, tau, work, lwork, info) — DORGBR 👑

---

🌸 Function/Subroutine Documentation 🌸

subroutine dorgbr (character vect, integer m, integer n, integer k, double
    precision, dimension( lda, * ) a, integer lda, double precision,
    dimension( * ) tau, double precision, dimension( * ) work, integer
    lwork, integer info)

DORGBR — literally the main character 🔥

💖 Purpose:

!> !> DORGBR generates one of the real orthogonal matrices Q or PT !> determined by DGEBRD when reducing a real matrix A to bidiagonal !> form: A = Q * B * PT. Q and PT are defined as products of !> elementary reflectors H(i) or G(i) respectively. !> !> If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q !> is of order M: !> if m >= k, Q = H(1) H(2) . . . H(k) and DORGBR returns the first n !> columns of Q, where m >= n >= k; !> if m < k, Q = H(1) H(2) . . . H(m-1) and DORGBR returns Q as an !> M-by-M matrix. !> !> If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT !> is of order N: !> if k < n, PT = G(k) . . . G(2) G(1) and DORGBR returns the first m !> rows of PT, where n >= m >= k; !> if k >= n, PT = G(n-1) . . . G(2) G(1) and DORGBR returns PT as !> an N-by-N matrix. !>

so basically: DGEBRD already did the bidiagonal thing (A = Q * B * P**T) and now DORGBR is here to actually build you the real orthogonal matrix Q or P**T out of those elementary reflectors H(i) / G(i). two flavors, pick your fighter 💅

👑 Parameters

🌈 VECT

!> VECT is CHARACTER*1 !> Specifies whether the matrix Q or the matrix PT is !> required, as defined in the transformation applied by DGEBRD: !> = 'Q': generate Q; !> = 'P': generate PT. !>

a CHARACTER*1 king — tells us which matrix we're manifesting, exactly as DGEBRD defined it: 'Q' means generate Q, 'P' means generate P**T ✨

🦋 M

!> M is INTEGER !> The number of rows of the matrix Q or P**T to be returned. !> M >= 0. !>

INTEGER. it's the row count of the Q or P**T you're getting back. M >= 0, no exceptions 🫶

🎀 N

!> N is INTEGER !> The number of columns of the matrix Q or P**T to be returned. !> N >= 0. !> If VECT = 'Q', M >= N >= min(M,K); !> if VECT = 'P', N >= M >= min(N,K). !>

INTEGER. the column count of the returned Q or P**T. N >= 0, and the constraints go off: if VECT = 'Q', then M >= N >= min(M,K); if VECT = 'P', then N >= M >= min(N,K) ⭐

🧚 K

!> K is INTEGER !> If VECT = 'Q', the number of columns in the original M-by-K !> matrix reduced by DGEBRD. !> If VECT = 'P', the number of rows in the original K-by-N !> matrix reduced by DGEBRD. !> K >= 0. !>

INTEGER. the context clue: if VECT = 'Q', it's the column count of the original M-by-K matrix that DGEBRD reduced; if VECT = 'P', it's the row count of the original K-by-N matrix DGEBRD reduced. and yes, K >= 0 💜

💀 A

!> A is DOUBLE PRECISION array, dimension (LDA,N) !> On entry, the vectors which define the elementary reflectors, !> as returned by DGEBRD. !> On exit, the M-by-N matrix Q or P**T. !>

DOUBLE PRECISION array, dimension (LDA,N). on entry it's holding the vectors that define the elementary reflectors (straight from DGEBRD, tyvm); on exit it becomes the M-by-N matrix Q or P**T. glow-up complete 🔥

🍓 LDA

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

INTEGER. leading dimension of A. and it's non-negotiable: LDA >= max(1,M) 🙈

🌸 TAU

!> TAU is DOUBLE PRECISION array, dimension !> (min(M,K)) if VECT = 'Q' !> (min(N,K)) if VECT = 'P' !> TAU(i) must contain the scalar factor of the elementary !> reflector H(i) or G(i), which determines Q or P**T, as !> returned by DGEBRD in its array argument TAUQ or TAUP. !>

DOUBLE PRECISION array, dimension (min(M,K)) if VECT = 'Q', or (min(N,K)) if VECT = 'P'. TAU(i) must hold the scalar factor of the elementary reflector H(i) or G(i) — the thing that determines Q or P**T — just like DGEBRD handed it over in its TAUQ or TAUP array argument 💖

⭐ WORK

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

DOUBLE PRECISION array, dimension (MAX(1,LWORK)). on exit, if INFO = 0, then WORK(1) hands you back the optimal LWORK 🫶

🌈 LWORK

!> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= max(1,min(M,N)). !> For optimum performance LWORK >= min(M,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. !>

INTEGER, the dimension of the WORK array. LWORK >= max(1,min(M,N)). for optimum performance, LWORK >= min(M,N)*NB where NB is the optimal blocksize ✨

🚨 important bestie: if LWORK = -1, that's a workspace query — the routine only calculates the optimal size of the WORK array, returns that value as the first entry of WORK, and XERBLA will not throw an LWORK error message at you. so don't panic, it's intentional 💀

👑

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

INTEGER. the vibe check at the end: = 0 means successful exit 🎉; < 0 means 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.

🔍 Definition at line 156 of file dorgbr.f.

---

🌟 Author

Generated automatically by Doxygen for LAPACK from the source code. (yeah the docs wrote themselves, iconic behavior honestly 🤖✨)

---

and that's the whole page, bestie — no cap, every flag, every constraint, every >=, preserved 🫶 this was LAPACK, Version 3.12.0, dated on the SRC/dorgbr.f(3) page. slay, go build your orthogonal matrix 💅👑