LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ ddrgvx()

subroutine ddrgvx ( integer  nsize,
double precision  thresh,
integer  nin,
integer  nout,
double precision, dimension( lda, * )  a,
integer  lda,
double precision, dimension( lda, * )  b,
double precision, dimension( lda, * )  ai,
double precision, dimension( lda, * )  bi,
double precision, dimension( * )  alphar,
double precision, dimension( * )  alphai,
double precision, dimension( * )  beta,
double precision, dimension( lda, * )  vl,
double precision, dimension( lda, * )  vr,
integer  ilo,
integer  ihi,
double precision, dimension( * )  lscale,
double precision, dimension( * )  rscale,
double precision, dimension( * )  s,
double precision, dimension( * )  dtru,
double precision, dimension( * )  dif,
double precision, dimension( * )  diftru,
double precision, dimension( * )  work,
integer  lwork,
integer, dimension( * )  iwork,
integer  liwork,
double precision, dimension( 4 )  result,
logical, dimension( * )  bwork,
integer  info 
)

DDRGVX

Purpose:
 DDRGVX checks the nonsymmetric generalized eigenvalue problem
 expert driver DGGEVX.

 DGGEVX computes the generalized eigenvalues, (optionally) the left
 and/or right eigenvectors, (optionally) computes a balancing
 transformation to improve the conditioning, and (optionally)
 reciprocal condition numbers for the eigenvalues and eigenvectors.

 When DDRGVX is called with NSIZE > 0, two types of test matrix pairs
 are generated by the subroutine DLATM6 and test the driver DGGEVX.
 The test matrices have the known exact condition numbers for
 eigenvalues. For the condition numbers of the eigenvectors
 corresponding the first and last eigenvalues are also know
 ``exactly'' (see DLATM6).

 For each matrix pair, the following tests will be performed and
 compared with the threshold THRESH.

 (1) max over all left eigenvalue/-vector pairs (beta/alpha,l) of

    | l**H * (beta A - alpha B) | / ( ulp max( |beta A|, |alpha B| ) )

     where l**H is the conjugate transpose of l.

 (2) max over all right eigenvalue/-vector pairs (beta/alpha,r) of

       | (beta A - alpha B) r | / ( ulp max( |beta A|, |alpha B| ) )

 (3) The condition number S(i) of eigenvalues computed by DGGEVX
     differs less than a factor THRESH from the exact S(i) (see
     DLATM6).

 (4) DIF(i) computed by DTGSNA differs less than a factor 10*THRESH
     from the exact value (for the 1st and 5th vectors only).

 Test Matrices
 =============

 Two kinds of test matrix pairs

          (A, B) = inverse(YH) * (Da, Db) * inverse(X)

 are used in the tests:

 1: Da = 1+a   0    0    0    0    Db = 1   0   0   0   0
          0   2+a   0    0    0         0   1   0   0   0
          0    0   3+a   0    0         0   0   1   0   0
          0    0    0   4+a   0         0   0   0   1   0
          0    0    0    0   5+a ,      0   0   0   0   1 , and

 2: Da =  1   -1    0    0    0    Db = 1   0   0   0   0
          1    1    0    0    0         0   1   0   0   0
          0    0    1    0    0         0   0   1   0   0
          0    0    0   1+a  1+b        0   0   0   1   0
          0    0    0  -1-b  1+a ,      0   0   0   0   1 .

 In both cases the same inverse(YH) and inverse(X) are used to compute
 (A, B), giving the exact eigenvectors to (A,B) as (YH, X):

 YH:  =  1    0   -y    y   -y    X =  1   0  -x  -x   x
         0    1   -y    y   -y         0   1   x  -x  -x
         0    0    1    0    0         0   0   1   0   0
         0    0    0    1    0         0   0   0   1   0
         0    0    0    0    1,        0   0   0   0   1 , where

 a, b, x and y will have all values independently of each other from
 { sqrt(sqrt(ULP)),  0.1,  1,  10,  1/sqrt(sqrt(ULP)) }.
Parameters
[in]NSIZE
          NSIZE is INTEGER
          The number of sizes of matrices to use.  NSIZE must be at
          least zero. If it is zero, no randomly generated matrices
          are tested, but any test matrices read from NIN will be
          tested.
[in]THRESH
          THRESH is DOUBLE PRECISION
          A test will count as "failed" if the "error", computed as
          described above, exceeds THRESH.  Note that the error
          is scaled to be O(1), so THRESH should be a reasonably
          small multiple of 1, e.g., 10 or 100.  In particular,
          it should not depend on the precision (single vs. double)
          or the size of the matrix.  It must be at least zero.
[in]NIN
          NIN is INTEGER
          The FORTRAN unit number for reading in the data file of
          problems to solve.
[in]NOUT
          NOUT is INTEGER
          The FORTRAN unit number for printing out error messages
          (e.g., if a routine returns IINFO not equal to 0.)
[out]A
          A is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.
[in]LDA
          LDA is INTEGER
          The leading dimension of A, B, AI, BI, Ao, and Bo.
          It must be at least 1 and at least NSIZE.
[out]B
          B is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, B contains the last matrix actually used.
[out]AI
          AI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Copy of A, modified by DGGEVX.
[out]BI
          BI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Copy of B, modified by DGGEVX.
[out]ALPHAR
          ALPHAR is DOUBLE PRECISION array, dimension (NSIZE)
[out]ALPHAI
          ALPHAI is DOUBLE PRECISION array, dimension (NSIZE)
[out]BETA
          BETA is DOUBLE PRECISION array, dimension (NSIZE)

          On exit, (ALPHAR + ALPHAI*i)/BETA are the eigenvalues.
[out]VL
          VL is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          VL holds the left eigenvectors computed by DGGEVX.
[out]VR
          VR is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          VR holds the right eigenvectors computed by DGGEVX.
[out]ILO
                ILO is INTEGER
[out]IHI
                IHI is INTEGER
[out]LSCALE
                LSCALE is DOUBLE PRECISION array, dimension (N)
[out]RSCALE
                RSCALE is DOUBLE PRECISION array, dimension (N)
[out]S
                S is DOUBLE PRECISION array, dimension (N)
[out]DTRU
                DTRU is DOUBLE PRECISION array, dimension (N)
[out]DIF
                DIF is DOUBLE PRECISION array, dimension (N)
[out]DIFTRU
                DIFTRU is DOUBLE PRECISION array, dimension (N)
[out]WORK
          WORK is DOUBLE PRECISION array, dimension (LWORK)
[in]LWORK
          LWORK is INTEGER
          Leading dimension of WORK.  LWORK >= 2*N*N+12*N+16.
[out]IWORK
          IWORK is INTEGER array, dimension (LIWORK)
[in]LIWORK
          LIWORK is INTEGER
          Leading dimension of IWORK.  Must be at least N+6.
[out]RESULT
                RESULT is DOUBLE PRECISION array, dimension (4)
[out]BWORK
          BWORK is LOGICAL array, dimension (N)
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value.
          > 0:  A routine returned an error code.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 296 of file ddrgvx.f.

