/home/abui.../dgeqrt3.f(3)

💅 dgeqrt3.f — Library Functions Manual, but make it a group chat 🫶

okay so bestie, this is the man page for /home/abui.../dgeqrt3.f(3) and it's lowkey a whole mood because it's recursive Fortran and it knows it. It's part of the Library Functions Manual, and ngl, this file ate. ✨

---

✨ NAME ✨

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

that's the whole name, yes the entire path, it's giving "my mom named me after where I was born" energy 💀 but we respect it.

---

🌸 SYNOPSIS 🌸

Functions/Subroutines

• recursive subroutine DGEQRT3 (m, n, a, lda, t, ldt, info) — DGEQRT3 recursively computes a QR factorization of a general real or complex matrix using the compact WY representation of Q.

literally the main character, recursive and everything 👑

---

🦋 Function/Subroutine Documentation 🦋

recursive subroutine DGEQRT3 (integer m, integer n, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( ldt, * ) t, integer ldt, integer info)

DGEQRT3 recursively computes a QR factorization of a general real or complex matrix using the compact WY representation of Q.

💖 Purpose: 💖

!>
!> DGEQRT3 recursively computes a QR factorization of a real M-by-N
!> matrix A, using the compact WY representation of Q.
!>
!> Based on the algorithm of Elmroth and Gustavson,
!> IBM J. Res. Develop. Vol 44 No. 4 July 2000.
!>

so it's out here doing QR factorization on a real M-by-N matrix A with the compact WY representation of Q, and it's built on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000. iconic citation, they knew their sources 💅

---

🎀 Parameters 🎀

• M — !> M is INTEGER → !> The number of rows of the matrix A. M >= N. so like, the row count, and it's gotta be at least N. no pressure or anything 🙈
• N — !> N is INTEGER → !> The number of columns of the matrix A. N >= 0. the column count, and it can be zero, she's flexible ✨
• A — !> A is DOUBLE PRECISION array, dimension (LDA,N) → !> On entry, the real M-by-N matrix A. On exit, the elements on and above the diagonal contain the N-by-N upper triangular matrix R; the elements below the diagonal are the columns of V. See below for further details. so it goes in as A and comes out as R on top and V on the bottom, a real glow-up transformation 🔥 (go read "See below" for the deets, it's worth it)
• LDA — !> LDA is INTEGER → !> The leading dimension of the array A. LDA >= max(1,M). the leading dimension of A, and it needs to be at least max(1,M). rules are rules 🫶
• T — !> T is DOUBLE PRECISION array, dimension (LDT,N) → !> The N-by-N upper triangular factor of the block reflector. / !> The elements on and above the diagonal contain the block reflector T; the elements below the diagonal are not used. / !> See below for further details. so the upper triangle is the actual T, the below-diagonal stuff is just vibes and is not used, don't come for it 💀
• LDT — !> LDT is INTEGER → !> The leading dimension of the array T. LDT >= max(1,N). leading dimension of T, minimum max(1,N), periodt ✨
• INFO — !> INFO is INTEGER → !> = 0: successful exit / !> < 0: if INFO = -i, the i-th argument had an illegal value so 0 means we slayed and everything worked, and a negative value means argument number i was out here behaving illegally 😭 not the i-th argument catching a case

---

🌈 Author 🌈

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

the whole friend group collaborated, we love a collective effort 🫶

---

⭐ Further Details: ⭐

!>
!>  The matrix V stores the elementary reflectors H(i) in the i-th column
!>  below the diagonal. For example, if M=5 and N=3, the matrix V is
!>
!>               V = (  1       )
!>                   ( v1  1    )
!>                   ( v1 v2  1 )
!>                   ( v1 v2 v3 )
!>                   ( v1 v2 v3 )
!>
!>  where the vi's represent the vectors which define H(i), which are returned
!>  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The
!>  block reflector H is then given by
!>
!>               H = I - V * T * V**T
!>
!>  where V**T is the transpose of V.
!>
!>  For details of the algorithm, see Elmroth and Gustavson (cited above).
!>

okay so bestie, V is storing the elementary reflectors H(i) in the i-th column below the diagonal, and if M=5 and N=3 you get exactly that cute little staircase of v1, v2, v3 above. the vi's are the vectors defining H(i), and they get returned in the matrix A. the 1's along the diagonal of V are not stored in A (so don't go looking for them, they're implied, it's giving minimalism 🎀).

and then the block reflector H is literally:

H = I - V * T * V**T

where V**T is the transpose of V. math ate, no notes 💅

for the full algorithm deets, go see Elmroth and Gustavson (cited above) — they said read the source, and honestly? respect.

---

Definition at line 131 of file dgeqrt3.f.

---

👑 Author 👑

Generated automatically by Doxygen for LAPACK from the source code. so nobody hand-wrote this, Doxygen did it, and honestly it did that 🫶

---

💀 reminder bestie: the 1s on V's diagonal are not stored in A, and the below-diagonal elements of T are not used — don't be out here reading uninitialized vibes, iykyk 🙈

---

LAPACK — Version 3.12.0 — /home/abui.../dgeqrt3.f(3) 🦋✨ and that's the whole man page, mwah, slay, bye 💖