dgeqrt2()

subroutine dgeqrt2	(	integer	m,
		integer	n,
		double precision, dimension( lda, * )	a,
		integer	lda,
		double precision, dimension( ldt, * )	t,
		integer	ldt,
		integer	info
	)

DGEQRT2 computes a QR factorization of a general real or complex matrix using the compact WY representation of Q.

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

Purpose:

 DGEQRT2 computes a QR factorization of a real M-by-N matrix A,
 using the compact WY representation of Q.

Parameters

[in]	M	M is INTEGER The number of rows of the matrix A. M >= N.
[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 real M-by-N matrix A. On exit, the elements on and above the diagonal contain the N-by-N upper triangular matrix R; the elements below the diagonal are the columns of V. See below for further details.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[out]	T	T is DOUBLE PRECISION array, dimension (LDT,N) The N-by-N upper triangular factor of the block reflector. The elements on and above the diagonal contain the block reflector T; the elements below the diagonal are not used. See below for further details.
[in]	LDT	LDT is INTEGER The leading dimension of the array T. LDT >= max(1,N).
[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 V stores the elementary reflectors H(i) in the i-th column
  below the diagonal. For example, if M=5 and N=3, the matrix V is

               V = (  1       )
                   ( v1  1    )
                   ( v1 v2  1 )
                   ( v1 v2 v3 )
                   ( v1 v2 v3 )

  where the vi's represent the vectors which define H(i), which are returned
  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The
  block reflector H is then given by

               H = I - V * T * V**T

  where V**T is the transpose of V.

Definition at line 126 of file dgeqrt2.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, LDT, M, N
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   A( LDA, * ), T( LDT, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION  ONE, ZERO
      parameter( one = 1.0d+00, zero = 0.0d+00 )
*     ..
*     .. Local Scalars ..
      INTEGER   I, K
      DOUBLE PRECISION   AII, ALPHA
*     ..
*     .. External Subroutines ..
      EXTERNAL  dlarfg, dgemv, dger, dtrmv, xerbla
*     ..
*     .. Executable Statements ..
*
*     Test the input arguments
*
      info = 0
      IF( n.LT.0 ) THEN
         info = -2
      ELSE IF( m.LT.n ) THEN
         info = -1
      ELSE IF( lda.LT.max( 1, m ) ) THEN
         info = -4
      ELSE IF( ldt.LT.max( 1, n ) ) THEN
         info = -6
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'DGEQRT2', -info )
         RETURN
      END IF
*
      k = min( m, n )
*
      DO i = 1, k
*
*        Generate elem. refl. H(i) to annihilate A(i+1:m,i), tau(I) -> T(I,1)
*
         CALL dlarfg( m-i+1, a( i, i ), a( min( i+1, m ), i ), 1,
     $                t( i, 1 ) )
         IF( i.LT.n ) THEN
*
*           Apply H(i) to A(I:M,I+1:N) from the left
*
            aii = a( i, i )
            a( i, i ) = one
*
*           W(1:N-I) := A(I:M,I+1:N)^H * A(I:M,I) [W = T(:,N)]
*
            CALL dgemv( 'T',m-i+1, n-i, one, a( i, i+1 ), lda,
     $                  a( i, i ), 1, zero, t( 1, n ), 1 )
*
*           A(I:M,I+1:N) = A(I:m,I+1:N) + alpha*A(I:M,I)*W(1:N-1)^H
*
            alpha = -(t( i, 1 ))
            CALL dger( m-i+1, n-i, alpha, a( i, i ), 1,
     $           t( 1, n ), 1, a( i, i+1 ), lda )
            a( i, i ) = aii
         END IF
      END DO
*
      DO i = 2, n
         aii = a( i, i )
         a( i, i ) = one
*
*        T(1:I-1,I) := alpha * A(I:M,1:I-1)**T * A(I:M,I)
*
         alpha = -t( i, 1 )
         CALL dgemv( 'T', m-i+1, i-1, alpha, a( i, 1 ), lda,
     $               a( i, i ), 1, zero, t( 1, i ), 1 )
         a( i, i ) = aii
*
*        T(1:I-1,I) := T(1:I-1,1:I-1) * T(1:I-1,I)
*
         CALL dtrmv( 'U', 'N', 'N', i-1, t, ldt, t( 1, i ), 1 )
*
*           T(I,I) = tau(I)
*
            t( i, i ) = t( i, 1 )
            t( i, 1) = zero
      END DO
 
*
*     End of DGEQRT2
*

Here is the call graph for this function:

Here is the caller graph for this function: