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

📦 version 3.12.0, in opensuse-leap 16.0

💖 NAME 💖

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/TESTING/LIN/sorhr_col01.f

okay so bestie, this page lives in the Library Functions Manual and it's about one single file — that big long path right up there. that's the whole name. it's giving "my address is a novel" energy but we move 💅

✨ SYNOPSIS ✨

🦋 Functions/Subroutines

subroutine SORHR_COL01 (m, n, mb1, nb1, nb2, result)
    SORHR_COL01

like, that's it. that's the girl. one subroutine, six arguments, no cap 🌸

🎀 Function/Subroutine Documentation 🎀

subroutine SORHR_COL01 (integer m, integer n, integer mb1, integer nb1,
    integer nb2, real, dimension(6) result)

SORHR_COL01

👑 Purpose:

!>
!> SORHR_COL01 tests SORGTSQR and SORHR_COL using SLATSQR, SGEMQRT.
!> Therefore, SLATSQR (part of SGEQR), SGEMQRT (part of SGEMQR)
!> have to be tested before this test.
!>
!>

so literally what this does: it runs a vibe check on SORGTSQR and SORHR_COL, and it does that using SLATSQR and SGEMQRT. which means — important — SLATSQR (which is part of SGEQR) and SGEMQRT (which is part of SGEMQR) have to be tested before this test. it's a whole prerequisite chain, bestie. don't skip steps 🫶

🌈 Parameters 🌈

🌸 M

!>          M is INTEGER
!>          Number of rows in test matrix.
!>

M is INTEGER. it's how many rows the test matrix has. simple as that 💜

🦋 N

!>          N is INTEGER
!>          Number of columns in test matrix.
!>

N is INTEGER. column count of the test matrix. iconic of her ✨

🍓 MB1

!>          MB1 is INTEGER
!>          Number of row in row block in an input test matrix.
!>

MB1 is INTEGER. number of row in row block in an input test matrix (yes, "row" — that's the original phrasing, we stan a typo that came to slay) 💀

🧚 NB1

!>          NB1 is INTEGER
!>          Number of columns in column block an input test matrix.
!>

NB1 is INTEGER. number of columns in column block an input test matrix 💖

⭐ NB2

!>          NB2 is INTEGER
!>          Number of columns in column block in an output test matrix.
!>

NB2 is INTEGER. number of columns in column block in an output test matrix. note the "output" — she's different from NB1, don't get it twisted 👑

💅 RESULT

!>          RESULT is REAL array, dimension (6)
!>          Results of each of the six tests below.
!>

RESULT is a REAL array, dimension (6). six slots, six tests, six results. she's holding all the receipts 📝

now the setup for those tests, fr fr:

!>            A is a m-by-n test input matrix to be factored.
!>            so that A = Q_gr * ( R )
!>                               ( 0 ),
!>
!>            Q_qr is an implicit m-by-m orthogonal Q matrix, the result
!>            of factorization in blocked WY-representation,
!>            stored in SGEQRT output format.
!>
!>            R is a n-by-n upper-triangular matrix,
!>
!>            0 is a (m-n)-by-n zero matrix,
!>
!>            Q is an explicit m-by-m orthogonal matrix Q = Q_gr * I
!>
!>            C is an m-by-n random matrix,
!>
!>            D is an n-by-m random matrix.
!>

okay so let's break the cast down, because the way this lineup ate:

  • A — the m-by-n test input matrix that gets factored, such that A = Q_gr * ( R ) over ( 0 )
  • Q_qr — an implicit m-by-m orthogonal Q matrix, aka the result of factorization in blocked WY-representation, stored in SGEQRT output format
  • R — a n-by-n upper-triangular matrix
  • 0 — a (m-n)-by-n zero matrix (yes she's literally just zeros, main character of nothing)
  • Q — an explicit m-by-m orthogonal matrix, Q = Q_gr * I
  • C — an m-by-n random matrix
  • D — an n-by-m random matrix

🔥 The six tests are:

!>          RESULT(1) = |R - (Q**H) * A| / ( eps * m * |A| )
!>            is equivalent to test for | A - Q * R | / (eps * m * |A|),
!>
!>          RESULT(2) = |I - (Q**H) * Q| / ( eps * m ),
!>
!>          RESULT(3) = | Q_qr * C - Q * C | / (eps * m * |C|),
!>
!>          RESULT(4) = | (Q_gr**H) * C - (Q**H) * C | / (eps * m * |C|)
!>
!>          RESULT(5) = | D * Q_qr - D * Q | / (eps * m * |D|)
!>
!>          RESULT(6) = | D * (Q_qr**H) - D * (Q**H) | / (eps * m * |D|),
!>
  • RESULT(1) = |R - (Q**H) * A| / ( eps * m * |A| ) — and that's equivalent to testing | A - Q * R | / (eps * m * |A|)
  • RESULT(2) = |I - (Q**H) * Q| / ( eps * m ) — orthogonality check, we love to see it
  • RESULT(3) = | Q_qr * C - Q * C | / (eps * m * |C|)
  • RESULT(4) = | (Q_gr**H) * C - (Q**H) * C | / (eps * m * |C|)
  • RESULT(5) = | D * Q_qr - D * Q | / (eps * m * |D|)
  • RESULT(6) = | D * (Q_qr**H) - D * (Q**H) | / (eps * m * |D|)

and then, the "where" clause, which is lowkey the most important part 👀:

!>          where:
!>            Q_qr * C, (Q_gr**H) * C, D * Q_qr, D * (Q_qr**H) are
!>            computed using SGEMQRT,
!>
!>            Q * C, (Q**H) * C, D * Q, D * (Q**H)  are
!>            computed using SGEMM.
!>

so:

  • Q_qr * C, (Q_gr**H) * C, D * Q_qr, D * (Q_qr**H) → computed using SGEMQRT
  • Q * C, (Q**H) * C, D * Q, D * (Q**H) → computed using SGEMM

two different routines doing the multiplying, and the whole test is basically checking they agree. iykyk 💅

🫶 Author 🫶

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

the whole squad showed up for this one 🌈

Definition at line 118 of file sorhr_col01.f.

💜 Author 💜

Generated automatically by Doxygen for LAPACK from the source code. (she's not hand-written, she was born this way 🧚)

and that's the page, bestie!! 🌸💖✨

LAPACK — Version 3.12.0 — /home/abui...hr_col01.f(3) 🎀

kisses, go test your SLATSQR and SGEMQRT first, mwah 💋🦋

📦 where this page comes from