Debian Codegraph @

Modules/ThirdParty/VNL/src/vxl/v3p/netlib/lapack/double/dhgeqz.f

raw
1 SUBROUTINE DHGEQZ( JOB, COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB,
2 $ ALPHAR, ALPHAI, BETA, Q, LDQ, Z, LDZ, WORK,
3 $ LWORK, INFO )
4 *
5 * -- LAPACK routine (version 3.0) --
6 * Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
7 * Courant Institute, Argonne National Lab, and Rice University
8 * June 30, 1999
9 *
10 * .. Scalar Arguments ..
11 CHARACTER COMPQ, COMPZ, JOB
12 INTEGER IHI, ILO, INFO, LDA, LDB, LDQ, LDZ, LWORK, N
13 * ..
14 * .. Array Arguments ..
15 DOUBLE PRECISION A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
16 $ B( LDB, * ), BETA( * ), Q( LDQ, * ), WORK( * ),
17 $ Z( LDZ, * )
18 * ..
19 *
20 * Purpose
21 * =======
22 *
23 * DHGEQZ implements a single-/double-shift version of the QZ method for
24 * finding the generalized eigenvalues
25 *
26 * w(j)=(ALPHAR(j) + i*ALPHAI(j))/BETAR(j) of the equation
27 *
28 * det( A - w(i) B ) = 0
29 *
30 * In addition, the pair A,B may be reduced to generalized Schur form:
31 * B is upper triangular, and A is block upper triangular, where the
32 * diagonal blocks are either 1-by-1 or 2-by-2, the 2-by-2 blocks having
33 * complex generalized eigenvalues (see the description of the argument
34 * JOB.)
35 *
36 * If JOB='S', then the pair (A,B) is simultaneously reduced to Schur
37 * form by applying one orthogonal transformation (usually called Q) on
38 * the left and another (usually called Z) on the right. The 2-by-2
39 * upper-triangular diagonal blocks of B corresponding to 2-by-2 blocks
40 * of A will be reduced to positive diagonal matrices. (I.e.,
41 * if A(j+1,j) is non-zero, then B(j+1,j)=B(j,j+1)=0 and B(j,j) and
42 * B(j+1,j+1) will be positive.)
43 *
44 * If JOB='E', then at each iteration, the same transformations
45 * are computed, but they are only applied to those parts of A and B
46 * which are needed to compute ALPHAR, ALPHAI, and BETAR.
47 *
48 * If JOB='S' and COMPQ and COMPZ are 'V' or 'I', then the orthogonal
49 * transformations used to reduce (A,B) are accumulated into the arrays
50 * Q and Z s.t.:
51 *
52 * Q(in) A(in) Z(in)* = Q(out) A(out) Z(out)*
53 * Q(in) B(in) Z(in)* = Q(out) B(out) Z(out)*
54 *
55 * Ref: C.B. Moler & G.W. Stewart, "An Algorithm for Generalized Matrix
56 * Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
57 * pp. 241--256.
58 *
59 * Arguments
60 * =========
61 *
62 * JOB (input) CHARACTER*1
63 * = 'E': compute only ALPHAR, ALPHAI, and BETA. A and B will
64 * not necessarily be put into generalized Schur form.
65 * = 'S': put A and B into generalized Schur form, as well
66 * as computing ALPHAR, ALPHAI, and BETA.
67 *
68 * COMPQ (input) CHARACTER*1
69 * = 'N': do not modify Q.
70 * = 'V': multiply the array Q on the right by the transpose of
71 * the orthogonal transformation that is applied to the
72 * left side of A and B to reduce them to Schur form.
73 * = 'I': like COMPQ='V', except that Q will be initialized to
74 * the identity first.
75 *
76 * COMPZ (input) CHARACTER*1
77 * = 'N': do not modify Z.
78 * = 'V': multiply the array Z on the right by the orthogonal
79 * transformation that is applied to the right side of
80 * A and B to reduce them to Schur form.
81 * = 'I': like COMPZ='V', except that Z will be initialized to
82 * the identity first.
83 *
84 * N (input) INTEGER
85 * The order of the matrices A, B, Q, and Z. N >= 0.
86 *
87 * ILO (input) INTEGER
88 * IHI (input) INTEGER
89 * It is assumed that A is already upper triangular in rows and
90 * columns 1:ILO-1 and IHI+1:N.
91 * 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.
92 *
93 * A (input/output) DOUBLE PRECISION array, dimension (LDA, N)
94 * On entry, the N-by-N upper Hessenberg matrix A. Elements
95 * below the subdiagonal must be zero.
96 * If JOB='S', then on exit A and B will have been
97 * simultaneously reduced to generalized Schur form.
98 * If JOB='E', then on exit A will have been destroyed.
99 * The diagonal blocks will be correct, but the off-diagonal
100 * portion will be meaningless.
101 *
102 * LDA (input) INTEGER
103 * The leading dimension of the array A. LDA >= max( 1, N ).
104 *
105 * B (input/output) DOUBLE PRECISION array, dimension (LDB, N)
106 * On entry, the N-by-N upper triangular matrix B. Elements
107 * below the diagonal must be zero. 2-by-2 blocks in B
108 * corresponding to 2-by-2 blocks in A will be reduced to
109 * positive diagonal form. (I.e., if A(j+1,j) is non-zero,
110 * then B(j+1,j)=B(j,j+1)=0 and B(j,j) and B(j+1,j+1) will be
111 * positive.)
112 * If JOB='S', then on exit A and B will have been
113 * simultaneously reduced to Schur form.
114 * If JOB='E', then on exit B will have been destroyed.
115 * Elements corresponding to diagonal blocks of A will be
116 * correct, but the off-diagonal portion will be meaningless.
117 *
118 * LDB (input) INTEGER
119 * The leading dimension of the array B. LDB >= max( 1, N ).
120 *
121 * ALPHAR (output) DOUBLE PRECISION array, dimension (N)
122 * ALPHAR(1:N) will be set to real parts of the diagonal
123 * elements of A that would result from reducing A and B to
124 * Schur form and then further reducing them both to triangular
125 * form using unitary transformations s.t. the diagonal of B
126 * was non-negative real. Thus, if A(j,j) is in a 1-by-1 block
127 * (i.e., A(j+1,j)=A(j,j+1)=0), then ALPHAR(j)=A(j,j).
128 * Note that the (real or complex) values
129 * (ALPHAR(j) + i*ALPHAI(j))/BETA(j), j=1,...,N, are the
130 * generalized eigenvalues of the matrix pencil A - wB.
131 *
132 * ALPHAI (output) DOUBLE PRECISION array, dimension (N)
133 * ALPHAI(1:N) will be set to imaginary parts of the diagonal
134 * elements of A that would result from reducing A and B to
135 * Schur form and then further reducing them both to triangular
136 * form using unitary transformations s.t. the diagonal of B
137 * was non-negative real. Thus, if A(j,j) is in a 1-by-1 block
138 * (i.e., A(j+1,j)=A(j,j+1)=0), then ALPHAR(j)=0.
139 * Note that the (real or complex) values
140 * (ALPHAR(j) + i*ALPHAI(j))/BETA(j), j=1,...,N, are the
141 * generalized eigenvalues of the matrix pencil A - wB.
142 *
143 * BETA (output) DOUBLE PRECISION array, dimension (N)
144 * BETA(1:N) will be set to the (real) diagonal elements of B
145 * that would result from reducing A and B to Schur form and
146 * then further reducing them both to triangular form using
147 * unitary transformations s.t. the diagonal of B was
148 * non-negative real. Thus, if A(j,j) is in a 1-by-1 block
149 * (i.e., A(j+1,j)=A(j,j+1)=0), then BETA(j)=B(j,j).
150 * Note that the (real or complex) values
151 * (ALPHAR(j) + i*ALPHAI(j))/BETA(j), j=1,...,N, are the
152 * generalized eigenvalues of the matrix pencil A - wB.
153 * (Note that BETA(1:N) will always be non-negative, and no
154 * BETAI is necessary.)
155 *
156 * Q (input/output) DOUBLE PRECISION array, dimension (LDQ, N)
157 * If COMPQ='N', then Q will not be referenced.
158 * If COMPQ='V' or 'I', then the transpose of the orthogonal
159 * transformations which are applied to A and B on the left
160 * will be applied to the array Q on the right.
161 *
162 * LDQ (input) INTEGER
163 * The leading dimension of the array Q. LDQ >= 1.
164 * If COMPQ='V' or 'I', then LDQ >= N.
165 *
166 * Z (input/output) DOUBLE PRECISION array, dimension (LDZ, N)
167 * If COMPZ='N', then Z will not be referenced.
168 * If COMPZ='V' or 'I', then the orthogonal transformations
169 * which are applied to A and B on the right will be applied
170 * to the array Z on the right.
171 *
172 * LDZ (input) INTEGER
173 * The leading dimension of the array Z. LDZ >= 1.
174 * If COMPZ='V' or 'I', then LDZ >= N.
175 *
176 * WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK)
177 * On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.
178 *
179 * LWORK (input) INTEGER
180 * The dimension of the array WORK. LWORK >= max(1,N).
181 *
182 * If LWORK = -1, then a workspace query is assumed; the routine
183 * only calculates the optimal size of the WORK array, returns
184 * this value as the first entry of the WORK array, and no error
185 * message related to LWORK is issued by XERBLA.
186 *
187 * INFO (output) INTEGER
188 * = 0: successful exit
189 * < 0: if INFO = -i, the i-th argument had an illegal value
190 * = 1,...,N: the QZ iteration did not converge. (A,B) is not
191 * in Schur form, but ALPHAR(i), ALPHAI(i), and
192 * BETA(i), i=INFO+1,...,N should be correct.
193 * = N+1,...,2*N: the shift calculation failed. (A,B) is not
194 * in Schur form, but ALPHAR(i), ALPHAI(i), and
195 * BETA(i), i=INFO-N+1,...,N should be correct.
196 * > 2*N: various "impossible" errors.
197 *
198 * Further Details
199 * ===============
200 *
201 * Iteration counters:
202 *
203 * JITER -- counts iterations.
204 * IITER -- counts iterations run since ILAST was last
205 * changed. This is therefore reset only when a 1-by-1 or
206 * 2-by-2 block deflates off the bottom.
207 *
208 * =====================================================================
209 *
210 * .. Parameters ..
211 * $ SAFETY = 1.0E+0 )
212 DOUBLE PRECISION HALF, ZERO, ONE, SAFETY
213 PARAMETER ( HALF = 0.5D+0, ZERO = 0.0D+0, ONE = 1.0D+0,
214 $ SAFETY = 1.0D+2 )
215 * ..
216 * .. Local Scalars ..
217 LOGICAL ILAZR2, ILAZRO, ILPIVT, ILQ, ILSCHR, ILZ,
218 $ LQUERY
219 INTEGER ICOMPQ, ICOMPZ, IFIRST, IFRSTM, IITER, ILAST,
220 $ ILASTM, IN, ISCHUR, ISTART, J, JC, JCH, JITER,
221 $ JR, MAXIT
222 DOUBLE PRECISION A11, A12, A1I, A1R, A21, A22, A2I, A2R, AD11,
223 $ AD11L, AD12, AD12L, AD21, AD21L, AD22, AD22L,
224 $ AD32L, AN, ANORM, ASCALE, ATOL, B11, B1A, B1I,
225 $ B1R, B22, B2A, B2I, B2R, BN, BNORM, BSCALE,
226 $ BTOL, C, C11I, C11R, C12, C21, C22I, C22R, CL,
227 $ CQ, CR, CZ, ESHIFT, S, S1, S1INV, S2, SAFMAX,
228 $ SAFMIN, SCALE, SL, SQI, SQR, SR, SZI, SZR, T,
229 $ TAU, TEMP, TEMP2, TEMPI, TEMPR, U1, U12, U12L,
230 $ U2, ULP, VS, W11, W12, W21, W22, WABS, WI, WR,
231 $ WR2
232 * ..
233 * .. Local Arrays ..
234 DOUBLE PRECISION V( 3 )
235 * ..
236 * .. External Functions ..
237 LOGICAL LSAME
238 DOUBLE PRECISION DLAMCH, DLANHS, DLAPY2, DLAPY3
239 EXTERNAL LSAME, DLAMCH, DLANHS, DLAPY2, DLAPY3
240 * ..
241 * .. External Subroutines ..
242 EXTERNAL DLAG2, DLARFG, DLARTG, DLASET, DLASV2, DROT,
243 $ XERBLA
244 * ..
245 * .. Intrinsic Functions ..
246 INTRINSIC ABS, DBLE, MAX, MIN, SQRT
247 * ..
248 * .. Executable Statements ..
249 *
250 * Decode JOB, COMPQ, COMPZ
251 *
252 IF( LSAME( JOB, 'E' ) ) THEN
253 ILSCHR = .FALSE.
254 ISCHUR = 1
255 ELSE IF( LSAME( JOB, 'S' ) ) THEN
256 ILSCHR = .TRUE.
257 ISCHUR = 2
258 ELSE
259 ISCHUR = 0
260 END IF
261 *
262 IF( LSAME( COMPQ, 'N' ) ) THEN
263 ILQ = .FALSE.
264 ICOMPQ = 1
265 ELSE IF( LSAME( COMPQ, 'V' ) ) THEN
266 ILQ = .TRUE.
267 ICOMPQ = 2
268 ELSE IF( LSAME( COMPQ, 'I' ) ) THEN
269 ILQ = .TRUE.
270 ICOMPQ = 3
271 ELSE
272 ICOMPQ = 0
273 END IF
274 *
275 IF( LSAME( COMPZ, 'N' ) ) THEN
276 ILZ = .FALSE.
277 ICOMPZ = 1
278 ELSE IF( LSAME( COMPZ, 'V' ) ) THEN
279 ILZ = .TRUE.
280 ICOMPZ = 2
281 ELSE IF( LSAME( COMPZ, 'I' ) ) THEN
282 ILZ = .TRUE.
283 ICOMPZ = 3
284 ELSE
285 ICOMPZ = 0
286 END IF
287 *
288 * Check Argument Values
289 *
290 INFO = 0
291 WORK( 1 ) = MAX( 1, N )
292 LQUERY = ( LWORK.EQ.-1 )
293 IF( ISCHUR.EQ.0 ) THEN
294 INFO = -1
295 ELSE IF( ICOMPQ.EQ.0 ) THEN
296 INFO = -2
297 ELSE IF( ICOMPZ.EQ.0 ) THEN
298 INFO = -3
299 ELSE IF( N.LT.0 ) THEN
300 INFO = -4
301 ELSE IF( ILO.LT.1 ) THEN
302 INFO = -5
303 ELSE IF( IHI.GT.N .OR. IHI.LT.ILO-1 ) THEN
304 INFO = -6
305 ELSE IF( LDA.LT.N ) THEN
306 INFO = -8
307 ELSE IF( LDB.LT.N ) THEN
308 INFO = -10
309 ELSE IF( LDQ.LT.1 .OR. ( ILQ .AND. LDQ.LT.N ) ) THEN
310 INFO = -15
311 ELSE IF( LDZ.LT.1 .OR. ( ILZ .AND. LDZ.LT.N ) ) THEN
312 INFO = -17
313 ELSE IF( LWORK.LT.MAX( 1, N ) .AND. .NOT.LQUERY ) THEN
314 INFO = -19
315 END IF
316 IF( INFO.NE.0 ) THEN
317 CALL XERBLA( 'DHGEQZ', -INFO )
318 RETURN
319 ELSE IF( LQUERY ) THEN
320 RETURN
321 END IF
322 *
323 * Quick return if possible
324 *
325 IF( N.LE.0 ) THEN
326 WORK( 1 ) = DBLE( 1 )
327 RETURN
328 END IF
329 *
330 * Initialize Q and Z
331 *
332 IF( ICOMPQ.EQ.3 )
333 $ CALL DLASET( 'Full', N, N, ZERO, ONE, Q, LDQ )
334 IF( ICOMPZ.EQ.3 )
335 $ CALL DLASET( 'Full', N, N, ZERO, ONE, Z, LDZ )
336 *
337 * Machine Constants
338 *
339 IN = IHI + 1 - ILO
340 SAFMIN = DLAMCH( 'S' )
341 SAFMAX = ONE / SAFMIN
342 ULP = DLAMCH( 'E' )*DLAMCH( 'B' )
343 ANORM = DLANHS( 'F', IN, A( ILO, ILO ), LDA, WORK )
344 BNORM = DLANHS( 'F', IN, B( ILO, ILO ), LDB, WORK )
345 ATOL = MAX( SAFMIN, ULP*ANORM )
346 BTOL = MAX( SAFMIN, ULP*BNORM )
347 ASCALE = ONE / MAX( SAFMIN, ANORM )
348 BSCALE = ONE / MAX( SAFMIN, BNORM )
349 *
350 * Set Eigenvalues IHI+1:N
351 *
352 DO 30 J = IHI + 1, N
353 IF( B( J, J ).LT.ZERO ) THEN
354 IF( ILSCHR ) THEN
355 DO 10 JR = 1, J
356 A( JR, J ) = -A( JR, J )
357 B( JR, J ) = -B( JR, J )
358 10 CONTINUE
359 ELSE
360 A( J, J ) = -A( J, J )
361 B( J, J ) = -B( J, J )
362 END IF
363 IF( ILZ ) THEN
364 DO 20 JR = 1, N
365 Z( JR, J ) = -Z( JR, J )
366 20 CONTINUE
367 END IF
368 END IF
369 ALPHAR( J ) = A( J, J )
370 ALPHAI( J ) = ZERO
371 BETA( J ) = B( J, J )
372 30 CONTINUE
373 *
374 * If IHI < ILO, skip QZ steps
375 *
376 IF( IHI.LT.ILO )
377 $ GO TO 380
378 *
379 * MAIN QZ ITERATION LOOP
380 *
381 * Initialize dynamic indices
382 *
383 * Eigenvalues ILAST+1:N have been found.
384 * Column operations modify rows IFRSTM:whatever.
385 * Row operations modify columns whatever:ILASTM.
386 *
387 * If only eigenvalues are being computed, then
388 * IFRSTM is the row of the last splitting row above row ILAST;
389 * this is always at least ILO.
390 * IITER counts iterations since the last eigenvalue was found,
391 * to tell when to use an extraordinary shift.
392 * MAXIT is the maximum number of QZ sweeps allowed.
393 *
394 ILAST = IHI
395 IF( ILSCHR ) THEN
396 IFRSTM = 1
397 ILASTM = N
398 ELSE
399 IFRSTM = ILO
400 ILASTM = IHI
401 END IF
402 IITER = 0
403 ESHIFT = ZERO
404 MAXIT = 30*( IHI-ILO+1 )
405 *
406 DO 360 JITER = 1, MAXIT
407 *
408 * Split the matrix if possible.
409 *
410 * Two tests:
411 * 1: A(j,j-1)=0 or j=ILO
412 * 2: B(j,j)=0
413 *
414 IF( ILAST.EQ.ILO ) THEN
415 *
416 * Special case: j=ILAST
417 *
418 GO TO 80
419 ELSE
420 IF( ABS( A( ILAST, ILAST-1 ) ).LE.ATOL ) THEN
421 A( ILAST, ILAST-1 ) = ZERO
422 GO TO 80
423 END IF
424 END IF
425 *
426 IF( ABS( B( ILAST, ILAST ) ).LE.BTOL ) THEN
427 B( ILAST, ILAST ) = ZERO
428 GO TO 70
429 END IF
430 *
431 * General case: j<ILAST
432 *
433 DO 60 J = ILAST - 1, ILO, -1
434 *
435 * Test 1: for A(j,j-1)=0 or j=ILO
436 *
437 IF( J.EQ.ILO ) THEN
438 ILAZRO = .TRUE.
439 ELSE
440 IF( ABS( A( J, J-1 ) ).LE.ATOL ) THEN
441 A( J, J-1 ) = ZERO
442 ILAZRO = .TRUE.
443 ELSE
444 ILAZRO = .FALSE.
445 END IF
446 END IF
447 *
448 * Test 2: for B(j,j)=0
449 *
450 IF( ABS( B( J, J ) ).LT.BTOL ) THEN
451 B( J, J ) = ZERO
452 *
453 * Test 1a: Check for 2 consecutive small subdiagonals in A
454 *
455 ILAZR2 = .FALSE.
456 IF( .NOT.ILAZRO ) THEN
457 TEMP = ABS( A( J, J-1 ) )
458 TEMP2 = ABS( A( J, J ) )
459 TEMPR = MAX( TEMP, TEMP2 )
460 IF( TEMPR.LT.ONE .AND. TEMPR.NE.ZERO ) THEN
461 TEMP = TEMP / TEMPR
462 TEMP2 = TEMP2 / TEMPR
463 END IF
464 IF( TEMP*( ASCALE*ABS( A( J+1, J ) ) ).LE.TEMP2*
465 $ ( ASCALE*ATOL ) )ILAZR2 = .TRUE.
466 END IF
467 *
468 * If both tests pass (1 & 2), i.e., the leading diagonal
469 * element of B in the block is zero, split a 1x1 block off
470 * at the top. (I.e., at the J-th row/column) The leading
471 * diagonal element of the remainder can also be zero, so
472 * this may have to be done repeatedly.
473 *
474 IF( ILAZRO .OR. ILAZR2 ) THEN
475 DO 40 JCH = J, ILAST - 1
476 TEMP = A( JCH, JCH )
477 CALL DLARTG( TEMP, A( JCH+1, JCH ), C, S,
478 $ A( JCH, JCH ) )
479 A( JCH+1, JCH ) = ZERO
480 CALL DROT( ILASTM-JCH, A( JCH, JCH+1 ), LDA,
481 $ A( JCH+1, JCH+1 ), LDA, C, S )
482 CALL DROT( ILASTM-JCH, B( JCH, JCH+1 ), LDB,
483 $ B( JCH+1, JCH+1 ), LDB, C, S )
484 IF( ILQ )
485 $ CALL DROT( N, Q( 1, JCH ), 1, Q( 1, JCH+1 ), 1,
486 $ C, S )
487 IF( ILAZR2 )
488 $ A( JCH, JCH-1 ) = A( JCH, JCH-1 )*C
489 ILAZR2 = .FALSE.
490 IF( ABS( B( JCH+1, JCH+1 ) ).GE.BTOL ) THEN
491 IF( JCH+1.GE.ILAST ) THEN
492 GO TO 80
493 ELSE
494 IFIRST = JCH + 1
495 GO TO 110
496 END IF
497 END IF
498 B( JCH+1, JCH+1 ) = ZERO
499 40 CONTINUE
500 GO TO 70
501 ELSE
502 *
503 * Only test 2 passed -- chase the zero to B(ILAST,ILAST)
504 * Then process as in the case B(ILAST,ILAST)=0
505 *
506 DO 50 JCH = J, ILAST - 1
507 TEMP = B( JCH, JCH+1 )
508 CALL DLARTG( TEMP, B( JCH+1, JCH+1 ), C, S,
509 $ B( JCH, JCH+1 ) )
510 B( JCH+1, JCH+1 ) = ZERO
511 IF( JCH.LT.ILASTM-1 )
512 $ CALL DROT( ILASTM-JCH-1, B( JCH, JCH+2 ), LDB,
513 $ B( JCH+1, JCH+2 ), LDB, C, S )
514 CALL DROT( ILASTM-JCH+2, A( JCH, JCH-1 ), LDA,
515 $ A( JCH+1, JCH-1 ), LDA, C, S )
516 IF( ILQ )
517 $ CALL DROT( N, Q( 1, JCH ), 1, Q( 1, JCH+1 ), 1,
518 $ C, S )
519 TEMP = A( JCH+1, JCH )
520 CALL DLARTG( TEMP, A( JCH+1, JCH-1 ), C, S,
521 $ A( JCH+1, JCH ) )
522 A( JCH+1, JCH-1 ) = ZERO
523 CALL DROT( JCH+1-IFRSTM, A( IFRSTM, JCH ), 1,
524 $ A( IFRSTM, JCH-1 ), 1, C, S )
525 CALL DROT( JCH-IFRSTM, B( IFRSTM, JCH ), 1,
526 $ B( IFRSTM, JCH-1 ), 1, C, S )
527 IF( ILZ )
528 $ CALL DROT( N, Z( 1, JCH ), 1, Z( 1, JCH-1 ), 1,
529 $ C, S )
530 50 CONTINUE
531 GO TO 70
532 END IF
533 ELSE IF( ILAZRO ) THEN
534 *
535 * Only test 1 passed -- work on J:ILAST
536 *
537 IFIRST = J
538 GO TO 110
539 END IF
540 *
541 * Neither test passed -- try next J
542 *
543 60 CONTINUE
544 *
545 * (Drop-through is "impossible")
546 *
547 INFO = N + 1
548 GO TO 420
549 *
550 * B(ILAST,ILAST)=0 -- clear A(ILAST,ILAST-1) to split off a
551 * 1x1 block.
552 *
553 70 CONTINUE
554 TEMP = A( ILAST, ILAST )
555 CALL DLARTG( TEMP, A( ILAST, ILAST-1 ), C, S,
556 $ A( ILAST, ILAST ) )
557 A( ILAST, ILAST-1 ) = ZERO
558 CALL DROT( ILAST-IFRSTM, A( IFRSTM, ILAST ), 1,
559 $ A( IFRSTM, ILAST-1 ), 1, C, S )
560 CALL DROT( ILAST-IFRSTM, B( IFRSTM, ILAST ), 1,
561 $ B( IFRSTM, ILAST-1 ), 1, C, S )
562 IF( ILZ )
563 $ CALL DROT( N, Z( 1, ILAST ), 1, Z( 1, ILAST-1 ), 1, C, S )
564 *
565 * A(ILAST,ILAST-1)=0 -- Standardize B, set ALPHAR, ALPHAI,
566 * and BETA
567 *
568 80 CONTINUE
569 IF( B( ILAST, ILAST ).LT.ZERO ) THEN
570 IF( ILSCHR ) THEN
571 DO 90 J = IFRSTM, ILAST
572 A( J, ILAST ) = -A( J, ILAST )
573 B( J, ILAST ) = -B( J, ILAST )
574 90 CONTINUE
575 ELSE
576 A( ILAST, ILAST ) = -A( ILAST, ILAST )
577 B( ILAST, ILAST ) = -B( ILAST, ILAST )
578 END IF
579 IF( ILZ ) THEN
580 DO 100 J = 1, N
581 Z( J, ILAST ) = -Z( J, ILAST )
582 100 CONTINUE
583 END IF
584 END IF
585 ALPHAR( ILAST ) = A( ILAST, ILAST )
586 ALPHAI( ILAST ) = ZERO
587 BETA( ILAST ) = B( ILAST, ILAST )
588 *
589 * Go to next block -- exit if finished.
590 *
591 ILAST = ILAST - 1
592 IF( ILAST.LT.ILO )
593 $ GO TO 380
594 *
595 * Reset counters
596 *
597 IITER = 0
598 ESHIFT = ZERO
599 IF( .NOT.ILSCHR ) THEN
600 ILASTM = ILAST
601 IF( IFRSTM.GT.ILAST )
602 $ IFRSTM = ILO
603 END IF
604 GO TO 350
605 *
606 * QZ step
607 *
608 * This iteration only involves rows/columns IFIRST:ILAST. We
609 * assume IFIRST < ILAST, and that the diagonal of B is non-zero.
610 *
611 110 CONTINUE
612 IITER = IITER + 1
613 IF( .NOT.ILSCHR ) THEN
614 IFRSTM = IFIRST
615 END IF
616 *
617 * Compute single shifts.
618 *
619 * At this point, IFIRST < ILAST, and the diagonal elements of
620 * B(IFIRST:ILAST,IFIRST,ILAST) are larger than BTOL (in
621 * magnitude)
622 *
623 IF( ( IITER / 10 )*10.EQ.IITER ) THEN
624 *
625 * Exceptional shift. Chosen for no particularly good reason.
626 * (Single shift only.)
627 *
628 IF( ( DBLE( MAXIT )*SAFMIN )*ABS( A( ILAST-1, ILAST ) ).LT.
629 $ ABS( B( ILAST-1, ILAST-1 ) ) ) THEN
630 ESHIFT = ESHIFT + A( ILAST-1, ILAST ) /
631 $ B( ILAST-1, ILAST-1 )
632 ELSE
633 ESHIFT = ESHIFT + ONE / ( SAFMIN*DBLE( MAXIT ) )
634 END IF
635 S1 = ONE
636 WR = ESHIFT
637 *
638 ELSE
639 *
640 * Shifts based on the generalized eigenvalues of the
641 * bottom-right 2x2 block of A and B. The first eigenvalue
642 * returned by DLAG2 is the Wilkinson shift (AEP p.512),
643 *
644 CALL DLAG2( A( ILAST-1, ILAST-1 ), LDA,
645 $ B( ILAST-1, ILAST-1 ), LDB, SAFMIN*SAFETY, S1,
646 $ S2, WR, WR2, WI )
647 *
648 TEMP = MAX( S1, SAFMIN*MAX( ONE, ABS( WR ), ABS( WI ) ) )
649 IF( WI.NE.ZERO )
650 $ GO TO 200
651 END IF
652 *
653 * Fiddle with shift to avoid overflow
654 *
655 TEMP = MIN( ASCALE, ONE )*( HALF*SAFMAX )
656 IF( S1.GT.TEMP ) THEN
657 SCALE = TEMP / S1
658 ELSE
659 SCALE = ONE
660 END IF
661 *
662 TEMP = MIN( BSCALE, ONE )*( HALF*SAFMAX )
663 IF( ABS( WR ).GT.TEMP )
664 $ SCALE = MIN( SCALE, TEMP / ABS( WR ) )
665 S1 = SCALE*S1
666 WR = SCALE*WR
667 *
668 * Now check for two consecutive small subdiagonals.
669 *
670 DO 120 J = ILAST - 1, IFIRST + 1, -1
671 ISTART = J
672 TEMP = ABS( S1*A( J, J-1 ) )
673 TEMP2 = ABS( S1*A( J, J )-WR*B( J, J ) )
674 TEMPR = MAX( TEMP, TEMP2 )
675 IF( TEMPR.LT.ONE .AND. TEMPR.NE.ZERO ) THEN
676 TEMP = TEMP / TEMPR
677 TEMP2 = TEMP2 / TEMPR
678 END IF
679 IF( ABS( ( ASCALE*A( J+1, J ) )*TEMP ).LE.( ASCALE*ATOL )*
680 $ TEMP2 )GO TO 130
681 120 CONTINUE
682 *
683 ISTART = IFIRST
684 130 CONTINUE
685 *
686 * Do an implicit single-shift QZ sweep.
687 *
688 * Initial Q
689 *
690 TEMP = S1*A( ISTART, ISTART ) - WR*B( ISTART, ISTART )
691 TEMP2 = S1*A( ISTART+1, ISTART )
692 CALL DLARTG( TEMP, TEMP2, C, S, TEMPR )
693 *
694 * Sweep
695 *
696 DO 190 J = ISTART, ILAST - 1
697 IF( J.GT.ISTART ) THEN
698 TEMP = A( J, J-1 )
699 CALL DLARTG( TEMP, A( J+1, J-1 ), C, S, A( J, J-1 ) )
700 A( J+1, J-1 ) = ZERO
701 END IF
702 *
703 DO 140 JC = J, ILASTM
704 TEMP = C*A( J, JC ) + S*A( J+1, JC )
705 A( J+1, JC ) = -S*A( J, JC ) + C*A( J+1, JC )
706 A( J, JC ) = TEMP
707 TEMP2 = C*B( J, JC ) + S*B( J+1, JC )
708 B( J+1, JC ) = -S*B( J, JC ) + C*B( J+1, JC )
709 B( J, JC ) = TEMP2
710 140 CONTINUE
711 IF( ILQ ) THEN
712 DO 150 JR = 1, N
713 TEMP = C*Q( JR, J ) + S*Q( JR, J+1 )
714 Q( JR, J+1 ) = -S*Q( JR, J ) + C*Q( JR, J+1 )
715 Q( JR, J ) = TEMP
716 150 CONTINUE
717 END IF
718 *
719 TEMP = B( J+1, J+1 )
720 CALL DLARTG( TEMP, B( J+1, J ), C, S, B( J+1, J+1 ) )
721 B( J+1, J ) = ZERO
722 *
723 DO 160 JR = IFRSTM, MIN( J+2, ILAST )
724 TEMP = C*A( JR, J+1 ) + S*A( JR, J )
725 A( JR, J ) = -S*A( JR, J+1 ) + C*A( JR, J )
726 A( JR, J+1 ) = TEMP
727 160 CONTINUE
728 DO 170 JR = IFRSTM, J
729 TEMP = C*B( JR, J+1 ) + S*B( JR, J )
730 B( JR, J ) = -S*B( JR, J+1 ) + C*B( JR, J )
731 B( JR, J+1 ) = TEMP
732 170 CONTINUE
733 IF( ILZ ) THEN
734 DO 180 JR = 1, N
735 TEMP = C*Z( JR, J+1 ) + S*Z( JR, J )
736 Z( JR, J ) = -S*Z( JR, J+1 ) + C*Z( JR, J )
737 Z( JR, J+1 ) = TEMP
738 180 CONTINUE
739 END IF
740 190 CONTINUE
741 *
742 GO TO 350
743 *
744 * Use Francis double-shift
745 *
746 * Note: the Francis double-shift should work with real shifts,
747 * but only if the block is at least 3x3.
748 * This code may break if this point is reached with
749 * a 2x2 block with real eigenvalues.
750 *
751 200 CONTINUE
752 IF( IFIRST+1.EQ.ILAST ) THEN
753 *
754 * Special case -- 2x2 block with complex eigenvectors
755 *
756 * Step 1: Standardize, that is, rotate so that
757 *
758 * ( B11 0 )
759 * B = ( ) with B11 non-negative.
760 * ( 0 B22 )
761 *
762 CALL DLASV2( B( ILAST-1, ILAST-1 ), B( ILAST-1, ILAST ),
763 $ B( ILAST, ILAST ), B22, B11, SR, CR, SL, CL )
764 *
765 IF( B11.LT.ZERO ) THEN
766 CR = -CR
767 SR = -SR
768 B11 = -B11
769 B22 = -B22
770 END IF
771 *
772 CALL DROT( ILASTM+1-IFIRST, A( ILAST-1, ILAST-1 ), LDA,
773 $ A( ILAST, ILAST-1 ), LDA, CL, SL )
774 CALL DROT( ILAST+1-IFRSTM, A( IFRSTM, ILAST-1 ), 1,
775 $ A( IFRSTM, ILAST ), 1, CR, SR )
776 *
777 IF( ILAST.LT.ILASTM )
778 $ CALL DROT( ILASTM-ILAST, B( ILAST-1, ILAST+1 ), LDB,
779 $ B( ILAST, ILAST+1 ), LDA, CL, SL )
780 IF( IFRSTM.LT.ILAST-1 )
781 $ CALL DROT( IFIRST-IFRSTM, B( IFRSTM, ILAST-1 ), 1,
782 $ B( IFRSTM, ILAST ), 1, CR, SR )
783 *
784 IF( ILQ )
785 $ CALL DROT( N, Q( 1, ILAST-1 ), 1, Q( 1, ILAST ), 1, CL,
786 $ SL )
787 IF( ILZ )
788 $ CALL DROT( N, Z( 1, ILAST-1 ), 1, Z( 1, ILAST ), 1, CR,
789 $ SR )
790 *
791 B( ILAST-1, ILAST-1 ) = B11
792 B( ILAST-1, ILAST ) = ZERO
793 B( ILAST, ILAST-1 ) = ZERO
794 B( ILAST, ILAST ) = B22
795 *
796 * If B22 is negative, negate column ILAST
797 *
798 IF( B22.LT.ZERO ) THEN
799 DO 210 J = IFRSTM, ILAST
800 A( J, ILAST ) = -A( J, ILAST )
801 B( J, ILAST ) = -B( J, ILAST )
802 210 CONTINUE
803 *
804 IF( ILZ ) THEN
805 DO 220 J = 1, N
806 Z( J, ILAST ) = -Z( J, ILAST )
807 220 CONTINUE
808 END IF
809 END IF
810 *
811 * Step 2: Compute ALPHAR, ALPHAI, and BETA (see refs.)
812 *
813 * Recompute shift
814 *
815 CALL DLAG2( A( ILAST-1, ILAST-1 ), LDA,
816 $ B( ILAST-1, ILAST-1 ), LDB, SAFMIN*SAFETY, S1,
817 $ TEMP, WR, TEMP2, WI )
818 *
819 * If standardization has perturbed the shift onto real line,
820 * do another (real single-shift) QR step.
821 *
822 IF( WI.EQ.ZERO )
823 $ GO TO 350
824 S1INV = ONE / S1
825 *
826 * Do EISPACK (QZVAL) computation of alpha and beta
827 *
828 A11 = A( ILAST-1, ILAST-1 )
829 A21 = A( ILAST, ILAST-1 )
830 A12 = A( ILAST-1, ILAST )
831 A22 = A( ILAST, ILAST )
832 *
833 * Compute complex Givens rotation on right
834 * (Assume some element of C = (sA - wB) > unfl )
835 * __
836 * (sA - wB) ( CZ -SZ )
837 * ( SZ CZ )
838 *
839 C11R = S1*A11 - WR*B11
840 C11I = -WI*B11
841 C12 = S1*A12
842 C21 = S1*A21
843 C22R = S1*A22 - WR*B22
844 C22I = -WI*B22
845 *
846 IF( ABS( C11R )+ABS( C11I )+ABS( C12 ).GT.ABS( C21 )+
847 $ ABS( C22R )+ABS( C22I ) ) THEN
848 T = DLAPY3( C12, C11R, C11I )
849 CZ = C12 / T
850 SZR = -C11R / T
851 SZI = -C11I / T
852 ELSE
853 CZ = DLAPY2( C22R, C22I )
854 IF( CZ.LE.SAFMIN ) THEN
855 CZ = ZERO
856 SZR = ONE
857 SZI = ZERO
858 ELSE
859 TEMPR = C22R / CZ
860 TEMPI = C22I / CZ
861 T = DLAPY2( CZ, C21 )
862 CZ = CZ / T
863 SZR = -C21*TEMPR / T
864 SZI = C21*TEMPI / T
865 END IF
866 END IF
867 *
868 * Compute Givens rotation on left
869 *
870 * ( CQ SQ )
871 * ( __ ) A or B
872 * ( -SQ CQ )
873 *
874 AN = ABS( A11 ) + ABS( A12 ) + ABS( A21 ) + ABS( A22 )
875 BN = ABS( B11 ) + ABS( B22 )
876 WABS = ABS( WR ) + ABS( WI )
877 IF( S1*AN.GT.WABS*BN ) THEN
878 CQ = CZ*B11
879 SQR = SZR*B22
880 SQI = -SZI*B22
881 ELSE
882 A1R = CZ*A11 + SZR*A12
883 A1I = SZI*A12
884 A2R = CZ*A21 + SZR*A22
885 A2I = SZI*A22
886 CQ = DLAPY2( A1R, A1I )
887 IF( CQ.LE.SAFMIN ) THEN
888 CQ = ZERO
889 SQR = ONE
890 SQI = ZERO
891 ELSE
892 TEMPR = A1R / CQ
893 TEMPI = A1I / CQ
894 SQR = TEMPR*A2R + TEMPI*A2I
895 SQI = TEMPI*A2R - TEMPR*A2I
896 END IF
897 END IF
898 T = DLAPY3( CQ, SQR, SQI )
899 CQ = CQ / T
900 SQR = SQR / T
901 SQI = SQI / T
902 *
903 * Compute diagonal elements of QBZ
904 *
905 TEMPR = SQR*SZR - SQI*SZI
906 TEMPI = SQR*SZI + SQI*SZR
907 B1R = CQ*CZ*B11 + TEMPR*B22
908 B1I = TEMPI*B22
909 B1A = DLAPY2( B1R, B1I )
910 B2R = CQ*CZ*B22 + TEMPR*B11
911 B2I = -TEMPI*B11
912 B2A = DLAPY2( B2R, B2I )
913 *
914 * Normalize so beta > 0, and Im( alpha1 ) > 0
915 *
916 BETA( ILAST-1 ) = B1A
917 BETA( ILAST ) = B2A
918 ALPHAR( ILAST-1 ) = ( WR*B1A )*S1INV
919 ALPHAI( ILAST-1 ) = ( WI*B1A )*S1INV
920 ALPHAR( ILAST ) = ( WR*B2A )*S1INV
921 ALPHAI( ILAST ) = -( WI*B2A )*S1INV
922 *
923 * Step 3: Go to next block -- exit if finished.
924 *
925 ILAST = IFIRST - 1
926 IF( ILAST.LT.ILO )
927 $ GO TO 380
928 *
929 * Reset counters
930 *
931 IITER = 0
932 ESHIFT = ZERO
933 IF( .NOT.ILSCHR ) THEN
934 ILASTM = ILAST
935 IF( IFRSTM.GT.ILAST )
936 $ IFRSTM = ILO
937 END IF
938 GO TO 350
939 ELSE
940 *
941 * Usual case: 3x3 or larger block, using Francis implicit
942 * double-shift
943 *
944 * 2
945 * Eigenvalue equation is w - c w + d = 0,
946 *
947 * -1 2 -1
948 * so compute 1st column of (A B ) - c A B + d
949 * using the formula in QZIT (from EISPACK)
950 *
951 * We assume that the block is at least 3x3
952 *
953 AD11 = ( ASCALE*A( ILAST-1, ILAST-1 ) ) /
954 $ ( BSCALE*B( ILAST-1, ILAST-1 ) )
955 AD21 = ( ASCALE*A( ILAST, ILAST-1 ) ) /
956 $ ( BSCALE*B( ILAST-1, ILAST-1 ) )
957 AD12 = ( ASCALE*A( ILAST-1, ILAST ) ) /
958 $ ( BSCALE*B( ILAST, ILAST ) )
959 AD22 = ( ASCALE*A( ILAST, ILAST ) ) /
960 $ ( BSCALE*B( ILAST, ILAST ) )
961 U12 = B( ILAST-1, ILAST ) / B( ILAST, ILAST )
962 AD11L = ( ASCALE*A( IFIRST, IFIRST ) ) /
963 $ ( BSCALE*B( IFIRST, IFIRST ) )
964 AD21L = ( ASCALE*A( IFIRST+1, IFIRST ) ) /
965 $ ( BSCALE*B( IFIRST, IFIRST ) )
966 AD12L = ( ASCALE*A( IFIRST, IFIRST+1 ) ) /
967 $ ( BSCALE*B( IFIRST+1, IFIRST+1 ) )
968 AD22L = ( ASCALE*A( IFIRST+1, IFIRST+1 ) ) /
969 $ ( BSCALE*B( IFIRST+1, IFIRST+1 ) )
970 AD32L = ( ASCALE*A( IFIRST+2, IFIRST+1 ) ) /
971 $ ( BSCALE*B( IFIRST+1, IFIRST+1 ) )
972 U12L = B( IFIRST, IFIRST+1 ) / B( IFIRST+1, IFIRST+1 )
973 *
974 V( 1 ) = ( AD11-AD11L )*( AD22-AD11L ) - AD12*AD21 +
975 $ AD21*U12*AD11L + ( AD12L-AD11L*U12L )*AD21L
976 V( 2 ) = ( ( AD22L-AD11L )-AD21L*U12L-( AD11-AD11L )-
977 $ ( AD22-AD11L )+AD21*U12 )*AD21L
978 V( 3 ) = AD32L*AD21L
979 *
980 ISTART = IFIRST
981 *
982 CALL DLARFG( 3, V( 1 ), V( 2 ), 1, TAU )
983 V( 1 ) = ONE
984 *
985 * Sweep
986 *
987 DO 290 J = ISTART, ILAST - 2
988 *
989 * All but last elements: use 3x3 Householder transforms.
990 *
991 * Zero (j-1)st column of A
992 *
993 IF( J.GT.ISTART ) THEN
994 V( 1 ) = A( J, J-1 )
995 V( 2 ) = A( J+1, J-1 )
996 V( 3 ) = A( J+2, J-1 )
997 *
998 CALL DLARFG( 3, A( J, J-1 ), V( 2 ), 1, TAU )
999 V( 1 ) = ONE
1000 A( J+1, J-1 ) = ZERO
1001 A( J+2, J-1 ) = ZERO
1002 END IF
1003 *
1004 DO 230 JC = J, ILASTM
1005 TEMP = TAU*( A( J, JC )+V( 2 )*A( J+1, JC )+V( 3 )*
1006 $ A( J+2, JC ) )
1007 A( J, JC ) = A( J, JC ) - TEMP
1008 A( J+1, JC ) = A( J+1, JC ) - TEMP*V( 2 )
1009 A( J+2, JC ) = A( J+2, JC ) - TEMP*V( 3 )
1010 TEMP2 = TAU*( B( J, JC )+V( 2 )*B( J+1, JC )+V( 3 )*
1011 $ B( J+2, JC ) )
1012 B( J, JC ) = B( J, JC ) - TEMP2
1013 B( J+1, JC ) = B( J+1, JC ) - TEMP2*V( 2 )
1014 B( J+2, JC ) = B( J+2, JC ) - TEMP2*V( 3 )
1015 230 CONTINUE
1016 IF( ILQ ) THEN
1017 DO 240 JR = 1, N
1018 TEMP = TAU*( Q( JR, J )+V( 2 )*Q( JR, J+1 )+V( 3 )*
1019 $ Q( JR, J+2 ) )
1020 Q( JR, J ) = Q( JR, J ) - TEMP
1021 Q( JR, J+1 ) = Q( JR, J+1 ) - TEMP*V( 2 )
1022 Q( JR, J+2 ) = Q( JR, J+2 ) - TEMP*V( 3 )
1023 240 CONTINUE
1024 END IF
1025 *
1026 * Zero j-th column of B (see DLAGBC for details)
1027 *
1028 * Swap rows to pivot
1029 *
1030 ILPIVT = .FALSE.
1031 TEMP = MAX( ABS( B( J+1, J+1 ) ), ABS( B( J+1, J+2 ) ) )
1032 TEMP2 = MAX( ABS( B( J+2, J+1 ) ), ABS( B( J+2, J+2 ) ) )
1033 IF( MAX( TEMP, TEMP2 ).LT.SAFMIN ) THEN
1034 SCALE = ZERO
1035 U1 = ONE
1036 U2 = ZERO
1037 GO TO 250
1038 ELSE IF( TEMP.GE.TEMP2 ) THEN
1039 W11 = B( J+1, J+1 )
1040 W21 = B( J+2, J+1 )
1041 W12 = B( J+1, J+2 )
1042 W22 = B( J+2, J+2 )
1043 U1 = B( J+1, J )
1044 U2 = B( J+2, J )
1045 ELSE
1046 W21 = B( J+1, J+1 )
1047 W11 = B( J+2, J+1 )
1048 W22 = B( J+1, J+2 )
1049 W12 = B( J+2, J+2 )
1050 U2 = B( J+1, J )
1051 U1 = B( J+2, J )
1052 END IF
1053 *
1054 * Swap columns if nec.
1055 *
1056 IF( ABS( W12 ).GT.ABS( W11 ) ) THEN
1057 ILPIVT = .TRUE.
1058 TEMP = W12
1059 TEMP2 = W22
1060 W12 = W11
1061 W22 = W21
1062 W11 = TEMP
1063 W21 = TEMP2
1064 END IF
1065 *
1066 * LU-factor
1067 *
1068 TEMP = W21 / W11
1069 U2 = U2 - TEMP*U1
1070 W22 = W22 - TEMP*W12
1071 W21 = ZERO
1072 *
1073 * Compute SCALE
1074 *
1075 SCALE = ONE
1076 IF( ABS( W22 ).LT.SAFMIN ) THEN
1077 SCALE = ZERO
1078 U2 = ONE
1079 U1 = -W12 / W11
1080 GO TO 250
1081 END IF
1082 IF( ABS( W22 ).LT.ABS( U2 ) )
1083 $ SCALE = ABS( W22 / U2 )
1084 IF( ABS( W11 ).LT.ABS( U1 ) )
1085 $ SCALE = MIN( SCALE, ABS( W11 / U1 ) )
1086 *
1087 * Solve
1088 *
1089 U2 = ( SCALE*U2 ) / W22
1090 U1 = ( SCALE*U1-W12*U2 ) / W11
1091 *
1092 250 CONTINUE
1093 IF( ILPIVT ) THEN
1094 TEMP = U2
1095 U2 = U1
1096 U1 = TEMP
1097 END IF
1098 *
1099 * Compute Householder Vector
1100 *
1101 T = SQRT( SCALE**2+U1**2+U2**2 )
1102 TAU = ONE + SCALE / T
1103 VS = -ONE / ( SCALE+T )
1104 V( 1 ) = ONE
1105 V( 2 ) = VS*U1
1106 V( 3 ) = VS*U2
1107 *
1108 * Apply transformations from the right.
1109 *
1110 DO 260 JR = IFRSTM, MIN( J+3, ILAST )
1111 TEMP = TAU*( A( JR, J )+V( 2 )*A( JR, J+1 )+V( 3 )*
1112 $ A( JR, J+2 ) )
1113 A( JR, J ) = A( JR, J ) - TEMP
1114 A( JR, J+1 ) = A( JR, J+1 ) - TEMP*V( 2 )
1115 A( JR, J+2 ) = A( JR, J+2 ) - TEMP*V( 3 )
1116 260 CONTINUE
1117 DO 270 JR = IFRSTM, J + 2
1118 TEMP = TAU*( B( JR, J )+V( 2 )*B( JR, J+1 )+V( 3 )*
1119 $ B( JR, J+2 ) )
1120 B( JR, J ) = B( JR, J ) - TEMP
1121 B( JR, J+1 ) = B( JR, J+1 ) - TEMP*V( 2 )
1122 B( JR, J+2 ) = B( JR, J+2 ) - TEMP*V( 3 )
1123 270 CONTINUE
1124 IF( ILZ ) THEN
1125 DO 280 JR = 1, N
1126 TEMP = TAU*( Z( JR, J )+V( 2 )*Z( JR, J+1 )+V( 3 )*
1127 $ Z( JR, J+2 ) )
1128 Z( JR, J ) = Z( JR, J ) - TEMP
1129 Z( JR, J+1 ) = Z( JR, J+1 ) - TEMP*V( 2 )
1130 Z( JR, J+2 ) = Z( JR, J+2 ) - TEMP*V( 3 )
1131 280 CONTINUE
1132 END IF
1133 B( J+1, J ) = ZERO
1134 B( J+2, J ) = ZERO
1135 290 CONTINUE
1136 *
1137 * Last elements: Use Givens rotations
1138 *
1139 * Rotations from the left
1140 *
1141 J = ILAST - 1
1142 TEMP = A( J, J-1 )
1143 CALL DLARTG( TEMP, A( J+1, J-1 ), C, S, A( J, J-1 ) )
1144 A( J+1, J-1 ) = ZERO
1145 *
1146 DO 300 JC = J, ILASTM
1147 TEMP = C*A( J, JC ) + S*A( J+1, JC )
1148 A( J+1, JC ) = -S*A( J, JC ) + C*A( J+1, JC )
1149 A( J, JC ) = TEMP
1150 TEMP2 = C*B( J, JC ) + S*B( J+1, JC )
1151 B( J+1, JC ) = -S*B( J, JC ) + C*B( J+1, JC )
1152 B( J, JC ) = TEMP2
1153 300 CONTINUE
1154 IF( ILQ ) THEN
1155 DO 310 JR = 1, N
1156 TEMP = C*Q( JR, J ) + S*Q( JR, J+1 )
1157 Q( JR, J+1 ) = -S*Q( JR, J ) + C*Q( JR, J+1 )
1158 Q( JR, J ) = TEMP
1159 310 CONTINUE
1160 END IF
1161 *
1162 * Rotations from the right.
1163 *
1164 TEMP = B( J+1, J+1 )
1165 CALL DLARTG( TEMP, B( J+1, J ), C, S, B( J+1, J+1 ) )
1166 B( J+1, J ) = ZERO
1167 *
1168 DO 320 JR = IFRSTM, ILAST
1169 TEMP = C*A( JR, J+1 ) + S*A( JR, J )
1170 A( JR, J ) = -S*A( JR, J+1 ) + C*A( JR, J )
1171 A( JR, J+1 ) = TEMP
1172 320 CONTINUE
1173 DO 330 JR = IFRSTM, ILAST - 1
1174 TEMP = C*B( JR, J+1 ) + S*B( JR, J )
1175 B( JR, J ) = -S*B( JR, J+1 ) + C*B( JR, J )
1176 B( JR, J+1 ) = TEMP
1177 330 CONTINUE
1178 IF( ILZ ) THEN
1179 DO 340 JR = 1, N
1180 TEMP = C*Z( JR, J+1 ) + S*Z( JR, J )
1181 Z( JR, J ) = -S*Z( JR, J+1 ) + C*Z( JR, J )
1182 Z( JR, J+1 ) = TEMP
1183 340 CONTINUE
1184 END IF
1185 *
1186 * End of Double-Shift code
1187 *
1188 END IF
1189 *
1190 GO TO 350
1191 *
1192 * End of iteration loop
1193 *
1194 350 CONTINUE
1195 360 CONTINUE
1196 *
1197 * Drop-through = non-convergence
1198 *
1199 370 CONTINUE
1200 INFO = ILAST
1201 GO TO 420
1202 *
1203 * Successful completion of all QZ steps
1204 *
1205 380 CONTINUE
1206 *
1207 * Set Eigenvalues 1:ILO-1
1208 *
1209 DO 410 J = 1, ILO - 1
1210 IF( B( J, J ).LT.ZERO ) THEN
1211 IF( ILSCHR ) THEN
1212 DO 390 JR = 1, J
1213 A( JR, J ) = -A( JR, J )
1214 B( JR, J ) = -B( JR, J )
1215 390 CONTINUE
1216 ELSE
1217 A( J, J ) = -A( J, J )
1218 B( J, J ) = -B( J, J )
1219 END IF
1220 IF( ILZ ) THEN
1221 DO 400 JR = 1, N
1222 Z( JR, J ) = -Z( JR, J )
1223 400 CONTINUE
1224 END IF
1225 END IF
1226 ALPHAR( J ) = A( J, J )
1227 ALPHAI( J ) = ZERO
1228 BETA( J ) = B( J, J )
1229 410 CONTINUE
1230 *
1231 * Normal Termination
1232 *
1233 INFO = 0
1234 *
1235 * Exit (other than argument error) -- return optimal workspace size
1236 *
1237 420 CONTINUE
1238 WORK( 1 ) = DBLE( N )
1239 RETURN
1240 *
1241 * End of DHGEQZ
1242 *
1243 END