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

📦 version 3.12.0, in opensuse-leap 16.0

💅 NAME 💅

ok so bestie, this page is all about /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/cgetrf2.f — yes that is literally the whole name, it's giving "my full legal name on the birth certificate" energy and honestly? iconic.

✨ SYNOPSIS ✨

Functions/Subroutines

  • recursive subroutine CGETRF2 (m, n, a, lda, ipiv, info) — CGETRF2 🫶

🦋 Function/Subroutine Documentation 🦋

recursive subroutine CGETRF2 (integer m, integer n, complex, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, integer info)

CGETRF2

🌸 Purpose:

!>
!> CGETRF2 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 real talk: it's the recursive version of the LU factorization algorithm, no cap. It chops your matrix into four lil submatrices — A11, A12, A21, A22 — where A11 is n1 by n1 and A22 is n2 by n2, with n1 = min(m,n)/2 and n2 = n-n1. Then it literally calls itself to factor the first column block, does the swaps, solves A12, updates A22, and then calls itself again to factor A22 and do the swaps on A21. recursion ate, periodt 💅✨

🎀 Parameters 🎀

M

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

the row count bestie, M >= 0. that's it, that's the vibe. 💖

N

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

column count, N >= 0, we love a non-negative queen. 🦋

A

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

ok so A is a COMPLEX array sized (LDA,N). on the way in it's the M-by-N matrix you wanna factor. on the way out it's holding the factors L and U from A = P*L*U — and heads up, the unit diagonal elements of L are not stored, so don't go looking for them, they're not invited to the party 🙈

LDA

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

the leading dimension of A, and it must be LDA >= max(1,M). no negotiating on this one fr fr 💀

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

IPIV is an INTEGER array of dimension (min(M,N)) and it's holding the pivot indices — for 1 <= i <= min(M,N), row i of the matrix got swapped with row IPIV(i). she's the receipts of every row interchange 🧚

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

INFO is the vibe check at the end:

  • = 0 — successful exit, we ate, no notes 👑
  • < 0 — if INFO = -i, the i-th argument had an illegal value (you gave her something illegal bestie, check yourself)
  • > 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, it finished but it's cursed 😭💀
lowkey important: that > 0 case is not a warning to ignore — the factor is exactly singular, periodt. use it to solve a system and you're dividing by zero, no cap.

🌈 Author 🌈

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

Definition at line 112 of file cgetrf2.f.

⭐ Author ⭐

Generated automatically by Doxygen for LAPACK from the source code. (the robots wrote the docs, we just gave them a glow-up ✨)

and that's the whole page bestie! 💜 this was brought to you by LAPACK, Version 3.12.0, dated /home/abui.../cgetrf2.f(3) — mwah, go factor something iconic 🎀🫶

📦 where this page comes from