 LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches

## ◆ zlargv()

 subroutine zlargv ( integer N, complex*16, dimension( * ) X, integer INCX, complex*16, dimension( * ) Y, integer INCY, double precision, dimension( * ) C, integer INCC )

ZLARGV generates a vector of plane rotations with real cosines and complex sines.

Purpose:
``` ZLARGV generates a vector of complex plane rotations with real
cosines, determined by elements of the complex vectors x and y.
For i = 1,2,...,n

(        c(i)   s(i) ) ( x(i) ) = ( r(i) )
( -conjg(s(i))  c(i) ) ( y(i) ) = (   0  )

where c(i)**2 + ABS(s(i))**2 = 1

The following conventions are used (these are the same as in ZLARTG,
but differ from the BLAS1 routine ZROTG):
If y(i)=0, then c(i)=1 and s(i)=0.
If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.```
Parameters
 [in] N ``` N is INTEGER The number of plane rotations to be generated.``` [in,out] X ``` X is COMPLEX*16 array, dimension (1+(N-1)*INCX) On entry, the vector x. On exit, x(i) is overwritten by r(i), for i = 1,...,n.``` [in] INCX ``` INCX is INTEGER The increment between elements of X. INCX > 0.``` [in,out] Y ``` Y is COMPLEX*16 array, dimension (1+(N-1)*INCY) On entry, the vector y. On exit, the sines of the plane rotations.``` [in] INCY ``` INCY is INTEGER The increment between elements of Y. INCY > 0.``` [out] C ``` C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC) The cosines of the plane rotations.``` [in] INCC ``` INCC is INTEGER The increment between elements of C. INCC > 0.```
Further Details:
```  6-6-96 - Modified with a new algorithm by W. Kahan and J. Demmel

This version has a few statements commented out for thread safety
(machine parameters are computed on each entry). 10 feb 03, SJH.```

Definition at line 121 of file zlargv.f.

