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.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
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 dlamch(CMACH)
DLAMCH
Definition: dlamch.f:65
double precision function dlapy3(X, Y, Z)
DLAPY3 returns sqrt(x2+y2+z2).
Definition: dlapy3.f:70
double precision function dznrm2(N, X, INCX)
DZNRM2
Definition: dznrm2.f:77
complex *16 function zladiv(X, Y)
ZLADIV performs complex division in real arithmetic, avoiding unnecessary overflow.
Definition: zladiv.f:66
subroutine zdscal(N, DA, ZX, INCX)
ZDSCAL
Definition: zdscal.f:80
subroutine zscal(N, ZA, ZX, INCX)
ZSCAL
Definition: zscal.f:80
Here is the call graph for this function:
Here is the caller graph for this function: