DecompositionOperations<TReal, TComplex>.QRDecompose Method

Definition

Namespace: Numerics.NET.LinearAlgebra.Implementation
Assembly: Numerics.NET (in Numerics.NET.dll) Version: 9.0.2

Overload List

QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

QRDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32) ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) 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 Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. 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 (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== 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 inthis. A(i+1:m,i), and tau inthis. TAU(i).
QRDecompose(Int32, Int32, Span2D<TReal>, Span<TReal>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

QRDecompose(Int32, Int32, Span2D<TComplex>, Span<TComplex>, Int32) ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) 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 Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. 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 (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== 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 inthis. A(i+1:m,i), and tau inthis. TAU(i).
QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array1D<TReal>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

QRDecompose(Int32, Int32, Span2D<TReal>, Span<Int32>, Span<TReal>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

QRDecompose(Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

QRDecompose(Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32) ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) 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 Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. 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 (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== 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 inthis. A(i+1:m,i), and tau inthis. TAU(i).
QRDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Span<TReal>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

C# 
public void QRDecompose(
	int m,
	int n,
	Array2D<TReal> a,
	Array1D<TReal> tau,
	out int info
)

Parameters

m  Int32
            The number of rows of the matrix A.  M >= 0.
n  Int32
            The number of columns of the matrix A.  N >= 0.
a  Array2D<TReal>
            A is TReal 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).
            
            The leading dimension of the array A.  LDA >= max(1,M).
tau  Array1D<TReal>
            TAU is TReal array, dimension (min(M,N))
            The scalar factors of the elementary reflectors (see Further
            Details).
info  Int32
            = 0:  successful exit
            < 0:  if INFO = -i, the i-th argument had an illegal value

Remarks

 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**T
            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).
            
This method corresponds to the LAPACK routine ?GEQRF.

QRDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32)

ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) 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 Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. 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 (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== 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 inthis. A(i+1:m,i), and tau inthis. TAU(i).
C# 
public void QRDecompose(
	int m,
	int n,
	Array2D<TComplex> a,
	Array1D<TComplex> tau,
	out int info
)

Parameters

m  Int32
 
n  Int32
 
a  Array2D<TComplex>
 
tau  Array1D<TComplex>
 
info  Int32
 

QRDecompose(Int32, Int32, Span2D<TReal>, Span<TReal>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

C# 
public void QRDecompose(
	int m,
	int n,
	Span2D<TReal> a,
	Span<TReal> tau,
	out int info
)

Parameters

m  Int32
            The number of rows of the matrix A.  M >= 0.
n  Int32
            The number of columns of the matrix A.  N >= 0.
a  Span2D<TReal>
            A is TReal 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).
            
            The leading dimension of the array A.  LDA >= max(1,M).
tau  Span<TReal>
            TAU is TReal array, dimension (min(M,N))
            The scalar factors of the elementary reflectors (see Further
            Details).
info  Int32
            = 0:  successful exit
            < 0:  if INFO = -i, the i-th argument had an illegal value

Remarks

 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**T
            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).
            
This method corresponds to the LAPACK routine ?GEQRF.

QRDecompose(Int32, Int32, Span2D<TComplex>, Span<TComplex>, Int32)

ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) 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 Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. 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 (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== 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 inthis. A(i+1:m,i), and tau inthis. TAU(i).
C# 
public void QRDecompose(
	int m,
	int n,
	Span2D<TComplex> a,
	Span<TComplex> tau,
	out int info
)

Parameters

m  Int32
 
n  Int32
 
a  Span2D<TComplex>
 
tau  Span<TComplex>
 
info  Int32
 

QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array1D<TReal>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

C# 
public void QRDecompose(
	int m,
	int n,
	Array2D<TReal> a,
	Array1D<int> jpvt,
	Array1D<TReal> tau,
	out int info
)

Parameters

m  Int32
            The number of rows of the matrix A. M >= 0.
n  Int32
            The number of columns of the matrix A.  N >= 0.
a  Array2D<TReal>
            A is TReal array, dimension (LDA,N)
            On entry, the M-by-N matrix A.
            On exit, the upper triangle of the array contains the
            min(M,N)-by-N upper trapezoidal matrix R; the elements below
            the diagonal, together with the array TAU, represent the
            orthogonal matrix Q as a product of min(M,N) elementary
            reflectors.
            
            The leading dimension of the array A. LDA >= max(1,M).
jpvt  Array1D<Int32>
            Dimension (N)
            On entry, if JPVT(J).ne.0, the J-th column of A is permuted
            to the front of A*P (a leading column); if JPVT(J)=0,
            the J-th column of A is a free column.
            On exit, if JPVT(J)=K, then the J-th column of A*P was the
            the K-th column of A.
tau  Array1D<TReal>
            TAU is TReal array, dimension (min(M,N))
            The scalar factors of the elementary reflectors.
info  Int32
            = 0: successful exit.
            < 0: if INFO = -i, the i-th argument had an illegal value.

Remarks

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**T
            where tau is a real/complex scalar, and v is a real/complex 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).

