hprfs(3)

📦
version 3.12.1 · 9 versions
, in arch rolling

💖 hprfs(3) 💖

okay so bestie, you're looking at hprfs(3) — straight out of the Library Functions Manual, and it's giving "the whole {hp,sp}rfs family in one place" ✨. Buckle up, because there are six subroutines in here and each one is a whole vibe.

🌸 NAME 🌸

hprfs — {hp,sp}rfs: iterative refinement 🎀

✨ SYNOPSIS ✨

🦋 Functions 🦋

Here's the whole squad, all six of them 💅 — every one takes the same shape, and the letter in front tells you the type and the flavor:

  • chprfs — CHPRFS
  • csprfs — CSPRFS
  • dsprfs — DSPRFS
  • ssprfs — SSPRFS
  • zhprfs — ZHPRFS
  • zsprfs — ZSPRFS
subroutine chprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr,
    berr, work, rwork, info)
    CHPRFS
subroutine csprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr,
    berr, work, rwork, info)
    CSPRFS
subroutine dsprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr,
    berr, work, iwork, info)
    DSPRFS
subroutine ssprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr,
    berr, work, iwork, info)
    SSPRFS
subroutine zhprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr,
    berr, work, rwork, info)
    ZHPRFS
subroutine zsprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr,
    berr, work, rwork, info)
    ZSPRFS

quick heads up: the real ones carry full type declarations, and those are spelled out (character for character, no cap) down in the [Function Documentation](#-function-documentation-) 💀

🔥 DETAILED DESCRIPTION 🔥

the details live in the function docs below, one subroutine at a time 🌈

🎀 FUNCTION DOCUMENTATION 🎀

💜 chprfs — CHPRFS

subroutine chprfs (character uplo, integer n, integer nrhs, complex,
    dimension( * ) ap, complex, dimension( * ) afp, integer, dimension( * )
    ipiv, complex, dimension( ldb, * ) b, integer ldb, complex, dimension(
    ldx, * ) x, integer ldx, real, dimension( * ) ferr, real, dimension( * )
    berr, complex, dimension( * ) work, real, dimension( * ) rwork, integer
    info)

🌟 Purpose

CHPRFS is the glow-up arc for a solution you already have. When your coefficient matrix is Hermitian indefinite and packed, it takes the computed solution to a system of linear equations and refines it, then hands you error bounds and backward error estimates for that solution. literally the "make it make sense" subroutine 🫶

⭐ Parameters

  • UPLO — UPLO is CHARACTER*1. Which triangle of A you've stashed: 'U' means the upper triangle of A is stored; 'L' means the lower triangle of A is stored.
  • N — N is INTEGER. The order of the matrix A. Constraint: N >= 0.
  • NRHS — NRHS is INTEGER. How many right hand sides you're slinging — like, the number of columns of the matrices B and X. Constraint: NRHS >= 0.
  • AP — AP is COMPLEX array, dimension (N*(N+1)/2). This is the upper or lower triangle of the Hermitian matrix A, packed columnwise into one long linear array. The j-th column of A lands in AP like this:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
  • AFP — AFP is COMPLEX array, dimension (N*(N+1)/2). The factored form of the matrix A, periodt. AFP is holding the block diagonal matrix D plus the multipliers that got you the factor U or L from the factorization A = U*D*U**H or A = L*D*L**H — exactly as CHPTRF computed them — stored as a packed triangular matrix.
  • IPIV — IPIV is INTEGER array, dimension (N). The receipts on the interchanges and the block structure of D, as determined by CHPTRF.
  • B — B is COMPLEX array, dimension (LDB,NRHS). The right hand side matrix B. 🧚
  • LDB — LDB is INTEGER. The leading dimension of the array B. Constraint: LDB >= max(1,N).
  • X — X is COMPLEX array, dimension (LDX,NRHS). On entry: the solution matrix X, as computed by CHPTRS. On exit: the improved solution matrix X. glow-up complete ✨
  • LDX — LDX is INTEGER. The leading dimension of the array X. Constraint: LDX >= max(1,N).
  • FERR — FERR is REAL array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), then FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and it is almost always a slight overestimate of the true error. (yes, overestimating is the safe direction, we love a cautious queen 🫶)
  • BERR — BERR is REAL array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) — i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution.
  • WORK — WORK is COMPLEX array, dimension (2*N). Scratch space, no thoughts head empty 💀
  • RWORK — RWORK is REAL array, dimension (N). More scratch space, real edition.
  • INFO — INFO is INTEGER. The vibe check on the exit:
    • = 0: successful exit 🌈
    • < 0: if INFO = -i, the i-th argument had an illegal value 🙈