300*
301* -- LAPACK test routine --
302* -- LAPACK is a software package provided by Univ. of Tennessee, --
303* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
304*
305* .. Scalar Arguments ..
306 INTEGER IHI, ILO, INFO, LDA, LIWORK, LWORK, NIN, NOUT,
307 $ NSIZE
308 DOUBLE PRECISION THRESH
309* ..
310* .. Array Arguments ..
311 LOGICAL BWORK( * )
312 INTEGER IWORK( * )
313 DOUBLE PRECISION A( LDA, * ), AI( LDA, * ), ALPHAI( * ),
314 $ ALPHAR( * ), B( LDA, * ), BETA( * ),
315 $ BI( LDA, * ), DIF( * ), DIFTRU( * ), DTRU( * ),
316 $ LSCALE( * ), RESULT( 4 ), RSCALE( * ), S( * ),
317 $ VL( LDA, * ), VR( LDA, * ), WORK( * )
318* ..
319*
320* =====================================================================
321*
322* .. Parameters ..
323 DOUBLE PRECISION ZERO, ONE, TEN, TNTH, HALF
324 parameter( zero = 0.0d+0, one = 1.0d+0, ten = 1.0d+1,
325 $ tnth = 1.0d-1, half = 0.5d+0 )
326* ..
327* .. Local Scalars ..
328 INTEGER I, IPTYPE, IWA, IWB, IWX, IWY, J, LINFO,
329 $ MAXWRK, MINWRK, N, NERRS, NMAX, NPTKNT, NTESTT
330 DOUBLE PRECISION ABNORM, ANORM, BNORM, RATIO1, RATIO2, THRSH2,
331 $ ULP, ULPINV
332* ..
333* .. Local Arrays ..
334 DOUBLE PRECISION WEIGHT( 5 )
335* ..
336* .. External Functions ..
337 INTEGER ILAENV
338 DOUBLE PRECISION DLAMCH, DLANGE
339 EXTERNAL ilaenv, dlamch, dlange
340* ..
341* .. External Subroutines ..
342 EXTERNAL alasvm, dget52, dggevx, dlacpy, dlatm6, xerbla
343* ..
344* .. Intrinsic Functions ..
345 INTRINSIC abs, max, sqrt
346* ..
347* .. Executable Statements ..
348*
349* Check for errors
350*
351 info = 0
352*
353 nmax = 5
354*
355 IF( nsize.LT.0 ) THEN
356 info = -1
357 ELSE IF( thresh.LT.zero ) THEN
358 info = -2
359 ELSE IF( nin.LE.0 ) THEN
360 info = -3
361 ELSE IF( nout.LE.0 ) THEN
362 info = -4
363 ELSE IF( lda.LT.1 .OR. lda.LT.nmax ) THEN
364 info = -6
365 ELSE IF( liwork.LT.nmax+6 ) THEN
366 info = -26
367 END IF
368*
369* Compute workspace
370* (Note: Comments in the code beginning "Workspace:" describe the
371* minimal amount of workspace needed at that point in the code,
372* as well as the preferred amount for good performance.
373* NB refers to the optimal block size for the immediately
374* following subroutine, as returned by ILAENV.)
375*
376 minwrk = 1
377 IF( info.EQ.0 .AND. lwork.GE.1 ) THEN
378 minwrk = 2*nmax*nmax + 12*nmax + 16
379 maxwrk = 6*nmax + nmax*ilaenv( 1, 'DGEQRF', ' ', nmax, 1, nmax,
380 $ 0 )
381 maxwrk = max( maxwrk, 2*nmax*nmax+12*nmax+16 )
382 work( 1 ) = maxwrk
383 END IF
384*
385 IF( lwork.LT.minwrk )
386 $ info = -24
387*
388 IF( info.NE.0 ) THEN
389 CALL xerbla( 'DDRGVX', -info )
390 RETURN
391 END IF
392*
393 n = 5
394 ulp = dlamch( 'P' )
395 ulpinv = one / ulp
396 thrsh2 = ten*thresh
397 nerrs = 0
398 nptknt = 0
399 ntestt = 0
400*
401 IF( nsize.EQ.0 )
402 $ GO TO 90
403*
404* Parameters used for generating test matrices.
405*
406 weight( 1 ) = tnth
407 weight( 2 ) = half
408 weight( 3 ) = one
409 weight( 4 ) = one / weight( 2 )
410 weight( 5 ) = one / weight( 1 )
411*
412 DO 80 iptype = 1, 2
413 DO 70 iwa = 1, 5
414 DO 60 iwb = 1, 5
415 DO 50 iwx = 1, 5
416 DO 40 iwy = 1, 5
417*
418* generated a test matrix pair
419*
420 CALL dlatm6( iptype, 5, a, lda, b, vr, lda, vl,
421 $ lda, weight( iwa ), weight( iwb ),
422 $ weight( iwx ), weight( iwy ), dtru,
423 $ diftru )
424*
425* Compute eigenvalues/eigenvectors of (A, B).
426* Compute eigenvalue/eigenvector condition numbers
427* using computed eigenvectors.
428*
429 CALL dlacpy( 'F', n, n, a, lda, ai, lda )
430 CALL dlacpy( 'F', n, n, b, lda, bi, lda )
431*
432 CALL dggevx( 'N', 'V', 'V', 'B', n, ai, lda, bi,
433 $ lda, alphar, alphai, beta, vl, lda,
434 $ vr, lda, ilo, ihi, lscale, rscale,
435 $ anorm, bnorm, s, dif, work, lwork,
436 $ iwork, bwork, linfo )
437 IF( linfo.NE.0 ) THEN
438 result( 1 ) = ulpinv
439 WRITE( nout, fmt = 9999 )'DGGEVX', linfo, n,
440 $ iptype
441 GO TO 30
442 END IF
443*
444* Compute the norm(A, B)
445*
446 CALL dlacpy( 'Full', n, n, ai, lda, work, n )
447 CALL dlacpy( 'Full', n, n, bi, lda, work( n*n+1 ),
448 $ n )
449 abnorm = dlange( 'Fro', n, 2*n, work, n, work )
450*
451* Tests (1) and (2)
452*
453 result( 1 ) = zero
454 CALL dget52( .true., n, a, lda, b, lda, vl, lda,
455 $ alphar, alphai, beta, work,
456 $ result( 1 ) )
457 IF( result( 2 ).GT.thresh ) THEN
458 WRITE( nout, fmt = 9998 )'Left', 'DGGEVX',
459 $ result( 2 ), n, iptype, iwa, iwb, iwx, iwy
460 END IF
461*
462 result( 2 ) = zero
463 CALL dget52( .false., n, a, lda, b, lda, vr, lda,
464 $ alphar, alphai, beta, work,
465 $ result( 2 ) )
466 IF( result( 3 ).GT.thresh ) THEN
467 WRITE( nout, fmt = 9998 )'Right', 'DGGEVX',
468 $ result( 3 ), n, iptype, iwa, iwb, iwx, iwy
469 END IF
470*
471* Test (3)
472*
473 result( 3 ) = zero
474 DO 10 i = 1, n
475 IF( s( i ).EQ.zero ) THEN
476 IF( dtru( i ).GT.abnorm*ulp )
477 $ result( 3 ) = ulpinv
478 ELSE IF( dtru( i ).EQ.zero ) THEN
479 IF( s( i ).GT.abnorm*ulp )
480 $ result( 3 ) = ulpinv
481 ELSE
482 work( i ) = max( abs( dtru( i ) / s( i ) ),
483 $ abs( s( i ) / dtru( i ) ) )
484 result( 3 ) = max( result( 3 ), work( i ) )
485 END IF
486 10 CONTINUE
487*
488* Test (4)
489*
490 result( 4 ) = zero
491 IF( dif( 1 ).EQ.zero ) THEN
492 IF( diftru( 1 ).GT.abnorm*ulp )
493 $ result( 4 ) = ulpinv
494 ELSE IF( diftru( 1 ).EQ.zero ) THEN
495 IF( dif( 1 ).GT.abnorm*ulp )
496 $ result( 4 ) = ulpinv
497 ELSE IF( dif( 5 ).EQ.zero ) THEN
498 IF( diftru( 5 ).GT.abnorm*ulp )
499 $ result( 4 ) = ulpinv
500 ELSE IF( diftru( 5 ).EQ.zero ) THEN
501 IF( dif( 5 ).GT.abnorm*ulp )
502 $ result( 4 ) = ulpinv
503 ELSE
504 ratio1 = max( abs( diftru( 1 ) / dif( 1 ) ),
505 $ abs( dif( 1 ) / diftru( 1 ) ) )
506 ratio2 = max( abs( diftru( 5 ) / dif( 5 ) ),
507 $ abs( dif( 5 ) / diftru( 5 ) ) )
508 result( 4 ) = max( ratio1, ratio2 )
509 END IF
510*
511 ntestt = ntestt + 4
512*
513* Print out tests which fail.
514*
515 DO 20 j = 1, 4
516 IF( ( result( j ).GE.thrsh2 .AND. j.GE.4 ) .OR.
517 $ ( result( j ).GE.thresh .AND. j.LE.3 ) )
518 $ THEN
519*
520* If this is the first test to fail,
521* print a header to the data file.
522*
523 IF( nerrs.EQ.0 ) THEN
524 WRITE( nout, fmt = 9997 )'DXV'
525*
526* Print out messages for built-in examples
527*
528* Matrix types
529*
530 WRITE( nout, fmt = 9995 )
531 WRITE( nout, fmt = 9994 )
532 WRITE( nout, fmt = 9993 )
533*
534* Tests performed
535*
536 WRITE( nout, fmt = 9992 )'''',
537 $ 'transpose', ''''
538*
539 END IF
540 nerrs = nerrs + 1
541 IF( result( j ).LT.10000.0d0 ) THEN
542 WRITE( nout, fmt = 9991 )iptype, iwa,
543 $ iwb, iwx, iwy, j, result( j )
544 ELSE
545 WRITE( nout, fmt = 9990 )iptype, iwa,
546 $ iwb, iwx, iwy, j, result( j )
547 END IF
548 END IF
549 20 CONTINUE
550*
551 30 CONTINUE
552*
553 40 CONTINUE
554 50 CONTINUE
555 60 CONTINUE
556 70 CONTINUE
557 80 CONTINUE
558*
559 GO TO 150
560*
561 90 CONTINUE
562*
563* Read in data from file to check accuracy of condition estimation
564* Read input data until N=0
565*
566 READ( nin, fmt = *, END = 150 )n
567 IF( n.EQ.0 )
568 $ GO TO 150
569 DO 100 i = 1, n
570 READ( nin, fmt = * )( a( i, j ), j = 1, n )
571 100 CONTINUE
572 DO 110 i = 1, n
573 READ( nin, fmt = * )( b( i, j ), j = 1, n )
574 110 CONTINUE
575 READ( nin, fmt = * )( dtru( i ), i = 1, n )
576 READ( nin, fmt = * )( diftru( i ), i = 1, n )
577*
578 nptknt = nptknt + 1
579*
580* Compute eigenvalues/eigenvectors of (A, B).
581* Compute eigenvalue/eigenvector condition numbers
582* using computed eigenvectors.
583*
584 CALL dlacpy( 'F', n, n, a, lda, ai, lda )
585 CALL dlacpy( 'F', n, n, b, lda, bi, lda )
586*
587 CALL dggevx( 'N', 'V', 'V', 'B', n, ai, lda, bi, lda, alphar,
588 $ alphai, beta, vl, lda, vr, lda, ilo, ihi, lscale,
589 $ rscale, anorm, bnorm, s, dif, work, lwork, iwork,
590 $ bwork, linfo )
591*
592 IF( linfo.NE.0 ) THEN
593 result( 1 ) = ulpinv
594 WRITE( nout, fmt = 9987 )'DGGEVX', linfo, n, nptknt
595 GO TO 140
596 END IF
597*
598* Compute the norm(A, B)
599*
600 CALL dlacpy( 'Full', n, n, ai, lda, work, n )
601 CALL dlacpy( 'Full', n, n, bi, lda, work( n*n+1 ), n )
602 abnorm = dlange( 'Fro', n, 2*n, work, n, work )
603*
604* Tests (1) and (2)
605*
606 result( 1 ) = zero
607 CALL dget52( .true., n, a, lda, b, lda, vl, lda, alphar, alphai,
608 $ beta, work, result( 1 ) )
609 IF( result( 2 ).GT.thresh ) THEN
610 WRITE( nout, fmt = 9986 )'Left', 'DGGEVX', result( 2 ), n,
611 $ nptknt
612 END IF
613*
614 result( 2 ) = zero
615 CALL dget52( .false., n, a, lda, b, lda, vr, lda, alphar, alphai,
616 $ beta, work, result( 2 ) )
617 IF( result( 3 ).GT.thresh ) THEN
618 WRITE( nout, fmt = 9986 )'Right', 'DGGEVX', result( 3 ), n,
619 $ nptknt
620 END IF
621*
622* Test (3)
623*
624 result( 3 ) = zero
625 DO 120 i = 1, n
626 IF( s( i ).EQ.zero ) THEN
627 IF( dtru( i ).GT.abnorm*ulp )
628 $ result( 3 ) = ulpinv
629 ELSE IF( dtru( i ).EQ.zero ) THEN
630 IF( s( i ).GT.abnorm*ulp )
631 $ result( 3 ) = ulpinv
632 ELSE
633 work( i ) = max( abs( dtru( i ) / s( i ) ),
634 $ abs( s( i ) / dtru( i ) ) )
635 result( 3 ) = max( result( 3 ), work( i ) )
636 END IF
637 120 CONTINUE
638*
639* Test (4)
640*
641 result( 4 ) = zero
642 IF( dif( 1 ).EQ.zero ) THEN
643 IF( diftru( 1 ).GT.abnorm*ulp )
644 $ result( 4 ) = ulpinv
645 ELSE IF( diftru( 1 ).EQ.zero ) THEN
646 IF( dif( 1 ).GT.abnorm*ulp )
647 $ result( 4 ) = ulpinv
648 ELSE IF( dif( 5 ).EQ.zero ) THEN
649 IF( diftru( 5 ).GT.abnorm*ulp )
650 $ result( 4 ) = ulpinv
651 ELSE IF( diftru( 5 ).EQ.zero ) THEN
652 IF( dif( 5 ).GT.abnorm*ulp )
653 $ result( 4 ) = ulpinv
654 ELSE
655 ratio1 = max( abs( diftru( 1 ) / dif( 1 ) ),
656 $ abs( dif( 1 ) / diftru( 1 ) ) )
657 ratio2 = max( abs( diftru( 5 ) / dif( 5 ) ),
658 $ abs( dif( 5 ) / diftru( 5 ) ) )
659 result( 4 ) = max( ratio1, ratio2 )
660 END IF
661*
662 ntestt = ntestt + 4
663*
664* Print out tests which fail.
665*
666 DO 130 j = 1, 4
667 IF( result( j ).GE.thrsh2 ) THEN
668*
669* If this is the first test to fail,
670* print a header to the data file.
671*
672 IF( nerrs.EQ.0 ) THEN
673 WRITE( nout, fmt = 9997 )'DXV'
674*
675* Print out messages for built-in examples
676*
677* Matrix types
678*
679 WRITE( nout, fmt = 9996 )
680*
681* Tests performed
682*
683 WRITE( nout, fmt = 9992 )'''', 'transpose', ''''
684*
685 END IF
686 nerrs = nerrs + 1
687 IF( result( j ).LT.10000.0d0 ) THEN
688 WRITE( nout, fmt = 9989 )nptknt, n, j, result( j )
689 ELSE
690 WRITE( nout, fmt = 9988 )nptknt, n, j, result( j )
691 END IF
692 END IF
693 130 CONTINUE
694*
695 140 CONTINUE
696*
697 GO TO 90
698 150 CONTINUE
699*
700* Summary
701*
702 CALL alasvm( 'DXV', nout, nerrs, ntestt, 0 )
703*
704 work( 1 ) = maxwrk
705*
706 RETURN
707*
708 9999 FORMAT( ' DDRGVX: ', a, ' returned INFO=', i6, '.', / 9x, 'N=',
709 $ i6, ', JTYPE=', i6, ')' )
710*
711 9998 FORMAT( ' DDRGVX: ', a, ' Eigenvectors from ', a, ' incorrectly ',
712 $ 'normalized.', / ' Bits of error=', 0p, g10.3, ',', 9x,
713 $ 'N=', i6, ', JTYPE=', i6, ', IWA=', i5, ', IWB=', i5,
714 $ ', IWX=', i5, ', IWY=', i5 )
715*
716 9997 FORMAT( / 1x, a3, ' -- Real Expert Eigenvalue/vector',
717 $ ' problem driver' )
718*
719 9996 FORMAT( ' Input Example' )
720*
721 9995 FORMAT( ' Matrix types: ', / )
722*
723 9994 FORMAT( ' TYPE 1: Da is diagonal, Db is identity, ',
724 $ / ' A = Y^(-H) Da X^(-1), B = Y^(-H) Db X^(-1) ',
725 $ / ' YH and X are left and right eigenvectors. ', / )
726*
727 9993 FORMAT( ' TYPE 2: Da is quasi-diagonal, Db is identity, ',
728 $ / ' A = Y^(-H) Da X^(-1), B = Y^(-H) Db X^(-1) ',
729 $ / ' YH and X are left and right eigenvectors. ', / )
730*
731 9992 FORMAT( / ' Tests performed: ', / 4x,
732 $ ' a is alpha, b is beta, l is a left eigenvector, ', / 4x,
733 $ ' r is a right eigenvector and ', a, ' means ', a, '.',
734 $ / ' 1 = max | ( b A - a B )', a, ' l | / const.',
735 $ / ' 2 = max | ( b A - a B ) r | / const.',
736 $ / ' 3 = max ( Sest/Stru, Stru/Sest ) ',
737 $ ' over all eigenvalues', /
738 $ ' 4 = max( DIFest/DIFtru, DIFtru/DIFest ) ',
739 $ ' over the 1st and 5th eigenvectors', / )
740*
741 9991 FORMAT( ' Type=', i2, ',', ' IWA=', i2, ', IWB=', i2, ', IWX=',
742 $ i2, ', IWY=', i2, ', result ', i2, ' is', 0p, f8.2 )
743 9990 FORMAT( ' Type=', i2, ',', ' IWA=', i2, ', IWB=', i2, ', IWX=',
744 $ i2, ', IWY=', i2, ', result ', i2, ' is', 1p, d10.3 )
745 9989 FORMAT( ' Input example #', i2, ', matrix order=', i4, ',',
746 $ ' result ', i2, ' is', 0p, f8.2 )
747 9988 FORMAT( ' Input example #', i2, ', matrix order=', i4, ',',
748 $ ' result ', i2, ' is', 1p, d10.3 )
749 9987 FORMAT( ' DDRGVX: ', a, ' returned INFO=', i6, '.', / 9x, 'N=',
750 $ i6, ', Input example #', i2, ')' )
751*
752 9986 FORMAT( ' DDRGVX: ', a, ' Eigenvectors from ', a, ' incorrectly ',
753 $ 'normalized.', / ' Bits of error=', 0p, g10.3, ',', 9x,
754 $ 'N=', i6, ', Input Example #', i2, ')' )
755*
756*
757* End of DDRGVX
758*
alasvm
subroutine alasvm(type, nout, nfail, nrun, nerrs)
ALASVM
Definition alasvm.f:73
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
dget52
subroutine dget52(left, n, a, lda, b, ldb, e, lde, alphar, alphai, beta, work, result)
DGET52
Definition dget52.f:199
dlatm6
subroutine dlatm6(type, n, a, lda, b, x, ldx, y, ldy, alpha, beta, wx, wy, s, dif)
DLATM6
Definition dlatm6.f:176
dggevx
subroutine dggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info)
DGGEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices
Definition dggevx.f:391
ilaenv
integer function ilaenv(ispec, name, opts, n1, n2, n3, n4)
ILAENV
Definition ilaenv.f:162
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
dlamch
double precision function dlamch(cmach)
DLAMCH
Definition dlamch.f:69
dlange
double precision function dlange(norm, m, n, a, lda, work)
DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition dlange.f:114
Here is the call graph for this function:
Here is the caller graph for this function: