/home/abui...RC/sgbsv.f(3)

💜 SGBSV 💜 — /home/abui...RC/sgbsv.f(3)

okay so this page lives in the Library Functions Manual (yes bestie, the LAPACK one) and it's literally all about one little subroutine that's out here solving banded linear systems like it's nothing. main character energy fr fr 💅

---

🌸 NAME 🌸

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/sgbsv.f

that's the whole name, that's the vibe, it's giving "full absolute path realness" ✨

---

🦋 SYNOPSIS 🦋

Functions/Subroutines

subroutine SGBSV (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)
     SGBSV computes the solution to system of linear equations A * X = B
    for GB matrices (simple driver)

like, she does exactly what it says on the tin 🎀

---

⭐ Function/Subroutine Documentation ⭐

subroutine SGBSV (integer n, integer kl, integer ku, integer nrhs, real,
    dimension( ldab, * ) ab, integer ldab, integer, dimension( * ) ipiv,
    real, dimension( ldb, * ) b, integer ldb, integer info)

SGBSV computes the solution to system of linear equations A * X = B for GB matrices (simple driver)

💖 Purpose 💖

!> !> SGBSV computes the solution to a real system of linear equations !> A * X = B, where A is a band matrix of order N with KL subdiagonals !> and KU superdiagonals, and X and B are N-by-NRHS matrices. !> !> The LU decomposition with partial pivoting and row interchanges is !> used to factor A as A = L * U, where L is a product of permutation !> and unit lower triangular matrices with KL subdiagonals, and U is !> upper triangular with KL+KU superdiagonals. The factored form of A !> is then used to solve the system of equations A * X = B. !>

so basically: band matrix A comes in, gets LU-factored as A = L * U with partial pivoting + row interchanges, and then that factored form gets used to solve A * X = B. icon behavior, no notes 👑

---

🌈 Parameters 🌈

okay bestie here's the whole cast, every single one of them 🫶

N

!> N is INTEGER !> The number of linear equations, i.e., the order of the !> matrix A. N >= 0.

the number of linear equations — aka the order of matrix A. and it's gotta be N >= 0 ⭐

KL

!> KL is INTEGER !> The number of subdiagonals within the band of A. KL >= 0.

how many subdiagonals are chilling inside A's band. KL >= 0 💜

KU

!> KU is INTEGER !> The number of superdiagonals within the band of A. KU >= 0.

how many superdiagonals are up in there. KU >= 0 🦋

NRHS

!> NRHS is INTEGER !> The number of right hand sides, i.e., the number of columns !> of the matrix B. NRHS >= 0.

the number of right hand sides, meaning the number of columns of matrix B. NRHS >= 0 🎀

AB

!> AB is REAL array, dimension (LDAB,N) !> On entry, the matrix A in band storage, in rows KL+1 to !> 2*KL+KU+1; rows 1 to KL of the array need not be set. !> The j-th column of A is stored in the j-th column of the !> array AB as follows: !> AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL) !> On exit, details of the factorization: U is stored as an !> upper triangular band matrix with KL+KU superdiagonals in !> rows 1 to KL+KU+1, and the multipliers used during the !> factorization are stored in rows KL+KU+2 to 2*KL+KU+1. !> See below for further details.

okay this one's the whole personality of the routine. on entry it's matrix A in band storage, in rows KL+1 to 2*KL+KU+1 — and rows 1 to KL literally need not be set (we don't care about them yet). the j-th column of A lives in the j-th column of AB like this:

AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL)

on exit it's all factorization details: U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers from the factorization are in rows KL+KU+2 to 2*KL+KU+1. and there's more further down 👀💀

LDAB

!> LDAB is INTEGER !> The leading dimension of the array AB. LDAB >= 2*KL+KU+1.

the leading dimension of AB. LDAB >= 2*KL+KU+1. periodt 🔥

IPIV

!> IPIV is INTEGER array, dimension (N) !> The pivot indices that define the permutation matrix P; !> row i of the matrix was interchanged with row IPIV(i).

the pivot indices defining the permutation matrix P — row i of the matrix got swapped with row IPIV(i). so it remembers who traded places with who 🙈

B

!> B is REAL array, dimension (LDB,NRHS) !> On entry, the N-by-NRHS right hand side matrix B. !> On exit, if INFO = 0, the N-by-NRHS solution matrix X.

on entry: the N-by-NRHS right hand side matrix B. on exit, if INFO = 0: the N-by-NRHS solution matrix X. glow-up moment ✨

LDB

!> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N).

leading dimension of B, and it's gotta be LDB >= max(1,N) 💖

INFO

!> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value !> > 0: if INFO = i, U(i,i) is exactly zero. The factorization !> has been completed, but the factor U is exactly !> singular, and the solution has not been computed.

the vibe check at the end:

= 0:  successful exit
< 0:  if INFO = -i, the i-th argument had an illegal value
> 0:  if INFO = i, U(i,i) is exactly zero.  The factorization
      has been completed, but the factor U is exactly
      singular, and the solution has not been computed.

so like, INFO = 0? slay, we're done. negative? somebody passed a bad argument (the -i-th one, to be specific). positive? that's the ✨singular✨ situation — factorization finished but U is exactly singular and the solution was never computed. so don't be out here reading X like it means something 😭

---

🧚 Author 🧚

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

four whole institutions collaborated on this. group project that actually ate 💅

---

🔥 Further Details: 🔥

!> !> The band storage scheme is illustrated by the following example, when !> M = N = 6, KL = 2, KU = 1: !> !> On entry: On exit: !> !> * * * + + + * * * u14 u25 u36 !> * * + + + + * * u13 u24 u35 u46 !> * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 !> a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 !> a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * !> a31 a42 a53 a64 * * m31 m42 m53 m64 * * !> !> Array elements marked * are not used by the routine; elements marked !> + need not be set on entry, but are required by the routine to store !> elements of U because of fill-in resulting from the row interchanges. !>

here's the visual, because a diagram just hits different 🎨 M = N = 6, KL = 2, KU = 1:

On entry:                       On exit:

    *    *    *    +    +    +       *    *    *   u14  u25  u36
    *    *    +    +    +    +       *    *   u13  u24  u35  u46
    *   a12  a23  a34  a45  a56      *   u12  u23  u34  u45  u56
   a11  a22  a33  a44  a55  a66     u11  u22  u33  u44  u55  u66
   a21  a32  a43  a54  a65   *      m21  m32  m43  m54  m65   *
   a31  a42  a53  a64   *    *      m31  m42  m53  m64   *    *

and the legend, because we love clarity:

• * elements are not used by the routine — ignore them, they're just there for the aesthetic 💀
• + elements need not be set on entry, but the routine needs them to store elements of U because of fill-in from the row interchanges. so like, don't bother setting them, but don't be surprised when they get written to 🫶

---

👑 Definition 👑

Definition at line 161 of file sgbsv.f. that's where she lives, go say hi 🌸

---

💜 Author 💜

Generated automatically by Doxygen for LAPACK from the source code. not a human, just a robot doing its little documentation thing 🤖✨

---

mwah 💋 that's the whole page — LAPACK, Version 3.12.0, /home/abui...RC/sgbsv.f(3) — go solve some banded systems bestie, ily 🎀💖🦋