🔧 Internal Parameters

ITMAX is the maximum number of steps of iterative refinement.

👑 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📌 Definition

Definition at line 178 of file chprfs.f.

💙 csprfs — CSPRFS

subroutine csprfs (character uplo, integer n, integer nrhs, complex,
    dimension( * ) ap, complex, dimension( * ) afp, integer, dimension( * )
    ipiv, complex, dimension( ldb, * ) b, integer ldb, complex, dimension(
    ldx, * ) x, integer ldx, real, dimension( * ) ferr, real, dimension( * )
    berr, complex, dimension( * ) work, real, dimension( * ) rwork, integer
    info)

🌟 Purpose

CSPRFS does the exact same iterative-refinement magic, but for the case where the coefficient matrix is symmetric indefinite and packed. It improves your computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution. same energy, different symmetry 💅

⭐ Parameters

  • UPLO — UPLO is CHARACTER*1. Which triangle of A you've stored: 'U' means the upper triangle of A is stored; 'L' means the lower triangle of A is stored.
  • N — N is INTEGER. The order of the matrix A. Constraint: N >= 0.
  • NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. Constraint: NRHS >= 0.
  • AP — AP is COMPLEX array, dimension (N*(N+1)/2). The upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
  • AFP — AFP is COMPLEX array, dimension (N*(N+1)/2). The factored form of the matrix A. AFP contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by CSPTRF, stored as a packed triangular matrix. (note: **T, not **H — she's symmetric, not Hermitian, and that distinction is the whole personality 🔥)
  • IPIV — IPIV is INTEGER array, dimension (N). Details of the interchanges and the block structure of D as determined by CSPTRF.
  • B — B is COMPLEX array, dimension (LDB,NRHS). The right hand side matrix B.
  • LDB — LDB is INTEGER. The leading dimension of the array B. Constraint: LDB >= max(1,N).
  • X — X is COMPLEX array, dimension (LDX,NRHS). On entry, the solution matrix X, as computed by CSPTRS. On exit, the improved solution matrix X. ✨
  • LDX — LDX is INTEGER. The leading dimension of the array X. Constraint: LDX >= max(1,N).
  • FERR — FERR is REAL array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error.
  • BERR — BERR is REAL array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution).
  • WORK — WORK is COMPLEX array, dimension (2*N).
  • RWORK — RWORK is REAL array, dimension (N).
  • INFO — INFO is INTEGER:
    • = 0: successful exit 🌈
    • < 0: if INFO = -i, the i-th argument had an illegal value 🙈

🔧 Internal Parameters

ITMAX is the maximum number of steps of iterative refinement.

👑 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📌 Definition

Definition at line 178 of file csprfs.f.

🍓 dsprfs — DSPRFS

subroutine dsprfs (character uplo, integer n, integer nrhs, double
    precision, dimension( * ) ap, double precision, dimension( * ) afp,
    integer, dimension( * ) ipiv, double precision, dimension( ldb, * ) b,
    integer ldb, double precision, dimension( ldx, * ) x, integer ldx,
    double precision, dimension( * ) ferr, double precision, dimension( * )
    berr, double precision, dimension( * ) work, integer, dimension( * )
    iwork, integer info)

⭐ Parameters

  • UPLO — UPLO is CHARACTER*1. Which triangle of A is stored: 'U' means the upper triangle of A is stored; 'L' means the lower triangle of A is stored.
  • N — N is INTEGER. The order of the matrix A. Constraint: N >= 0.
  • NRHS — ...and this is exactly where part 1 runs out, bestie — the NRHS description picks up in part 2 💫
  • NRHS — INTEGER. The number of right hand sides, aka the number of columns of the matrices B and X. Gotta be NRHS >= 0, no cap.
  • AP — DOUBLE PRECISION array, dimension (N*(N+1)/2). This is the upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in AP like so:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
  • AFP — DOUBLE PRECISION array, dimension (N*(N+1)/2). It's the factored form of the matrix A, bestie. AFP contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by DSPTRF, stored as a packed triangular matrix. It's giving "already did the hard work" energy 💅
  • IPIV — INTEGER array, dimension (N). The details of the interchanges and the block structure of D, exactly as determined by DSPTRF. Receipts included 🧾
  • B — DOUBLE PRECISION array, dimension (LDB,NRHS). The right hand side matrix B. That's the "what we're solving for" side, iykyk.
  • LDB — INTEGER. The leading dimension of the array B. Constraint: LDB >= max(1,N). Respect the leading dimension or it will not respect you 🙈
  • X — DOUBLE PRECISION array, dimension (LDX,NRHS). On entry, the solution matrix X, as computed by DSPTRS. On exit, the improved solution matrix X. So it comes in solved and leaves even more solved. Character development ✨
  • LDX — INTEGER. The leading dimension of the array X. Constraint: LDX >= max(1,N). Same deal as LDB, do not play with it.
  • FERR — DOUBLE PRECISION array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), then FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and it is almost always a slight overestimate of the true error — so it's a little dramatic, but in a "better safe than sorry" way, not a "lying to you" way 🫶
  • BERR — DOUBLE PRECISION array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) — i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution. Basically: how much would we have to fudge the inputs to make this answer perfect. A tiny amount = slay ✅
  • WORK — DOUBLE PRECISION array, dimension (3*N). Scratch space, do not perceive it 💜
  • IWORK — INTEGER array, dimension (N). Also scratch space, just integer flavored 🍓
  • INFO — INTEGER. The vibes report:
    • = 0: successful exit 🎉
    • < 0: if INFO = -i, the i-th argument had an illegal value 💀

