/home/abui...L/dgeqrf.f(3)

💖 DGEQRF — the left-looking Level 3 BLAS QR glow-up 💖

okay bestie, so this page is from the LAPACK library manual — it's /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/VARIANTS/qr/LL/dgeqrf.f and honestly? it's giving variant energy. this is the LL (left-looking) girlie of the DGEQRF family, and she's here to factorize your matrix and serve looks. 🦋

---

✨ NAME ✨

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/VARIANTS/qr/LL/dgeqrf.f

like, yes, that's the whole name. it's a whole path. she's that girl, she lives deep in the VARIANTS/qr/LL/ folder and she knows it. 💅

---

🌸 SYNOPSIS 🌸

Functions/Subroutines

subroutine DGEQRF (m, n, a, lda, tau, work, lwork, info)

DGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm. periodt. 🔥

---

👑 Function/Subroutine Documentation 👑

subroutine DGEQRF (integer m, integer n, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( * ) tau, double precision, dimension( * ) work, integer lwork, integer info)

DGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm. (yes she says it twice, she's confident, let her live 🙈)

🎀 Purpose 🎀

!> !> DGEQRF computes a QR factorization of a real M-by-N matrix A: !> A = Q * R. !> !> This is the left-looking Level 3 BLAS version of the algorithm. !> !>

so basically: you hand her a real M-by-N matrix A, and she breaks it into A = Q * R. iconic behavior. and she does it the left-looking Level 3 BLAS way, which is a whole vibe. ngl the plain dgeqrf could never. 😌

💜 Parameters 💜

• M — lowkey the important one first:

!> M is INTEGER !> The number of rows of the matrix A. M >= 0. !>

so M is an INTEGER, it's how many rows A has, and M >= 0. no negative rows bestie, that's not a thing. 🫶

• N — the other dimension:

!> N is INTEGER !> The number of columns of the matrix A. N >= 0. !>

N is an INTEGER, the number of columns of A, and N >= 0. she's keeping it legal ✨

• A — the main character of this whole manpage:

!> A is DOUBLE PRECISION array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, the elements on and above the diagonal of the array !> contain the min(M,N)-by-N upper trapezoidal matrix R (R is !> upper triangular if m >= n); the elements below the diagonal, !> with the array TAU, represent the orthogonal matrix Q as a !> product of min(m,n) elementary reflectors (see Further !> Details). !>

okay so A is a DOUBLE PRECISION array, dimension (LDA,N). on entry it's literally just your M-by-N matrix A — cute. on exit though? glow-up 💅 the elements on and above the diagonal now hold the min(M,N)-by-N upper trapezoidal matrix R (and R is upper triangular if m >= n — yes, lowercase m in the original, she's quirky like that). and the elements below the diagonal, together with TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors. see Further Details if you wanna get into it 👀

• LDA — the leading dimension, respect her:

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

LDA is an INTEGER, it's the leading dimension of the array A, and it must satisfy LDA >= max(1,M). fr fr, don't skip the max(1,M), that 1 is doing important work when M is zero. 🧚

• TAU — the scalars:

!> TAU is DOUBLE PRECISION array, dimension (min(M,N)) !> The scalar factors of the elementary reflectors (see Further !> Details). !>

TAU is a DOUBLE PRECISION array of dimension (min(M,N)) holding the scalar factors of the elementary reflectors. again: Further Details, babes. 🍓

• WORK — the workspace, she's doing a lot:

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

WORK is a DOUBLE PRECISION array of dimension (MAX(1,LWORK)). on exit, if INFO = 0, then WORK(1) returns the optimal LWORK. free glow-up intel ✨

• LWORK — buckle up, this is the long one:

!> LWORK is INTEGER !>

LWORK is an INTEGER. cool cool cool. and then:

!> The dimension of the array WORK. LWORK >= 1 if MIN(M,N) = 0, !> otherwise the dimension can be divided into three parts. !>

so it's the dimension of the array WORK. LWORK >= 1 if MIN(M,N) = 0, otherwise the dimension can be divided into three parts. THREE parts. she's organized. 💀

!> 1) The part for the triangular factor T. If the very last T is not bigger !> than any of the rest, then this part is NB x ceiling(K/NB), otherwise, !> NB x (K-NT), where K = min(M,N) and NT is the dimension of the very last T !>

part 1) is for the triangular factor T. if the very last T is not bigger than any of the rest, then this part is NB x ceiling(K/NB); otherwise it's NB x (K-NT), where K = min(M,N) and NT is the dimension of the very last T. iykyk 🌀

!> 2) The part for the very last T when T is bigger than any of the rest T. !> The size of this part is NT x NT, where NT = K - ceiling ((K-NX)/NB) x NB, !> where K = min(M,N), NX is calculated by !> NX = MAX( 0, ILAENV( 3, 'DGEQRF', ' ', M, N, -1, -1 ) ) !>

part 2) is for the very last T when T is bigger than any of the rest T. the size of this part is NT x NT, where NT = K - ceiling ((K-NX)/NB) x NB, where K = min(M,N), and NX is calculated by:

NX = MAX( 0, ILAENV( 3, 'DGEQRF', ' ', M, N, -1, -1 ) )

copy that line exactly bestie, the spaces and the -1, -1 matter. 👑

!> 3) The part for dlarfb is of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB) !>

part 3) is for dlarfb, and it's of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB). four candidates, one winner. 🔥

!> So LWORK = part1 + part2 + part3 !>

so yeah: LWORK = part1 + part2 + part3. math ate. 💅

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

and here's the fun one: 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 -1 is not a bug, it's a question mark. 🙈

• INFO — the vibe check:

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

INFO is an INTEGER. = 0 means successful exit, slay. < 0 means if INFO = -i, then the i-th argument had an illegal value — so read the negative number as "which argument was bad," genius honestly. 😭

🦋 Author 🦋

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

the whole group chat contributed, we love a collab 🫶

🌈 Date 🌈

December 2016

she's vintage but she's still that girl 💜

⭐ Further Details ⭐

!> !> The matrix Q is represented as a product of elementary reflectors !> !> Q = H(1) H(2) . . . H(k), where k = min(m,n). !> !> Each H(i) has the form !> !> H(i) = I - tau * v * v' !> !> where tau is a real scalar, and v is a real vector with !> v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), !> and tau in TAU(i). !> !>

so the matrix Q is represented as a product of elementary reflectors:

Q = H(1) H(2) . . . H(k), where k = min(m,n).

and each H(i) has the form:

H(i) = I - tau * v * v'

where tau is a real scalar and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i). that's the whole lore. main character energy from a vector with a single 1 in it, honestly. 🧚✨

---

Definition at line 151 of file dgeqrf.f. literally line 151, go look, she's right there 📍

🍓 Author (again, yes) 🍓

Generated automatically by Doxygen for LAPACK from the source code. (a bot wrote this part, but a bot with taste 💅)

---

and that's the whole page, bestie! 💖 this was LAPACK, Version 3.12.0, dated December 2016 — and the file lives at /home/abui...L/dgeqrf.f(3) if you ever need to find her again. mwah, go factorize something pretty 😘🎀🦋