table of contents
| variantsGEcomputational(3) | LAPACK | variantsGEcomputational(3) |
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
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:
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
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:
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
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 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
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:
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:
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
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 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
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, '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
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 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
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:
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.
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
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
Author¶
Generated automatically by Doxygen for LAPACK from the source code.
| Sun Nov 27 2022 | Version 3.11.0 |