 LAPACK  3.8.0 LAPACK: Linear Algebra PACKage

## ◆ zlarfg()

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

ZLARFG generates an elementary reflector (Householder matrix).

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

Purpose:
``` ZLARFG 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*16 On entry, the value alpha. On exit, it is overwritten with the value beta.``` [in,out] X ``` X is COMPLEX*16 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*16 The value tau.```
Date
November 2017

Definition at line 108 of file zlarfg.f.

108 *
109 * -- LAPACK auxiliary routine (version 3.8.0) --
110 * -- LAPACK is a software package provided by Univ. of Tennessee, --
111 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
112 * November 2017
113 *
114 * .. Scalar Arguments ..
115  INTEGER incx, n
116  COMPLEX*16 alpha, tau
117 * ..
118 * .. Array Arguments ..
119  COMPLEX*16 x( * )
120 * ..
121 *
122 * =====================================================================
123 *
124 * .. Parameters ..
125  DOUBLE PRECISION one, zero
126  parameter( one = 1.0d+0, zero = 0.0d+0 )
127 * ..
128 * .. Local Scalars ..
129  INTEGER j, knt
130  DOUBLE PRECISION alphi, alphr, beta, rsafmn, safmin, xnorm
131 * ..
132 * .. External Functions ..
133  DOUBLE PRECISION dlamch, dlapy3, dznrm2
134  COMPLEX*16 zladiv
135  EXTERNAL dlamch, dlapy3, dznrm2, zladiv
136 * ..
137 * .. Intrinsic Functions ..
138  INTRINSIC abs, dble, dcmplx, dimag, sign
139 * ..
140 * .. External Subroutines ..
141  EXTERNAL zdscal, zscal
142 * ..
143 * .. Executable Statements ..
144 *
145  IF( n.LE.0 ) THEN
146  tau = zero
147  RETURN
148  END IF
149 *
150  xnorm = dznrm2( n-1, x, incx )
151  alphr = dble( alpha )
152  alphi = dimag( alpha )
153 *
154  IF( xnorm.EQ.zero .AND. alphi.EQ.zero ) THEN
155 *
156 * H = I
157 *
158  tau = zero
159  ELSE
160 *
161 * general case
162 *
163  beta = -sign( dlapy3( alphr, alphi, xnorm ), alphr )
164  safmin = dlamch( 'S' ) / dlamch( 'E' )
165  rsafmn = one / safmin
166 *
167  knt = 0
168  IF( abs( beta ).LT.safmin ) THEN
169 *
170 * XNORM, BETA may be inaccurate; scale X and recompute them
171 *
172  10 CONTINUE
173  knt = knt + 1
174  CALL zdscal( n-1, rsafmn, x, incx )
175  beta = beta*rsafmn
176  alphi = alphi*rsafmn
177  alphr = alphr*rsafmn
178  IF( (abs( beta ).LT.safmin) .AND. (knt .LT. 20) )
179  \$ GO TO 10
180 *
181 * New BETA is at most 1, at least SAFMIN
182 *
183  xnorm = dznrm2( n-1, x, incx )
184  alpha = dcmplx( alphr, alphi )
185  beta = -sign( dlapy3( alphr, alphi, xnorm ), alphr )
186  END IF
187  tau = dcmplx( ( beta-alphr ) / beta, -alphi / beta )
188  alpha = zladiv( dcmplx( one ), alpha-beta )
189  CALL zscal( n-1, alpha, x, incx )
190 *
191 * If ALPHA is subnormal, it may lose relative accuracy
192 *
193  DO 20 j = 1, knt
194  beta = beta*safmin
195  20 CONTINUE
196  alpha = beta
197  END IF
198 *
199  RETURN
200 *
201 * End of ZLARFG
202 *
double precision function dznrm2(N, X, INCX)
DZNRM2
Definition: dznrm2.f:77
subroutine zscal(N, ZA, ZX, INCX)
ZSCAL
Definition: zscal.f:80
subroutine zdscal(N, DA, ZX, INCX)
ZDSCAL
Definition: zdscal.f:80
complex *16 function zladiv(X, Y)
ZLADIV performs complex division in real arithmetic, avoiding unnecessary overflow.
Definition: zladiv.f:66
double precision function dlapy3(X, Y, Z)
DLAPY3 returns sqrt(x2+y2+z2).
Definition: dlapy3.f:70
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:65
Here is the call graph for this function:
Here is the caller graph for this function: