LAPACK 3.11.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
dlaqz3.f
Go to the documentation of this file.
1*> \brief \b DLAQZ3
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8*> \htmlonly
9*> Download DLAQZ3 + dependencies
10*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlaqz3.f">
11*> [TGZ]</a>
12*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlaqz3.f">
13*> [ZIP]</a>
14*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlaqz3.f">
15*> [TXT]</a>
16*> \endhtmlonly
17*
18* Definition:
19* ===========
20*
21* SUBROUTINE DLAQZ3( ILSCHUR, ILQ, ILZ, N, ILO, IHI, NW, A, LDA, B,
22* $ LDB, Q, LDQ, Z, LDZ, NS, ND, ALPHAR, ALPHAI, BETA, QC, LDQC,
23* $ ZC, LDZC, WORK, LWORK, REC, INFO )
24* IMPLICIT NONE
25*
26* Arguments
27* LOGICAL, INTENT( IN ) :: ILSCHUR, ILQ, ILZ
28* INTEGER, INTENT( IN ) :: N, ILO, IHI, NW, LDA, LDB, LDQ, LDZ,
29* $ LDQC, LDZC, LWORK, REC
30*
31* DOUBLE PRECISION, INTENT( INOUT ) :: A( LDA, * ), B( LDB, * ),
32* $ Q( LDQ, * ), Z( LDZ, * ), ALPHAR( * ), ALPHAI( * ), BETA( * )
33* INTEGER, INTENT( OUT ) :: NS, ND, INFO
34* DOUBLE PRECISION :: QC( LDQC, * ), ZC( LDZC, * ), WORK( * )
35* ..
36*
37*
38*> \par Purpose:
39* =============
40*>
41*> \verbatim
42*>
43*> DLAQZ3 performs AED
44*> \endverbatim
45*
46* Arguments:
47* ==========
48*
49*> \param[in] ILSCHUR
50*> \verbatim
51*> ILSCHUR is LOGICAL
52*> Determines whether or not to update the full Schur form
53*> \endverbatim
54*>
55*> \param[in] ILQ
56*> \verbatim
57*> ILQ is LOGICAL
58*> Determines whether or not to update the matrix Q
59*> \endverbatim
60*>
61*> \param[in] ILZ
62*> \verbatim
63*> ILZ is LOGICAL
64*> Determines whether or not to update the matrix Z
65*> \endverbatim
66*>
67*> \param[in] N
68*> \verbatim
69*> N is INTEGER
70*> The order of the matrices A, B, Q, and Z. N >= 0.
71*> \endverbatim
72*>
73*> \param[in] ILO
74*> \verbatim
75*> ILO is INTEGER
76*> \endverbatim
77*>
78*> \param[in] IHI
79*> \verbatim
80*> IHI is INTEGER
81*> ILO and IHI mark the rows and columns of (A,B) which
82*> are to be normalized
83*> \endverbatim
84*>
85*> \param[in] NW
86*> \verbatim
87*> NW is INTEGER
88*> The desired size of the deflation window.
89*> \endverbatim
90*>
91*> \param[in,out] A
92*> \verbatim
93*> A is DOUBLE PRECISION array, dimension (LDA, N)
94*> \endverbatim
95*>
96*> \param[in] LDA
97*> \verbatim
98*> LDA is INTEGER
99*> The leading dimension of the array A. LDA >= max( 1, N ).
100*> \endverbatim
101*>
102*> \param[in,out] B
103*> \verbatim
104*> B is DOUBLE PRECISION array, dimension (LDB, N)
105*> \endverbatim
106*>
107*> \param[in] LDB
108*> \verbatim
109*> LDB is INTEGER
110*> The leading dimension of the array B. LDB >= max( 1, N ).
111*> \endverbatim
112*>
113*> \param[in,out] Q
114*> \verbatim
115*> Q is DOUBLE PRECISION array, dimension (LDQ, N)
116*> \endverbatim
117*>
118*> \param[in] LDQ
119*> \verbatim
120*> LDQ is INTEGER
121*> \endverbatim
122*>
123*> \param[in,out] Z
124*> \verbatim
125*> Z is DOUBLE PRECISION array, dimension (LDZ, N)
126*> \endverbatim
127*>
128*> \param[in] LDZ
129*> \verbatim
130*> LDZ is INTEGER
131*> \endverbatim
132*>
133*> \param[out] NS
134*> \verbatim
135*> NS is INTEGER
136*> The number of unconverged eigenvalues available to
137*> use as shifts.
138*> \endverbatim
139*>
140*> \param[out] ND
141*> \verbatim
142*> ND is INTEGER
143*> The number of converged eigenvalues found.
144*> \endverbatim
145*>
146*> \param[out] ALPHAR
147*> \verbatim
148*> ALPHAR is DOUBLE PRECISION array, dimension (N)
149*> The real parts of each scalar alpha defining an eigenvalue
150*> of GNEP.
151*> \endverbatim
152*>
153*> \param[out] ALPHAI
154*> \verbatim
155*> ALPHAI is DOUBLE PRECISION array, dimension (N)
156*> The imaginary parts of each scalar alpha defining an
157*> eigenvalue of GNEP.
158*> If ALPHAI(j) is zero, then the j-th eigenvalue is real; if
159*> positive, then the j-th and (j+1)-st eigenvalues are a
160*> complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).
161*> \endverbatim
162*>
163*> \param[out] BETA
164*> \verbatim
165*> BETA is DOUBLE PRECISION array, dimension (N)
166*> The scalars beta that define the eigenvalues of GNEP.
167*> Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and
168*> beta = BETA(j) represent the j-th eigenvalue of the matrix
169*> pair (A,B), in one of the forms lambda = alpha/beta or
170*> mu = beta/alpha. Since either lambda or mu may overflow,
171*> they should not, in general, be computed.
172*> \endverbatim
173*>
174*> \param[in,out] QC
175*> \verbatim
176*> QC is DOUBLE PRECISION array, dimension (LDQC, NW)
177*> \endverbatim
178*>
179*> \param[in] LDQC
180*> \verbatim
181*> LDQC is INTEGER
182*> \endverbatim
183*>
184*> \param[in,out] ZC
185*> \verbatim
186*> ZC is DOUBLE PRECISION array, dimension (LDZC, NW)
187*> \endverbatim
188*>
189*> \param[in] LDZC
190*> \verbatim
191*> LDZ is INTEGER
192*> \endverbatim
193*>
194*> \param[out] WORK
195*> \verbatim
196*> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
197*> On exit, if INFO >= 0, WORK(1) returns the optimal LWORK.
198*> \endverbatim
199*>
200*> \param[in] LWORK
201*> \verbatim
202*> LWORK is INTEGER
203*> The dimension of the array WORK. LWORK >= max(1,N).
204*>
205*> If LWORK = -1, then a workspace query is assumed; the routine
206*> only calculates the optimal size of the WORK array, returns
207*> this value as the first entry of the WORK array, and no error
208*> message related to LWORK is issued by XERBLA.
209*> \endverbatim
210*>
211*> \param[in] REC
212*> \verbatim
213*> REC is INTEGER
214*> REC indicates the current recursion level. Should be set
215*> to 0 on first call.
216*> \endverbatim
217*>
218*> \param[out] INFO
219*> \verbatim
220*> INFO is INTEGER
221*> = 0: successful exit
222*> < 0: if INFO = -i, the i-th argument had an illegal value
223*> \endverbatim
224*
225* Authors:
226* ========
227*
228*> \author Thijs Steel, KU Leuven
229*
230*> \date May 2020
231*
232*> \ingroup doubleGEcomputational
233*>
234* =====================================================================
235 RECURSIVE SUBROUTINE dlaqz3( ILSCHUR, ILQ, ILZ, N, ILO, IHI, NW,
236 $ A, LDA, B, LDB, Q, LDQ, Z, LDZ, NS,
237 $ ND, ALPHAR, ALPHAI, BETA, QC, LDQC,
238 $ ZC, LDZC, WORK, LWORK, REC, INFO )
239 IMPLICIT NONE
240
241* Arguments
242 LOGICAL, INTENT( IN ) :: ilschur, ilq, ilz
243 INTEGER, INTENT( IN ) :: n, ilo, ihi, nw, lda, ldb, ldq, ldz,
244 $ ldqc, ldzc, lwork, rec
245
246 DOUBLE PRECISION, INTENT( INOUT ) :: a( lda, * ), b( ldb, * ),
247 $ q( ldq, * ), z( ldz, * ), alphar( * ),
248 $ alphai( * ), beta( * )
249 INTEGER, INTENT( OUT ) :: ns, nd, info
250 DOUBLE PRECISION :: qc( ldqc, * ), zc( ldzc, * ), work( * )
251
252* Parameters
253 DOUBLE PRECISION :: zero, one, half
254 PARAMETER( zero = 0.0d0, one = 1.0d0, half = 0.5d0 )
255
256* Local Scalars
257 LOGICAL :: bulge
258 INTEGER :: jw, kwtop, kwbot, istopm, istartm, k, k2, dtgexc_info,
259 $ ifst, ilst, lworkreq, qz_small_info
260 DOUBLE PRECISION :: s, smlnum, ulp, safmin, safmax, c1, s1, temp
261
262* External Functions
263 EXTERNAL :: xerbla, dtgexc, dlabad, dlaqz0, dlacpy, dlaset,
264 $ dlaqz2, drot, dlartg, dlag2, dgemm
265 DOUBLE PRECISION, EXTERNAL :: dlamch
266
267 info = 0
268
269* Set up deflation window
270 jw = min( nw, ihi-ilo+1 )
271 kwtop = ihi-jw+1
272 IF ( kwtop .EQ. ilo ) THEN
273 s = zero
274 ELSE
275 s = a( kwtop, kwtop-1 )
276 END IF
277
278* Determine required workspace
279 ifst = 1
280 ilst = jw
281 CALL dtgexc( .true., .true., jw, a, lda, b, ldb, qc, ldqc, zc,
282 $ ldzc, ifst, ilst, work, -1, dtgexc_info )
283 lworkreq = int( work( 1 ) )
284 CALL dlaqz0( 'S', 'V', 'V', jw, 1, jw, a( kwtop, kwtop ), lda,
285 $ b( kwtop, kwtop ), ldb, alphar, alphai, beta, qc,
286 $ ldqc, zc, ldzc, work, -1, rec+1, qz_small_info )
287 lworkreq = max( lworkreq, int( work( 1 ) )+2*jw**2 )
288 lworkreq = max( lworkreq, n*nw, 2*nw**2+n )
289 IF ( lwork .EQ.-1 ) THEN
290* workspace query, quick return
291 work( 1 ) = lworkreq
292 RETURN
293 ELSE IF ( lwork .LT. lworkreq ) THEN
294 info = -26
295 END IF
296
297 IF( info.NE.0 ) THEN
298 CALL xerbla( 'DLAQZ3', -info )
299 RETURN
300 END IF
301
302* Get machine constants
303 safmin = dlamch( 'SAFE MINIMUM' )
304 safmax = one/safmin
305 CALL dlabad( safmin, safmax )
306 ulp = dlamch( 'PRECISION' )
307 smlnum = safmin*( dble( n )/ulp )
308
309 IF ( ihi .EQ. kwtop ) THEN
310* 1 by 1 deflation window, just try a regular deflation
311 alphar( kwtop ) = a( kwtop, kwtop )
312 alphai( kwtop ) = zero
313 beta( kwtop ) = b( kwtop, kwtop )
314 ns = 1
315 nd = 0
316 IF ( abs( s ) .LE. max( smlnum, ulp*abs( a( kwtop,
317 $ kwtop ) ) ) ) THEN
318 ns = 0
319 nd = 1
320 IF ( kwtop .GT. ilo ) THEN
321 a( kwtop, kwtop-1 ) = zero
322 END IF
323 END IF
324 END IF
325
326
327* Store window in case of convergence failure
328 CALL dlacpy( 'ALL', jw, jw, a( kwtop, kwtop ), lda, work, jw )
329 CALL dlacpy( 'ALL', jw, jw, b( kwtop, kwtop ), ldb, work( jw**2+
330 $ 1 ), jw )
331
332* Transform window to real schur form
333 CALL dlaset( 'FULL', jw, jw, zero, one, qc, ldqc )
334 CALL dlaset( 'FULL', jw, jw, zero, one, zc, ldzc )
335 CALL dlaqz0( 'S', 'V', 'V', jw, 1, jw, a( kwtop, kwtop ), lda,
336 $ b( kwtop, kwtop ), ldb, alphar, alphai, beta, qc,
337 $ ldqc, zc, ldzc, work( 2*jw**2+1 ), lwork-2*jw**2,
338 $ rec+1, qz_small_info )
339
340 IF( qz_small_info .NE. 0 ) THEN
341* Convergence failure, restore the window and exit
342 nd = 0
343 ns = jw-qz_small_info
344 CALL dlacpy( 'ALL', jw, jw, work, jw, a( kwtop, kwtop ), lda )
345 CALL dlacpy( 'ALL', jw, jw, work( jw**2+1 ), jw, b( kwtop,
346 $ kwtop ), ldb )
347 RETURN
348 END IF
349
350* Deflation detection loop
351 IF ( kwtop .EQ. ilo .OR. s .EQ. zero ) THEN
352 kwbot = kwtop-1
353 ELSE
354 kwbot = ihi
355 k = 1
356 k2 = 1
357 DO WHILE ( k .LE. jw )
358 bulge = .false.
359 IF ( kwbot-kwtop+1 .GE. 2 ) THEN
360 bulge = a( kwbot, kwbot-1 ) .NE. zero
361 END IF
362 IF ( bulge ) THEN
363
364* Try to deflate complex conjugate eigenvalue pair
365 temp = abs( a( kwbot, kwbot ) )+sqrt( abs( a( kwbot,
366 $ kwbot-1 ) ) )*sqrt( abs( a( kwbot-1, kwbot ) ) )
367 IF( temp .EQ. zero )THEN
368 temp = abs( s )
369 END IF
370 IF ( max( abs( s*qc( 1, kwbot-kwtop ) ), abs( s*qc( 1,
371 $ kwbot-kwtop+1 ) ) ) .LE. max( smlnum,
372 $ ulp*temp ) ) THEN
373* Deflatable
374 kwbot = kwbot-2
375 ELSE
376* Not deflatable, move out of the way
377 ifst = kwbot-kwtop+1
378 ilst = k2
379 CALL dtgexc( .true., .true., jw, a( kwtop, kwtop ),
380 $ lda, b( kwtop, kwtop ), ldb, qc, ldqc,
381 $ zc, ldzc, ifst, ilst, work, lwork,
382 $ dtgexc_info )
383 k2 = k2+2
384 END IF
385 k = k+2
386 ELSE
387
388* Try to deflate real eigenvalue
389 temp = abs( a( kwbot, kwbot ) )
390 IF( temp .EQ. zero ) THEN
391 temp = abs( s )
392 END IF
393 IF ( ( abs( s*qc( 1, kwbot-kwtop+1 ) ) ) .LE. max( ulp*
394 $ temp, smlnum ) ) THEN
395* Deflatable
396 kwbot = kwbot-1
397 ELSE
398* Not deflatable, move out of the way
399 ifst = kwbot-kwtop+1
400 ilst = k2
401 CALL dtgexc( .true., .true., jw, a( kwtop, kwtop ),
402 $ lda, b( kwtop, kwtop ), ldb, qc, ldqc,
403 $ zc, ldzc, ifst, ilst, work, lwork,
404 $ dtgexc_info )
405 k2 = k2+1
406 END IF
407
408 k = k+1
409
410 END IF
411 END DO
412 END IF
413
414* Store eigenvalues
415 nd = ihi-kwbot
416 ns = jw-nd
417 k = kwtop
418 DO WHILE ( k .LE. ihi )
419 bulge = .false.
420 IF ( k .LT. ihi ) THEN
421 IF ( a( k+1, k ) .NE. zero ) THEN
422 bulge = .true.
423 END IF
424 END IF
425 IF ( bulge ) THEN
426* 2x2 eigenvalue block
427 CALL dlag2( a( k, k ), lda, b( k, k ), ldb, safmin,
428 $ beta( k ), beta( k+1 ), alphar( k ),
429 $ alphar( k+1 ), alphai( k ) )
430 alphai( k+1 ) = -alphai( k )
431 k = k+2
432 ELSE
433* 1x1 eigenvalue block
434 alphar( k ) = a( k, k )
435 alphai( k ) = zero
436 beta( k ) = b( k, k )
437 k = k+1
438 END IF
439 END DO
440
441 IF ( kwtop .NE. ilo .AND. s .NE. zero ) THEN
442* Reflect spike back, this will create optimally packed bulges
443 a( kwtop:kwbot, kwtop-1 ) = a( kwtop, kwtop-1 )*qc( 1,
444 $ 1:jw-nd )
445 DO k = kwbot-1, kwtop, -1
446 CALL dlartg( a( k, kwtop-1 ), a( k+1, kwtop-1 ), c1, s1,
447 $ temp )
448 a( k, kwtop-1 ) = temp
449 a( k+1, kwtop-1 ) = zero
450 k2 = max( kwtop, k-1 )
451 CALL drot( ihi-k2+1, a( k, k2 ), lda, a( k+1, k2 ), lda, c1,
452 $ s1 )
453 CALL drot( ihi-( k-1 )+1, b( k, k-1 ), ldb, b( k+1, k-1 ),
454 $ ldb, c1, s1 )
455 CALL drot( jw, qc( 1, k-kwtop+1 ), 1, qc( 1, k+1-kwtop+1 ),
456 $ 1, c1, s1 )
457 END DO
458
459* Chase bulges down
460 istartm = kwtop
461 istopm = ihi
462 k = kwbot-1
463 DO WHILE ( k .GE. kwtop )
464 IF ( ( k .GE. kwtop+1 ) .AND. a( k+1, k-1 ) .NE. zero ) THEN
465
466* Move double pole block down and remove it
467 DO k2 = k-1, kwbot-2
468 CALL dlaqz2( .true., .true., k2, kwtop, kwtop+jw-1,
469 $ kwbot, a, lda, b, ldb, jw, kwtop, qc,
470 $ ldqc, jw, kwtop, zc, ldzc )
471 END DO
472
473 k = k-2
474 ELSE
475
476* k points to single shift
477 DO k2 = k, kwbot-2
478
479* Move shift down
480 CALL dlartg( b( k2+1, k2+1 ), b( k2+1, k2 ), c1, s1,
481 $ temp )
482 b( k2+1, k2+1 ) = temp
483 b( k2+1, k2 ) = zero
484 CALL drot( k2+2-istartm+1, a( istartm, k2+1 ), 1,
485 $ a( istartm, k2 ), 1, c1, s1 )
486 CALL drot( k2-istartm+1, b( istartm, k2+1 ), 1,
487 $ b( istartm, k2 ), 1, c1, s1 )
488 CALL drot( jw, zc( 1, k2+1-kwtop+1 ), 1, zc( 1,
489 $ k2-kwtop+1 ), 1, c1, s1 )
490
491 CALL dlartg( a( k2+1, k2 ), a( k2+2, k2 ), c1, s1,
492 $ temp )
493 a( k2+1, k2 ) = temp
494 a( k2+2, k2 ) = zero
495 CALL drot( istopm-k2, a( k2+1, k2+1 ), lda, a( k2+2,
496 $ k2+1 ), lda, c1, s1 )
497 CALL drot( istopm-k2, b( k2+1, k2+1 ), ldb, b( k2+2,
498 $ k2+1 ), ldb, c1, s1 )
499 CALL drot( jw, qc( 1, k2+1-kwtop+1 ), 1, qc( 1,
500 $ k2+2-kwtop+1 ), 1, c1, s1 )
501
502 END DO
503
504* Remove the shift
505 CALL dlartg( b( kwbot, kwbot ), b( kwbot, kwbot-1 ), c1,
506 $ s1, temp )
507 b( kwbot, kwbot ) = temp
508 b( kwbot, kwbot-1 ) = zero
509 CALL drot( kwbot-istartm, b( istartm, kwbot ), 1,
510 $ b( istartm, kwbot-1 ), 1, c1, s1 )
511 CALL drot( kwbot-istartm+1, a( istartm, kwbot ), 1,
512 $ a( istartm, kwbot-1 ), 1, c1, s1 )
513 CALL drot( jw, zc( 1, kwbot-kwtop+1 ), 1, zc( 1,
514 $ kwbot-1-kwtop+1 ), 1, c1, s1 )
515
516 k = k-1
517 END IF
518 END DO
519
520 END IF
521
522* Apply Qc and Zc to rest of the matrix
523 IF ( ilschur ) THEN
524 istartm = 1
525 istopm = n
526 ELSE
527 istartm = ilo
528 istopm = ihi
529 END IF
530
531 IF ( istopm-ihi > 0 ) THEN
532 CALL dgemm( 'T', 'N', jw, istopm-ihi, jw, one, qc, ldqc,
533 $ a( kwtop, ihi+1 ), lda, zero, work, jw )
534 CALL dlacpy( 'ALL', jw, istopm-ihi, work, jw, a( kwtop,
535 $ ihi+1 ), lda )
536 CALL dgemm( 'T', 'N', jw, istopm-ihi, jw, one, qc, ldqc,
537 $ b( kwtop, ihi+1 ), ldb, zero, work, jw )
538 CALL dlacpy( 'ALL', jw, istopm-ihi, work, jw, b( kwtop,
539 $ ihi+1 ), ldb )
540 END IF
541 IF ( ilq ) THEN
542 CALL dgemm( 'N', 'N', n, jw, jw, one, q( 1, kwtop ), ldq, qc,
543 $ ldqc, zero, work, n )
544 CALL dlacpy( 'ALL', n, jw, work, n, q( 1, kwtop ), ldq )
545 END IF
546
547 IF ( kwtop-1-istartm+1 > 0 ) THEN
548 CALL dgemm( 'N', 'N', kwtop-istartm, jw, jw, one, a( istartm,
549 $ kwtop ), lda, zc, ldzc, zero, work,
550 $ kwtop-istartm )
551 CALL dlacpy( 'ALL', kwtop-istartm, jw, work, kwtop-istartm,
552 $ a( istartm, kwtop ), lda )
553 CALL dgemm( 'N', 'N', kwtop-istartm, jw, jw, one, b( istartm,
554 $ kwtop ), ldb, zc, ldzc, zero, work,
555 $ kwtop-istartm )
556 CALL dlacpy( 'ALL', kwtop-istartm, jw, work, kwtop-istartm,
557 $ b( istartm, kwtop ), ldb )
558 END IF
559 IF ( ilz ) THEN
560 CALL dgemm( 'N', 'N', n, jw, jw, one, z( 1, kwtop ), ldz, zc,
561 $ ldzc, zero, work, n )
562 CALL dlacpy( 'ALL', n, jw, work, n, z( 1, kwtop ), ldz )
563 END IF
564
565 END SUBROUTINE
dlamch
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
dlabad
subroutine dlabad(SMALL, LARGE)
DLABAD
Definition: dlabad.f:74
dlacpy
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:103
dlartg
subroutine dlartg(f, g, c, s, r)
DLARTG generates a plane rotation with real cosine and real sine.
Definition: dlartg.f90:111
dlaset
subroutine dlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: dlaset.f:110
xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
drot
subroutine drot(N, DX, INCX, DY, INCY, C, S)
DROT
Definition: drot.f:92
dgemm
subroutine dgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
DGEMM
Definition: dgemm.f:187
dtgexc
subroutine dtgexc(WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, LDZ, IFST, ILST, WORK, LWORK, INFO)
DTGEXC
Definition: dtgexc.f:220
dlaqz0
recursive subroutine dlaqz0(WANTS, WANTQ, WANTZ, N, ILO, IHI, A, LDA, B, LDB, ALPHAR, ALPHAI, BETA, Q, LDQ, Z, LDZ, WORK, LWORK, REC, INFO)
DLAQZ0
Definition: dlaqz0.f:306
dlaqz3
recursive subroutine dlaqz3(ILSCHUR, ILQ, ILZ, N, ILO, IHI, NW, A, LDA, B, LDB, Q, LDQ, Z, LDZ, NS, ND, ALPHAR, ALPHAI, BETA, QC, LDQC, ZC, LDZC, WORK, LWORK, REC, INFO)
DLAQZ3
Definition: dlaqz3.f:239
dlaqz2
subroutine dlaqz2(ILQ, ILZ, K, ISTARTM, ISTOPM, IHI, A, LDA, B, LDB, NQ, QSTART, Q, LDQ, NZ, ZSTART, Z, LDZ)
DLAQZ2
Definition: dlaqz2.f:174
dlag2
subroutine dlag2(A, LDA, B, LDB, SAFMIN, SCALE1, SCALE2, WR1, WR2, WI)
DLAG2 computes the eigenvalues of a 2-by-2 generalized eigenvalue problem, with scaling as necessary ...
Definition: dlag2.f:156