SRC/zgemqr.f(3)

📦
version 3.12.1 · 4 versions
, in arch rolling

💅 SRC/zgemqr.f

okay so bestie, listen — this is the manpage for SRC/zgemqr.f, straight out of the LAPACK library functions manual, and it's literally the glow-up doc for one (1) subroutine. she's giving linear algebra main character energy, and honestly? ate. 🎀

✨ SYNOPSIS ✨

🌸 Functions/Subroutines

  • subroutine zgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) — ZGEMQR

🦋 Function/Subroutine Documentation 🦋

💖 subroutine zgemqr (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)

ZGEMQR

👑 Purpose:

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

so yeah — she takes your matrix C and multiplies it by Q (or Q**H) from whichever side you picked. no cap, that's the whole job. ✨

🌈 Parameters

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

left or right, babe — you pick the side. 🫶

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

'N' = no transpose, you're applying plain Q. 'C' = conjugate transpose, so you're applying Q**H. choose your fighter. 💅

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

the row count of A, and she's gotta be M >=0.

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

the column count of C. also 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 = how many elementary reflectors are multiplying together to define Q. and the bounds flex depending on side: if SIDE = 'L' then M >= K >= 0; if SIDE = 'R' then N >= K >= 0. iykyk. 🔥

  • A
!>          A is COMPLEX*16 array, dimension (LDA,K)
!>          Part of the data structure to represent Q as returned by ZGEQR.
!>

she's a COMPLEX*16 array of dimension (LDA,K), and she's part of the data structure that represents Q as returned by ZGEQR. iconic team effort.

  • 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 — if SIDE = 'L', LDA >= max(1,M); if SIDE = 'R', LDA >= max(1,N). do not skip the max(1, …), bestie, it's load-bearing. 😭

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

COMPLEX*16 array, dimension (MAX(5,TSIZE)), and also part of the Q data structure from ZGEQR. her and A are literally a duo. 🧚

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

dimension of T, and TSIZE >= 5. five is the floor, periodt.

  • 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, dimension (LDC,N). on entry she's your M-by-N matrix C; on exit she's been overwritten by Q*C or Q**H*C or C*Q**H or C*Q. she does not survive the makeover, that's the point. 💀

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

leading dimension of C, and LDC >= max(1,M). no exceptions.

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

the workspace! COMPLEX*16 array, dimension (MAX(1,LWORK)). on exit, if INFO = 0, then WORK(1) hands you the minimal LWORK. she's helpful like that. 🌸

  • LWORK
!>          LWORK is INTEGER
!>          The dimension of the array WORK. LWORK >= 1.
!>          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.
!>

dimension of WORK, and LWORK >= 1. important: if LWORK = -1, it's a workspace query — the routine only calculates the size of the WORK array, returns that as WORK(1), and XERBLA will not throw a WORK-related error at you. she's just peeking, not committing. 👀

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

INFO = 0 means slay, successful exit. INFO < 0 means if INFO = -i, then the i-th argument had an illegal value. rude but fair.

🎀 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

⭐ 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.
!>
!> 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
!>                           ZLATSQR or ZGEQRT
!>
!>  Depending on the matrix dimensions M and N, and row and column
!>  block sizes MB and NB returned by ILAENV, ZGEQR will use either
!>  ZLATSQR (if the matrix is tall-and-skinny) or ZGEQRT to compute
!>  the QR factorization.
!>  This version of ZGEMQR will use either ZLAMTSQR or ZGEMQRT to
!>  multiply matrix Q by another matrix.
!>  Further Details in ZLAMTSQR or ZGEMQRT.
!>
!>
⚠️ bestie read this part carefully: these details are particular for this LAPACK implementation. users should not take them for granted. they may change in the future, and they are not likely true for another LAPACK implementation. they're relevant if you want to try to understand the code, but they are not part of the interface. so like… cute lore, not a contract. 💅

Definition at line 173 of file zgemqr.f.

🌟 Author

Generated automatically by Doxygen for LAPACK from the source code.

and that's the whole page, bestie — no notes, no crumbs. 🍓

LAPACK · Version 3.12.0 · SRC/zgemqr.f(3) — mwah, that's the sign-off, see u in the next subroutine 💜🦋✨

📦 where this page comes from