ZCHKGB(3)

📦 version 3.12.0, in opensuse-leap 16.0

💅 ZCHKGB(3) — like, the whole manual page, bestie

okay so this is a page from the Library Functions Manual, and the star of the show lives at /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/TESTING/LIN/zchkgb.f — yes that's the whole path, yes it's giving "I was compiled in a directory with a lot of feelings" 💀

✨ SYNOPSIS ✨

Functions/Subroutines 🫶

subroutine ZCHKGB (dotype, nm, mval, nn, nval, nnb, nbval, nns, nsval,
    thresh, tsterr, a, la, afac, lafac, b, x, xact, work, rwork, iwork,
    nout)

ZCHKGB

🎀 Function/Subroutine Documentation 🎀

subroutine ZCHKGB (logical, dimension( * ) dotype, integer nm, integer,
    dimension( * ) mval, integer nn, integer, dimension( * ) nval, integer
    nnb, integer, dimension( * ) nbval, integer nns, integer, dimension( * )
    nsval, double precision thresh, logical tsterr, complex*16, dimension( *
    ) a, integer la, complex*16, dimension( * ) afac, integer lafac,
    complex*16, dimension( * ) b, complex*16, dimension( * ) x, complex*16,
    dimension( * ) xact, complex*16, dimension( * ) work, double precision,
    dimension( * ) rwork, integer, dimension( * ) iwork, integer nout)

ZCHKGB

🌸 Purpose 🌸

So what does she actually do? She's the vibe check for a whole squad of routines:

!>
!> ZCHKGB tests ZGBTRF, -TRS, -RFS, and -CON
!>

Like, ZGBTRF, ZGBTRS, ZGBTRS-adjacent energy, ZGBRFS, ZGBCON — she runs them all through their paces. Obsessed. 🔥

💖 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.
!>

the guest list basically 💅 — type j (with 1 <= j <= NTYPES) shows up to the party if DOTYPE(j) = .TRUE., and if DOTYPE(j) = .FALSE. then type j did not get an invite, no cap.

NM

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

how many M-values are chilling in MVAL, fr fr.

MVAL

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

the actual row dimension M values, main character energy ✨

NN

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

the headcount of N-values sitting inside NVAL.

NVAL

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

the column dimension N values themselves 🎀

NNB

!>          NNB is INTEGER
!>          The number of values of NB contained in the vector NBVAL.
!>

how many blocksize values are hanging out in NBVAL.

NBVAL

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

the blocksize NB values. iconic.

NNS

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

the count of right-hand-side counts (say that five times fast 😭) inside NSVAL.

NSVAL

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

the number-of-right-hand-sides NRHS values, periodt.

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.
!>

the cutoff for the test ratios — a result makes it into the output file if RESULT >= THRESH. wanna see every single test ratio printed? set THRESH = 0. she's not shy 👑

TSTERR

!>          TSTERR is LOGICAL
!>          Flag that indicates whether error exits are to be tested.
!>

a flag saying whether we're testing the error exits too. yep, we're testing the behavior when things go wrong. character development 💀

A

!>          A is COMPLEX*16 array, dimension (LA)
!>

just A. COMPLEX*16, dimension (LA). slay.

LA

!>          LA is INTEGER
!>          The length of the array A.  LA >= (KLMAX+KUMAX+1)*NMAX
!>          where KLMAX is the largest entry in the local array KLVAL,
!>                KUMAX is the largest entry in the local array KUVAL and
!>                NMAX is the largest entry in the input array NVAL.
!>

the length of array A, and the rule is LA >= (KLMAX+KUMAX+1)*NMAX, where:

  • KLMAX is the largest entry in the local array KVAL... psst, it's KLVAL 💖
  • KUMAX is the largest entry in the local array KUVAL
  • NMAX is the largest entry in the input array NVAL

AFAC

!>          AFAC is COMPLEX*16 array, dimension (LAFAC)
!>

the factored one. COMPLEX*16, dimension (LAFAC).

LAFAC

!>          LAFAC is INTEGER
!>          The length of the array AFAC. LAFAC >= (2*KLMAX+KUMAX+1)*NMAX
!>          where KLMAX is the largest entry in the local array KLVAL,
!>                KUMAX is the largest entry in the local array KUVAL and
!>                NMAX is the largest entry in the input array NVAL.
!>

length of AFAC, and here's the flex: LAFAC >= (2*KLMAX+KUMAX+1)*NMAX — note the 2* bestie, that's not a typo, that's the whole point 🫶. Same definitions: KLMAX = largest entry in local array KLVAL, KUMAX = largest entry in local array KUVAL, NMAX = largest entry in input array NVAL.

B

!>          B is COMPLEX*16 array, dimension (NMAX*NSMAX)
!>

COMPLEX*16, dimension (NMAX*NSMAX).

X

!>          X is COMPLEX*16 array, dimension (NMAX*NSMAX)
!>

COMPLEX*16, dimension (NMAX*NSMAX).

XACT

!>          XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
!>

COMPLEX*16, dimension (NMAX*NSMAX). (yes, same dimension as the other two — that's the assignment ✨)

WORK

!>          WORK is COMPLEX*16 array, dimension
!>                      (NMAX*max(3,NSMAX,NMAX))
!>

COMPLEX*16, dimension (NMAX*max(3,NSMAX,NMAX)) — she does the heavy lifting, honestly.

RWORK

!>          RWORK is DOUBLE PRECISION array, dimension
!>                      (NMAX+2*NSMAX)
!>

DOUBLE PRECISION, dimension (NMAX+2*NSMAX).

IWORK

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

INTEGER, dimension (NMAX). small but mighty.

NOUT

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

the unit number where all the output goes. where the receipts get printed, iykyk.

🌈 Author 🌈

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

⭐ Definition ⭐

She's defined at line 188 of file zchkgb.f. noted. 📌

💜 Author (again, but doxygen's turn) 💜

Generated automatically by Doxygen for LAPACK from the source code. so basically the manpage has a ghostwriter 🙈

💅 friendly reminder bestie: every one of these arrays has a required minimum length spelled out above — respect the dimensions or the vibe check will not pass. no cap.

and that's the whole page, mwah 💖 — from the LAPACK girlies, Version 3.12.0, documented at /home/abui...IN/zchkgb.f(3). bye bestie, go test some band matrices 🦋🌸💅

📦 where this page comes from