SRC/slaqps.f(3)

📦
version 3.12.1 · 7 versions
, in arch rolling

💅 SRC/slaqps.f(3) — Library Functions Manual

okay so bestie, welcome to SRC/slaqps.f(3), straight out of the LAPACK library manual ✨ this one is a Fortran subroutine page and it's honestly kind of a baddie.

🦋 SYNOPSIS

Functions/Subroutines

  • subroutine slaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) — SLAQPS computes a step of QR factorization with column pivoting of a real m-by-n matrix A by using BLAS level 3.

🌸 Function/Subroutine Documentation

subroutine slaqps

here's the full signature, no cap, exactly as it lives:

subroutine slaqps (integer m, integer n, integer offset, integer nb, integer
    kb, real, dimension( lda, * ) a, integer lda, integer, dimension( * )
    jpvt, real, dimension( * ) tau, real, dimension( * ) vn1, real,
    dimension( * ) vn2, real, dimension( * ) auxv, real, dimension( ldf, * )
    f, integer ldf)

ok so what does it do? SLAQPS computes a step of QR factorization with column pivoting of a real m-by-n matrix A by using BLAS level 3. 💅

✨ Purpose

!>
!> SLAQPS computes a step of QR factorization with column pivoting
!> of a real M-by-N matrix A by using Blas-3.  It tries to factorize
!> NB columns from A starting from the row OFFSET+1, and updates all
!> of the matrix with Blas-3 xGEMM.
!>
!> In some cases, due to catastrophic cancellations, it cannot
!> factorize NB columns.  Hence, the actual number of factorized
!> columns is returned in KB.
!>
!> Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
!>

so it tries to factorize NB columns starting at row OFFSET+1, and it updates the whole matrix using Blas-3 xGEMM. but 💀 sometimes catastrophic cancellations happen and it just can't factorize all NB columns — so the actual number it managed to factorize comes back in KB. and block A(1:OFFSET,1:N) gets pivoted accordingly but is not factorized, slay.

🎀 Parameters

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

the number of rows of matrix A, and M >= 0 fr fr.

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

the number of columns of matrix A, and N >= 0. periodt.

  • OFFSET
!>          OFFSET is INTEGER
!>          The number of rows of A that have been factorized in
!>          previous steps.
!>

how many rows of A already got factorized in previous steps — think of it as the "we've been here before" counter 🫶.

  • NB
!>          NB is INTEGER
!>          The number of columns to factorize.
!>

how many columns we're aiming to factorize this round.

  • KB
!>          KB is INTEGER
!>          The number of columns actually factorized.
!>

how many columns actually got factorized. the vibe check result, basically 😭.

  • A
!>          A is REAL array, dimension (LDA,N)
!>          On entry, the M-by-N matrix A.
!>          On exit, block A(OFFSET+1:M,1:KB) is the triangular
!>          factor obtained and block A(1:OFFSET,1:N) has been
!>          accordingly pivoted, but no factorized.
!>          The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has
!>          been updated.
!>

a REAL array of dimension (LDA,N). on entry it's the M-by-N matrix A. on exit, block A(OFFSET+1:M,1:KB) is the triangular factor you got, block A(1:OFFSET,1:N) has been accordingly pivoted but not factorized (yes, the source says "no factorized" — iconic typo, we keep it 💖), and the rest of the matrix, block A(OFFSET+1:M,KB+1:N), has been updated.

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

leading dimension of A, and it has to be LDA >= max(1,M).

  • JPVT
!>          JPVT is INTEGER array, dimension (N)
!>          JPVT(I) = K <==> Column K of the full matrix A has been
!>          permuted into position I in AP.
!>

INTEGER array of dimension (N). JPVT(I) = K <==> Column K of the full matrix A has been permuted into position I in AP. read it twice, it clicks 🔥.

  • TAU
!>          TAU is REAL array, dimension (KB)
!>          The scalar factors of the elementary reflectors.
!>

REAL array of dimension (KB) holding the scalar factors of the elementary reflectors. the little gremlins doing the work ✨.

  • VN1
!>          VN1 is REAL array, dimension (N)
!>          The vector with the partial column norms.
!>

REAL array of dimension (N) — the vector with the partial column norms.

  • VN2
!>          VN2 is REAL array, dimension (N)
!>          The vector with the exact column norms.
!>

REAL array of dimension (N) — the vector with the exact column norms. the more honest sibling of VN1 ngl.

  • AUXV
!>          AUXV is REAL array, dimension (NB)
!>          Auxiliary vector.
!>

REAL array of dimension (NB), just an auxiliary vector. supporting cast energy 🎀.

  • F
!>          F is REAL array, dimension (LDF,NB)
!>          Matrix F**T = L*Y**T*A.
!>

REAL array of dimension (LDF,NB), and it holds Matrix F**T = L*Y**T*A.

  • LDF
!>          LDF is INTEGER
!>          The leading dimension of the array F. LDF >= max(1,N).
!>

leading dimension of F, and it must satisfy LDF >= max(1,N).

👑 Author

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

🌈 Contributors:

  • G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain
  • X. Sun, Computer Science Dept., Duke University, USA
also!! the partial column norm updating strategy was modified on April 2011 by Z. Drmac and Z. Bujanovic, Dept. of Mathematics, University of Zagreb, Croatia. not me remembering the glow-up era 💅

⭐ References:

  • LAPACK Working Note 176

Definition at line 176 of file slaqps.f.

💜 Author

Generated automatically by Doxygen for LAPACK from the source code. (the robots did this one, we just gave it flavor 🧚)

🌸 ok that's the whole page bestie — LAPACK Version 3.12.0, dated, and living at SRC/slaqps.f(3). go forth and factorize responsibly 🫶💖

📦 where this page comes from