variantsGEcomputational(3)

📦
version 3.11.0 · 2 versions
, in debian bookworm

💖 variantsGEcomputational(3) 💖

okay bestie, this is variantsGEcomputational(3) from LAPACK — the page all about the Variants Computational routines. it's a long one so we're doing this in parts, stay with me 🫶

🌸 NAME 🌸

variantsGEcomputational — Variants Computational routines ✨

✨ SYNOPSIS ✨

🧚 Functions 🧚

  • subroutine cgetrf (M, N, A, LDA, IPIV, INFO) — CGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. 💅
  • subroutine dgetrf (M, N, A, LDA, IPIV, INFO) — DGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. 💅
  • subroutine sgetrf (M, N, A, LDA, IPIV, INFO) — SGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. 💅
  • subroutine zgetrf (M, N, A, LDA, IPIV, INFO) — ZGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. 💅
  • subroutine cgeqrf (M, N, A, LDA, TAU, WORK, LWORK, INFO) — CGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm. 🌈
  • subroutine dgeqrf (M, N, A, LDA, TAU, WORK, LWORK, INFO) — DGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm. 🌈
  • subroutine sgeqrf (M, N, A, LDA, TAU, WORK, LWORK, INFO) — SGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm. 🌈
  • subroutine zgeqrf (M, N, A, LDA, TAU, WORK, LWORK, INFO) — ZGEQRF VARIANT: left-looking Level 3 BLAS of the algorithm. 🌈

🦋 Detailed Description 🦋

This is the group of Variants Computational routines. periodt. 💖

👑 Function Documentation 👑

🍓 subroutine cgeqrf (integer M, integer N, complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer INFO) 🍓

CGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm. no cap, this is the one that goes left-looking. ✨

💜 Purpose:

CGEQRF computes a QR factorization of a real M-by-N matrix A:

A = Q * R.

This is the left-looking Level 3 BLAS version of the algorithm. 🎀

💜 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 array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details).

  • LDA

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

  • TAU

TAU is COMPLEX array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details).

  • WORK

WORK is COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK

LWORK is INTEGER

The dimension of the array WORK. LWORK >= 1 if MIN(M,N) = 0, otherwise the dimension can be divided into three parts.

  1. The part for the triangular factor T. If the very last T is not bigger than any of the rest, then this part is NB x ceiling(K/NB), otherwise, NB x (K-NT), where K = min(M,N) and NT is the dimension of the very last T.
  2. The part for the very last T when T is bigger than any of the rest T. The size of this part is NT x NT, where NT = K - ceiling ((K-NX)/NB) x NB, where K = min(M,N), NX is calculated by
NX = MAX( 0, ILAENV( 3, 'CGEQRF', ' ', M, N, -1, -1 ) )
  1. The part for dlarfb is of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB)

So LWORK = part1 + part2 + part3 💅

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.

  • INFO

INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

💜 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

💜 Date

December 2016

💜 Further Details

The matrix Q is represented as a product of elementary reflectors

   Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

   H(i) = I - tau * v * v'

where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).

🍓 subroutine cgetrf (integer M, integer N, complex, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, integer INFO) 🍓

CGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. CGETRF VARIANT: iterative version of Sivan Toledo's recursive LU algorithm

CGETRF VARIANT: left-looking Level 3 BLAS version of the algorithm.

yeah bestie, this one's got THREE whole variants living in it. iconic. 👑

💜 Purpose: (the Crout Level 3 BLAS one)

CGETRF 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 Crout Level 3 BLAS version of the algorithm. 🎀

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

💜 Date

December 2016

💜 Purpose: (the left-looking Level 3 BLAS one)

CGETRF 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 left-looking Level 3 BLAS version of the algorithm. 🎀

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

💜 Date

December 2016

