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

💅 NAME

ok so bestie, this is the manual page for the file at /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/ctplqt2.f — it's from the LAPACK Library Functions Manual, and yes the path is giving "deep in the build directory" energy but that's literally where it lives, no cap.

---

✨ SYNOPSIS ✨

Functions/Subroutines 🫶

subroutine CTPLQT2 (m, n, l, a, lda, b, ldb, t, ldt, info)

CTPLQT2 — that's her, that's the main character 💜

---

🎀 Function/Subroutine Documentation 🎀

subroutine CTPLQT2 (integer m, integer n, integer l, complex, dimension(
    lda, * ) a, integer lda, complex, dimension( ldb, * ) b, integer ldb,
    complex, dimension( ldt, * ) t, integer ldt, integer info)

CTPLQT2 ⭐

🌸 Purpose 🌸

ok so here's the vibe:

!>
!> CTPLQT2 computes a LQ a factorization of a complex
!> matrix C, which is composed of a triangular block A and pentagonal block B,
!> using the compact WY representation for Q.
!>

like literally that's the whole point of her existence 💖

---

👑 Parameters 👑

M

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

total rows of B, bestie — and M >= 0, we don't do negative rows here 🚫

N

!>          N is INTEGER
!>          The number of columns of the matrix B, and the order of
!>          the triangular matrix A.
!>          N >= 0.
!>

columns of B and the order of the triangular matrix A — she's doing double duty, iconic. N >= 0 💅

L

!>          L is INTEGER
!>          The number of rows of the lower trapezoidal part of B.
!>          MIN(M,N) >= L >= 0.  See Further Details.
!>

rows in the lower trapezoidal part of B. Constraint is MIN(M,N) >= L >= 0, and yeah go read Further Details, it's worth it 🦋

A

!>          A is COMPLEX array, dimension (LDA,M)
!>          On entry, the lower triangular M-by-M matrix A.
!>          On exit, the elements on and below the diagonal of the array
!>          contain the lower triangular matrix L.
!>

input: lower triangular M-by-M. output: everything on and below the diagonal is the lower triangular matrix L. she transforms ✨

LDA

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

leading dimension of A, and LDA >= max(1,M) — respect the constraint fr fr 🙏

B

!>          B is COMPLEX array, dimension (LDB,N)
!>          On entry, the pentagonal M-by-N matrix B.  The first N-L columns
!>          are rectangular, and the last L columns are lower trapezoidal.
!>          On exit, B contains the pentagonal matrix V.  See Further Details.
!>

on entry: pentagonal M-by-N matrix B, first N-L columns rectangular, last L columns lower trapezoidal. on exit: B holds the pentagonal matrix V. glow-up complete 💀

LDB

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

leading dimension of B, with LDB >= max(1,M) 🫶

T

!>          T is COMPLEX array, dimension (LDT,M)
!>          The N-by-N upper triangular factor T of the block reflector.
!>          See Further Details.
!>

the N-by-N upper triangular factor T of the block reflector 💜 (dimension is (LDT,M), in case you were wondering — keep that straight, bestie)

LDT

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

leading dimension of T, and it's LDT >= max(1,M) — note there's no period at the end in the original, we're keeping it real 😌

INFO

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

0 = we ate and left no crumbs 🔥. < 0 = if INFO = -i, the i-th argument had an illegal value — someone did NOT read the constraints, and it shows 🙈

---

🌈 Author 🌈

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

the whole squad contributed, we love a collab 👑

---

⭐ Further Details: ⭐

ok this is the part where it gets good, so pay attention bestie:

!>
!>  The input matrix C is a M-by-(M+N) matrix
!>
!>               C = [ A ][ B ]
!>
!>
!>  where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
!>  matrix consisting of a M-by-(N-L) rectangular matrix B1 left of a M-by-L
!>  upper trapezoidal matrix B2:
!>
!>               B = [ B1 ][ B2 ]
!>                   [ B1 ]  <-     M-by-(N-L) rectangular
!>                   [ B2 ]  <-     M-by-L lower trapezoidal.
!>
!>  The lower trapezoidal matrix B2 consists of the first L columns of a
!>  N-by-N lower triangular matrix, where 0 <= L <= MIN(M,N).  If L=0,
!>  B is rectangular M-by-N; if M=L=N, B is lower triangular.
!>

so B2 = first L columns of an N-by-N lower triangular matrix, and 0 <= L <= MIN(M,N). Special cases, because there always are some:

• if L=0, B is rectangular M-by-N
• if M=L=N, B is lower triangular

then the matrix W stores the elementary reflectors H(i) in the i-th row above the diagonal (of A) in the M-by-(M+N) input matrix C:

!>
!>               C = [ A ][ B ]
!>                   [ A ]  <- lower triangular M-by-M
!>                   [ B ]  <- M-by-N pentagonal
!>
!>  so that W can be represented as
!>
!>               W = [ I ][ V ]
!>                   [ I ]  <- identity, M-by-M
!>                   [ V ]  <- M-by-N, same form as B.
!>

I is the identity, M-by-M, and V is M-by-N, same form as B, iykyk.

!>
!>  Thus, all of information needed for W is contained on exit in B, which
!>  we call V above.  Note that V has the same form as B; that is,
!>
!>               W = [ V1 ][ V2 ]
!>                   [ V1 ] <-     M-by-(N-L) rectangular
!>                   [ V2 ] <-     M-by-L lower trapezoidal.
!>

so yeah — everything you need for W lives on exit in B, and we're calling her V now. V has the same form as B:

• V1 <- M-by-(N-L) rectangular
• V2 <- M-by-L lower trapezoidal

!>
!>  The rows of V represent the vectors which define the H(i)'s.
!>  The (M+N)-by-(M+N) block reflector H is then given by
!>
!>               H = I - W**T * T * W
!>
!>  where W^H is the conjugate transpose of W and T is the upper triangular
!>  factor of the block reflector.
!>

the rows of V are the vectors defining the H(i)'s, and the (M+N)-by-(M+N) block reflector H is:

H = I - W**T * T * W

⚠️ heads up bestie: the !> comment says W^H is the conjugate transpose of W, while the formula written above it has W**T — that's exactly how it is in the source, so don't come for me, I'm just the messenger 💀

---

🦋 Definition at line 161 of file ctplqt2.f. 🦋

---

🍓 Author 🍓

Generated automatically by Doxygen for LAPACK from the source code. yes she was auto-generated, but she still ate 💅✨

---

🌸 signed, sealed, delivered by LAPACK, Version 3.12.0, dated /home/abui.../ctplqt2.f(3) — periodt, bestie, go factor something 💖🎀🫶