subroutine clarfg	(	integer	N,
		complex	ALPHA,
		complex, dimension( * )	X,
		integer	INCX,
		complex	TAU
	)

CLARFG generates an elementary reflector (Householder matrix).

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

Purpose:

 CLARFG generates a complex elementary reflector H of order n, such
 that

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

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

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

 where tau is a complex scalar and v is a complex (n-1)-element
 vector. Note that H is not hermitian.

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

 Otherwise  1 <= real(tau) <= 2  and  abs(tau-1) <= 1 .

Parameters

[in]	N	N is INTEGER The order of the elementary reflector.
[in,out]	ALPHA	ALPHA is COMPLEX On entry, the value alpha. On exit, it is overwritten with the value beta.
[in,out]	X	X is COMPLEX 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 COMPLEX 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 clarfg.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
      COMPLEX            alpha, tau
*     ..
*     .. Array Arguments ..
      COMPLEX            x( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               one, zero
      parameter                ( one = 1.0e+0, zero = 0.0e+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            j, knt
      REAL               alphi, alphr, beta, rsafmn, safmin, xnorm
*     ..
*     .. External Functions ..
      REAL               scnrm2, slamch, slapy3
      COMPLEX            cladiv
      EXTERNAL           scnrm2, slamch, slapy3, cladiv
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, aimag, cmplx, REAL, sign
*     ..
*     .. External Subroutines ..
      EXTERNAL           cscal, csscal
*     ..
*     .. Executable Statements ..
*
      IF( n.LE.0 ) THEN
         tau = zero
         RETURN
      END IF
*
      xnorm = scnrm2( n-1, x, incx )
      alphr = REAL( alpha )
      alphi = aimag( alpha )
*
      IF( xnorm.EQ.zero .AND. alphi.EQ.zero ) THEN
*
*        H  =  I
*
         tau = zero
      ELSE
*
*        general case
*
         beta = -sign( slapy3( alphr, alphi, xnorm ), alphr )
         safmin = slamch( 'S' ) / slamch( 'E' )
         rsafmn = one / safmin
*
         knt = 0
         IF( abs( beta ).LT.safmin ) THEN
*
*           XNORM, BETA may be inaccurate; scale X and recompute them
*
   10       CONTINUE
            knt = knt + 1
            CALL csscal( n-1, rsafmn, x, incx )
            beta = beta*rsafmn
            alphi = alphi*rsafmn
            alphr = alphr*rsafmn
            IF( abs( beta ).LT.safmin )
     $         GO TO 10
*
*           New BETA is at most 1, at least SAFMIN
*
            xnorm = scnrm2( n-1, x, incx )
            alpha = cmplx( alphr, alphi )
            beta = -sign( slapy3( alphr, alphi, xnorm ), alphr )
         END IF
         tau = cmplx( ( beta-alphr ) / beta, -alphi / beta )
         alpha = cladiv( cmplx( one ), alpha-beta )
         CALL cscal( n-1, alpha, 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 CLARFG
*

Here is the call graph for this function:

Here is the caller graph for this function: