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

📦 version 3.12.0, in opensuse-leap 16.0

💅 /home/abui...chkqp3rk.f — Library Functions Manual

okay bestie, gather round 🫶 this is a page from the LAPACK manual (that's the Library Functions Manual series, mwah) and it's literally the doc for one tester subroutine. yes it's a .f file. yes it's Fortran. no we're not scared of it. 💖

✨ NAME ✨

That absolutely unhinged path, in full, no cap:

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

she lives in the TESTING/LIN folder, she's a Fortran source file, that's the whole vibe 🎀

🌸 SYNOPSIS 🌸

Functions/Subroutines

  • subroutine ZCHKQP3RK — the icon herself 👑
subroutine ZCHKQP3RK (dotype, nm, mval, nn, nval, nns, nsval, nnb,
    nbval, nxval, thresh, a, copya, b, copyb, s, tau, work, rwork,
    iwork, nout)

ZCHKQP3RK

🦋 Function/Subroutine Documentation 🦋

subroutine ZCHKQP3RK — the full signature, lowkey long but we love her

subroutine ZCHKQP3RK (logical, dimension( * ) dotype, integer nm, integer,
    dimension( * ) mval, integer nn, integer, dimension( * ) nval, integer
    nns, integer, dimension( * ) nsval, integer nnb, integer, dimension( * )
    nbval, integer, dimension( * ) nxval, double precision thresh,
    complex*16, dimension( * ) a, complex*16, dimension( * ) copya,
    complex*16, dimension( * ) b, complex*16, dimension( * ) copyb, double
    precision, dimension( * ) s, complex*16, dimension( * ) tau, complex*16,
    dimension( * ) work, double precision, dimension( * ) rwork, integer,
    dimension( * ) iwork, integer nout)

ZCHKQP3RK

🎯 Purpose:

!>
!> ZCHKQP3RK tests ZGEQP3RK.
!>

that's it, that's the purpose — she tests ZGEQP3RK. main character energy, honestly ✨

💜 Parameters

DOTYPE

!>          DOTYPE is LOGICAL array, dimension (NTYPES)
!>          The matrix types to be used for testing.  Matrices of type j
!>          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
!>          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
!>

so DOTYPE is a logical array sized (NTYPES) and it's basically the guest list 🎟️ matrix type j (for 1 <= j <= NTYPES) gets tested if DOTYPE(j) = .TRUE. — and if DOTYPE(j) = .FALSE. then type j is not used. not invited. blocked. 💀

NM

!>          NM is INTEGER
!>          The number of values of M contained in the vector MVAL.
!>

NM is INTEGER, and she's the count of how many M values are chillin' inside the vector MVAL 🌸

MVAL

!>          MVAL is INTEGER array, dimension (NM)
!>          The values of the matrix row dimension M.
!>

MVAL is an INTEGER array, dimension (NM), holding the values of the matrix row dimension M 👑

NN

!>          NN is INTEGER
!>          The number of values of N contained in the vector NVAL.
!>

NN is INTEGER, the number of N values inside the vector NVAL 🎀

NVAL

!>          NVAL is INTEGER array, dimension (NN)
!>          The values of the matrix column dimension N.
!>

NVAL is an INTEGER array, dimension (NN), carrying the values of the matrix column dimension N 💖

NNS

!>          NNS is INTEGER
!>          The number of values of NRHS contained in the vector NSVAL.
!>

NNS is INTEGER — how many NRHS values live in the vector NSVAL 🦋

NSVAL

!>          NSVAL is INTEGER array, dimension (NNS)
!>          The values of the number of right hand sides NRHS.
!>

NSVAL is an INTEGER array, dimension (NNS), with the values of the number of right hand sides NRHS ⭐

NNB

!>          NNB is INTEGER
!>          The number of values of NB and NX contained in the
!>          vectors NBVAL and NXVAL.  The blocking parameters are used
!>          in pairs (NB,NX).
!>

NNB is INTEGER, the count of NB and NX values inside the vectors NBVAL and NXVAL. and here's the thing, bestie — the blocking parameters are used in pairs (NB,NX). they're a package deal, iykyk 🫶

NBVAL

!>          NBVAL is INTEGER array, dimension (NNB)
!>          The values of the blocksize NB.
!>

NBVAL is an INTEGER array, dimension (NNB), holding the values of the blocksize NB 🔥

NXVAL

!>          NXVAL is INTEGER array, dimension (NNB)
!>          The values of the crossover point NX.
!>

NXVAL is an INTEGER array, dimension (NNB), holding the values of the crossover point NX 🌈

THRESH

!>          THRESH is DOUBLE PRECISION
!>          The threshold value for the test ratios.  A result is
!>          included in the output file if RESULT >= THRESH.  To have
!>          every test ratio printed, use THRESH = 0.
!>

THRESH is DOUBLE PRECISION and she's the threshold for the test ratios 💅 a result makes it into the output file if RESULT >= THRESH. and if you want every single test ratio printed? use THRESH = 0. no filter, no gatekeeping, we see everything 😭

A

!>          A is COMPLEX*16 array, dimension (MMAX*NMAX)
!>          where MMAX is the maximum value of M in MVAL and NMAX is the
!>          maximum value of N in NVAL.
!>

A is a COMPLEX*16 array, dimension (MMAX*NMAX) — where MMAX is the maximum value of M in MVAL and NMAX is the maximum value of N in NVAL 👑

COPYA

!>          COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
!>

COPYA is a COMPLEX*16 array, dimension (MMAX*NMAX) — that's all she says, and honestly? respect the minimalism 🎀

B

!>          B is COMPLEX*16 array, dimension (MMAX*NSMAX)
!>          where MMAX is the maximum value of M in MVAL and NSMAX is the
!>          maximum value of NRHS in NSVAL.
!>

B is a COMPLEX*16 array, dimension (MMAX*NSMAX) — MMAX being the maximum value of M in MVAL, and NSMAX the maximum value of NRHS in NSVAL 🌸

COPYB

!>          COPYB is COMPLEX*16 array, dimension (MMAX*NSMAX)
!>

COPYB is a COMPLEX*16 array, dimension (MMAX*NSMAX) 🦋

S

!>          S is DOUBLE PRECISION array, dimension
!>                      (min(MMAX,NMAX))
!>

S is a DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) ⭐

