ZLAMTSQR(3)

💅 ZLAMTSQR(3) — ok bestie, let's talk tall-skinny QR

So this is a page out of the LAPACK Library Functions Manual, and the file we're stanning today is /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/zlamtsqr.f. Yes that's the whole path, no I'm not shortening it, it's literally the NAME section, okurrr? 🫶

---

✨ NAME ✨

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

That's it. That's the name. It's giving "my full government name on the attendance sheet" energy and honestly? Iconic. 👑

---

🌸 SYNOPSIS 🌸

Functions/Subroutines

subroutine ZLAMTSQR (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c,
    ldc, work, lwork, info)
    ZLAMTSQR

Lowkey that's the whole vibe check right there. 🦋

---

💖 Function/Subroutine Documentation 💖

ZLAMTSQR — the full signature, bestie

subroutine ZLAMTSQR (character side, character trans, integer m, integer n,
    integer k, integer mb, integer nb, complex*16, dimension( lda, * ) a,
    integer lda, complex*16, dimension( ldt, * ) t, integer ldt, complex*16,
    dimension(ldc, * ) c, integer ldc, complex*16, dimension( * ) work,
    integer lwork, integer info)

🎀 Purpose

!> !> ZLAMTSQR overwrites the general complex M-by-N matrix C with !> !> !> SIDE = 'L' SIDE = 'R' !> TRANS = 'N': Q * C C * Q !> TRANS = 'C': QH * C C * QH !> where Q is a complex unitary matrix defined as the product !> of blocked elementary reflectors computed by tall skinny !> QR factorization (ZLATSQR) !>

Translation for the girlies: it slaps Q (or Q**H) onto C, from whichever side you asked for. Q isn't some random matrix either — it's built out of blocked elementary reflectors from a tall skinny QR factorization (ZLATSQR). It's giving "Q is a group project and every reflector did their part." 💀

---

🌈 Parameters

SIDE

!> SIDE is CHARACTER*1 !> = 'L': apply Q or QH from the Left; !> = 'R': apply Q or QH from the Right. !>

Left or right, bestie. Pick a lane. 👀

TRANS

!> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'C': Conjugate Transpose, apply Q**H. !>

'N' = plain Q, 'C' = the conjugate transpose Q**H. No in-between, no "ehh kinda transpose." ✨

M

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

Rows of A. Also M >= 0, so no negatives, we don't do that here.

N

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

Columns of C. Again, N >= 0. Respect the non-negativity fr fr. 💅

K

!> K is INTEGER !> The number of elementary reflectors whose product defines !> the matrix Q. M >= K >= 0; !> !>

K elementary reflectors, M >= K >= 0. That's the squad that multiplies together into Q. 🫶

MB

!> MB is INTEGER !> The block size to be used in the blocked QR. !> MB > N. (must be the same as ZLATSQR) !>

Block size for the blocked QR, and MB > N — that's a strict greater-than, don't push it. Also: must be the same as ZLATSQR. If you change it here and not there, that's on you, not me. 🙈

NB

!> NB is INTEGER !> The column block size to be used in the blocked QR. !> N >= NB >= 1. !>

The column block size. N >= NB >= 1. Periodt. 🎀

A

!> A is COMPLEX*16 array, dimension (LDA,K) !> The i-th column must contain the vector which defines the !> blockedelementary reflector H(i), for i = 1,2,...,k, as !> returned by ZLATSQR in the first k columns of !> its array argument A. !>

