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

📦 version 3.12.0, in opensuse-leap 16.0

🌸 /home/abui.../dlaswlq.f(3) — Library Functions Manual 🌸

okay so bestie, brace yourself: this is a page from the LAPACK manual (that's the Library Functions Manual, the fancy-pants numerical linear algebra one), and it's all about one very specific Fortran subroutine. no cap, it's giving "niche but iconic." 💅

✨ NAME ✨

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

like... that's the whole name. it's literally just the file path, bestie. that's the whole vibe. 🫶

🦋 SYNOPSIS 🦋

Functions/Subroutines

  • subroutine DLASWLQ (m, n, mb, nb, a, lda, t, ldt, work, lwork, info) — DLASWLQ

👑 Function/Subroutine Documentation 👑

subroutine DLASWLQ (integer m, integer n, integer mb, integer nb, double
    precision, dimension( lda, * ) a, integer lda, double precision,
    dimension( ldt, *) t, integer ldt, double precision, dimension( * )
    work, integer lwork, integer info)

DLASWLQ

🎀 Purpose 🎀

!>
!> DLASWLQ computes a blocked Tall-Skinny LQ factorization of
!> a real M-by-N matrix A for M <= N:
!>
!>    A = ( L 0 ) *  Q,
!>
!> where:
!>
!>    Q is a n-by-N orthogonal matrix, stored on exit in an implicit
!>    form in the elements above the diagonal of the array A and in
!>    the elements of the array T;
!>    L is a lower-triangular M-by-M matrix stored on exit in
!>    the elements on and below the diagonal of the array A.
!>    0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.
!>
!>

so basically it factors a tall-skinny matrix into ( L 0 ) * Q and honestly? slay. 🔥

💖 Parameters 💖

M

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

the row count, bestie. M >= 0.

N

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

the column count. and listen — N >= M >= 0. it's tall-skinny szn. 🦋

MB

!>          MB is INTEGER
!>          The row block size to be used in the blocked QR.
!>          M >= MB >= 1
!>

row block size for the blocked QR. M >= MB >= 1, periodt.

NB

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

column block size. just NB > 0. that's it, that's the constraint. 💀

A

!>          A is DOUBLE PRECISION array, dimension (LDA,N)
!>          On entry, the M-by-N matrix A.
!>          On exit, the elements on and below the diagonal
!>          of the array contain the N-by-N lower triangular matrix L;
!>          the elements above the diagonal represent Q by the rows
!>          of blocked V (see Further Details).
!>
!>

double precision, dimension (LDA,N). goes in as your M-by-N matrix, comes out carrying L on-and-below the diagonal and Q (as blocked V rows) above it. glow-up fr. ✨

LDA

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

leading dimension of A. must be LDA >= max(1,M).

T

!>          T is DOUBLE PRECISION array,
!>          dimension (LDT, N * Number_of_row_blocks)
!>          where Number_of_row_blocks = CEIL((N-M)/(NB-M))
!>          The blocked upper triangular block reflectors stored in compact form
!>          as a sequence of upper triangular blocks.
!>          See Further Details below.
!>

double precision, dimension (LDT, N * Number_of_row_blocks) where Number_of_row_blocks = CEIL((N-M)/(NB-M)). it's holding all the blocked upper triangular block reflectors, packed cute and compact. see the Further Details below, iykyk. 🎀

LDT

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

leading dimension of T. LDT >= MB.

WORK

!>         (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
!>
!>

(workspace) double precision array, dimension (MAX(1,LWORK)). the little helper. 🧚

LWORK

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

dimension of WORK, and you need LWORK >= MB*M. and the iconic trick: if LWORK = -1, it's a workspace query — it only computes the optimal size of the WORK array, hands it back as the first entry of WORK, and XERBLA stays quiet, no error message about LWORK at all. sneaky but valid. 😌

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 🎉
  • < 0: if INFO = -i, the i-th argument had an illegal value 🙈

🌈 Author 🌈

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

look at that lineup. main character energy from four institutions at once. 👑

⭐ Further Details ⭐

!> Short-Wide LQ (SWLQ) performs LQ by a sequence of orthogonal transformations,
!> representing Q as a product of other orthogonal matrices
!>   Q = Q(1) * Q(2) * . . . * Q(k)
!> where each Q(i) zeros out upper diagonal entries of a block of NB rows of A:
!>   Q(1) zeros out the upper diagonal entries of rows 1:NB of A
!>   Q(2) zeros out the bottom MB-N rows of rows [1:M,NB+1:2*NB-M] of A
!>   Q(3) zeros out the bottom MB-N rows of rows [1:M,2*NB-M+1:3*NB-2*M] of A
!>   . . .
!>
!> Q(1) is computed by GELQT, 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 GELQT.
!>
!> Q(i) for i>1 is computed by TPLQT, which represents Q(i) by Householder vectors
!> stored in columns [(i-1)*(NB-M)+M+1:i*(NB-M)+M] of A, and by upper triangular
!> block reflectors, stored in array T(1:LDT,(i-1)*M+1:i*M).
!> 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
!>

so the tea is: Short-Wide LQ (SWLQ) does LQ via a whole chain of orthogonal transformations, building Q as a product Q = Q(1) * Q(2) * . . . * Q(k). each Q(i) knocks out the upper diagonal entries of a block of NB rows of A:

  • Q(1) zeroes the upper diagonal entries of rows 1:NB of A
  • Q(2) zeroes the bottom MB-N rows of rows [1:M,NB+1:2*NB-M] of A
  • Q(3) zeroes the bottom MB-N rows of rows [1:M,2*NB-M+1:3*NB-2*M] of A
  • . . . and so on, you get the pattern 💫

Q(1) comes from GELQT, which stores Q(1) as Householder vectors under the diagonal of rows 1:MB of A, plus upper triangular block reflectors in T(1:LDT,1:N). more deets in Further Details in GELQT.

Q(i) for i>1 comes from TPLQT, which stores Q(i) as Householder vectors in columns [(i-1)*(NB-M)+M+1:i*(NB-M)+M] of A, plus upper triangular block reflectors in T(1:LDT,(i-1)*M+1:i*M). the last one, Q(k), may use fewer rows. more deets in Further Details in TPQRT.

for the big-picture algorithm, go read 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 165 of file dlaswlq.f.

🍓 Author (the meta one) 🍓

Generated automatically by Doxygen for LAPACK from the source code.

okay that's the whole page bestie, you ate that 💅 and for the cute sign-off: this lil beauty is from LAPACK, Version 3.12.0, and it lives at /home/abui.../dlaswlq.f(3) — go forth and factor some tall-skinny matrices, mwah 🫶💖✨

📦 where this page comes from