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

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

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

**Purpose:**

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:**

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:**

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

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

**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 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 DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details).

*WORK*

WORK is DOUBLE PRECISION 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, '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

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

**Purpose:**

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*

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*

*INFO*

**Author**

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

**Date**

December 2016

**Purpose:**

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*

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*

*INFO*

**Author**

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

**Date**

December 2016

**Purpose:**

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

*INFO*

**Author**

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

**Date**

December 2016

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

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

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

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

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

**Purpose:**

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.

*LDA*

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

*IPIV*

*INFO*

**Author**

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

**Date**

December 2016

**Purpose:**

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*

*INFO*

**Author**

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

**Date**

December 2016

**Purpose:**

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. [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*

*INFO*

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

**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 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*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details).

*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

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

3) The part for dlarfb is of size max((N-M)*K, (N-M)*NB, K*NB, NB*NB)

So LWORK = part1 + part2 + part3

*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**

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

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

*LDA*

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

*IPIV*

*INFO*

**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*

*INFO*

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

*INFO*

**Author**

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

**Date**

December 2016

## Author

Generated automatically by Doxygen for LAPACK from the source code.Sun Nov 27 2022 | Version 3.11.0 |