subroutine slarfg	(	integer	N,
		real	ALPHA,
		real, dimension( * )	X,
		integer	INCX,
		real	TAU
	)

SLARFG generates an elementary reflector (Householder matrix).

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

Purpose:

 SLARFG 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 REAL On entry, the value alpha. On exit, it is overwritten with the value beta.
[in,out]	X	X is REAL 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 REAL 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 slarfg.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
      REAL               alpha, tau
*     ..
*     .. Array Arguments ..
      REAL               x( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               one, zero
      parameter                ( one = 1.0e+0, zero = 0.0e+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            j, knt
      REAL               beta, rsafmn, safmin, xnorm
*     ..
*     .. External Functions ..
      REAL               slamch, slapy2, snrm2
      EXTERNAL           slamch, slapy2, snrm2
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, sign
*     ..
*     .. External Subroutines ..
      EXTERNAL           sscal
*     ..
*     .. Executable Statements ..
*
      IF( n.LE.1 ) THEN
         tau = zero
         RETURN
      END IF
*
      xnorm = snrm2( n-1, x, incx )
*
      IF( xnorm.EQ.zero ) THEN
*
*        H  =  I
*
         tau = zero
      ELSE
*
*        general case
*
         beta = -sign( slapy2( alpha, xnorm ), alpha )
         safmin = slamch( 'S' ) / slamch( '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 sscal( 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 = snrm2( n-1, x, incx )
            beta = -sign( slapy2( alpha, xnorm ), alpha )
         END IF
         tau = ( beta-alpha ) / beta
         CALL sscal( 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 SLARFG
*

Here is the call graph for this function:

Here is the caller graph for this function: