LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ 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 tranpose 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 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
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
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:73
subroutine dget52(LEFT, N, A, LDA, B, LDB, E, LDE, ALPHAR, ALPHAI, BETA, WORK, RESULT)
DGET52
Definition: dget52.f:199
subroutine dlatm6(TYPE, N, A, LDA, B, X, LDX, Y, LDY, ALPHA, BETA, WX, WY, S, DIF)
DLATM6
Definition: dlatm6.f:176
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
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
Here is the call graph for this function:
Here is the caller graph for this function: