ManagedLapackOfSingle.QRDecompose Method

Definition

Namespace: Extreme.Mathematics.LinearAlgebra.Implementation
Assembly: Extreme.Numerics.SinglePrecision (in Extreme.Numerics.SinglePrecision.dll) Version: 8.1.4

Overload List

QRDecompose(Int32, Int32, Array2D<Complex<Single>>, Array1D<Complex<Single>>, 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) ZOUBLE 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) ZOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) ZOUBLE 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<Single>, Array1D<Single>, Int32)

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

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

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

QRDecompose(Int32, Int32, Array2D<Complex<Single>>, Array1D<Complex<Single>>, 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) ZOUBLE 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) ZOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) ZOUBLE 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 override void QRDecompose(
	int m,
	int n,
	Array2D<Complex<float>> a,
	Array1D<Complex<float>> tau,
	out int info
)

Parameters

m  Int32
 
n  Int32
 
a  Array2D<Complex<Single>>
 
tau  Array1D<Complex<Single>>
 
info  Int32
 

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

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

C# 
public override void QRDecompose(
	int m,
	int n,
	Array2D<float> a,
	Array1D<float> 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<Single>
            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<Single>
            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 DGEQRF.

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

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

C# 
public override void QRDecompose(
	int m,
	int n,
	Array2D<float> a,
	Array1D<int> jpvt,
	Array1D<float> 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<Single>
            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.0f, 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<Single>
            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