💜 Purpose: (the iterative Sivan Toledo one, and yes she's a whole vibe)

CGETRF 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 code implements an iterative version of Sivan Toledo's recursive LU algorithm[1]. For square matrices, this iterative versions should be within a factor of two of the optimum number of memory transfers. 🔥

The pattern is as follows, with the large blocks of U being updated in one call to DTRSM, and the dotted lines denoting sections that have had all pending permutations applied:

 1 2 3 4 5 6 7 8
+-+-+---+-------+------
| |1|   |       |
|.+-+ 2 |       |
| | |   |       |
|.|.+-+-+   4   |
| | | |1|       |
| | |.+-+       |
| | | | |       |
|.|.|.|.+-+-+---+  8
| | | | | |1|   |
| | | | |.+-+ 2 |
| | | | | | |   |
| | | | |.|.+-+-+
| | | | | | | |1|
| | | | | | |.+-+
| | | | | | | | |
|.|.|.|.|.|.|.|.+-----
| | | | | | | | |

The 1-2-1-4-1-2-1-8-... pattern is the position of the last 1 bit in the binary expansion of the current column. Each Schur update is applied as soon as the necessary portion of U is available. 🧚

[1] Toledo, S. 1997. Locality of Reference in LU Decomposition with Partial Pivoting. SIAM J. Matrix Anal. Appl. 18, 4 (Oct. 1997), 1065-1081. http://dx.doi.org/10.1137/S0895479896297744

💜 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 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 — INTEGER, the leading dimension of the array A. Rule of thumb: LDA >= max(1,M). No negotiating 💅
  • IPIV — an INTEGER array, dimension (min(M,N)), and it's literally the receipt of every swap 🎀 these are the pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
  • INFO — INTEGER, the final vibe check:
= 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.
Heads up bestie: an INFO = i > 0 means U(i,i) is exactly zero — the factorization finished, sure, but the factor U is exactly singular, and if you go use it to solve a system of equations, division by zero is gonna happen. Not a drill. 😭

Author 💖

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

Date 📅

December 2016

subroutine dgeqrf (integer M, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, integer LWORK, integer INFO)

DGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm.

Purpose ✨

DGEQRF computes a QR factorization of a real M-by-N matrix A:

A = Q * R.

This is the left-looking Level 3 BLAS version of the algorithm. Obsessed, honestly.

Parameters 🫶

  • M — INTEGER. The number of rows of the matrix A. M >= 0.
  • N — INTEGER. The number of columns of the matrix A. N >= 0.
  • A — DOUBLE PRECISION array, dimension (LDA,N). On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details). It's giving glow-up 💖
  • LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
  • TAU — DOUBLE PRECISION array, dimension (min(M,N)). The scalar factors of the elementary reflectors (see Further Details).
  • WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. She's an overachiever ✨
  • LWORK — INTEGER. The dimension of the array WORK. LWORK >= 1 if MIN(M,N) = 0, otherwise the dimension can be divided into three parts:
    1. The part for the triangular factor T. If the very last T is not bigger than any of the rest, then this part is NB x ceiling(K/NB), otherwise, NB x (K-NT), where K = min(M,N) and NT is the dimension of the very last T.
    2. The part for the very last T when T is bigger than any of the rest T. The size of this part is NT x NT, where NT = K - ceiling ((K-NX)/NB) x NB, where K = min(M,N), NX is calculated by NX = MAX( 0, ILAENV( 3, 'DGEQRF', ' ', M, N, -1, -1 ) ).
    3. The part for dlarfb is of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB).

So LWORK = part1 + part2 + part3. Math girlies, this one's for you 💅

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. Sneaky but iconic.

  • INFO — INTEGER:
    • = 0: successful exit 🌸
    • < 0: if INFO = -i, the i-th argument had an illegal value 🙈

Author 💖

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

Date 📅

December 2016

Further Details 🔍

The matrix Q is represented as a product of elementary reflectors

   Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

   H(i) = I - tau * v * v'

where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i). That's the whole lore 🦋

subroutine dgetrf (integer M, integer N, double precision, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, integer INFO)

DGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. DGETRF VARIANT: iterative version of Sivan Toledo's recursive LU algorithm

DGETRF VARIANT: left-looking Level 3 BLAS version of the algorithm.

Three variants in one coat, she contains multitudes. 🧚

Purpose 🔥 (Crout Level 3 BLAS version)

DGETRF 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 Crout Level 3 BLAS version of the algorithm.

Parameters 🫶

  • M — INTEGER. The number of rows of the matrix A. M >= 0.
  • N — INTEGER. The number of columns of the matrix A. N >= 0.
  • A — 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. (She's minimal, she's efficient 💅)
  • LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
  • IPIV — 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 — 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. Trauma. 😭

Author 💖

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

Date 📅

December 2016

Purpose ✨ (left-looking Level 3 BLAS version)

DGETRF 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 left-looking Level 3 BLAS version of the algorithm.

Parameters 🫶

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

Date 📅

December 2016

Purpose 🌈 (iterative version of Sivan Toledo's recursive LU algorithm)

DGETRF 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 code implements an iterative version of Sivan Toledo's recursive LU algorithm[1]. For square matrices, this iterative versions should be within a factor of two of the optimum number of memory transfers. Lowkey a flex 🔥

The pattern is as follows, with the large blocks of U being updated in one call to DTRSM, and the dotted lines denoting sections that have had all pending permutations applied:

 1 2 3 4 5 6 7 8
+-+---+---+-------+------
| |1|   |       |
|.+-+ 2 |       |
| | |   |       |
|.|.+-+-+   4   |
| | | |1|       |
| | |.+-+       |
| | | | |       |
|.|.|.|.+-+-+---+  8
| | | | | |1|   |
| | | | |.+-+ 2 |
| | | | | | |   |
| | | | |.|.+-+-+
| | | | | | | |1|
| | | | | | |.+-+
| | | | | | | | |
|.|.|.|.|.|.|.|.+-----
| | | | | | | | |

The 1-2-1-4-1-2-1-8-... pattern is the position of the last 1 bit in the binary expansion of the current column. Each Schur update is applied as soon as the necessary portion of U is available. It's giving fractal energy, she ate 🍓

[1] Toledo, S. 1997. Locality of Reference in LU Decomposition with Partial Pivoting. SIAM J. Matrix Anal. Appl. 18, 4 (Oct. 1997), 1065-1081. http://dx.doi.org/10.1137/S0895479896297744

Parameters 🫶

  • M — INTEGER. The number of rows of the matrix A. M >= 0.
  • N — INTEGER. The number of columns of the matrix A. N >= 0.
  • A — 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 — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
  • IPIV
  • IPIV — IPIV is INTEGER array, dimension (min(M,N)) — the pivot indices, bestie. For 1 <= i <= min(M,N), row i of the matrix got swapped with row IPIV(i). That's the tea. 🔄
  • INFO — INFO is INTEGER, and here's the vibe check:
    • = 0: successful exit ✨
    • < 0: if INFO = -i, the i-th argument had an illegal value (not me being dramatic, that's literally what it means 🙈)
    • > 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. So like… genuinely do not do that. 💀

🎀 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📅 Date

December 2016

💖 sgeqrf — the QR one, she's iconic

subroutine sgeqrf (integer M, integer N, real, dimension( lda, * ) A,
    integer LDA, real, dimension( * ) TAU, real, dimension( * ) WORK,
    integer LWORK, integer INFO)

SGEQRF VARIANT: left-looking Level 3 BLAS version of the algorithm.

✨ Purpose

SGEQRF computes a QR factorization of a real M-by-N matrix A:

A = Q * R.

This is the left-looking Level 3 BLAS version of the algorithm. She's the glow-up edition, periodt. 💅

🌸 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 A.
    • On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details).
  • LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
  • TAU — TAU is REAL array, dimension (min(M,N)). The scalar factors of the elementary reflectors (see Further Details). She's little but she matters 🫶
  • WORK — WORK is REAL array, dimension (MAX(1,LWORK)).
    • On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
  • LWORK — LWORK is INTEGER.

The dimension of the array WORK. LWORK >= 1 if MIN(M,N) = 0, otherwise the dimension can be divided into three parts. Yes, three. She's got layers, like an onion, or a group chat. 🧅

  1. The part for the triangular factor T. If the very last T is not bigger than any of the rest, then this part is NB x ceiling(K/NB), otherwise, NB x (K-NT), where K = min(M,N) and NT is the dimension of the very last T
  2. The part for the very last T when T is bigger than any of the rest T. The size of this part is NT x NT, where NT = K - ceiling ((K-NX)/NB) x NB, where K = min(M,N), NX is calculated by
NX = MAX( 0, ILAENV( 3, 'SGEQRF', ' ', M, N, -1, -1 ) )
  1. The part for dlarfb is of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB)

So LWORK = part1 + part2 + part3

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. It's giving "just asking, no commitment" energy. 🙈

  • INFO — INFO is INTEGER.
    • = 0: successful exit ✨
    • < 0: if INFO = -i, the i-th argument had an illegal value

🎀 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📅 Date

December 2016

🔍 Further Details

The matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).

🦋 sgetrf — the LU one, and she contains multitudes

subroutine sgetrf (integer M, integer N, real, dimension( lda, * ) A,
    integer LDA, integer, dimension( * ) IPIV, integer INFO)

SGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. SGETRF VARIANT: iterative version of Sivan Toledo's recursive LU algorithm

SGETRF VARIANT: left-looking Level 3 BLAS version of the algorithm.

Three variants. One name. Main character energy fr fr.

✨ Purpose (the Crout one)

SGETRF 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 Crout Level 3 BLAS version of the algorithm.

🌸 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. (They're implied. She's subtle 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. Again. Do not. 😭

🎀 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

📅 Date

December 2016

✨ Purpose (the left-looking one)

SGETRF 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 left-looking Level 3 BLAS version of the algorithm.

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

📅 Date

December 2016

✨ Purpose (the iterative Toledo one — this is the lore drop)

SGETRF 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 code implements an iterative version of Sivan Toledo's recursive LU algorithm[1]. For square matrices, this iterative versions should be within a factor of two of the optimum number of memory transfers.

The pattern is as follows, with the large blocks of U being updated in one call to STRSM, and the dotted lines denoting sections that have had all pending permutations applied:

         1 2 3 4 5 6 7 8
        +-+-+---+-------+------
        | |1|   |       |
        |.+-+ 2 |       |
        | | |   |       |
        |.|.+-+-+   4   |
        | | | |1|       |
        | | |.+-+       |
        | | | | |       |
        |.|.|.|.+-+-+---+  8
        | | | | | |1|   |
        | | | | |.+-+ 2 |
        | | | | | | |   |
        | | | | |.|.+-+-+
        | | | | | | | |1|
        | | | | | | |.+-+
        | | | | | | | | |
        |.|.|.|.|.|.|.|.+-----
        | | | | | | | | |

The 1-2-1-4-1-2-1-8-... pattern is the position of the last 1 bit in the binary expansion of the current column. Each Schur update is applied as soon as the necessary portion of U is available. Not me reading a bit pattern like it's a horoscope but honestly? Slay. ⭐

[1] Toledo, S. 1997. Locality of Reference in LU Decomposition with Partial Pivoting. SIAM J. Matrix Anal. Appl. 18, 4 (Oct. 1997), 1065-1081. http://dx.doi.org/10.1137/S0895479896297744

🌸 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 — this one's an INTEGER, bestie, and it's the vibe check at the end:
    • = 0 — slay, successful exit ✨
    • < 0 — if INFO = -i, then the i-th argument was giving illegal value energy and we're not okay with that 💀
    • > 0 — if INFO = i, then U(i,i) is exactly zero. The factorization finished, but the factor U is exactly singular, and division by zero is gonna happen the second you try to use it to solve a system of equations. Not a drill, fr fr 😭

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

December 2016

subroutine zgeqrf (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, integer LWORK, integer INFO)

ZGEQRF VARIANT: left-looking Level 3 BLAS of the algorithm. 👑

Purpose:

ZGEQRF computes a QR factorization of a real M-by-N matrix A:

A = Q * R.

This is the left-looking Level 3 BLAS version of the algorithm. She's the upgraded edition, periodt 💅

Parameters

  • M

M is INTEGER The number of rows of the matrix A. M >= 0. No negatives, we don't do that here 🙅‍♀️

  • 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 A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Details). She transforms, she serves, she leaves receipts ✨

  • LDA

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

  • TAU

TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details). Little scalars, big responsibilities 🎀

  • WORK

WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK

LWORK is INTEGER