🧠 Internal Parameters:

ITMAX is the maximum number of steps of iterative refinement. It's literally the "okay one more pass" budget 🔁

💖 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📍 Definition at line 177 of file dsprfs.f.

🌈 subroutine ssprfs — SSPRFS 🌈

Same whole situation but in single precision, and it ate:

subroutine ssprfs (character uplo, integer n, integer nrhs, real, dimension(
    * ) ap, real, dimension( * ) afp, integer, dimension( * ) ipiv, real,
    dimension( ldb, * ) b, integer ldb, real, dimension( ldx, * ) x, integer
    ldx, real, dimension( * ) ferr, real, dimension( * ) berr, real,
    dimension( * ) work, integer, dimension( * ) iwork, integer info)

SSPRFS

🎯 Purpose:

SSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and it provides error bounds and backward error estimates for the solution. So it's not just solving — it's refining and then handing you the receipts. Main character behavior, honestly 👑

✨ Parameters

  • UPLO — CHARACTER*1. Which triangle of A we're storing:
    • = 'U': upper triangle of A is stored;
    • = 'L': lower triangle of A is stored.
  • N — INTEGER. The order of the matrix A. Constraint: N >= 0. Zero is a valid vibe, apparently.
  • NRHS — INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. Constraint: NRHS >= 0.
  • AP — REAL array, dimension (N*(N+1)/2). The upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
  • AFP — REAL array, dimension (N*(N+1)/2). The factored form of the matrix A. AFP contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by SSPTRF, stored as a packed triangular matrix. Already factored, already iconic 💅
  • IPIV — INTEGER array, dimension (N). Details of the interchanges and the block structure of D as determined by SSPTRF. The whole plot, in integer form.
  • B — REAL array, dimension (LDB,NRHS). The right hand side matrix B.
  • LDB — INTEGER. The leading dimension of the array B. Constraint: LDB >= max(1,N).
  • X — REAL array, dimension (LDX,NRHS). On entry, the solution matrix X, as computed by SSPTRS. On exit, the improved solution matrix X. Glow-up arc, honestly.
  • LDX — INTEGER. The leading dimension of the array X. Constraint: LDX >= max(1,N).
  • FERR — REAL array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), then FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and it is almost always a slight overestimate of the true error. Overthinking but correct 🫶
  • BERR — REAL array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) — i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution.
  • WORK — REAL array, dimension (3*N). Scratch space, moving on 🦋
  • IWORK — INTEGER array, dimension (N). More scratch space, also moving on 🌸
  • INFO — INTEGER:
    • = 0: successful exit ✨
    • < 0: if INFO = -i, the i-th argument had an illegal value 💀

🧠 Internal Parameters:

ITMAX is the maximum number of steps of iterative refinement. Same deal as before, it's the "one more little pass" allowance 🔁

💖 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📍 Definition at line 177 of file ssprfs.f.

🦋 subroutine zhprfs — ZHPRFS 🦋

Now we're in complex double precision territory and she is Hermitian and indefinite, which is honestly such a mood. Signature:

subroutine zhprfs (character uplo, integer n, integer nrhs, complex*16,
    dimension( * ) ap, complex*16, dimension( * ) afp, integer, dimension( *
    ) ipiv, complex*16, dimension( ldb, * ) b, integer ldb, complex*16,
    dimension( ldx, * ) x, integer ldx, double precision, dimension( * )
    ferr, double precision, dimension( * ) berr, complex*16, dimension( * )
    work, double precision, dimension( * ) rwork, integer info)

ZHPRFS

🎯 Purpose:

ZHPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution. Note the H instead of T in the factorizations below — complex conjugates are literally part of the lore 🧚