Contributors:

G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain X. Sun, Computer Science Dept., Duke University, USA

This method corresponds to the LAPACK routine DGEQP3.

QRDecompose(Int32, Int32, Span2D<TReal>, Span<Int32>, Span<TReal>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

C# 
public void QRDecompose(
	int m,
	int n,
	Span2D<TReal> a,
	Span<int> jpvt,
	Span<TReal> tau,
	out int info
)

Parameters

m  Int32
            The number of rows of the matrix A. M >= 0.
n  Int32
            The number of columns of the matrix A.  N >= 0.
a  Span2D<TReal>
            A is TReal array, dimension (LDA,N)
            On entry, the M-by-N matrix A.
            On exit, the upper triangle of the array contains the
            min(M,N)-by-N upper trapezoidal matrix R; the elements below
            the diagonal, together with the array TAU, represent the
            orthogonal matrix Q as a product of min(M,N) elementary
            reflectors.
            
            The leading dimension of the array A. LDA >= max(1,M).
jpvt  Span<Int32>
            Dimension (N)
            On entry, if JPVT(J).ne.0, the J-th column of A is permuted
            to the front of A*P (a leading column); if JPVT(J)=0,
            the J-th column of A is a free column.
            On exit, if JPVT(J)=K, then the J-th column of A*P was the
            the K-th column of A.
tau  Span<TReal>
            TAU is TReal array, dimension (min(M,N))
            The scalar factors of the elementary reflectors.
info  Int32
            = 0: successful exit.
            < 0: if INFO = -i, the i-th argument had an illegal value.

Remarks

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**T
            where tau is a real/complex scalar, and v is a real/complex 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).

Contributors:

G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain X. Sun, Computer Science Dept., Duke University, USA

This method corresponds to the LAPACK routine DGEQP3.

QRDecompose(Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

C# 
public abstract void QRDecompose(
	int m,
	int n,
	Span<TReal> a,
	int lda,
	Span<TReal> tau,
	out int info
)

Parameters

m  Int32
            The number of rows of the matrix A.  M >= 0.
n  Int32
            The number of columns of the matrix A.  N >= 0.
a  Span<TReal>
            A is TReal 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  Int32
            The leading dimension of the array A.  LDA >= max(1,M).
tau  Span<TReal>
            TAU is TReal array, dimension (min(M,N))
            The scalar factors of the elementary reflectors (see Further
            Details).
info  Int32
            = 0:  successful exit
            < 0:  if INFO = -i, the i-th argument had an illegal value

Remarks

 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**T
            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).
            
This method corresponds to the LAPACK routine ?GEQRF.

QRDecompose(Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32)

ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) 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 Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. 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 (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== 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 inthis. A(i+1:m,i), and tau inthis. TAU(i).
C# 
public abstract void QRDecompose(
	int m,
	int n,
	Span<TComplex> a,
	int lda,
	Span<TComplex> tau,
	out int info
)

Parameters

m  Int32
 
n  Int32
 
a  Span<TComplex>
 
lda  Int32
 
tau  Span<TComplex>
 
info  Int32
 

QRDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Span<TReal>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

C# 
public abstract void QRDecompose(
	int m,
	int n,
	Span<TReal> a,
	int lda,
	Span<int> jpvt,
	Span<TReal> tau,
	out int info
)

Parameters

m  Int32
            The number of rows of the matrix A. M >= 0.
n  Int32
            The number of columns of the matrix A.  N >= 0.
a  Span<TReal>
            A is TReal array, dimension (LDA,N)
            On entry, the M-by-N matrix A.
            On exit, the upper triangle of the array contains the
            min(M,N)-by-N upper trapezoidal matrix R; the elements below
            the diagonal, together with the array TAU, represent the
            orthogonal matrix Q as a product of min(M,N) elementary
            reflectors.
lda  Int32
            The leading dimension of the array A. LDA >= max(1,M).
jpvt  Span<Int32>
            Dimension (N)
            On entry, if JPVT(J).ne.0, the J-th column of A is permuted
            to the front of A*P (a leading column); if JPVT(J)=0,
            the J-th column of A is a free column.
            On exit, if JPVT(J)=K, then the J-th column of A*P was the
            the K-th column of A.
tau  Span<TReal>
            TAU is TReal array, dimension (min(M,N))
            The scalar factors of the elementary reflectors.
info  Int32
            = 0: successful exit.
            < 0: if INFO = -i, the i-th argument had an illegal value.

Remarks

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**T
            where tau is a real/complex scalar, and v is a real/complex 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).

Contributors:

G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain X. Sun, Computer Science Dept., Duke University, USA

This method corresponds to the LAPACK routine DGEQP3.

See Also