/home/abui.../sgetrf2.f(3)

📦 version 3.12.0, in opensuse-leap 16.0

💅 sgetrf2.f — like, the whole entire manual, bestie

okay so this page lives in the Library Functions Manual, and the file it's describing is literally:

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

yes the path is a whole journey, we don't talk about it 💀

✨ NAME ✨

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/sgetrf2.f — that's the file, that's the name, no notes 🎀

🌸 SYNOPSIS 🌸

Functions/Subroutines

  • recursive subroutine SGETRF2 (m, n, a, lda, ipiv, info) — SGETRF2, the icon herself 👑

🦋 Function/Subroutine Documentation 🦋

recursive subroutine SGETRF2 (integer m, integer n, real, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, integer info)

SGETRF2. that's it, that's the girl.

💖 Purpose 💖

!>
!> SGETRF2 computes an LU factorization of a general M-by-N matrix A
!> using partial pivoting with row interchanges.
!>
!> The factorization has the form
!>    A = P * L * U
!> where P is a permutation matrix, L is lower triangular with unit
!> diagonal elements (lower trapezoidal if m > n), and U is upper
!> triangular (upper trapezoidal if m < n).
!>
!> This is the recursive version of the algorithm. It divides
!> the matrix into four submatrices:
!>
!>        [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2
!>    A = [ -----|----- ]  with n1 = min(m,n)/2
!>        [  A21 | A22  ]       n2 = n-n1
!>
!>                                       [ A11 ]
!> The subroutine calls itself to factor [ --- ],
!>                                       [ A12 ]
!>                 [ A12 ]
!> do the swaps on [ --- ], solve A12, update A22,
!>                 [ A22 ]
!>
!> then calls itself to factor A22 and do the swaps on A21.
!>
!>

so basically: she factors A into A = P * L * U, P being a permutation matrix, L lower triangular with unit diagonal elements (lower trapezoidal when m > n), and U upper triangular (upper trapezoidal when m < n). and the recursive part is the main character energy here — she chops the matrix into four submatrices, calls herself to do the work, does the swaps, solves A12, updates A22, then calls herself again to factor A22 and do the swaps on A21. iconic behavior honestly 🔥

👑 Parameters 👑

M

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

the row count, bestie. M >= 0, no negativity allowed 💅

N

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

the column count. again, N >= 0, we stay positive 🌈

A

!>          A is REAL array, dimension (LDA,N)
!>          On entry, the M-by-N matrix to be factored.
!>          On exit, the factors L and U from the factorization
!>          A = P*L*U; the unit diagonal elements of L are not stored.
!>

this is the actual REAL array, dimension (LDA,N). on entry it's your M-by-N matrix waiting to be factored; on exit it holds the L and U factors from A = P*L*U — and heads up, the unit diagonal elements of L are not stored 🙈 (they're implied, she doesn't need to write them down, she knows who she is.)

LDA

!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,M).
!>

leading dimension of A, and it's gotta be LDA >= max(1,M). respect the constraint or it's not gonna slay ⭐

IPIV

!>          IPIV is INTEGER array, dimension (min(M,N))
!>          The pivot indices; for 1 <= i <= min(M,N), row i of the
!>          matrix was interchanged with row IPIV(i).
!>

the pivot indices, INTEGER array of dimension (min(M,N)). for 1 <= i <= min(M,N), row i of the matrix got swapped with row IPIV(i). it's giving trade routes tbh 🔄

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 division by zero will occur if it is used
!>                to solve a system of equations.
!>

vibe check on the exit:

  • = 0 — successful exit, we ate 💖
  • < 0 — if INFO = -i, the i-th argument had an illegal value. you handed her something she cannot work with 😭
  • > 0 — if INFO = i, then U(i,i) is exactly zero. the factorization has been completed, but the factor U is exactly singular, and division by zero will occur if you use it to solve a system of equations. so like… noted, fr fr 💀
lowkey important: INFO > 0 is not an error in the factoring sense, she finished. it's a warning that U is singular and using it to solve systems is gonna blow up. proceed with caution, bestie.

🎀 Author 🎀

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

all of them. a whole committee. the group project that actually got submitted 🫶

Definition at line 112 of file sgetrf2.f.

🌟 Author 🌟

Generated automatically by Doxygen for LAPACK from the source code. (yes, a robot wrote this, we respect the automation 💅)

okay bye bestie, hope the LU factorization goes off without a hitch — LAPACK Version 3.12.0, and the page itself is /home/abui.../sgetrf2.f(3). mwah 💜✨

📦 where this page comes from