SRC/zptsvx.f(3)

📦
version 3.12.1 · 7 versions
, in arch rolling

🦋 NAME 🦋

ok so this is SRC/zptsvx.f — yes bestie, it's a Library Functions Manual page, and it's literally the whole file. we stan a self-titled icon 💅

✨ SYNOPSIS ✨

🎀 Functions/Subroutines

subroutine zptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond,
    ferr, berr, work, rwork, info)
     ZPTSVX computes the solution to system of linear equations A * X =
     B for PT matrices

like, that's the whole vibe. it solves A * X = B for PT matrices, no big deal 🫶

💜 Function/Subroutine Documentation 💜

subroutine zptsvx (character fact, integer n, integer nrhs, double
    precision, dimension( * ) d, complex*16, dimension( * ) e, double
    precision, dimension( * ) df, complex*16, dimension( * ) ef, complex*16,
    dimension( ldb, * ) b, integer ldb, complex*16, dimension( ldx, * ) x,
    integer ldx, double precision rcond, double precision, dimension( * )
    ferr, double precision, dimension( * ) berr, complex*16, dimension( * )
    work, double precision, dimension( * ) rwork, integer info)

ZPTSVX computes the solution to system of linear equations A * X = B for PT matrices. periodt. 🔥

🌸 Purpose 🌸

fortran !> !> ZPTSVX uses the factorization A = L*D*L**H to compute the solution !> to a complex system of linear equations A*X = B, where A is an !> N-by-N Hermitian positive definite tridiagonal matrix and X and B !> are N-by-NRHS matrices. !> !> Error bounds on the solution and a condition estimate are also !> provided. !>

so it takes your Hermitian positive definite tridiagonal matrix A and your N-by-NRHS matrices X and B, factorizes with A = L*D*L**H, solves the system, and also hands you error bounds plus a condition estimate. it's giving overachiever, honestly 👑

🧚 Description 🧚

fortran !> !> The following steps are performed: !> !> 1. If FACT = 'N', the matrix A is factored as A = L*D*L**H, where L !> is a unit lower bidiagonal matrix and D is diagonal. The !> factorization can also be regarded as having the form !> A = U**H*D*U. !> !> 2. If the leading principal minor of order i is not positive, !> then the routine returns with INFO = i. Otherwise, the factored !> form of A is used to estimate the condition number of the matrix !> A. If the reciprocal of the condition number is less than machine !> precision, INFO = N+1 is returned as a warning, but the routine !> still goes on to solve for X and compute error bounds as !> described below. !> !> 3. The system of equations is solved for X using the factored form !> of A. !> !> 4. Iterative refinement is applied to improve the computed solution !> matrix and calculate error bounds and backward error estimates !> for it. !>

ok so the steps, bestie, in order:

  1. if FACT = 'N', A gets factored as A = L*D*L**H, where L is a unit lower bidiagonal matrix and D is diagonal. and fun fact: you can also clock the factorization as A = U**H*D*U.
  2. if the leading principal minor of order i is not positive, the routine bounces with INFO = i. otherwise the factored form of A is used to estimate the condition number of A. if the reciprocal of the condition number is less than machine precision, INFO = N+1 comes back as a warning — but it still goes on to solve for X and compute error bounds like described below. not a quitter 💪
  3. the system of equations gets solved for X using the factored form of A.
  4. iterative refinement gets applied to improve the computed solution matrix and calculate error bounds and backward error estimates for it. glow-up behavior ✨

🌈 Parameters 🌈

  • FACT — FACT is CHARACTER*1, specifies whether or not the factored form of the matrix A is supplied on entry. options are:
    • = 'F': on entry, DF and EF contain the factored form of A. D, E, DF, and EF will not be modified.
    • = 'N': the matrix A will be copied to DF and EF and factored.
  • 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.
  • D — D is DOUBLE PRECISION array, dimension (N), the n diagonal elements of the tridiagonal matrix A.
  • E — E is COMPLEX*16 array, dimension (N-1), the (n-1) subdiagonal elements of the tridiagonal matrix A.
  • DF — DF is DOUBLE PRECISION array, dimension (N). if FACT = 'F', then DF is an input argument and on entry contains the n diagonal elements of the diagonal matrix D from the L*D*L**H factorization of A. if FACT = 'N', then DF is an output argument and on exit contains the n diagonal elements of the diagonal matrix D from the L*D*L**H factorization of A. she switches roles depending on the situation, main character energy fr 💅
  • EF — EF is COMPLEX*16 array, dimension (N-1). if FACT = 'F', then EF is an input argument and on entry contains the (n-1) subdiagonal elements of the unit bidiagonal factor L from the L*D*L**H factorization of A. if FACT = 'N', then EF is an output argument and on exit contains the (n-1) subdiagonal elements of the unit bidiagonal factor L from the L*D*L**H factorization of A.
  • B — B is COMPLEX*16 array, dimension (LDB,NRHS), the N-by-NRHS 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). if INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X. 🎀
  • LDX — LDX is INTEGER, the leading dimension of the array X. LDX >= max(1,N).
  • RCOND — RCOND is DOUBLE PRECISION, the reciprocal condition number of the matrix A. if RCOND is less than the machine precision (in particular, if RCOND = 0), the matrix is singular to working precision. this condition is indicated by a return code of INFO > 0.
  • FERR — FERR is DOUBLE PRECISION array, dimension (NRHS), the 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).
  • 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 (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
    • > 0: if INFO = i, and i is
      • <= N: the leading principal minor of order i of A is not positive, so the factorization could not be completed, and the solution has not been computed. RCOND = 0 is returned.
      • = N+1: U is nonsingular, but RCOND is less than machine precision, meaning that the matrix is singular to working precision. nevertheless, the solution and error bounds are computed because there are a number of situations where the computed solution can be more accurate than the value of RCOND would suggest.
ngl that INFO = N+1 case is lowkey iconic — the matrix is technically singular to working precision but the routine still shows up and does the work anyway 😭🫶

👑 Author 👑

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

⭐ Definition ⭐

definition at line 232 of file zptsvx.f. iykyk 📍

💖 Author 💖

generated automatically by Doxygen for LAPACK from the source code. not me being auto-generated and still serving looks 🙈✨

and that's the page, bestie! shoutout to LAPACK, Version 3.12.0, and the file formerly known as SRC/zptsvx.f(3) — this has been your girl, signing off 💜🦋🌸

📦 where this page comes from