ZUNMQR(3)

💅 NAME 💅

okay so bestie, this is a zunmqr.f situation — specifically the file at /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/zunmqr.f, which lives in the LAPACK Library Functions Manual section of your man pages. yes the whole path is the name. it's giving "my full legal name on the birth certificate" energy and honestly? iconic. 🎀

---

✨ SYNOPSIS ✨

🌸 Functions/Subroutines 🌸

subroutine ZUNMQR (side, trans, m, n, k, a, lda, tau, c, ldc, work,
    lwork, info)

ZUNMQR — no cap, that's her. 💜

---

🦋 Function/Subroutine Documentation 🦋

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

ZUNMQR 💫 (yes, again, we're doing the full signature, slay)

👑 Purpose 👑

!> !> ZUNMQR overwrites the general complex 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 k !> elementary reflectors !> !> Q = H(1) H(2) . . . H(k) !> !> as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N !> if SIDE = 'R'. !>

so basically: this routine takes your matrix C and straight-up overwrites it with Q * C, or C * Q, or the conjugate-transposed versions Q**H * C / C * Q**H, depending on which side and which transpose vibe you're on. Q itself is that complex unitary matrix built as the product of k elementary reflectors — Q = H(1) H(2) . . . H(k) — exactly like ZGEQRF handed it to you. and Q is order M when SIDE = 'L', order N when SIDE = 'R'. periodt. 💅

---

💖 Parameters 💖

🌈 SIDE

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

SIDE is a CHARACTER*1 — pick a side bestie. 'L' = apply Q or Q**H from the Left. 'R' = apply Q or Q**H from the Right. no in-between, we don't do situationships. 🙈

🌸 TRANS

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

TRANS is CHARACTER*1. 'N' = No transpose, just apply Q. 'C' = Conjugate transpose, apply Q**H. short king, two options, both valid. ✨

🎀 M

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

M is INTEGER — the number of rows of matrix C. M >= 0. that's the rule, don't fight it. 🌸

🦋 N

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

N is INTEGER — the number of columns of C. N >= 0. we love a non-negative queen. 💜

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

K is INTEGER — how many elementary reflectors are in the product that defines Q. constraints: if SIDE = 'L' then M >= K >= 0; if SIDE = 'R' then N >= K >= 0. yes you have to check both, no skipping. ⭐

🔥 A

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

A is a COMPLEX*16 array, dimension (LDA,K). the i-th column has to contain the vector that defines elementary reflector H(i), for i = 1,2,...,k — exactly as ZGEQRF returned it in the first k columns of its own array argument A. same A, same energy, no reshuffling. 🫶

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

LDA is INTEGER — the leading dimension of A. if SIDE = 'L', then LDA >= max(1,M); if SIDE = 'R', then LDA >= max(1,N). get it wrong and the routine will simply Not. 😭

🍓 TAU

!> TAU is COMPLEX*16 array, dimension (K) !> TAU(i) must contain the scalar factor of the elementary !> reflector H(i), as returned by ZGEQRF. !>

TAU is a COMPLEX*16 array, dimension (K). TAU(i) must hold the scalar factor of elementary reflector H(i), as returned by ZGEQRF. she's the little scalar that could. 💖

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

C is a 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. so like, your original C is gone gone. main character transformation arc, but the original self does not survive. 💅

🌈 LDC

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

LDC is INTEGER — leading dimension of C. LDC >= max(1,M). one job and she does it. ✨

💜 WORK

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

WORK is a COMPLEX*16 array, dimension (MAX(1,LWORK)). on exit, if INFO = 0, then WORK(1) returns the optimal LWORK — she's basically a fortune teller who tells you the right buffer size. 🔮

⭐ LWORK

!> LWORK is INTEGER !> The dimension of the array WORK. !> If SIDE = 'L', LWORK >= max(1,N); !> if SIDE = 'R', LWORK >= max(1,M). !> For good performance, LWORK should generally be larger. !> !> 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. !>

LWORK is INTEGER — the dimension of the WORK array. if SIDE = 'L', then LWORK >= max(1,N); if SIDE = 'R', then LWORK >= max(1,M). and for good performance — listen bestie, this part matters — LWORK should generally be larger. give her room to breathe. 🦋

also: 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 — plot twist — no error message related to LWORK is issued by XERBLA. so don't expect to get yelled at. it's a vibe check, not a fight. 🙈

🎀 INFO

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

INFO is INTEGER. = 0: successful exit, we ate and left no crumbs. < 0: if INFO = -i, the i-th argument had an illegal value — so it's telling you exactly which one flopped. 💀

---

🌸 Author 🌸

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

the whole friend group showed up for the credit. 🫶

Definition at line 165 of file zunmqr.f. ⭐

---

🌈 Author 🌈

Generated automatically by Doxygen for LAPACK from the source code. so nobody hand-wrote this, it's a bot with a glow-up. 🤖💅

---

okay that's the whole page, mwah. 🎀 this cutie is LAPACK, Version 3.12.0, brought to you from /home/abui...RC/zunmqr.f(3) — go forth, apply your Q on the correct side, and remember: LWORK larger = better performance, no cap. 💖✨👑