122*
123* -- LAPACK auxiliary routine --
124* -- LAPACK is a software package provided by Univ. of Tennessee, --
125* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
126*
127* .. Scalar Arguments ..
128 INTEGER INCC, INCX, INCY, N
129* ..
130* .. Array Arguments ..
131 DOUBLE PRECISION C( * )
132 COMPLEX*16 X( * ), Y( * )
133* ..
134*
135* =====================================================================
136*
137* .. Parameters ..
138 DOUBLE PRECISION TWO, ONE, ZERO
139 parameter( two = 2.0d+0, one = 1.0d+0, zero = 0.0d+0 )
140 COMPLEX*16 CZERO
141 parameter( czero = ( 0.0d+0, 0.0d+0 ) )
142* ..
143* .. Local Scalars ..
144* LOGICAL FIRST
145
146 INTEGER COUNT, I, IC, IX, IY, J
147 DOUBLE PRECISION CS, D, DI, DR, EPS, F2, F2S, G2, G2S, SAFMIN,
148 \$ SAFMN2, SAFMX2, SCALE
149 COMPLEX*16 F, FF, FS, G, GS, R, SN
150* ..
151* .. External Functions ..
152 DOUBLE PRECISION DLAMCH, DLAPY2
153 EXTERNAL dlamch, dlapy2
154* ..
155* .. Intrinsic Functions ..
156 INTRINSIC abs, dble, dcmplx, dconjg, dimag, int, log,
157 \$ max, sqrt
158* ..
159* .. Statement Functions ..
160 DOUBLE PRECISION ABS1, ABSSQ
161* ..
162* .. Save statement ..
163* SAVE FIRST, SAFMX2, SAFMIN, SAFMN2
164* ..
165* .. Data statements ..
166* DATA FIRST / .TRUE. /
167* ..
168* .. Statement Function definitions ..
169 abs1( ff ) = max( abs( dble( ff ) ), abs( dimag( ff ) ) )
170 abssq( ff ) = dble( ff )**2 + dimag( ff )**2
171* ..
172* .. Executable Statements ..
173*
174* IF( FIRST ) THEN
175* FIRST = .FALSE.
176 safmin = dlamch( 'S' )
177 eps = dlamch( 'E' )
178 safmn2 = dlamch( 'B' )**int( log( safmin / eps ) /
179 \$ log( dlamch( 'B' ) ) / two )
180 safmx2 = one / safmn2
181* END IF
182 ix = 1
183 iy = 1
184 ic = 1
185 DO 60 i = 1, n
186 f = x( ix )
187 g = y( iy )
188*
189* Use identical algorithm as in ZLARTG
190*
191 scale = max( abs1( f ), abs1( g ) )
192 fs = f
193 gs = g
194 count = 0
195 IF( scale.GE.safmx2 ) THEN
196 10 CONTINUE
197 count = count + 1
198 fs = fs*safmn2
199 gs = gs*safmn2
200 scale = scale*safmn2
201 IF( scale.GE.safmx2 .AND. count .LT. 20 )
202 \$ GO TO 10
203 ELSE IF( scale.LE.safmn2 ) THEN
204 IF( g.EQ.czero ) THEN
205 cs = one
206 sn = czero
207 r = f
208 GO TO 50
209 END IF
210 20 CONTINUE
211 count = count - 1
212 fs = fs*safmx2
213 gs = gs*safmx2
214 scale = scale*safmx2
215 IF( scale.LE.safmn2 )
216 \$ GO TO 20
217 END IF
218 f2 = abssq( fs )
219 g2 = abssq( gs )
220 IF( f2.LE.max( g2, one )*safmin ) THEN
221*
222* This is a rare case: F is very small.
223*
224 IF( f.EQ.czero ) THEN
225 cs = zero
226 r = dlapy2( dble( g ), dimag( g ) )
227* Do complex/real division explicitly with two real
228* divisions
229 d = dlapy2( dble( gs ), dimag( gs ) )
230 sn = dcmplx( dble( gs ) / d, -dimag( gs ) / d )
231 GO TO 50
232 END IF
233 f2s = dlapy2( dble( fs ), dimag( fs ) )
234* G2 and G2S are accurate
235* G2 is at least SAFMIN, and G2S is at least SAFMN2
236 g2s = sqrt( g2 )
237* Error in CS from underflow in F2S is at most
238* UNFL / SAFMN2 .lt. sqrt(UNFL*EPS) .lt. EPS
239* If MAX(G2,ONE)=G2, then F2 .lt. G2*SAFMIN,
240* and so CS .lt. sqrt(SAFMIN)
241* If MAX(G2,ONE)=ONE, then F2 .lt. SAFMIN
242* and so CS .lt. sqrt(SAFMIN)/SAFMN2 = sqrt(EPS)
243* Therefore, CS = F2S/G2S / sqrt( 1 + (F2S/G2S)**2 ) = F2S/G2S
244 cs = f2s / g2s
245* Make sure abs(FF) = 1
246* Do complex/real division explicitly with 2 real divisions
247 IF( abs1( f ).GT.one ) THEN
248 d = dlapy2( dble( f ), dimag( f ) )
249 ff = dcmplx( dble( f ) / d, dimag( f ) / d )
250 ELSE
251 dr = safmx2*dble( f )
252 di = safmx2*dimag( f )
253 d = dlapy2( dr, di )
254 ff = dcmplx( dr / d, di / d )
255 END IF
256 sn = ff*dcmplx( dble( gs ) / g2s, -dimag( gs ) / g2s )
257 r = cs*f + sn*g
258 ELSE
259*
260* This is the most common case.
261* Neither F2 nor F2/G2 are less than SAFMIN
262* F2S cannot overflow, and it is accurate
263*
264 f2s = sqrt( one+g2 / f2 )
265* Do the F2S(real)*FS(complex) multiply with two real
266* multiplies
267 r = dcmplx( f2s*dble( fs ), f2s*dimag( fs ) )
268 cs = one / f2s
269 d = f2 + g2
270* Do complex/real division explicitly with two real divisions
271 sn = dcmplx( dble( r ) / d, dimag( r ) / d )
272 sn = sn*dconjg( gs )
273 IF( count.NE.0 ) THEN
274 IF( count.GT.0 ) THEN
275 DO 30 j = 1, count
276 r = r*safmx2
277 30 CONTINUE
278 ELSE
279 DO 40 j = 1, -count
280 r = r*safmn2
281 40 CONTINUE
282 END IF
283 END IF
284 END IF
285 50 CONTINUE
286 c( ic ) = cs
287 y( iy ) = sn
288 x( ix ) = r
289 ic = ic + incc
290 iy = iy + incy
291 ix = ix + incx
292 60 CONTINUE
293 RETURN
294*
295* End of ZLARGV
296*
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
double precision function dlapy2(X, Y)
DLAPY2 returns sqrt(x2+y2).
Definition: dlapy2.f:63
Here is the caller graph for this function: