SRC/cgbsv.f(3)

📦
version 3.12.1 · 4 versions
, in arch rolling

💅 SRC/cgbsv.f — the LAPACK Library Functions Manual, but make it make sense

okay so bestie, welcome to cgbsv ✨ this is a page from the LAPACK Library Functions Manual, and it's lowkey iconic — it's the whole reason your band-matrix linear solves just work. Let's get into it 🫶

✨ SYNOPSIS ✨

Functions/Subroutines

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

🌸 Function/Subroutine Documentation 🌸

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

CGBSV computes the solution to system of linear equations A * X = B for GB matrices (simple driver) — yes, that's the whole flex 💅

🎀 Purpose:

!> !> CGBSV computes the solution to a complex 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: it does the LU factorization thing with partial pivoting and row interchanges, splits your A into A = L * U, and then solves A * X = B for you. main character behavior, honestly 👑

🦋 Parameters 🦋

okay bestie, here's the cast of characters — every single one, no skips 🫶

N

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

the number of linear equations — i.e. the order of the matrix A. and it's N >= 0, no negativity allowed ✨

KL

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

how many subdiagonals live inside the band of A. KL >= 0, periodt 💅

KU

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

how many superdiagonals are in the band of A. KU >= 0, same energy 🌈

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, aka the number of columns of the matrix B. NRHS >= 0 for sure 🌸

AB

!> AB is COMPLEX 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. !>

this one's a COMPLEX array with dimension (LDAB,N) and it's kind of the moment 👀

  • on entry: it's the matrix A in band storage, sitting in rows KL+1 to 2*KL+KU+1. rows 1 to KL of the array don't even need to be set — leave them, they're fine 🙈
  • how the j-th column of A lives in the j-th column of AB:
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 from the factorization are chillin' in rows KL+KU+2 to 2*KL+KU+1.
  • further details down below, iykyk ⭐

LDAB

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

the leading dimension of the array AB. and it must be LDAB >= 2*KL+KU+1 — no cap, that's the rule 💅

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

INTEGER array, dimension (N) — the pivot indices that define the permutation matrix P. row i of the matrix was interchanged with row IPIV(i). slay 🔥

B

!> B is COMPLEX 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. !>

COMPLEX array, dimension (LDB,NRHS). on entry it's the N-by-NRHS right hand side matrix B; on exit, if INFO = 0, it's the N-by-NRHS solution matrix X. glow-up of the century tbh ✨

LDB

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

the leading dimension of the array B, and LDB >= max(1,N). that's it, that's the whole vibe 🦋

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 receipts, bestie — read them carefully 👑

  • = 0: successful exit 🎉
  • < 0: if INFO = -i, the i-th argument had an illegal value (rude)
  • > 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 😭

🧚 Author 🧚

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

absolute legends, all of them 🫶

🌟 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 it is in a code block so you can actually read it, bestie:

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   *    *
⚠️ lowkey important: 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. don't skip this part 🙈

Definition at line 161 of file cgbsv.f.

💖 Author 💖

Generated automatically by Doxygen for LAPACK from the source code. (the robots did this one, and honestly? they ate 🤖✨)

and that's the whole page, bestie 🎀 this was LAPACK, Version 3.12.0, comin' at you from SRC/cgbsv.f(3) — go forth and solve those band systems 💅🦋

📦 where this page comes from