The dimension of the array WORK. LWORK >= 1 if MIN(M,N) = 0, otherwise the dimension can be divided into three parts. Yes bestie, three whole parts, buckle up 🌸

  1. The part for the triangular factor T. If the very last T is not bigger than any of the rest, then this part is NB x ceiling(K/NB), otherwise, NB x (K-NT), where K = min(M,N) and NT is the dimension of the very last T
  2. The part for the very last T when T is bigger than any of the rest T. The size of this part is NT x NT, where NT = K - ceiling ((K-NX)/NB) x NB, where K = min(M,N), NX is calculated by
NX = MAX( 0, ILAENV( 3, 'ZGEQRF', ' ', M, N, -1, -1 ) )
  1. The part for dlarfb is of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB)

So LWORK = part1 + part2 + part3 🧮

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. Sneaky little query mode, iykyk 👀

  • INFO

INFO is INTEGER

  • = 0 — successful exit 💖
  • < 0 — if INFO = -i, the i-th argument had an illegal value

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

December 2016

Further Details

The matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i). It's giving math poetry, honestly 🦋

subroutine zgetrf (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, integer INFO)

ZGETRF VARIANT: Crout Level 3 BLAS version of the algorithm. ZGETRF VARIANT: iterative version of Sivan Toledo's recursive LU algorithm

ZGETRF VARIANT: left-looking Level 3 BLAS version of the algorithm. — yes, all three of them, she contains multitudes 💅

Purpose:

ZGETRF 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 Crout Level 3 BLAS version of the algorithm. ✨

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. She keeps her secrets 🤫

  • 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). The swaps! The drama! 🔄

  • 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. Do not proceed. She's giving singular energy and it's dangerous. 💀

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

December 2016

Purpose:

ZGETRF 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 left-looking Level 3 BLAS version of the algorithm. 🌈

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

  • 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. Same warning, same stakes, no cap. 😭

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

December 2016

Purpose:

ZGETRF 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 code implements an iterative version of Sivan Toledo's recursive LU algorithm[1]. For square matrices, this iterative versions should be within a factor of two of the optimum number of memory transfers. Okay so that's lowkey iconic — within a factor of two of optimal, she's efficient AND humble 🌟

The pattern is as follows, with the large blocks of U being updated in one call to DTRSM, and the dotted lines denoting sections that have had all pending permutations applied:

 1 2 3 4 5 6 7 8
+-+-+---+-------+------
| |1|   |       |
|.+-+ 2 |       |
| | |   |       |
|.|.+-+-+   4   |
| | | |1|       |
| | |.+-+       |
| | | | |       |
|.|.|.|.+-+-+---+  8
| | | | | |1|   |
| | | | |.+-+ 2 |
| | | | | | |   |
| | | | |.|.+-+-+
| | | | | | | |1|
| | | | | | |.+-+
| | | | | | | | |
|.|.|.|.|.|.|.|.+-----
| | | | | | | | |

The 1-2-1-4-1-2-1-8-... pattern is the position of the last 1 bit in the binary expansion of the current column. Each Schur update is applied as soon as the necessary portion of U is available. It's giving ✨binary✨ and honestly? obsessed 🧚

[1] Toledo, S. 1997. Locality of Reference in LU Decomposition with Partial Pivoting. SIAM J. Matrix Anal. Appl. 18, 4 (Oct. 1997), 1065-1081. http://dx.doi.org/10.1137/S0895479896297744

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

  • 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, bestie — it's literally the lil report card the routine hands back so you know how the whole thing went down. Here's how to read it:

  • = 0 — slay!! successful exit. Everything worked, nothing is on fire, go live your life. ✨
  • < 0 — okay so if INFO = -i, that means the i-th argument had an illegal value. Translation: you passed it something cursed and it's side-eyeing you. Go check argument number i. 🫶
  • > 0 — and 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 it is used to solve a system of equations. Not a drill, not a vibe, it's giving math crimes 💀 — do not go solving anything with this.

💖 Author 💖

The absolute icons who brought you this:

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

🎀 Date 🎀

December 2016 — yes bestie, she's been iconic for a minute. 👑

Author: Generated automatically by Doxygen for LAPACK from the source code. (so if you were about to @ me about the formatting, it was literally the robot, not me 🙈)

Version 3.11.0 · Sun Nov 27 2022 — and that's the whole page, bestie! Go forth and factor responsibly. 🦋💅 periodt.

📦 where this page comes from