TESTING/LIN/zlarhs.f(3)

📦
version 3.12.1 · 2 versions
, in arch rolling

💅 TESTING/LIN/zlarhs.f(3) — the LAPACK manual page, but make it make sense

okay so bestie, welcome to TESTING/LIN/zlarhs.f(3) from the LAPACK Library Functions Manual ✨ this is the page for ZLARHS and she is lowkey the backbone of the whole LAPACK test suite, no cap.

🎀 NAME 🎀

TESTING/LIN/zlarhs.f — that's the file, that's the name, we move 💅

✨ SYNOPSIS ✨

🌸 Functions/Subroutines 🌸

subroutine zlarhs (path, xtype, uplo, trans, m, n, kl, ku, nrhs, a, lda,
    x, ldx, b, ldb, iseed, info)
    ZLARHS

🦋 Function/Subroutine Documentation 🦋

subroutine zlarhs (character*3 path, character xtype, character uplo,
    character trans, integer m, integer n, integer kl, integer ku, integer
    nrhs, complex*16, dimension( lda, * ) a, integer lda, complex*16,
    dimension( ldx, * ) x, integer ldx, complex*16, dimension( ldb, * ) b,
    integer ldb, integer, dimension( 4 ) iseed, integer info)

ZLARHS 👑 okay so she's the one who picks out a set of NRHS random solution vectors and sets up the right hand sides for the linear system. Basically she's setting the table for the whole test, fr fr.

💖 Purpose 💖

!>
!> ZLARHS chooses a set of NRHS random solution vectors and sets
!> up the right hand sides for the linear system
!>    op(A) * X = B,
!> where op(A) = A, A**T, or A**H, depending on TRANS.
!>

🌈 Parameters 🌈

⭐ PATH

!>          PATH is CHARACTER*3
!>          The type of the complex matrix A.  PATH may be given in any
!>          combination of upper and lower case.  Valid paths include
!>             xGE:  General m x n matrix
!>             xGB:  General banded matrix
!>             xPO:  Hermitian positive definite, 2-D storage
!>             xPP:  Hermitian positive definite packed
!>             xPB:  Hermitian positive definite banded
!>             xHE:  Hermitian indefinite, 2-D storage
!>             xHP:  Hermitian indefinite packed
!>             xHB:  Hermitian indefinite banded
!>             xSY:  Symmetric indefinite, 2-D storage
!>             xSP:  Symmetric indefinite packed
!>             xSB:  Symmetric indefinite banded
!>             xTR:  Triangular
!>             xTP:  Triangular packed
!>             xTB:  Triangular banded
!>             xQR:  General m x n matrix
!>             xLQ:  General m x n matrix
!>             xQL:  General m x n matrix
!>             xRQ:  General m x n matrix
!>          where the leading character indicates the precision.
!>

so PATH is literally the whole vibe check for your matrix 💅 it's CHARACTER*3, and you can shout it in caps or whisper it lowercase, any combo is fine. That leading character? That's the precision, babe. The last two letters tell her which flavor of matrix you're serving 🔥

⭐ XTYPE

!>          XTYPE is CHARACTER*1
!>          Specifies how the exact solution X will be determined:
!>          = 'N':  New solution; generate a random X.
!>          = 'C':  Computed; use value of X on entry.
!>

XTYPE is CHARACTER*1 and it's the main character decision 🎀

  • 'N' — New solution, she generates a random X for you 🎲
  • 'C' — Computed, she just uses whatever X you already handed her on entry 💁‍♀️

⭐ UPLO

!>          UPLO is CHARACTER*1
!>          Used only if A is symmetric or triangular; specifies whether
!>          the upper or lower triangular part of the matrix A is stored.
!>          = 'U':  Upper triangular
!>          = 'L':  Lower triangular
!>

UPLO is CHARACTER*1 and she only shows up when A is symmetric or triangular, so like, know your audience 🫶

  • 'U' — Upper triangular ⬆️
  • 'L' — Lower triangular ⬇️

⭐ TRANS

!>          TRANS is CHARACTER*1
!>          Used only if A is nonsymmetric; specifies the operation
!>          applied to the matrix A.
!>          = 'N':  B := A    * X  (No transpose)
!>          = 'T':  B := A**T * X  (Transpose)
!>          = 'C':  B := A**H * X  (Conjugate transpose)
!>

TRANS is CHARACTER*1, only relevant when A is nonsymmetric, and she dictates the operation:

  • 'N' — B := A * X (No transpose, keep it as is 💅)
  • 'T' — B := A**T * X (Transpose 🔄)
  • 'C' — B := A**H * X (Conjugate transpose, the fancy one ✨)

⭐ M

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

M is INTEGER — the number of rows of A. M >= 0, periodt.

⭐ N

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

N is INTEGER — the number of columns of A. N >= 0, we stay non-negative 💖

⭐ KL

!>          KL is INTEGER
!>          Used only if A is a band matrix; specifies the number of
!>          subdiagonals of A if A is a general band matrix or if A is
!>          symmetric or triangular and UPLO = 'L'; specifies the number
!>          of superdiagonals of A if A is symmetric or triangular and
!>          UPLO = 'U'.  0 <= KL <= M-1.
!>