(Yes, the original says blockedelementary — one word, no space, we're leaving it exactly as found, character for character. 💀) Column i holds the vector defining H(i) for i = 1,2,...,k, straight-up as ZLATSQR handed it back in the first k columns of its A.

LDA

!> LDA is INTEGER !> The leading dimension of the array A. !> If SIDE = 'L', LDA >= max(1,M); !> if SIDE = 'R', LDA >= max(1,N). !>

Leading dimension of A, and it flexes by side: LDA >= max(1,M) for 'L', LDA >= max(1,N) for 'R'.

T

!> T is COMPLEX*16 array, dimension !> ( N * Number of blocks(CEIL(M-K/MB-K)), !> The blocked upper triangular block reflectors stored in compact form !> as a sequence of upper triangular blocks. See below !> for further details. !>

The blocked upper triangular block reflectors, stored compact, as a sequence of upper triangular blocks. Dimension is N * Number of blocks(CEIL(M-K/MB-K)). See below for the details — and yes, "below" means the Further Details section, we're getting there, be patient. 🌸

LDT

!> LDT is INTEGER !> The leading dimension of the array T. LDT >= NB. !>

LDT >= NB. Simple. Clean. Slay. ⭐

C

!> C is COMPLEX*16 array, dimension (LDC,N) !> On entry, the M-by-N matrix C. !> On exit, C is overwritten by Q*C or QH*C or C*QH or C*Q. !>

You bring the M-by-N matrix C, you leave with it overwritten — Q*C or Q**H*C or C*Q**H or C*Q. She does not preserve your data, she transforms it. Main character energy. 🔥

LDC

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

LDC >= max(1,M). That's the rule, no cap.

WORK

!> (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK)) !> !>

Workspace, COMPLEX*16, dimension (MAX(1,LWORK)). The lil scratchpad. 🧚

LWORK

!> LWORK is INTEGER !> The dimension of the array WORK. !> !> If SIDE = 'L', LWORK >= max(1,N)*NB; !> if SIDE = 'R', LWORK >= max(1,MB)*NB. !> 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. !>

Size of WORK: LWORK >= max(1,N)*NB for 'L', LWORK >= max(1,MB)*NB for 'R'.

⚠️ And listen: if LWORK = -1, that's the workspace query mode. It only computes the optimal size of WORK, sticks that value as the first entry of WORK, and — key detail — no error message related to LWORK is issued by XERBLA. So -1 is a legit move, not a bug. Don't come for me. 💅

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 = INFO = -i means the i-th argument was illegal — go check your args bestie. 😭

---

👑 Author

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

The founding mothers of this routine. Respect the lineage. 🌺

---

🦋 Further Details

!> Tall-Skinny QR (TSQR) performs QR by a sequence of unitary transformations, !> representing Q as a product of other unitary matrices !> Q = Q(1) * Q(2) * . . . * Q(k) !> where each Q(i) zeros out subdiagonal entries of a block of MB rows of A: !> Q(1) zeros out the subdiagonal entries of rows 1:MB of A !> Q(2) zeros out the bottom MB-N rows of rows [1:N,MB+1:2*MB-N] of A !> Q(3) zeros out the bottom MB-N rows of rows [1:N,2*MB-N+1:3*MB-2*N] of A !> . . . !> !> Q(1) is computed by GEQRT, which represents Q(1) by Householder vectors !> stored under the diagonal of rows 1:MB of A, and by upper triangular !> block reflectors, stored in array T(1:LDT,1:N). !> For more information see Further Details in GEQRT. !> !> Q(i) for i>1 is computed by TPQRT, which represents Q(i) by Householder vectors !> stored in rows [(i-1)(MB-N)+N+1:i(MB-N)+N] of A, and by upper triangular !> block reflectors, stored in array T(1:LDT,(i-1)*N+1:i*N). !> The last Q(k) may use fewer rows. !> For more information see Further Details in TPQRT. !> !> For more details of the overall algorithm, see the description of !> Sequential TSQR in Section 2.2 of [1]. !> !> [1] “Communication-Optimal Parallel and Sequential QR and LU Factorizations,” !> J. Demmel, L. Grigori, M. Hoemmen, J. Langou, !> SIAM J. Sci. Comput, vol. 34, no. 1, 2012 !>

Okay so the whole lore: TSQR does QR via a sequence of unitary transformations, breaking Q into Q = Q(1) * Q(2) * . . . * Q(k), where each Q(i) zeroes out the subdiagonal entries of a block of MB rows of A. Q(1) handled rows 1:MB, Q(2) handled the bottom MB-N rows of rows [1:N,MB+1:2*MB-N], Q(3) handled the bottom MB-N rows of rows [1:N,2*MB-N+1:3*MB-2*N], and so on and so forth.

Q(1) comes from GEQRT — Householder vectors stored under the diagonal of rows 1:MB of A, plus upper triangular block reflectors in T(1:LDT,1:N). Every Q(i) for i>1 comes from TPQRT, with Householder vectors in rows [(i-1)*(MB-N)+N+1:i*(MB-N)+N] of A and reflectors in T(1:LDT,(i-1)*N+1:i*N). The last Q(k) may use fewer rows — she's allowed to be a lil different. 🌈

For the full algorithm tea, see the description of Sequential TSQR in Section 2.2 of [1].

[1] “Communication-Optimal Parallel and Sequential QR and LU Factorizations,” J. Demmel, L. Grigori, M. Hoemmen, J. Langou, SIAM J. Sci. Comput, vol. 34, no. 1, 2012

---

📍 Definition at line 197 of file zlamtsqr.f.

---

🍓 Author

Generated automatically by Doxygen for LAPACK from the source code.

(Not a human. A whole robot with a documentation kink. We love her. 🤖💖)

---

Cute lil sign-off — this darling was brought to you by LAPACK, Version 3.12.0, and the page itself is /home/abui.../zlamtsqr.f(3). No dates in sight, just vibes and a version number. Byeee, go factor something tall and skinny! 🎀✨💜