TAU

!>          TAU is COMPLEX*16 array, dimension (MMAX)
!>

TAU is a COMPLEX*16 array, dimension (MMAX) 💜

WORK

!>          WORK is COMPLEX*16 array, dimension
!>                      (max(M*max(M,N) + 4*min(M,N) + max(M,N)))
!>

WORK is a COMPLEX*16 array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N))) — yes that's the whole formula, copy it exactly, do not freestyle 🔥

RWORK

!>          RWORK is DOUBLE PRECISION array, dimension (4*NMAX)
!>

RWORK is a DOUBLE PRECISION array, dimension (4*NMAX) 🎀

IWORK

!>          IWORK is INTEGER array, dimension (2*NMAX)
!>

IWORK is an INTEGER array, dimension (2*NMAX) 💖

NOUT

!>          NOUT is INTEGER
!>          The unit number for output.
!>

NOUT is INTEGER — the unit number for output 📤

👑 Author

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

and fr fr, she's Definition at line 180 of file zchkqp3rk.f. ⭐

ok but genuine heads up bestie — this whole page was Generated automatically by Doxygen for LAPACK from the source code, so if something looks quirky, blame the generator, not me 🙈

🧚 Sign-off

that's the whole page, diva 💅 LAPACK, Version 3.12.0, and the file header /home/abui...chkqp3rk.f(3) — go forth and test ZGEQP3RK responsibly, mwah 🫶💖✨

📦 where this page comes from