subroutine dlarfg	(	integer	N,
		double precision	ALPHA,
		double precision, dimension( * )	X,
		integer	INCX,
		double precision	TAU
	)

DLARFG generates an elementary reflector (Householder matrix).

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

Purpose:

 DLARFG generates a real elementary reflector H of order n, such
 that

       H * ( alpha ) = ( beta ),   H**T * H = I.
           (   x   )   (   0  )

 where alpha and beta are scalars, and x is an (n-1)-element real
 vector. H is represented in the form

       H = I - tau * ( 1 ) * ( 1 v**T ) ,
                     ( v )

 where tau is a real scalar and v is a real (n-1)-element
 vector.

 If the elements of x are all zero, then tau = 0 and H is taken to be
 the unit matrix.

 Otherwise  1 <= tau <= 2.

Parameters

[in]	N	N is INTEGER The order of the elementary reflector.
[in,out]	ALPHA	ALPHA is DOUBLE PRECISION On entry, the value alpha. On exit, it is overwritten with the value beta.
[in,out]	X	X is DOUBLE PRECISION array, dimension (1+(N-2)*abs(INCX)) On entry, the vector x. On exit, it is overwritten with the vector v.
[in]	INCX	INCX is INTEGER The increment between elements of X. INCX > 0.
[out]	TAU	TAU is DOUBLE PRECISION The value tau.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

September 2012

Definition at line 108 of file dlarfg.f.

*
*  -- LAPACK auxiliary routine (version 3.4.2) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     September 2012
*
*     .. Scalar Arguments ..
      INTEGER            incx, n
      DOUBLE PRECISION   alpha, tau
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   x( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   one, zero
      parameter                ( one = 1.0d+0, zero = 0.0d+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            j, knt
      DOUBLE PRECISION   beta, rsafmn, safmin, xnorm
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   dlamch, dlapy2, dnrm2
      EXTERNAL           dlamch, dlapy2, dnrm2
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, sign
*     ..
*     .. External Subroutines ..
      EXTERNAL           dscal
*     ..
*     .. Executable Statements ..
*
      IF( n.LE.1 ) THEN
         tau = zero
         RETURN
      END IF
*
      xnorm = dnrm2( n-1, x, incx )
*
      IF( xnorm.EQ.zero ) THEN
*
*        H  =  I
*
         tau = zero
      ELSE
*
*        general case
*
         beta = -sign( dlapy2( alpha, xnorm ), alpha )
         safmin = dlamch( 'S' ) / dlamch( 'E' )
         knt = 0
         IF( abs( beta ).LT.safmin ) THEN
*
*           XNORM, BETA may be inaccurate; scale X and recompute them
*
            rsafmn = one / safmin
   10       CONTINUE
            knt = knt + 1
            CALL dscal( n-1, rsafmn, x, incx )
            beta = beta*rsafmn
            alpha = alpha*rsafmn
            IF( abs( beta ).LT.safmin )
     $         GO TO 10
*
*           New BETA is at most 1, at least SAFMIN
*
            xnorm = dnrm2( n-1, x, incx )
            beta = -sign( dlapy2( alpha, xnorm ), alpha )
         END IF
         tau = ( beta-alpha ) / beta
         CALL dscal( n-1, one / ( alpha-beta ), x, incx )
*
*        If ALPHA is subnormal, it may lose relative accuracy
*
         DO 20 j = 1, knt
            beta = beta*safmin
 20      CONTINUE
         alpha = beta
      END IF
*
      RETURN
*
*     End of DLARFG
*

Here is the call graph for this function:

Here is the caller graph for this function: