ZGEMLQ(3)

💅 ZGEMLQ(3) — bestie edition 🎀

ok so this page lives in the Library Functions Manual ((3) = library functions, iykyk), and the file it came from is literally:

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

like that's the whole path, no cap. it's a Fortran source file in the LAPACK SRC directory and we're about to read its whole documentation page together. grab a snack 🍓

---

✨ NAME ✨

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

yep, the NAME is just... the path. iconic minimalism honestly. 🫶

---

🌸 SYNOPSIS 🌸

Functions/Subroutines

subroutine ZGEMLQ (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work,
    lwork, info)

ZGEMLQ

that's the whole vibe check: one subroutine, fourteen arguments, zero chill.

---

🦋 Function/Subroutine Documentation 🦋

subroutine ZGEMLQ (character side, character trans, integer m, integer n,
    integer k, complex*16, dimension( lda, * ) a, integer lda, complex*16,
    dimension( * ) t, integer tsize, complex*16, dimension( ldc, * ) c,
    integer ldc, complex*16, dimension( * ) work, integer lwork, integer
    info)

ZGEMLQ

💖 Purpose:

!>
!>     ZGEMLQ overwrites the general real M-by-N matrix C with
!>
!>                      SIDE = 'L'     SIDE = 'R'
!>      TRANS = 'N':      Q * C          C * Q
!>      TRANS = 'C':      Q**H * C       C * Q**H
!>      where Q is a complex unitary matrix defined as the product
!>      of blocked elementary reflectors computed by short wide
!>      LQ factorization (ZGELQ)
!>
!>

so basically: you hand it a matrix C and it comes back overwritten with Q*C, Q**H*C, C*Q or C*Q**H depending on your SIDE/TRANS choices. and Q? she's a complex unitary matrix, built as the product of blocked elementary reflectors coming out of the short wide LQ factorization (ZGELQ). it's giving matrix math main character energy 🔥

---

⭐ Parameters ⭐

💜 SIDE

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

so: 'L' = apply from the Left, 'R' = apply from the Right. that's it, that's the whole choice. 🎀

💜 TRANS

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

'N' = no transpose, you apply plain Q. 'C' = conjugate transpose, you apply Q**H. pick your fighter ✨

💜 M

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

it's an INTEGER, it's the number of rows of the matrix A, and it must satisfy M >=0. keep it non-negative bestie 🙈

💜 N

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

INTEGER, the number of columns of the matrix C, and N >= 0. literally the column count of C, don't overthink it 💅

💜 K

!>          K is INTEGER
!>          The number of elementary reflectors whose product defines
!>          the matrix Q.
!>          If SIDE = 'L', M >= K >= 0;
!>          if SIDE = 'R', N >= K >= 0.
!>
!>

INTEGER, and it's the number of elementary reflectors whose product defines Q. the bounds change based on your side choice:

• if SIDE = 'L', then M >= K >= 0
• if SIDE = 'R', then N >= K >= 0

so the vibe check depends on the side, fr fr 🦋

💜 A

!>          A is COMPLEX*16 array, dimension
!>                               (LDA,M) if SIDE = 'L',
!>                               (LDA,N) if SIDE = 'R'
!>          Part of the data structure to represent Q as returned by ZGELQ.
!>

COMPLEX*16 array, and its dimension is (LDA,M) when SIDE = 'L' or (LDA,N) when SIDE = 'R'. it's part of the data structure that represents Q, exactly as returned by ZGELQ. so like, don't just make one up, get it from ZGELQ okay 😭

💜 LDA

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

INTEGER, the leading dimension of the array A, and LDA >= max(1,K). that max(1,K) is doing the heavy lifting for tiny cases, slay ⭐

💜 T

!>          T is COMPLEX*16 array, dimension (MAX(5,TSIZE)).
!>          Part of the data structure to represent Q as returned by ZGELQ.
!>

COMPLEX*16 array with dimension (MAX(5,TSIZE)). again: part of the data structure representing Q as returned by ZGELQ. it and A are a matched set, don't separate them 🫶

💜 TSIZE

!>          TSIZE is INTEGER
!>          The dimension of the array T. TSIZE >= 5.
!>

INTEGER, the dimension of the array T, and TSIZE >= 5. that's a hard floor, no going below five 💀

💜 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 Q**H*C or C*Q**H or C*Q.
!>

COMPLEX*16 array with dimension (LDC,N). on entry it's the M-by-N matrix C. on exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q. key word: overwritten — your original C is gone, she's been transformed 👑

💜 LDC

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

INTEGER, the leading dimension of the array C, and LDC >= max(1,M). same little max(1,M) safety net, we love consistency 🌈

💜 WORK

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

it's the (workspace) — a COMPLEX*16 array with dimension (MAX(1,LWORK)). the behind-the-scenes queen of this whole routine, doing unpaid labor 🧚

💜 LWORK

!>          LWORK is INTEGER
!>          The dimension of the array WORK.
!>          If LWORK = -1, then a workspace query is assumed. The routine
!>          only calculates the size of the WORK array, returns this
!>          value as WORK(1), and no error message related to WORK
!>          is issued by XERBLA.
!>

INTEGER, the dimension of the array WORK. but here's the little trick bestie: if LWORK = -1, then a workspace query is assumed — the routine only calculates the size of the WORK array, returns that value as WORK(1), and no error message related to WORK is issued by XERBLA. so -1 isn't an error, it's a "hey how much room do I need" text message 📱💅

💜 INFO

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

INTEGER status report:

• = 0: successful exit, we ate 💖
• < 0: if INFO = -i, then the i-th argument had an illegal value — so INFO literally tells you which argument misbehaved. very considerate of her honestly 🙈

---

🌟 Author 🌟

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

the whole squad showed up for this one 🫶

---

🔥 Further Details 🔥

!>
!> These details are particular for this LAPACK implementation. Users should not
!> take them for granted. These details may change in the future, and are not likely
!> true for another LAPACK implementation. These details are relevant if one wants
!> to try to understand the code. They are not part of the interface.
!>

⚠️ okay big warning here: these details are particular to this LAPACK implementation. users should not take them for granted. they may change in the future, and are not likely true for another LAPACK implementation. they're only relevant if you want to understand the code — they are not part of the interface. read them like lore, not like a contract, bestie 😭

!> In this version,
!>
!>          T(2): row block size (MB)
!>          T(3): column block size (NB)
!>          T(6:TSIZE): data structure needed for Q, computed by
!>                           ZLASWLQ or ZGELQT
!>

so in this version:

• T(2): row block size (MB)
• T(3): column block size (NB)
• T(6:TSIZE): the data structure needed for Q, computed by ZLASWLQ or ZGELQT

!>  Depending on the matrix dimensions M and N, and row and column
!>  block sizes MB and NB returned by ILAENV, ZGELQ will use either
!>  ZLASWLQ (if the matrix is wide-and-short) or ZGELQT to compute
!>  the LQ factorization.
!>  This version of ZGEMLQ will use either ZLAMSWLQ or ZGEMLQT to
!>  multiply matrix Q by another matrix.
!>  Further Details in ZLAMSWLQ or ZGEMLQT.
!>

depending on the matrix dimensions M and N, plus the row and column block sizes MB and NB returned by ILAENV, ZGELQ will use either ZLASWLQ (if the matrix is wide-and-short) or ZGELQT to compute the LQ factorization. and this version of ZGEMLQ will use either ZLAMSWLQ or ZGEMLQT to multiply matrix Q by another matrix. further details live in ZLAMSWLQ or ZGEMLQT — go read those if you want the full tea ☕

Definition at line 169 of file zgemlq.f.

---

🎀 Author 🎀

Generated automatically by Doxygen for LAPACK from the source code.

like she didn't even write her own bio, doxygen did it for her 💀

---

ok that's the whole page!! and as for the sign-off: this is LAPACK, Version 3.12.0, and the footer path/date situation is /home/abui...RC/zgemlq.f(3) — you know the drill, truncated path, library-functions-manual business, timestamp energy 🌸 go forth and multiply your matrices correctly bestie, Q**H and all 💖✨🦋