✨ Parameters

  • UPLO — CHARACTER*1:
    • = 'U': upper triangle of A is stored;
    • = 'L': lower triangle of A is stored.
  • N — INTEGER. The order of the matrix A. Constraint: N >= 0.
  • NRHS — INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. Constraint: NRHS >= 0.
  • AP — COMPLEX*16 array, dimension (N*(N+1)/2). The upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array. The j-th column of A is stored in AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
  • AFP — COMPLEX*16 array, dimension (N*(N+1)/2). The factored form of the matrix A. AFP contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**H or A = L*D*L**H as computed by ZHPTRF, stored as a packed triangular matrix. Yes, **H — conjugate transpose, she's fancy like that 💅
  • IPIV — INTEGER array, dimension (N). Details of the interchanges and the block structure of D as determined by ZHPTRF.
  • B — COMPLEX*16 array, dimension (LDB,NRHS). The right hand side matrix B.
  • LDB — INTEGER. The leading dimension of the array B. Constraint: LDB >= max(1,N).
  • X — COMPLEX*16 array, dimension (LDX,NRHS). On entry, the solution matrix X, as computed by ZHPTRS. On exit, the improved solution matrix X.
  • LDX — INTEGER. The leading dimension of the array X. Constraint: LDX >= max(1,N).
  • FERR —
  • FERR — FERR is DOUBLE PRECISION array, dimension (NRHS). It’s the estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error. 🫶
  • BERR — BERR is DOUBLE PRECISION array, dimension (NRHS). It’s the componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution). 💅
  • WORK — WORK is COMPLEX*16 array, dimension (2*N). 🧚
  • RWORK — RWORK is DOUBLE PRECISION array, dimension (N). 🌸
  • INFO — INFO is INTEGER:
    • = 0: successful exit ✨
    • < 0: if INFO = -i, the i-th argument had an illegal value 😭

🛠️ Internal Parameters

ITMAX is the maximum number of steps of iterative refinement. 🔁

🌟 Author

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

Definition at line 178 of file zhprfs.f. 📌

💜 zsprfs / ZSPRFS

Signature, exactly as the source serves it:

   subroutine zsprfs (character uplo, integer n, integer nrhs, complex*16,
       dimension( * ) ap, complex*16, dimension( * ) afp, integer, dimension( *
       ) ipiv, complex*16, dimension( ldb, * ) b, integer ldb, complex*16,
       dimension( ldx, * ) x, integer ldx, double precision, dimension( * )
       ferr, double precision, dimension( * ) berr, complex*16, dimension( * )
       work, double precision, dimension( * ) rwork, integer info)
       ZSPRFS

🎯 Purpose

ZSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution. iconic behavior, honestly. 💖

🌈 Parameters

  • UPLO — UPLO is CHARACTER*1:
    • = 'U': Upper triangle of A is stored;
    • = 'L': Lower triangle of A is stored.
  • N — N is INTEGER. The order of the matrix A. N >= 0. ✨
  • NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 🎀
  • AP — AP is COMPLEX*16 array, dimension (N*(N+1)/2). The upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
    • if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
    • if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
  • AFP — AFP is COMPLEX*16 array, dimension (N*(N+1)/2). The factored form of the matrix A. AFP contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by ZSPTRF, stored as a packed triangular matrix. 🦋
  • IPIV — IPIV is INTEGER array, dimension (N). Details of the interchanges and the block structure of D as determined by ZSPTRF. 🔥
  • B — B is COMPLEX*16 array, dimension (LDB,NRHS). The right hand side matrix B. 💜
  • LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N). 📏
  • X — X is COMPLEX*16 array, dimension (LDX,NRHS). On entry, the solution matrix X, as computed by ZSPTRS. On exit, the improved solution matrix X. glow-up complete ✨
  • LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,N). 📏
  • FERR — FERR is DOUBLE PRECISION array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error. 🫶
  • BERR — BERR is DOUBLE PRECISION array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution). 💅
  • WORK — WORK is COMPLEX*16 array, dimension (2*N). 🧚
  • RWORK — RWORK is DOUBLE PRECISION array, dimension (N). 🌸
  • INFO — INFO is INTEGER:
    • = 0: successful exit ✨
    • < 0: if INFO = -i, the i-th argument had an illegal value 😭

🛠️ Internal Parameters

ITMAX is the maximum number of steps of iterative refinement. 🔁

🌟 Author

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

Definition at line 178 of file zsprfs.f. 📌

🧚 Author

Generated automatically by Doxygen for LAPACK from the source code.

okay that’s the whole page, bestie 💖 — source/version is LAPACK Version 3.12.0, and the footer tag is hprfs(3). mwah 🫶

📦 where this page comes from