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.

Recommended readings

Pages related to cgeqrf you should read also:
H(1) H(2) WORK(1)

Questions & Answers

Helpful answers and articles about cgeqrf you may found on these sites:
Stack Overflow Server Fault Super User Unix & Linux Ask Ubuntu Network Engineering DevOps Raspberry Pi Webmasters Google Search