SRC/dgeqrt3.f(3)

✨ NAME ✨

SRC/dgeqrt3.f — ok so this is the man page for one specific little function file, and honestly it's giving main character energy 💅

Also hi, quick thing: this whole page lives in the Library Functions Manual section, so that's the vibe. Carry on 🫶

---

🌸 SYNOPSIS 🌸

Functions/Subroutines

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

---

🦋 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)

Okay so like — DGEQRT3 recursively computes a QR factorization of a general real or complex matrix using the compact WY representation of Q. That's the whole personality ✨

💜 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 yeah: it does a QR factorization of a real M-by-N matrix A with the compact WY representation of Q, and the whole recursion situation is built on the algorithm of Elmroth and Gustavson — that's IBM J. Res. Develop. Vol 44 No. 4 July 2000, no cap 📚

---

🎀 Parameters 🎀

• M — okay so M is INTEGER, and it's the number of rows of the matrix A. Constraint: M >= N. Respect the constraint, bestie 🙈

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

• N — N is INTEGER, the number of columns of the matrix A. Constraint: N >= 0. Lowkey the simplest one here 🍓

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

• A — A is a DOUBLE PRECISION array, dimension (LDA,N). On entry, it's the real M-by-N matrix A. On exit — and this is the glow-up moment — the elements on and above the diagonal contain the N-by-N upper triangular matrix R, and the elements below the diagonal are the columns of V. See below for further details ✨

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

• LDA — LDA is INTEGER, the leading dimension of the array A. Constraint: LDA >= max(1,M). She's the leading dimension, she sets the rules 💅

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

• T — T is a DOUBLE PRECISION array, dimension (LDT,N), and it holds 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 (they're just there, vibing 💀). See below for further details.

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

• LDT — LDT is INTEGER, the leading dimension of the array T. Constraint: LDT >= max(1,N). Match her energy, don't skip it 🧚

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

• INFO — INFO is INTEGER, and it's the little status report we all need:
  • = 0: successful exit 🎉
  • < 0: if INFO = -i, the i-th argument had an illegal value 😭 (rude but fair)

!>          INFO is INTEGER
!>          = 0: successful exit
!>          < 0: 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.

The whole friend group contributed, we love a collab 🫶

---

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

So real talk: the matrix V stores the elementary reflectors H(i) in the i-th column below the diagonal. Example time, and it's lowkey cute — 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. Important detail, do not skip: the 1's along the diagonal of V are not stored in A 🙅

Then the block reflector H is given by:

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

where V**T is the transpose of V. Slay 🐍

And for the full details of the algorithm, see Elmroth and Gustavson — cited above, iykyk ⭐

---

⭐ Definition ⭐

Definition at line 131 of file dgeqrt3.f.

---

💖 Author 💖

Generated automatically by Doxygen for LAPACK from the source code. (Not a human, just a robot doing its little tasks 🤖✨)

---

And that's the page, bestie! Big sign-off energy: this is LAPACK, Version 3.12.0, from SRC/dgeqrt3.f(3) — go forth and factorize your little heart out 💜🎀🦋