KL is INTEGER and only clocks in if A is a band matrix. She's the subdiagonal count when A is general banded, or when A is symmetric/triangular with UPLO = 'L'. But if A is symmetric/triangular and UPLO = 'U', she switches teams and counts the *super*diagonals 😭. Constraint: 0 <= KL <= M-1.

⭐ KU

!>          KU is INTEGER
!>          Used only if A is a general band matrix or if A is
!>          triangular.
!>
!>          If PATH = xGB, specifies the number of superdiagonals of A,
!>          and 0 <= KU <= N-1.
!>
!>          If PATH = xTR, xTP, or xTB, specifies whether or not the
!>          matrix has unit diagonal:
!>          = 1:  matrix has non-unit diagonal (default)
!>          = 2:  matrix has unit diagonal
!>

KU is INTEGER, only used when A is a general band matrix or triangular. Two completely different jobs, one variable — she contains multitudes 💀

  • If PATH = xGB, she's the number of superdiagonals of A, and 0 <= KU <= N-1.
  • If PATH = xTR, xTP, or xTB, she tells you whether the matrix has a unit diagonal:
    • = 1: matrix has non-unit diagonal (that's the default, fyi 👀)
    • = 2: matrix has unit diagonal

⭐ NRHS

!>          NRHS is INTEGER
!>          The number of right hand side vectors in the system A*X = B.
!>

NRHS is INTEGER — how many right hand side vectors are in the system A*X = B. It's giving quantity 🍓

⭐ A

!>          A is COMPLEX*16 array, dimension (LDA,N)
!>          The test matrix whose type is given by PATH.
!>

A is a COMPLEX*16 array with dimension (LDA,N) — and she's the test matrix, the icon, the moment. Her type is whatever PATH said 👑

⭐ LDA

!>          LDA is INTEGER
!>          The leading dimension of the array A.
!>          If PATH = xGB, LDA >= KL+KU+1.
!>          If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
!>          Otherwise, LDA >= max(1,M).
!>

LDA is INTEGER — the leading dimension of A. Rules, bestie, don't skip them:

  • If PATH = xGB, then LDA >= KL+KU+1.
  • If PATH = xPB, xSB, xHB, or xTB, then LDA >= KL+1.
  • Otherwise, LDA >= max(1,M).

⭐ X

!>          X is or output) COMPLEX*16 array, dimension (LDX,NRHS)
!>          On entry, if XTYPE = 'C' (for 'Computed'), then X contains
!>          the exact solution to the system of linear equations.
!>          On exit, if XTYPE = 'N' (for 'New'), then X is initialized
!>          with random values.
!>

X is a COMPLEX*16 array with dimension (LDX,NRHS) — she's input or output, a true dual-threat 💅

  • On entry, if XTYPE = 'C' (for 'Computed'), then X contains the exact solution to the system of linear equations.
  • On exit, if XTYPE = 'N' (for 'New'), then X is initialized with random values 🎲

⭐ LDX

!>          LDX is INTEGER
!>          The leading dimension of the array X.  If TRANS = 'N',
!>          LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).
!>

LDX is INTEGER — leading dimension of X. If TRANS = 'N', then LDX >= max(1,N); if TRANS = 'T', then LDX >= max(1,M). Flip flop based on TRANS, iykyk 🦋

⭐ B

!>          B is COMPLEX*16 array, dimension (LDB,NRHS)
!>          The right hand side vector(s) for the system of equations,
!>          computed from B = op(A) * X, where op(A) is determined by
!>          TRANS.
!>

B is a COMPLEX*16 array, dimension (LDB,NRHS) — the right hand side vector(s) for the system of equations, computed from B = op(A) * X, where op(A) is decided by TRANS. She's the end product, the glow-up 🌟

⭐ LDB

!>          LDB is INTEGER
!>          The leading dimension of the array B.  If TRANS = 'N',
!>          LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).
!>

LDB is INTEGER — leading dimension of B. If TRANS = 'N', then LDB >= max(1,M); if TRANS = 'T', then LDB >= max(1,N). Yes she's the mirror opposite of LDX, that's the joke 🪞

⭐ ISEED

!>          ISEED is INTEGER array, dimension (4)
!>          The seed vector for the random number generator (used in
!>          ZLATMS).  Modified on exit.
!>

ISEED is an INTEGER array with dimension (4) — the seed vector for the random number generator, used in ZLATMS. Modified on exit, so heads up, she does not come back the same 🙈

⭐ INFO

!>          INFO is INTEGER
!>          = 0: successful exit
!>          < 0: if INFO = -i, the i-th argument had an illegal value
!>

INFO is INTEGER, the emotional support exit code 🫶

  • = 0: successful exit, we love to see it 🎉
  • < 0: if INFO = -i, the i-th argument had an illegal value — so like, check your args bestie 😭

👑 Author 👑

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

Definition at line 206 of file zlarhs.f. ✨

🌸 Author (again, the meta one) 🌸

Generated automatically by Doxygen for LAPACK from the source code 🤖💖

okay and that's the whole page, bestie!! 🎀 this was brought to you by LAPACK, Version 3.12.0 — treat her right, cite her properly, and go set up some right hand sides 💅🦋💜

📦 where this page comes from