LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
cggesx.f
Go to the documentation of this file.
1*> \brief <b> CGGESX computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices</b>
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8*> \htmlonly
9*> Download CGGESX + dependencies
10*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cggesx.f">
11*> [TGZ]</a>
12*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cggesx.f">
13*> [ZIP]</a>
14*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cggesx.f">
15*> [TXT]</a>
16*> \endhtmlonly
17*
18* Definition:
19* ===========
20*
21* SUBROUTINE CGGESX( JOBVSL, JOBVSR, SORT, SELCTG, SENSE, N, A, LDA,
22* B, LDB, SDIM, ALPHA, BETA, VSL, LDVSL, VSR,
23* LDVSR, RCONDE, RCONDV, WORK, LWORK, RWORK,
24* IWORK, LIWORK, BWORK, INFO )
25*
26* .. Scalar Arguments ..
27* CHARACTER JOBVSL, JOBVSR, SENSE, SORT
28* INTEGER INFO, LDA, LDB, LDVSL, LDVSR, LIWORK, LWORK, N,
29* $ SDIM
30* ..
31* .. Array Arguments ..
32* LOGICAL BWORK( * )
33* INTEGER IWORK( * )
34* REAL RCONDE( 2 ), RCONDV( 2 ), RWORK( * )
35* COMPLEX A( LDA, * ), ALPHA( * ), B( LDB, * ),
36* $ BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
37* $ WORK( * )
38* ..
39* .. Function Arguments ..
40* LOGICAL SELCTG
41* EXTERNAL SELCTG
42* ..
43*
44*
45*> \par Purpose:
46* =============
47*>
48*> \verbatim
49*>
50*> CGGESX computes for a pair of N-by-N complex nonsymmetric matrices
51*> (A,B), the generalized eigenvalues, the complex Schur form (S,T),
52*> and, optionally, the left and/or right matrices of Schur vectors (VSL
53*> and VSR). This gives the generalized Schur factorization
54*>
55*> (A,B) = ( (VSL) S (VSR)**H, (VSL) T (VSR)**H )
56*>
57*> where (VSR)**H is the conjugate-transpose of VSR.
58*>
59*> Optionally, it also orders the eigenvalues so that a selected cluster
60*> of eigenvalues appears in the leading diagonal blocks of the upper
61*> triangular matrix S and the upper triangular matrix T; computes
62*> a reciprocal condition number for the average of the selected
63*> eigenvalues (RCONDE); and computes a reciprocal condition number for
64*> the right and left deflating subspaces corresponding to the selected
65*> eigenvalues (RCONDV). The leading columns of VSL and VSR then form
66*> an orthonormal basis for the corresponding left and right eigenspaces
67*> (deflating subspaces).
68*>
69*> A generalized eigenvalue for a pair of matrices (A,B) is a scalar w
70*> or a ratio alpha/beta = w, such that A - w*B is singular. It is
71*> usually represented as the pair (alpha,beta), as there is a
72*> reasonable interpretation for beta=0 or for both being zero.
73*>
74*> A pair of matrices (S,T) is in generalized complex Schur form if T is
75*> upper triangular with non-negative diagonal and S is upper
76*> triangular.
77*> \endverbatim
78*
79* Arguments:
80* ==========
81*
82*> \param[in] JOBVSL
83*> \verbatim
84*> JOBVSL is CHARACTER*1
85*> = 'N': do not compute the left Schur vectors;
86*> = 'V': compute the left Schur vectors.
87*> \endverbatim
88*>
89*> \param[in] JOBVSR
90*> \verbatim
91*> JOBVSR is CHARACTER*1
92*> = 'N': do not compute the right Schur vectors;
93*> = 'V': compute the right Schur vectors.
94*> \endverbatim
95*>
96*> \param[in] SORT
97*> \verbatim
98*> SORT is CHARACTER*1
99*> Specifies whether or not to order the eigenvalues on the
100*> diagonal of the generalized Schur form.
101*> = 'N': Eigenvalues are not ordered;
102*> = 'S': Eigenvalues are ordered (see SELCTG).
103*> \endverbatim
104*>
105*> \param[in] SELCTG
106*> \verbatim
107*> SELCTG is a LOGICAL FUNCTION of two COMPLEX arguments
108*> SELCTG must be declared EXTERNAL in the calling subroutine.
109*> If SORT = 'N', SELCTG is not referenced.
110*> If SORT = 'S', SELCTG is used to select eigenvalues to sort
111*> to the top left of the Schur form.
112*> Note that a selected complex eigenvalue may no longer satisfy
113*> SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since
114*> ordering may change the value of complex eigenvalues
115*> (especially if the eigenvalue is ill-conditioned), in this
116*> case INFO is set to N+3 see INFO below).
117*> \endverbatim
118*>
119*> \param[in] SENSE
120*> \verbatim
121*> SENSE is CHARACTER*1
122*> Determines which reciprocal condition numbers are computed.
123*> = 'N': None are computed;
124*> = 'E': Computed for average of selected eigenvalues only;
125*> = 'V': Computed for selected deflating subspaces only;
126*> = 'B': Computed for both.
127*> If SENSE = 'E', 'V', or 'B', SORT must equal 'S'.
128*> \endverbatim
129*>
130*> \param[in] N
131*> \verbatim
132*> N is INTEGER
133*> The order of the matrices A, B, VSL, and VSR. N >= 0.
134*> \endverbatim
135*>
136*> \param[in,out] A
137*> \verbatim
138*> A is COMPLEX array, dimension (LDA, N)
139*> On entry, the first of the pair of matrices.
140*> On exit, A has been overwritten by its generalized Schur
141*> form S.
142*> \endverbatim
143*>
144*> \param[in] LDA
145*> \verbatim
146*> LDA is INTEGER
147*> The leading dimension of A. LDA >= max(1,N).
148*> \endverbatim
149*>
150*> \param[in,out] B
151*> \verbatim
152*> B is COMPLEX array, dimension (LDB, N)
153*> On entry, the second of the pair of matrices.
154*> On exit, B has been overwritten by its generalized Schur
155*> form T.
156*> \endverbatim
157*>
158*> \param[in] LDB
159*> \verbatim
160*> LDB is INTEGER
161*> The leading dimension of B. LDB >= max(1,N).
162*> \endverbatim
163*>
164*> \param[out] SDIM
165*> \verbatim
166*> SDIM is INTEGER
167*> If SORT = 'N', SDIM = 0.
168*> If SORT = 'S', SDIM = number of eigenvalues (after sorting)
169*> for which SELCTG is true.
170*> \endverbatim
171*>
172*> \param[out] ALPHA
173*> \verbatim
174*> ALPHA is COMPLEX array, dimension (N)
175*> \endverbatim
176*>
177*> \param[out] BETA
178*> \verbatim
179*> BETA is COMPLEX array, dimension (N)
180*> On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the
181*> generalized eigenvalues. ALPHA(j) and BETA(j),j=1,...,N are
182*> the diagonals of the complex Schur form (S,T). BETA(j) will
183*> be non-negative real.
184*>
185*> Note: the quotients ALPHA(j)/BETA(j) may easily over- or
186*> underflow, and BETA(j) may even be zero. Thus, the user
187*> should avoid naively computing the ratio alpha/beta.
188*> However, ALPHA will be always less than and usually
189*> comparable with norm(A) in magnitude, and BETA always less
190*> than and usually comparable with norm(B).
191*> \endverbatim
192*>
193*> \param[out] VSL
194*> \verbatim
195*> VSL is COMPLEX array, dimension (LDVSL,N)
196*> If JOBVSL = 'V', VSL will contain the left Schur vectors.
197*> Not referenced if JOBVSL = 'N'.
198*> \endverbatim
199*>
200*> \param[in] LDVSL
201*> \verbatim
202*> LDVSL is INTEGER
203*> The leading dimension of the matrix VSL. LDVSL >=1, and
204*> if JOBVSL = 'V', LDVSL >= N.
205*> \endverbatim
206*>
207*> \param[out] VSR
208*> \verbatim
209*> VSR is COMPLEX array, dimension (LDVSR,N)
210*> If JOBVSR = 'V', VSR will contain the right Schur vectors.
211*> Not referenced if JOBVSR = 'N'.
212*> \endverbatim
213*>
214*> \param[in] LDVSR
215*> \verbatim
216*> LDVSR is INTEGER
217*> The leading dimension of the matrix VSR. LDVSR >= 1, and
218*> if JOBVSR = 'V', LDVSR >= N.
219*> \endverbatim
220*>
221*> \param[out] RCONDE
222*> \verbatim
223*> RCONDE is REAL array, dimension ( 2 )
224*> If SENSE = 'E' or 'B', RCONDE(1) and RCONDE(2) contain the
225*> reciprocal condition numbers for the average of the selected
226*> eigenvalues.
227*> Not referenced if SENSE = 'N' or 'V'.
228*> \endverbatim
229*>
230*> \param[out] RCONDV
231*> \verbatim
232*> RCONDV is REAL array, dimension ( 2 )
233*> If SENSE = 'V' or 'B', RCONDV(1) and RCONDV(2) contain the
234*> reciprocal condition number for the selected deflating
235*> subspaces.
236*> Not referenced if SENSE = 'N' or 'E'.
237*> \endverbatim
238*>
239*> \param[out] WORK
240*> \verbatim
241*> WORK is COMPLEX array, dimension (MAX(1,LWORK))
242*> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
243*> \endverbatim
244*>
245*> \param[in] LWORK
246*> \verbatim
247*> LWORK is INTEGER
248*> The dimension of the array WORK.
249*> If N = 0, LWORK >= 1, else if SENSE = 'E', 'V', or 'B',
250*> LWORK >= MAX(1,2*N,2*SDIM*(N-SDIM)), else
251*> LWORK >= MAX(1,2*N). Note that 2*SDIM*(N-SDIM) <= N*N/2.
252*> Note also that an error is only returned if
253*> LWORK < MAX(1,2*N), but if SENSE = 'E' or 'V' or 'B' this may
254*> not be large enough.
255*>
256*> If LWORK = -1, then a workspace query is assumed; the routine
257*> only calculates the bound on the optimal size of the WORK
258*> array and the minimum size of the IWORK array, returns these
259*> values as the first entries of the WORK and IWORK arrays, and
260*> no error message related to LWORK or LIWORK is issued by
261*> XERBLA.
262*> \endverbatim
263*>
264*> \param[out] RWORK
265*> \verbatim
266*> RWORK is REAL array, dimension ( 8*N )
267*> Real workspace.
268*> \endverbatim
269*>
270*> \param[out] IWORK
271*> \verbatim
272*> IWORK is INTEGER array, dimension (MAX(1,LIWORK))
273*> On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK.
274*> \endverbatim
275*>
276*> \param[in] LIWORK
277*> \verbatim
278*> LIWORK is INTEGER
279*> The dimension of the array WORK.
280*> If SENSE = 'N' or N = 0, LIWORK >= 1, otherwise
281*> LIWORK >= N+2.
282*>
283*> If LIWORK = -1, then a workspace query is assumed; the
284*> routine only calculates the bound on the optimal size of the
285*> WORK array and the minimum size of the IWORK array, returns
286*> these values as the first entries of the WORK and IWORK
287*> arrays, and no error message related to LWORK or LIWORK is
288*> issued by XERBLA.
289*> \endverbatim
290*>
291*> \param[out] BWORK
292*> \verbatim
293*> BWORK is LOGICAL array, dimension (N)
294*> Not referenced if SORT = 'N'.
295*> \endverbatim
296*>
297*> \param[out] INFO
298*> \verbatim
299*> INFO is INTEGER
300*> = 0: successful exit
301*> < 0: if INFO = -i, the i-th argument had an illegal value.
302*> = 1,...,N:
303*> The QZ iteration failed. (A,B) are not in Schur
304*> form, but ALPHA(j) and BETA(j) should be correct for
305*> j=INFO+1,...,N.
306*> > N: =N+1: other than QZ iteration failed in CHGEQZ
307*> =N+2: after reordering, roundoff changed values of
308*> some complex eigenvalues so that leading
309*> eigenvalues in the Generalized Schur form no
310*> longer satisfy SELCTG=.TRUE. This could also
311*> be caused due to scaling.
312*> =N+3: reordering failed in CTGSEN.
313*> \endverbatim
314*
315* Authors:
316* ========
317*
318*> \author Univ. of Tennessee
319*> \author Univ. of California Berkeley
320*> \author Univ. of Colorado Denver
321*> \author NAG Ltd.
322*
323*> \ingroup ggesx
324*
325* =====================================================================
326 SUBROUTINE cggesx( JOBVSL, JOBVSR, SORT, SELCTG, SENSE, N, A, LDA,
327 $ B, LDB, SDIM, ALPHA, BETA, VSL, LDVSL, VSR,
328 $ LDVSR, RCONDE, RCONDV, WORK, LWORK, RWORK,
329 $ IWORK, LIWORK, BWORK, INFO )
330*
331* -- LAPACK driver routine --
332* -- LAPACK is a software package provided by Univ. of Tennessee, --
333* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
334*
335* .. Scalar Arguments ..
336 CHARACTER JOBVSL, JOBVSR, SENSE, SORT
337 INTEGER INFO, LDA, LDB, LDVSL, LDVSR, LIWORK, LWORK, N,
338 $ SDIM
339* ..
340* .. Array Arguments ..
341 LOGICAL BWORK( * )
342 INTEGER IWORK( * )
343 REAL RCONDE( 2 ), RCONDV( 2 ), RWORK( * )
344 COMPLEX A( LDA, * ), ALPHA( * ), B( LDB, * ),
345 $ beta( * ), vsl( ldvsl, * ), vsr( ldvsr, * ),
346 $ work( * )
347* ..
348* .. Function Arguments ..
349 LOGICAL SELCTG
350 EXTERNAL SELCTG
351* ..
352*
353* =====================================================================
354*
355* .. Parameters ..
356 REAL ZERO, ONE
357 PARAMETER ( ZERO = 0.0e+0, one = 1.0e+0 )
358 COMPLEX CZERO, CONE
359 parameter( czero = ( 0.0e+0, 0.0e+0 ),
360 $ cone = ( 1.0e+0, 0.0e+0 ) )
361* ..
362* .. Local Scalars ..
363 LOGICAL CURSL, ILASCL, ILBSCL, ILVSL, ILVSR, LASTSL,
364 $ LQUERY, WANTSB, WANTSE, WANTSN, WANTST, WANTSV
365 INTEGER I, ICOLS, IERR, IHI, IJOB, IJOBVL, IJOBVR,
366 $ ileft, ilo, iright, irows, irwrk, itau, iwrk,
367 $ liwmin, lwrk, maxwrk, minwrk
368 REAL ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS, PL,
369 $ PR, SMLNUM
370* ..
371* .. Local Arrays ..
372 REAL DIF( 2 )
373* ..
374* .. External Subroutines ..
375 EXTERNAL cgeqrf, cggbak, cggbal, cgghrd, chgeqz, clacpy,
377* ..
378* .. External Functions ..
379 LOGICAL LSAME
380 INTEGER ILAENV
381 REAL CLANGE, SLAMCH, SROUNDUP_LWORK
382 EXTERNAL lsame, ilaenv, clange, slamch, sroundup_lwork
383* ..
384* .. Intrinsic Functions ..
385 INTRINSIC max, sqrt
386* ..
387* .. Executable Statements ..
388*
389* Decode the input arguments
390*
391 IF( lsame( jobvsl, 'N' ) ) THEN
392 ijobvl = 1
393 ilvsl = .false.
394 ELSE IF( lsame( jobvsl, 'V' ) ) THEN
395 ijobvl = 2
396 ilvsl = .true.
397 ELSE
398 ijobvl = -1
399 ilvsl = .false.
400 END IF
401*
402 IF( lsame( jobvsr, 'N' ) ) THEN
403 ijobvr = 1
404 ilvsr = .false.
405 ELSE IF( lsame( jobvsr, 'V' ) ) THEN
406 ijobvr = 2
407 ilvsr = .true.
408 ELSE
409 ijobvr = -1
410 ilvsr = .false.
411 END IF
412*
413 wantst = lsame( sort, 'S' )
414 wantsn = lsame( sense, 'N' )
415 wantse = lsame( sense, 'E' )
416 wantsv = lsame( sense, 'V' )
417 wantsb = lsame( sense, 'B' )
418 lquery = ( lwork.EQ.-1 .OR. liwork.EQ.-1 )
419 IF( wantsn ) THEN
420 ijob = 0
421 ELSE IF( wantse ) THEN
422 ijob = 1
423 ELSE IF( wantsv ) THEN
424 ijob = 2
425 ELSE IF( wantsb ) THEN
426 ijob = 4
427 END IF
428*
429* Test the input arguments
430*
431 info = 0
432 IF( ijobvl.LE.0 ) THEN
433 info = -1
434 ELSE IF( ijobvr.LE.0 ) THEN
435 info = -2
436 ELSE IF( ( .NOT.wantst ) .AND. ( .NOT.lsame( sort, 'N' ) ) ) THEN
437 info = -3
438 ELSE IF( .NOT.( wantsn .OR. wantse .OR. wantsv .OR. wantsb ) .OR.
439 $ ( .NOT.wantst .AND. .NOT.wantsn ) ) THEN
440 info = -5
441 ELSE IF( n.LT.0 ) THEN
442 info = -6
443 ELSE IF( lda.LT.max( 1, n ) ) THEN
444 info = -8
445 ELSE IF( ldb.LT.max( 1, n ) ) THEN
446 info = -10
447 ELSE IF( ldvsl.LT.1 .OR. ( ilvsl .AND. ldvsl.LT.n ) ) THEN
448 info = -15
449 ELSE IF( ldvsr.LT.1 .OR. ( ilvsr .AND. ldvsr.LT.n ) ) THEN
450 info = -17
451 END IF
452*
453* Compute workspace
454* (Note: Comments in the code beginning "Workspace:" describe the
455* minimal amount of workspace needed at that point in the code,
456* as well as the preferred amount for good performance.
457* NB refers to the optimal block size for the immediately
458* following subroutine, as returned by ILAENV.)
459*
460 IF( info.EQ.0 ) THEN
461 IF( n.GT.0) THEN
462 minwrk = 2*n
463 maxwrk = n*(1 + ilaenv( 1, 'CGEQRF', ' ', n, 1, n, 0 ) )
464 maxwrk = max( maxwrk, n*( 1 +
465 $ ilaenv( 1, 'CUNMQR', ' ', n, 1, n, -1 ) ) )
466 IF( ilvsl ) THEN
467 maxwrk = max( maxwrk, n*( 1 +
468 $ ilaenv( 1, 'CUNGQR', ' ', n, 1, n, -1 ) ) )
469 END IF
470 lwrk = maxwrk
471 IF( ijob.GE.1 )
472 $ lwrk = max( lwrk, n*n/2 )
473 ELSE
474 minwrk = 1
475 maxwrk = 1
476 lwrk = 1
477 END IF
478 work( 1 ) = sroundup_lwork(lwrk)
479 IF( wantsn .OR. n.EQ.0 ) THEN
480 liwmin = 1
481 ELSE
482 liwmin = n + 2
483 END IF
484 iwork( 1 ) = liwmin
485*
486 IF( lwork.LT.minwrk .AND. .NOT.lquery ) THEN
487 info = -21
488 ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery) THEN
489 info = -24
490 END IF
491 END IF
492*
493 IF( info.NE.0 ) THEN
494 CALL xerbla( 'CGGESX', -info )
495 RETURN
496 ELSE IF (lquery) THEN
497 RETURN
498 END IF
499*
500* Quick return if possible
501*
502 IF( n.EQ.0 ) THEN
503 sdim = 0
504 RETURN
505 END IF
506*
507* Get machine constants
508*
509 eps = slamch( 'P' )
510 smlnum = slamch( 'S' )
511 bignum = one / smlnum
512 smlnum = sqrt( smlnum ) / eps
513 bignum = one / smlnum
514*
515* Scale A if max element outside range [SMLNUM,BIGNUM]
516*
517 anrm = clange( 'M', n, n, a, lda, rwork )
518 ilascl = .false.
519 IF( anrm.GT.zero .AND. anrm.LT.smlnum ) THEN
520 anrmto = smlnum
521 ilascl = .true.
522 ELSE IF( anrm.GT.bignum ) THEN
523 anrmto = bignum
524 ilascl = .true.
525 END IF
526 IF( ilascl )
527 $ CALL clascl( 'G', 0, 0, anrm, anrmto, n, n, a, lda, ierr )
528*
529* Scale B if max element outside range [SMLNUM,BIGNUM]
530*
531 bnrm = clange( 'M', n, n, b, ldb, rwork )
532 ilbscl = .false.
533 IF( bnrm.GT.zero .AND. bnrm.LT.smlnum ) THEN
534 bnrmto = smlnum
535 ilbscl = .true.
536 ELSE IF( bnrm.GT.bignum ) THEN
537 bnrmto = bignum
538 ilbscl = .true.
539 END IF
540 IF( ilbscl )
541 $ CALL clascl( 'G', 0, 0, bnrm, bnrmto, n, n, b, ldb, ierr )
542*
543* Permute the matrix to make it more nearly triangular
544* (Real Workspace: need 6*N)
545*
546 ileft = 1
547 iright = n + 1
548 irwrk = iright + n
549 CALL cggbal( 'P', n, a, lda, b, ldb, ilo, ihi, rwork( ileft ),
550 $ rwork( iright ), rwork( irwrk ), ierr )
551*
552* Reduce B to triangular form (QR decomposition of B)
553* (Complex Workspace: need N, prefer N*NB)
554*
555 irows = ihi + 1 - ilo
556 icols = n + 1 - ilo
557 itau = 1
558 iwrk = itau + irows
559 CALL cgeqrf( irows, icols, b( ilo, ilo ), ldb, work( itau ),
560 $ work( iwrk ), lwork+1-iwrk, ierr )
561*
562* Apply the unitary transformation to matrix A
563* (Complex Workspace: need N, prefer N*NB)
564*
565 CALL cunmqr( 'L', 'C', irows, icols, irows, b( ilo, ilo ), ldb,
566 $ work( itau ), a( ilo, ilo ), lda, work( iwrk ),
567 $ lwork+1-iwrk, ierr )
568*
569* Initialize VSL
570* (Complex Workspace: need N, prefer N*NB)
571*
572 IF( ilvsl ) THEN
573 CALL claset( 'Full', n, n, czero, cone, vsl, ldvsl )
574 IF( irows.GT.1 ) THEN
575 CALL clacpy( 'L', irows-1, irows-1, b( ilo+1, ilo ), ldb,
576 $ vsl( ilo+1, ilo ), ldvsl )
577 END IF
578 CALL cungqr( irows, irows, irows, vsl( ilo, ilo ), ldvsl,
579 $ work( itau ), work( iwrk ), lwork+1-iwrk, ierr )
580 END IF
581*
582* Initialize VSR
583*
584 IF( ilvsr )
585 $ CALL claset( 'Full', n, n, czero, cone, vsr, ldvsr )
586*
587* Reduce to generalized Hessenberg form
588* (Workspace: none needed)
589*
590 CALL cgghrd( jobvsl, jobvsr, n, ilo, ihi, a, lda, b, ldb, vsl,
591 $ ldvsl, vsr, ldvsr, ierr )
592*
593 sdim = 0
594*
595* Perform QZ algorithm, computing Schur vectors if desired
596* (Complex Workspace: need N)
597* (Real Workspace: need N)
598*
599 iwrk = itau
600 CALL chgeqz( 'S', jobvsl, jobvsr, n, ilo, ihi, a, lda, b, ldb,
601 $ alpha, beta, vsl, ldvsl, vsr, ldvsr, work( iwrk ),
602 $ lwork+1-iwrk, rwork( irwrk ), ierr )
603 IF( ierr.NE.0 ) THEN
604 IF( ierr.GT.0 .AND. ierr.LE.n ) THEN
605 info = ierr
606 ELSE IF( ierr.GT.n .AND. ierr.LE.2*n ) THEN
607 info = ierr - n
608 ELSE
609 info = n + 1
610 END IF
611 GO TO 40
612 END IF
613*
614* Sort eigenvalues ALPHA/BETA and compute the reciprocal of
615* condition number(s)
616*
617 IF( wantst ) THEN
618*
619* Undo scaling on eigenvalues before SELCTGing
620*
621 IF( ilascl )
622 $ CALL clascl( 'G', 0, 0, anrmto, anrm, n, 1, alpha, n, ierr )
623 IF( ilbscl )
624 $ CALL clascl( 'G', 0, 0, bnrmto, bnrm, n, 1, beta, n, ierr )
625*
626* Select eigenvalues
627*
628 DO 10 i = 1, n
629 bwork( i ) = selctg( alpha( i ), beta( i ) )
630 10 CONTINUE
631*
632* Reorder eigenvalues, transform Generalized Schur vectors, and
633* compute reciprocal condition numbers
634* (Complex Workspace: If IJOB >= 1, need MAX(1, 2*SDIM*(N-SDIM))
635* otherwise, need 1 )
636*
637 CALL ctgsen( ijob, ilvsl, ilvsr, bwork, n, a, lda, b, ldb,
638 $ alpha, beta, vsl, ldvsl, vsr, ldvsr, sdim, pl, pr,
639 $ dif, work( iwrk ), lwork-iwrk+1, iwork, liwork,
640 $ ierr )
641*
642 IF( ijob.GE.1 )
643 $ maxwrk = max( maxwrk, 2*sdim*( n-sdim ) )
644 IF( ierr.EQ.-21 ) THEN
645*
646* not enough complex workspace
647*
648 info = -21
649 ELSE
650 IF( ijob.EQ.1 .OR. ijob.EQ.4 ) THEN
651 rconde( 1 ) = pl
652 rconde( 2 ) = pr
653 END IF
654 IF( ijob.EQ.2 .OR. ijob.EQ.4 ) THEN
655 rcondv( 1 ) = dif( 1 )
656 rcondv( 2 ) = dif( 2 )
657 END IF
658 IF( ierr.EQ.1 )
659 $ info = n + 3
660 END IF
661*
662 END IF
663*
664* Apply permutation to VSL and VSR
665* (Workspace: none needed)
666*
667 IF( ilvsl )
668 $ CALL cggbak( 'P', 'L', n, ilo, ihi, rwork( ileft ),
669 $ rwork( iright ), n, vsl, ldvsl, ierr )
670*
671 IF( ilvsr )
672 $ CALL cggbak( 'P', 'R', n, ilo, ihi, rwork( ileft ),
673 $ rwork( iright ), n, vsr, ldvsr, ierr )
674*
675* Undo scaling
676*
677 IF( ilascl ) THEN
678 CALL clascl( 'U', 0, 0, anrmto, anrm, n, n, a, lda, ierr )
679 CALL clascl( 'G', 0, 0, anrmto, anrm, n, 1, alpha, n, ierr )
680 END IF
681*
682 IF( ilbscl ) THEN
683 CALL clascl( 'U', 0, 0, bnrmto, bnrm, n, n, b, ldb, ierr )
684 CALL clascl( 'G', 0, 0, bnrmto, bnrm, n, 1, beta, n, ierr )
685 END IF
686*
687 IF( wantst ) THEN
688*
689* Check if reordering is correct
690*
691 lastsl = .true.
692 sdim = 0
693 DO 30 i = 1, n
694 cursl = selctg( alpha( i ), beta( i ) )
695 IF( cursl )
696 $ sdim = sdim + 1
697 IF( cursl .AND. .NOT.lastsl )
698 $ info = n + 2
699 lastsl = cursl
700 30 CONTINUE
701*
702 END IF
703*
704 40 CONTINUE
705*
706 work( 1 ) = sroundup_lwork(maxwrk)
707 iwork( 1 ) = liwmin
708*
709 RETURN
710*
711* End of CGGESX
712*
713 END
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine cgeqrf(m, n, a, lda, tau, work, lwork, info)
CGEQRF
Definition cgeqrf.f:146
subroutine cggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
CGGBAK
Definition cggbak.f:148
subroutine cggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
CGGBAL
Definition cggbal.f:177
subroutine cggesx(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, bwork, info)
CGGESX computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE ...
Definition cggesx.f:330
subroutine cgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
CGGHRD
Definition cgghrd.f:204
subroutine chgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)
CHGEQZ
Definition chgeqz.f:284
subroutine clacpy(uplo, m, n, a, lda, b, ldb)
CLACPY copies all or part of one two-dimensional array to another.
Definition clacpy.f:103
subroutine clascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)
CLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition clascl.f:143
subroutine claset(uplo, m, n, alpha, beta, a, lda)
CLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition claset.f:106
subroutine ctgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)
CTGSEN
Definition ctgsen.f:433
subroutine cungqr(m, n, k, a, lda, tau, work, lwork, info)
CUNGQR
Definition cungqr.f:128
subroutine cunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
CUNMQR
Definition cunmqr.f:168