LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
cdrgsx.f
Go to the documentation of this file.
1*> \brief \b CDRGSX
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8* Definition:
9* ===========
10*
11* SUBROUTINE CDRGSX( NSIZE, NCMAX, THRESH, NIN, NOUT, A, LDA, B,
12* AI, BI, Z, Q, ALPHA, BETA, C, LDC, S, WORK,
13* LWORK, RWORK, IWORK, LIWORK, BWORK, INFO )
14*
15* .. Scalar Arguments ..
16* INTEGER INFO, LDA, LDC, LIWORK, LWORK, NCMAX, NIN,
17* $ NOUT, NSIZE
18* REAL THRESH
19* ..
20* .. Array Arguments ..
21* LOGICAL BWORK( * )
22* INTEGER IWORK( * )
23* REAL RWORK( * ), S( * )
24* COMPLEX A( LDA, * ), AI( LDA, * ), ALPHA( * ),
25* $ B( LDA, * ), BETA( * ), BI( LDA, * ),
26* $ C( LDC, * ), Q( LDA, * ), WORK( * ),
27* $ Z( LDA, * )
28* ..
29*
30*
31*> \par Purpose:
32* =============
33*>
34*> \verbatim
35*>
36*> CDRGSX checks the nonsymmetric generalized eigenvalue (Schur form)
37*> problem expert driver CGGESX.
38*>
39*> CGGES factors A and B as Q*S*Z' and Q*T*Z' , where ' means conjugate
40*> transpose, S and T are upper triangular (i.e., in generalized Schur
41*> form), and Q and Z are unitary. It also computes the generalized
42*> eigenvalues (alpha(j),beta(j)), j=1,...,n. Thus,
43*> w(j) = alpha(j)/beta(j) is a root of the characteristic equation
44*>
45*> det( A - w(j) B ) = 0
46*>
47*> Optionally it also reorders the eigenvalues so that a selected
48*> cluster of eigenvalues appears in the leading diagonal block of the
49*> Schur forms; computes a reciprocal condition number for the average
50*> of the selected eigenvalues; and computes a reciprocal condition
51*> number for the right and left deflating subspaces corresponding to
52*> the selected eigenvalues.
53*>
54*> When CDRGSX is called with NSIZE > 0, five (5) types of built-in
55*> matrix pairs are used to test the routine CGGESX.
56*>
57*> When CDRGSX is called with NSIZE = 0, it reads in test matrix data
58*> to test CGGESX.
59*> (need more details on what kind of read-in data are needed).
60*>
61*> For each matrix pair, the following tests will be performed and
62*> compared with the threshold THRESH except for the tests (7) and (9):
63*>
64*> (1) | A - Q S Z' | / ( |A| n ulp )
65*>
66*> (2) | B - Q T Z' | / ( |B| n ulp )
67*>
68*> (3) | I - QQ' | / ( n ulp )
69*>
70*> (4) | I - ZZ' | / ( n ulp )
71*>
72*> (5) if A is in Schur form (i.e. triangular form)
73*>
74*> (6) maximum over j of D(j) where:
75*>
76*> |alpha(j) - S(j,j)| |beta(j) - T(j,j)|
77*> D(j) = ------------------------ + -----------------------
78*> max(|alpha(j)|,|S(j,j)|) max(|beta(j)|,|T(j,j)|)
79*>
80*> (7) if sorting worked and SDIM is the number of eigenvalues
81*> which were selected.
82*>
83*> (8) the estimated value DIF does not differ from the true values of
84*> Difu and Difl more than a factor 10*THRESH. If the estimate DIF
85*> equals zero the corresponding true values of Difu and Difl
86*> should be less than EPS*norm(A, B). If the true value of Difu
87*> and Difl equal zero, the estimate DIF should be less than
88*> EPS*norm(A, B).
89*>
90*> (9) If INFO = N+3 is returned by CGGESX, the reordering "failed"
91*> and we check that DIF = PL = PR = 0 and that the true value of
92*> Difu and Difl is < EPS*norm(A, B). We count the events when
93*> INFO=N+3.
94*>
95*> For read-in test matrices, the same tests are run except that the
96*> exact value for DIF (and PL) is input data. Additionally, there is
97*> one more test run for read-in test matrices:
98*>
99*> (10) the estimated value PL does not differ from the true value of
100*> PLTRU more than a factor THRESH. If the estimate PL equals
101*> zero the corresponding true value of PLTRU should be less than
102*> EPS*norm(A, B). If the true value of PLTRU equal zero, the
103*> estimate PL should be less than EPS*norm(A, B).
104*>
105*> Note that for the built-in tests, a total of 10*NSIZE*(NSIZE-1)
106*> matrix pairs are generated and tested. NSIZE should be kept small.
107*>
108*> SVD (routine CGESVD) is used for computing the true value of DIF_u
109*> and DIF_l when testing the built-in test problems.
110*>
111*> Built-in Test Matrices
112*> ======================
113*>
114*> All built-in test matrices are the 2 by 2 block of triangular
115*> matrices
116*>
117*> A = [ A11 A12 ] and B = [ B11 B12 ]
118*> [ A22 ] [ B22 ]
119*>
120*> where for different type of A11 and A22 are given as the following.
121*> A12 and B12 are chosen so that the generalized Sylvester equation
122*>
123*> A11*R - L*A22 = -A12
124*> B11*R - L*B22 = -B12
125*>
126*> have prescribed solution R and L.
127*>
128*> Type 1: A11 = J_m(1,-1) and A_22 = J_k(1-a,1).
129*> B11 = I_m, B22 = I_k
130*> where J_k(a,b) is the k-by-k Jordan block with ``a'' on
131*> diagonal and ``b'' on superdiagonal.
132*>
133*> Type 2: A11 = (a_ij) = ( 2(.5-sin(i)) ) and
134*> B11 = (b_ij) = ( 2(.5-sin(ij)) ) for i=1,...,m, j=i,...,m
135*> A22 = (a_ij) = ( 2(.5-sin(i+j)) ) and
136*> B22 = (b_ij) = ( 2(.5-sin(ij)) ) for i=m+1,...,k, j=i,...,k
137*>
138*> Type 3: A11, A22 and B11, B22 are chosen as for Type 2, but each
139*> second diagonal block in A_11 and each third diagonal block
140*> in A_22 are made as 2 by 2 blocks.
141*>
142*> Type 4: A11 = ( 20(.5 - sin(ij)) ) and B22 = ( 2(.5 - sin(i+j)) )
143*> for i=1,...,m, j=1,...,m and
144*> A22 = ( 20(.5 - sin(i+j)) ) and B22 = ( 2(.5 - sin(ij)) )
145*> for i=m+1,...,k, j=m+1,...,k
146*>
147*> Type 5: (A,B) and have potentially close or common eigenvalues and
148*> very large departure from block diagonality A_11 is chosen
149*> as the m x m leading submatrix of A_1:
150*> | 1 b |
151*> | -b 1 |
152*> | 1+d b |
153*> | -b 1+d |
154*> A_1 = | d 1 |
155*> | -1 d |
156*> | -d 1 |
157*> | -1 -d |
158*> | 1 |
159*> and A_22 is chosen as the k x k leading submatrix of A_2:
160*> | -1 b |
161*> | -b -1 |
162*> | 1-d b |
163*> | -b 1-d |
164*> A_2 = | d 1+b |
165*> | -1-b d |
166*> | -d 1+b |
167*> | -1+b -d |
168*> | 1-d |
169*> and matrix B are chosen as identity matrices (see SLATM5).
170*>
171*> \endverbatim
172*
173* Arguments:
174* ==========
175*
176*> \param[in] NSIZE
177*> \verbatim
178*> NSIZE is INTEGER
179*> The maximum size of the matrices to use. NSIZE >= 0.
180*> If NSIZE = 0, no built-in tests matrices are used, but
181*> read-in test matrices are used to test SGGESX.
182*> \endverbatim
183*>
184*> \param[in] NCMAX
185*> \verbatim
186*> NCMAX is INTEGER
187*> Maximum allowable NMAX for generating Kroneker matrix
188*> in call to CLAKF2
189*> \endverbatim
190*>
191*> \param[in] THRESH
192*> \verbatim
193*> THRESH is REAL
194*> A test will count as "failed" if the "error", computed as
195*> described above, exceeds THRESH. Note that the error
196*> is scaled to be O(1), so THRESH should be a reasonably
197*> small multiple of 1, e.g., 10 or 100. In particular,
198*> it should not depend on the precision (single vs. double)
199*> or the size of the matrix. THRESH >= 0.
200*> \endverbatim
201*>
202*> \param[in] NIN
203*> \verbatim
204*> NIN is INTEGER
205*> The FORTRAN unit number for reading in the data file of
206*> problems to solve.
207*> \endverbatim
208*>
209*> \param[in] NOUT
210*> \verbatim
211*> NOUT is INTEGER
212*> The FORTRAN unit number for printing out error messages
213*> (e.g., if a routine returns INFO not equal to 0.)
214*> \endverbatim
215*>
216*> \param[out] A
217*> \verbatim
218*> A is COMPLEX array, dimension (LDA, NSIZE)
219*> Used to store the matrix whose eigenvalues are to be
220*> computed. On exit, A contains the last matrix actually used.
221*> \endverbatim
222*>
223*> \param[in] LDA
224*> \verbatim
225*> LDA is INTEGER
226*> The leading dimension of A, B, AI, BI, Z and Q,
227*> LDA >= max( 1, NSIZE ). For the read-in test,
228*> LDA >= max( 1, N ), N is the size of the test matrices.
229*> \endverbatim
230*>
231*> \param[out] B
232*> \verbatim
233*> B is COMPLEX array, dimension (LDA, NSIZE)
234*> Used to store the matrix whose eigenvalues are to be
235*> computed. On exit, B contains the last matrix actually used.
236*> \endverbatim
237*>
238*> \param[out] AI
239*> \verbatim
240*> AI is COMPLEX array, dimension (LDA, NSIZE)
241*> Copy of A, modified by CGGESX.
242*> \endverbatim
243*>
244*> \param[out] BI
245*> \verbatim
246*> BI is COMPLEX array, dimension (LDA, NSIZE)
247*> Copy of B, modified by CGGESX.
248*> \endverbatim
249*>
250*> \param[out] Z
251*> \verbatim
252*> Z is COMPLEX array, dimension (LDA, NSIZE)
253*> Z holds the left Schur vectors computed by CGGESX.
254*> \endverbatim
255*>
256*> \param[out] Q
257*> \verbatim
258*> Q is COMPLEX array, dimension (LDA, NSIZE)
259*> Q holds the right Schur vectors computed by CGGESX.
260*> \endverbatim
261*>
262*> \param[out] ALPHA
263*> \verbatim
264*> ALPHA is COMPLEX array, dimension (NSIZE)
265*> \endverbatim
266*>
267*> \param[out] BETA
268*> \verbatim
269*> BETA is COMPLEX array, dimension (NSIZE)
270*>
271*> On exit, ALPHA/BETA are the eigenvalues.
272*> \endverbatim
273*>
274*> \param[out] C
275*> \verbatim
276*> C is COMPLEX array, dimension (LDC, LDC)
277*> Store the matrix generated by subroutine CLAKF2, this is the
278*> matrix formed by Kronecker products used for estimating
279*> DIF.
280*> \endverbatim
281*>
282*> \param[in] LDC
283*> \verbatim
284*> LDC is INTEGER
285*> The leading dimension of C. LDC >= max(1, LDA*LDA/2 ).
286*> \endverbatim
287*>
288*> \param[out] S
289*> \verbatim
290*> S is REAL array, dimension (LDC)
291*> Singular values of C
292*> \endverbatim
293*>
294*> \param[out] WORK
295*> \verbatim
296*> WORK is COMPLEX array, dimension (LWORK)
297*> \endverbatim
298*>
299*> \param[in] LWORK
300*> \verbatim
301*> LWORK is INTEGER
302*> The dimension of the array WORK. LWORK >= 3*NSIZE*NSIZE/2
303*> \endverbatim
304*>
305*> \param[out] RWORK
306*> \verbatim
307*> RWORK is REAL array,
308*> dimension (5*NSIZE*NSIZE/2 - 4)
309*> \endverbatim
310*>
311*> \param[out] IWORK
312*> \verbatim
313*> IWORK is INTEGER array, dimension (LIWORK)
314*> \endverbatim
315*>
316*> \param[in] LIWORK
317*> \verbatim
318*> LIWORK is INTEGER
319*> The dimension of the array IWORK. LIWORK >= NSIZE + 2.
320*> \endverbatim
321*>
322*> \param[out] BWORK
323*> \verbatim
324*> BWORK is LOGICAL array, dimension (NSIZE)
325*> \endverbatim
326*>
327*> \param[out] INFO
328*> \verbatim
329*> INFO is INTEGER
330*> = 0: successful exit
331*> < 0: if INFO = -i, the i-th argument had an illegal value.
332*> > 0: A routine returned an error code.
333*> \endverbatim
334*
335* Authors:
336* ========
337*
338*> \author Univ. of Tennessee
339*> \author Univ. of California Berkeley
340*> \author Univ. of Colorado Denver
341*> \author NAG Ltd.
342*
343*> \ingroup complex_eig
344*
345* =====================================================================
346 SUBROUTINE cdrgsx( NSIZE, NCMAX, THRESH, NIN, NOUT, A, LDA, B,
347 $ AI, BI, Z, Q, ALPHA, BETA, C, LDC, S, WORK,
348 $ LWORK, RWORK, IWORK, LIWORK, BWORK, INFO )
349*
350* -- LAPACK test routine --
351* -- LAPACK is a software package provided by Univ. of Tennessee, --
352* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
353*
354* .. Scalar Arguments ..
355 INTEGER INFO, LDA, LDC, LIWORK, LWORK, NCMAX, NIN,
356 $ NOUT, NSIZE
357 REAL THRESH
358* ..
359* .. Array Arguments ..
360 LOGICAL BWORK( * )
361 INTEGER IWORK( * )
362 REAL RWORK( * ), S( * )
363 COMPLEX A( LDA, * ), AI( LDA, * ), ALPHA( * ),
364 $ b( lda, * ), beta( * ), bi( lda, * ),
365 $ c( ldc, * ), q( lda, * ), work( * ),
366 $ z( lda, * )
367* ..
368*
369* =====================================================================
370*
371* .. Parameters ..
372 REAL ZERO, ONE, TEN
373 PARAMETER ( ZERO = 0.0e+0, one = 1.0e+0, ten = 1.0e+1 )
374 COMPLEX CZERO
375 parameter( czero = ( 0.0e+0, 0.0e+0 ) )
376* ..
377* .. Local Scalars ..
378 LOGICAL ILABAD
379 CHARACTER SENSE
380 INTEGER BDSPAC, I, IFUNC, J, LINFO, MAXWRK, MINWRK, MM,
381 $ mn2, nerrs, nptknt, ntest, ntestt, prtype, qba,
382 $ qbb
383 REAL ABNRM, BIGNUM, DIFTRU, PLTRU, SMLNUM, TEMP1,
384 $ TEMP2, THRSH2, ULP, ULPINV, WEIGHT
385 COMPLEX X
386* ..
387* .. Local Arrays ..
388 REAL DIFEST( 2 ), PL( 2 ), RESULT( 10 )
389* ..
390* .. External Functions ..
391 LOGICAL CLCTSX
392 INTEGER ILAENV
393 REAL CLANGE, SLAMCH
394 EXTERNAL clctsx, ilaenv, clange, slamch
395* ..
396* .. External Subroutines ..
397 EXTERNAL alasvm, cgesvd, cget51, cggesx, clacpy, clakf2,
399* ..
400* .. Scalars in Common ..
401 LOGICAL FS
402 INTEGER K, M, MPLUSN, N
403* ..
404* .. Common blocks ..
405 COMMON / mn / m, n, mplusn, k, fs
406* ..
407* .. Intrinsic Functions ..
408 INTRINSIC abs, aimag, max, real, sqrt
409* ..
410* .. Statement Functions ..
411 REAL ABS1
412* ..
413* .. Statement Function definitions ..
414 abs1( x ) = abs( real( x ) ) + abs( aimag( x ) )
415* ..
416* .. Executable Statements ..
417*
418* Check for errors
419*
420 IF( nsize.LT.0 ) THEN
421 info = -1
422 ELSE IF( thresh.LT.zero ) THEN
423 info = -2
424 ELSE IF( nin.LE.0 ) THEN
425 info = -3
426 ELSE IF( nout.LE.0 ) THEN
427 info = -4
428 ELSE IF( lda.LT.1 .OR. lda.LT.nsize ) THEN
429 info = -6
430 ELSE IF( ldc.LT.1 .OR. ldc.LT.nsize*nsize / 2 ) THEN
431 info = -15
432 ELSE IF( liwork.LT.nsize+2 ) THEN
433 info = -21
434 END IF
435*
436* Compute workspace
437* (Note: Comments in the code beginning "Workspace:" describe the
438* minimal amount of workspace needed at that point in the code,
439* as well as the preferred amount for good performance.
440* NB refers to the optimal block size for the immediately
441* following subroutine, as returned by ILAENV.)
442*
443 minwrk = 1
444 IF( info.EQ.0 .AND. lwork.GE.1 ) THEN
445 minwrk = 3*nsize*nsize / 2
446*
447* workspace for cggesx
448*
449 maxwrk = nsize*( 1+ilaenv( 1, 'CGEQRF', ' ', nsize, 1, nsize,
450 $ 0 ) )
451 maxwrk = max( maxwrk, nsize*( 1+ilaenv( 1, 'CUNGQR', ' ',
452 $ nsize, 1, nsize, -1 ) ) )
453*
454* workspace for cgesvd
455*
456 bdspac = 3*nsize*nsize / 2
457 maxwrk = max( maxwrk, nsize*nsize*
458 $ ( 1+ilaenv( 1, 'CGEBRD', ' ', nsize*nsize / 2,
459 $ nsize*nsize / 2, -1, -1 ) ) )
460 maxwrk = max( maxwrk, bdspac )
461*
462 maxwrk = max( maxwrk, minwrk )
463*
464 work( 1 ) = maxwrk
465 END IF
466*
467 IF( lwork.LT.minwrk )
468 $ info = -18
469*
470 IF( info.NE.0 ) THEN
471 CALL xerbla( 'CDRGSX', -info )
472 RETURN
473 END IF
474*
475* Important constants
476*
477 ulp = slamch( 'P' )
478 ulpinv = one / ulp
479 smlnum = slamch( 'S' ) / ulp
480 bignum = one / smlnum
481 thrsh2 = ten*thresh
482 ntestt = 0
483 nerrs = 0
484*
485* Go to the tests for read-in matrix pairs
486*
487 ifunc = 0
488 IF( nsize.EQ.0 )
489 $ GO TO 70
490*
491* Test the built-in matrix pairs.
492* Loop over different functions (IFUNC) of CGGESX, types (PRTYPE)
493* of test matrices, different size (M+N)
494*
495 prtype = 0
496 qba = 3
497 qbb = 4
498 weight = sqrt( ulp )
499*
500 DO 60 ifunc = 0, 3
501 DO 50 prtype = 1, 5
502 DO 40 m = 1, nsize - 1
503 DO 30 n = 1, nsize - m
504*
505 weight = one / weight
506 mplusn = m + n
507*
508* Generate test matrices
509*
510 fs = .true.
511 k = 0
512*
513 CALL claset( 'Full', mplusn, mplusn, czero, czero, ai,
514 $ lda )
515 CALL claset( 'Full', mplusn, mplusn, czero, czero, bi,
516 $ lda )
517*
518 CALL clatm5( prtype, m, n, ai, lda, ai( m+1, m+1 ),
519 $ lda, ai( 1, m+1 ), lda, bi, lda,
520 $ bi( m+1, m+1 ), lda, bi( 1, m+1 ), lda,
521 $ q, lda, z, lda, weight, qba, qbb )
522*
523* Compute the Schur factorization and swapping the
524* m-by-m (1,1)-blocks with n-by-n (2,2)-blocks.
525* Swapping is accomplished via the function CLCTSX
526* which is supplied below.
527*
528 IF( ifunc.EQ.0 ) THEN
529 sense = 'N'
530 ELSE IF( ifunc.EQ.1 ) THEN
531 sense = 'E'
532 ELSE IF( ifunc.EQ.2 ) THEN
533 sense = 'V'
534 ELSE IF( ifunc.EQ.3 ) THEN
535 sense = 'B'
536 END IF
537*
538 CALL clacpy( 'Full', mplusn, mplusn, ai, lda, a, lda )
539 CALL clacpy( 'Full', mplusn, mplusn, bi, lda, b, lda )
540*
541 CALL cggesx( 'V', 'V', 'S', clctsx, sense, mplusn, ai,
542 $ lda, bi, lda, mm, alpha, beta, q, lda, z,
543 $ lda, pl, difest, work, lwork, rwork,
544 $ iwork, liwork, bwork, linfo )
545*
546 IF( linfo.NE.0 .AND. linfo.NE.mplusn+2 ) THEN
547 result( 1 ) = ulpinv
548 WRITE( nout, fmt = 9999 )'CGGESX', linfo, mplusn,
549 $ prtype
550 info = linfo
551 GO TO 30
552 END IF
553*
554* Compute the norm(A, B)
555*
556 CALL clacpy( 'Full', mplusn, mplusn, ai, lda, work,
557 $ mplusn )
558 CALL clacpy( 'Full', mplusn, mplusn, bi, lda,
559 $ work( mplusn*mplusn+1 ), mplusn )
560 abnrm = clange( 'Fro', mplusn, 2*mplusn, work, mplusn,
561 $ rwork )
562*
563* Do tests (1) to (4)
564*
565 result( 2 ) = zero
566 CALL cget51( 1, mplusn, a, lda, ai, lda, q, lda, z,
567 $ lda, work, rwork, result( 1 ) )
568 CALL cget51( 1, mplusn, b, lda, bi, lda, q, lda, z,
569 $ lda, work, rwork, result( 2 ) )
570 CALL cget51( 3, mplusn, b, lda, bi, lda, q, lda, q,
571 $ lda, work, rwork, result( 3 ) )
572 CALL cget51( 3, mplusn, b, lda, bi, lda, z, lda, z,
573 $ lda, work, rwork, result( 4 ) )
574 ntest = 4
575*
576* Do tests (5) and (6): check Schur form of A and
577* compare eigenvalues with diagonals.
578*
579 temp1 = zero
580 result( 5 ) = zero
581 result( 6 ) = zero
582*
583 DO 10 j = 1, mplusn
584 ilabad = .false.
585 temp2 = ( abs1( alpha( j )-ai( j, j ) ) /
586 $ max( smlnum, abs1( alpha( j ) ),
587 $ abs1( ai( j, j ) ) )+
588 $ abs1( beta( j )-bi( j, j ) ) /
589 $ max( smlnum, abs1( beta( j ) ),
590 $ abs1( bi( j, j ) ) ) ) / ulp
591 IF( j.LT.mplusn ) THEN
592 IF( ai( j+1, j ).NE.zero ) THEN
593 ilabad = .true.
594 result( 5 ) = ulpinv
595 END IF
596 END IF
597 IF( j.GT.1 ) THEN
598 IF( ai( j, j-1 ).NE.zero ) THEN
599 ilabad = .true.
600 result( 5 ) = ulpinv
601 END IF
602 END IF
603 temp1 = max( temp1, temp2 )
604 IF( ilabad ) THEN
605 WRITE( nout, fmt = 9997 )j, mplusn, prtype
606 END IF
607 10 CONTINUE
608 result( 6 ) = temp1
609 ntest = ntest + 2
610*
611* Test (7) (if sorting worked)
612*
613 result( 7 ) = zero
614 IF( linfo.EQ.mplusn+3 ) THEN
615 result( 7 ) = ulpinv
616 ELSE IF( mm.NE.n ) THEN
617 result( 7 ) = ulpinv
618 END IF
619 ntest = ntest + 1
620*
621* Test (8): compare the estimated value DIF and its
622* value. first, compute the exact DIF.
623*
624 result( 8 ) = zero
625 mn2 = mm*( mplusn-mm )*2
626 IF( ifunc.GE.2 .AND. mn2.LE.ncmax*ncmax ) THEN
627*
628* Note: for either following two cases, there are
629* almost same number of test cases fail the test.
630*
631 CALL clakf2( mm, mplusn-mm, ai, lda,
632 $ ai( mm+1, mm+1 ), bi,
633 $ bi( mm+1, mm+1 ), c, ldc )
634*
635 CALL cgesvd( 'N', 'N', mn2, mn2, c, ldc, s, work,
636 $ 1, work( 2 ), 1, work( 3 ), lwork-2,
637 $ rwork, info )
638 diftru = s( mn2 )
639*
640 IF( difest( 2 ).EQ.zero ) THEN
641 IF( diftru.GT.abnrm*ulp )
642 $ result( 8 ) = ulpinv
643 ELSE IF( diftru.EQ.zero ) THEN
644 IF( difest( 2 ).GT.abnrm*ulp )
645 $ result( 8 ) = ulpinv
646 ELSE IF( ( diftru.GT.thrsh2*difest( 2 ) ) .OR.
647 $ ( diftru*thrsh2.LT.difest( 2 ) ) ) THEN
648 result( 8 ) = max( diftru / difest( 2 ),
649 $ difest( 2 ) / diftru )
650 END IF
651 ntest = ntest + 1
652 END IF
653*
654* Test (9)
655*
656 result( 9 ) = zero
657 IF( linfo.EQ.( mplusn+2 ) ) THEN
658 IF( diftru.GT.abnrm*ulp )
659 $ result( 9 ) = ulpinv
660 IF( ( ifunc.GT.1 ) .AND. ( difest( 2 ).NE.zero ) )
661 $ result( 9 ) = ulpinv
662 IF( ( ifunc.EQ.1 ) .AND. ( pl( 1 ).NE.zero ) )
663 $ result( 9 ) = ulpinv
664 ntest = ntest + 1
665 END IF
666*
667 ntestt = ntestt + ntest
668*
669* Print out tests which fail.
670*
671 DO 20 j = 1, 9
672 IF( result( j ).GE.thresh ) THEN
673*
674* If this is the first test to fail,
675* print a header to the data file.
676*
677 IF( nerrs.EQ.0 ) THEN
678 WRITE( nout, fmt = 9996 )'CGX'
679*
680* Matrix types
681*
682 WRITE( nout, fmt = 9994 )
683*
684* Tests performed
685*
686 WRITE( nout, fmt = 9993 )'unitary', '''',
687 $ 'transpose', ( '''', i = 1, 4 )
688*
689 END IF
690 nerrs = nerrs + 1
691 IF( result( j ).LT.10000.0 ) THEN
692 WRITE( nout, fmt = 9992 )mplusn, prtype,
693 $ weight, m, j, result( j )
694 ELSE
695 WRITE( nout, fmt = 9991 )mplusn, prtype,
696 $ weight, m, j, result( j )
697 END IF
698 END IF
699 20 CONTINUE
700*
701 30 CONTINUE
702 40 CONTINUE
703 50 CONTINUE
704 60 CONTINUE
705*
706 GO TO 150
707*
708 70 CONTINUE
709*
710* Read in data from file to check accuracy of condition estimation
711* Read input data until N=0
712*
713 nptknt = 0
714*
715 80 CONTINUE
716 READ( nin, fmt = *, END = 140 )mplusn
717 IF( mplusn.EQ.0 )
718 $ GO TO 140
719 READ( nin, fmt = *, END = 140 )n
720 DO 90 i = 1, mplusn
721 READ( nin, fmt = * )( ai( i, j ), j = 1, mplusn )
722 90 CONTINUE
723 DO 100 i = 1, mplusn
724 READ( nin, fmt = * )( bi( i, j ), j = 1, mplusn )
725 100 CONTINUE
726 READ( nin, fmt = * )pltru, diftru
727*
728 nptknt = nptknt + 1
729 fs = .true.
730 k = 0
731 m = mplusn - n
732*
733 CALL clacpy( 'Full', mplusn, mplusn, ai, lda, a, lda )
734 CALL clacpy( 'Full', mplusn, mplusn, bi, lda, b, lda )
735*
736* Compute the Schur factorization while swapping the
737* m-by-m (1,1)-blocks with n-by-n (2,2)-blocks.
738*
739 CALL cggesx( 'V', 'V', 'S', clctsx, 'B', mplusn, ai, lda, bi, lda,
740 $ mm, alpha, beta, q, lda, z, lda, pl, difest, work,
741 $ lwork, rwork, iwork, liwork, bwork, linfo )
742*
743 IF( linfo.NE.0 .AND. linfo.NE.mplusn+2 ) THEN
744 result( 1 ) = ulpinv
745 WRITE( nout, fmt = 9998 )'CGGESX', linfo, mplusn, nptknt
746 GO TO 130
747 END IF
748*
749* Compute the norm(A, B)
750* (should this be norm of (A,B) or (AI,BI)?)
751*
752 CALL clacpy( 'Full', mplusn, mplusn, ai, lda, work, mplusn )
753 CALL clacpy( 'Full', mplusn, mplusn, bi, lda,
754 $ work( mplusn*mplusn+1 ), mplusn )
755 abnrm = clange( 'Fro', mplusn, 2*mplusn, work, mplusn, rwork )
756*
757* Do tests (1) to (4)
758*
759 CALL cget51( 1, mplusn, a, lda, ai, lda, q, lda, z, lda, work,
760 $ rwork, result( 1 ) )
761 CALL cget51( 1, mplusn, b, lda, bi, lda, q, lda, z, lda, work,
762 $ rwork, result( 2 ) )
763 CALL cget51( 3, mplusn, b, lda, bi, lda, q, lda, q, lda, work,
764 $ rwork, result( 3 ) )
765 CALL cget51( 3, mplusn, b, lda, bi, lda, z, lda, z, lda, work,
766 $ rwork, result( 4 ) )
767*
768* Do tests (5) and (6): check Schur form of A and compare
769* eigenvalues with diagonals.
770*
771 ntest = 6
772 temp1 = zero
773 result( 5 ) = zero
774 result( 6 ) = zero
775*
776 DO 110 j = 1, mplusn
777 ilabad = .false.
778 temp2 = ( abs1( alpha( j )-ai( j, j ) ) /
779 $ max( smlnum, abs1( alpha( j ) ), abs1( ai( j, j ) ) )+
780 $ abs1( beta( j )-bi( j, j ) ) /
781 $ max( smlnum, abs1( beta( j ) ), abs1( bi( j, j ) ) ) )
782 $ / ulp
783 IF( j.LT.mplusn ) THEN
784 IF( ai( j+1, j ).NE.zero ) THEN
785 ilabad = .true.
786 result( 5 ) = ulpinv
787 END IF
788 END IF
789 IF( j.GT.1 ) THEN
790 IF( ai( j, j-1 ).NE.zero ) THEN
791 ilabad = .true.
792 result( 5 ) = ulpinv
793 END IF
794 END IF
795 temp1 = max( temp1, temp2 )
796 IF( ilabad ) THEN
797 WRITE( nout, fmt = 9997 )j, mplusn, nptknt
798 END IF
799 110 CONTINUE
800 result( 6 ) = temp1
801*
802* Test (7) (if sorting worked) <--------- need to be checked.
803*
804 ntest = 7
805 result( 7 ) = zero
806 IF( linfo.EQ.mplusn+3 )
807 $ result( 7 ) = ulpinv
808*
809* Test (8): compare the estimated value of DIF and its true value.
810*
811 ntest = 8
812 result( 8 ) = zero
813 IF( difest( 2 ).EQ.zero ) THEN
814 IF( diftru.GT.abnrm*ulp )
815 $ result( 8 ) = ulpinv
816 ELSE IF( diftru.EQ.zero ) THEN
817 IF( difest( 2 ).GT.abnrm*ulp )
818 $ result( 8 ) = ulpinv
819 ELSE IF( ( diftru.GT.thrsh2*difest( 2 ) ) .OR.
820 $ ( diftru*thrsh2.LT.difest( 2 ) ) ) THEN
821 result( 8 ) = max( diftru / difest( 2 ), difest( 2 ) / diftru )
822 END IF
823*
824* Test (9)
825*
826 ntest = 9
827 result( 9 ) = zero
828 IF( linfo.EQ.( mplusn+2 ) ) THEN
829 IF( diftru.GT.abnrm*ulp )
830 $ result( 9 ) = ulpinv
831 IF( ( ifunc.GT.1 ) .AND. ( difest( 2 ).NE.zero ) )
832 $ result( 9 ) = ulpinv
833 IF( ( ifunc.EQ.1 ) .AND. ( pl( 1 ).NE.zero ) )
834 $ result( 9 ) = ulpinv
835 END IF
836*
837* Test (10): compare the estimated value of PL and it true value.
838*
839 ntest = 10
840 result( 10 ) = zero
841 IF( pl( 1 ).EQ.zero ) THEN
842 IF( pltru.GT.abnrm*ulp )
843 $ result( 10 ) = ulpinv
844 ELSE IF( pltru.EQ.zero ) THEN
845 IF( pl( 1 ).GT.abnrm*ulp )
846 $ result( 10 ) = ulpinv
847 ELSE IF( ( pltru.GT.thresh*pl( 1 ) ) .OR.
848 $ ( pltru*thresh.LT.pl( 1 ) ) ) THEN
849 result( 10 ) = ulpinv
850 END IF
851*
852 ntestt = ntestt + ntest
853*
854* Print out tests which fail.
855*
856 DO 120 j = 1, ntest
857 IF( result( j ).GE.thresh ) THEN
858*
859* If this is the first test to fail,
860* print a header to the data file.
861*
862 IF( nerrs.EQ.0 ) THEN
863 WRITE( nout, fmt = 9996 )'CGX'
864*
865* Matrix types
866*
867 WRITE( nout, fmt = 9995 )
868*
869* Tests performed
870*
871 WRITE( nout, fmt = 9993 )'unitary', '''', 'transpose',
872 $ ( '''', i = 1, 4 )
873*
874 END IF
875 nerrs = nerrs + 1
876 IF( result( j ).LT.10000.0 ) THEN
877 WRITE( nout, fmt = 9990 )nptknt, mplusn, j, result( j )
878 ELSE
879 WRITE( nout, fmt = 9989 )nptknt, mplusn, j, result( j )
880 END IF
881 END IF
882*
883 120 CONTINUE
884*
885 130 CONTINUE
886 GO TO 80
887 140 CONTINUE
888*
889 150 CONTINUE
890*
891* Summary
892*
893 CALL alasvm( 'CGX', nout, nerrs, ntestt, 0 )
894*
895 work( 1 ) = maxwrk
896*
897 RETURN
898*
899 9999 FORMAT( ' CDRGSX: ', a, ' returned INFO=', i6, '.', / 9x, 'N=',
900 $ i6, ', JTYPE=', i6, ')' )
901*
902 9998 FORMAT( ' CDRGSX: ', a, ' returned INFO=', i6, '.', / 9x, 'N=',
903 $ i6, ', Input Example #', i2, ')' )
904*
905 9997 FORMAT( ' CDRGSX: S not in Schur form at eigenvalue ', i6, '.',
906 $ / 9x, 'N=', i6, ', JTYPE=', i6, ')' )
907*
908 9996 FORMAT( / 1x, a3, ' -- Complex Expert Generalized Schur form',
909 $ ' problem driver' )
910*
911 9995 FORMAT( 'Input Example' )
912*
913 9994 FORMAT( ' Matrix types: ', /
914 $ ' 1: A is a block diagonal matrix of Jordan blocks ',
915 $ 'and B is the identity ', / ' matrix, ',
916 $ / ' 2: A and B are upper triangular matrices, ',
917 $ / ' 3: A and B are as type 2, but each second diagonal ',
918 $ 'block in A_11 and ', /
919 $ ' each third diagonal block in A_22 are 2x2 blocks,',
920 $ / ' 4: A and B are block diagonal matrices, ',
921 $ / ' 5: (A,B) has potentially close or common ',
922 $ 'eigenvalues.', / )
923*
924 9993 FORMAT( / ' Tests performed: (S is Schur, T is triangular, ',
925 $ 'Q and Z are ', a, ',', / 19x,
926 $ ' a is alpha, b is beta, and ', a, ' means ', a, '.)',
927 $ / ' 1 = | A - Q S Z', a,
928 $ ' | / ( |A| n ulp ) 2 = | B - Q T Z', a,
929 $ ' | / ( |B| n ulp )', / ' 3 = | I - QQ', a,
930 $ ' | / ( n ulp ) 4 = | I - ZZ', a,
931 $ ' | / ( n ulp )', / ' 5 = 1/ULP if A is not in ',
932 $ 'Schur form S', / ' 6 = difference between (alpha,beta)',
933 $ ' and diagonals of (S,T)', /
934 $ ' 7 = 1/ULP if SDIM is not the correct number of ',
935 $ 'selected eigenvalues', /
936 $ ' 8 = 1/ULP if DIFEST/DIFTRU > 10*THRESH or ',
937 $ 'DIFTRU/DIFEST > 10*THRESH',
938 $ / ' 9 = 1/ULP if DIFEST <> 0 or DIFTRU > ULP*norm(A,B) ',
939 $ 'when reordering fails', /
940 $ ' 10 = 1/ULP if PLEST/PLTRU > THRESH or ',
941 $ 'PLTRU/PLEST > THRESH', /
942 $ ' ( Test 10 is only for input examples )', / )
943 9992 FORMAT( ' Matrix order=', i2, ', type=', i2, ', a=', e10.3,
944 $ ', order(A_11)=', i2, ', result ', i2, ' is ', 0p, f8.2 )
945 9991 FORMAT( ' Matrix order=', i2, ', type=', i2, ', a=', e10.3,
946 $ ', order(A_11)=', i2, ', result ', i2, ' is ', 0p, e10.3 )
947 9990 FORMAT( ' Input example #', i2, ', matrix order=', i4, ',',
948 $ ' result ', i2, ' is', 0p, f8.2 )
949 9989 FORMAT( ' Input example #', i2, ', matrix order=', i4, ',',
950 $ ' result ', i2, ' is', 1p, e10.3 )
951*
952* End of CDRGSX
953*
954 END
subroutine alasvm(type, nout, nfail, nrun, nerrs)
ALASVM
Definition alasvm.f:73
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine cdrgsx(nsize, ncmax, thresh, nin, nout, a, lda, b, ai, bi, z, q, alpha, beta, c, ldc, s, work, lwork, rwork, iwork, liwork, bwork, info)
CDRGSX
Definition cdrgsx.f:349
subroutine cget51(itype, n, a, lda, b, ldb, u, ldu, v, ldv, work, rwork, result)
CGET51
Definition cget51.f:155
subroutine clakf2(m, n, a, lda, b, d, e, z, ldz)
CLAKF2
Definition clakf2.f:105
subroutine clatm5(prtype, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, r, ldr, l, ldl, alpha, qblcka, qblckb)
CLATM5
Definition clatm5.f:268
logical function clctsx(alpha, beta)
CLCTSX
Definition clctsx.f:57
subroutine cgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)
CGESVD computes the singular value decomposition (SVD) for GE matrices
Definition cgesvd.f:214
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 clacpy(uplo, m, n, a, lda, b, ldb)
CLACPY copies all or part of one two-dimensional array to another.
Definition clacpy.f:103
real function clange(norm, m, n, a, lda, work)
CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition clange.f:115
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