dgeqrf()

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

Download DGEQRF + dependencies [TGZ] [ZIP] [TXT]

Purpose:

 DGEQRF computes a QR factorization of a real M-by-N matrix A:

    A = Q * ( R ),
            ( 0 )

 where:

    Q is a M-by-M orthogonal matrix;
    R is an upper-triangular N-by-N matrix;
    0 is a (M-N)-by-N zero matrix, if M > N.

Parameters

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in,out]	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).
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[out]	TAU	TAU is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details).
[out]	WORK	WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK. LWORK >= 1, if MIN(M,N) = 0, and LWORK >= N, otherwise. 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.
[out]	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.

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

Definition at line 145 of file dgeqrf.f.

*
*  -- LAPACK computational routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            INFO, LDA, LWORK, M, N
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      LOGICAL            LQUERY
      INTEGER            I, IB, IINFO, IWS, K, LDWORK, LWKOPT, NB,
     $                   NBMIN, NX
*     ..
*     .. External Subroutines ..
      EXTERNAL           dgeqr2, dlarfb, dlarft, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. External Functions ..
      INTEGER            ILAENV
      EXTERNAL           ilaenv
*     ..
*     .. Executable Statements ..
*
*     Test the input arguments
*
      k = min( m, n )
      info = 0
      nb = ilaenv( 1, 'DGEQRF', ' ', m, n, -1, -1 )
      lquery = ( lwork.EQ.-1 )
      IF( m.LT.0 ) THEN
         info = -1
      ELSE IF( n.LT.0 ) THEN
         info = -2
      ELSE IF( lda.LT.max( 1, m ) ) THEN
         info = -4
      ELSE IF( .NOT.lquery ) THEN
         IF( lwork.LE.0 .OR. ( m.GT.0 .AND. lwork.LT.max( 1, n ) ) )
     $      info = -7
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'DGEQRF', -info )
         RETURN
      ELSE IF( lquery ) THEN
         IF( k.EQ.0 ) THEN
            lwkopt = 1
         ELSE
            lwkopt = n*nb
         END IF
         work( 1 ) = lwkopt
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( k.EQ.0 ) THEN
         work( 1 ) = 1
         RETURN
      END IF
*
      nbmin = 2
      nx = 0
      iws = n
      IF( nb.GT.1 .AND. nb.LT.k ) THEN
*
*        Determine when to cross over from blocked to unblocked code.
*
         nx = max( 0, ilaenv( 3, 'DGEQRF', ' ', m, n, -1, -1 ) )
         IF( nx.LT.k ) THEN
*
*           Determine if workspace is large enough for blocked code.
*
            ldwork = n
            iws = ldwork*nb
            IF( lwork.LT.iws ) THEN
*
*              Not enough workspace to use optimal NB:  reduce NB and
*              determine the minimum value of NB.
*
               nb = lwork / ldwork
               nbmin = max( 2, ilaenv( 2, 'DGEQRF', ' ', m, n, -1,
     $                 -1 ) )
            END IF
         END IF
      END IF
*
      IF( nb.GE.nbmin .AND. nb.LT.k .AND. nx.LT.k ) THEN
*
*        Use blocked code initially
*
         DO 10 i = 1, k - nx, nb
            ib = min( k-i+1, nb )
*
*           Compute the QR factorization of the current block
*           A(i:m,i:i+ib-1)
*
            CALL dgeqr2( m-i+1, ib, a( i, i ), lda, tau( i ), work,
     $                   iinfo )
            IF( i+ib.LE.n ) THEN
*
*              Form the triangular factor of the block reflector
*              H = H(i) H(i+1) . . . H(i+ib-1)
*
               CALL dlarft( 'Forward', 'Columnwise', m-i+1, ib,
     $                      a( i, i ), lda, tau( i ), work, ldwork )
*
*              Apply H**T to A(i:m,i+ib:n) from the left
*
               CALL dlarfb( 'Left', 'Transpose', 'Forward',
     $                      'Columnwise', m-i+1, n-i-ib+1, ib,
     $                      a( i, i ), lda, work, ldwork, a( i, i+ib ),
     $                      lda, work( ib+1 ), ldwork )
            END IF
   10    CONTINUE
      ELSE
         i = 1
      END IF
*
*     Use unblocked code to factor the last or only block.
*
      IF( i.LE.k )
     $   CALL dgeqr2( m-i+1, n-i+1, a( i, i ), lda, tau( i ), work,
     $                iinfo )
*
      work( 1 ) = iws
      RETURN
*
*     End of DGEQRF
*

Here is the call graph for this function:

Here is the caller graph for this function: