getrf2(3)

🦋 getrf2(3) — the Library Functions Manual glow-up 🦋

okay bestie, welcome to getrf2(3) from the Library Functions Manual. this is the LAPACK girlies' recursive LU factorization serve, and she comes in four flavors. let's get into it 💅

---

✨ NAME ✨

getrf2 — getrf2: triangular factor panel, recursive? (yes, the manual really does put a question mark there. we stan a humble icon 🙈)

---

🌸 SYNOPSIS 🌸

💖 Functions

here's the whole squad, all of them recursive subroutines, all of them taking (m, n, a, lda, ipiv, info):

• recursive subroutine cgetrf2 (m, n, a, lda, ipiv, info) — CGETRF2
• recursive subroutine dgetrf2 (m, n, a, lda, ipiv, info) — DGETRF2
• recursive subroutine sgetrf2 (m, n, a, lda, ipiv, info) — SGETRF2
• recursive subroutine zgetrf2 (m, n, a, lda, ipiv, info) — ZGETRF2

---

🎀 Detailed Description 🎀

like, there isn't a big prose blurb up here — the real lore lives down in the Function Documentation section. scroll with me, bestie 🫶

---

💜 Function Documentation 💜

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

CGETRF2

⭐ Purpose:

okay so CGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. periodt.

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

it's giving main character energy: she literally calls herself 😭

🍓 Parameters

• M — M is INTEGER, the number of rows of the matrix A. M >= 0. no negativity allowed bestie.
• N — N is INTEGER, the number of columns of the matrix A. N >= 0.
• A — A is COMPLEX array, dimension (LDA,N). on entry, it's the M-by-N matrix to be factored. on exit, you get the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored (they're implied, she's mysterious like that).
• LDA — LDA is INTEGER, the leading dimension of the array A. LDA >= max(1,M).
• 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).
• 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 💀 (fr fr, heed the warning)

👑 Author

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

🌈 Definition

Definition at line 112 of file cgetrf2.f.

---

🧚 recursive subroutine dgetrf2 (integer m, integer n, double precision, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, integer info)

DGETRF2

⭐ Purpose:

DGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. same iconic routine, double precision edition.

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.

recursion queen 👑

🍓 Parameters

• M — M is INTEGER, the number of rows of the matrix A. M >= 0.
• N — N is INTEGER, the number of columns of the matrix A. N >= 0.
• A — A is DOUBLE PRECISION 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.
• LDA — LDA is INTEGER, the leading dimension of the array A. LDA >= max(1,M).
• 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).
• 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 💀

👑 Author

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

🌈 Definition

Definition at line 112 of file dgetrf2.f.

---

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

SGETRF2

⭐ Purpose:

SGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. single precision, same slay.

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.

🍓 Parameters

• M — M is INTEGER, the number of rows of the matrix A. M >= 0.
• N — N is INTEGER, the number of columns of the matrix A. N >= 0.
• 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.
• LDA — LDA is INTEGER, the leading dimension of the array A. LDA >= max(1,M).
• 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).
• 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 💀

👑 Author

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

🌈 Definition

Definition at line 112 of file sgetrf2.f.

---

🔥 recursive subroutine zgetrf2 (integer m, integer n, complex*16, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, integer info)

ZGETRF2

⭐ Purpose:

ZGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. double complex, double the drama, double the icon behavior 💜

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.

🍓 Parameters

• M — M is INTEGER, the number of rows of the matrix A. M >= 0.
• N — N is INTEGER, the number of columns of the matrix A. N >= 0.
• A — A is COMPLEX*16 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.
• LDA — LDA is INTEGER, the leading dimension of the array A. LDA >= max(1,M).
• LDA — INTEGER. This is the leading dimension of the array A, and the rule is literally LDA >= max(1,M). No cap, that bound is non-negotiable. 💅
• IPIV — INTEGER array, dimension (min(M,N)). The pivot indices, periodt: for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). ✨
• INFO — INTEGER, the exit-status check-in:
  • = 0: successful exit, we love to see it 💖
  • < 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. 🚨

👑 Author

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

Definition at line 112 of file zgetrf2.f.

🤖 Author

Generated automatically by Doxygen for LAPACK from the source code.

---

Okay bestie, that’s the whole page 💖 shoutout to the source: LAPACK, Version 3.12.0, page getrf2(3) — and the footer didn’t give us a date, so we’re not inventing one, periodt. 🎀