 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ ddrvsg()

 subroutine ddrvsg ( integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) D, double precision, dimension( ldz, * ) Z, integer LDZ, double precision, dimension( lda, * ) AB, double precision, dimension( ldb, * ) BB, double precision, dimension( * ) AP, double precision, dimension( * ) BP, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO )

DDRVSG

Purpose:
```      DDRVSG checks the real symmetric generalized eigenproblem
drivers.

DSYGV computes all eigenvalues and, optionally,
eigenvectors of a real symmetric-definite generalized
eigenproblem.

DSYGVD computes all eigenvalues and, optionally,
eigenvectors of a real symmetric-definite generalized
eigenproblem using a divide and conquer algorithm.

DSYGVX computes selected eigenvalues and, optionally,
eigenvectors of a real symmetric-definite generalized
eigenproblem.

DSPGV computes all eigenvalues and, optionally,
eigenvectors of a real symmetric-definite generalized
eigenproblem in packed storage.

DSPGVD computes all eigenvalues and, optionally,
eigenvectors of a real symmetric-definite generalized
eigenproblem in packed storage using a divide and
conquer algorithm.

DSPGVX computes selected eigenvalues and, optionally,
eigenvectors of a real symmetric-definite generalized
eigenproblem in packed storage.

DSBGV computes all eigenvalues and, optionally,
eigenvectors of a real symmetric-definite banded
generalized eigenproblem.

DSBGVD computes all eigenvalues and, optionally,
eigenvectors of a real symmetric-definite banded
generalized eigenproblem using a divide and conquer
algorithm.

DSBGVX computes selected eigenvalues and, optionally,
eigenvectors of a real symmetric-definite banded
generalized eigenproblem.

When DDRVSG is called, a number of matrix "sizes" ("n's") and a
number of matrix "types" are specified.  For each size ("n")
and each type of matrix, one matrix A of the given type will be
generated; a random well-conditioned matrix B is also generated
and the pair (A,B) is used to test the drivers.

For each pair (A,B), the following tests are performed:

(1) DSYGV with ITYPE = 1 and UPLO ='U':

| A Z - B Z D | / ( |A| |Z| n ulp )

(2) as (1) but calling DSPGV
(3) as (1) but calling DSBGV
(4) as (1) but with UPLO = 'L'
(5) as (4) but calling DSPGV
(6) as (4) but calling DSBGV

(7) DSYGV with ITYPE = 2 and UPLO ='U':

| A B Z - Z D | / ( |A| |Z| n ulp )

(8) as (7) but calling DSPGV
(9) as (7) but with UPLO = 'L'
(10) as (9) but calling DSPGV

(11) DSYGV with ITYPE = 3 and UPLO ='U':

| B A Z - Z D | / ( |A| |Z| n ulp )

(12) as (11) but calling DSPGV
(13) as (11) but with UPLO = 'L'
(14) as (13) but calling DSPGV

DSYGVD, DSPGVD and DSBGVD performed the same 14 tests.

DSYGVX, DSPGVX and DSBGVX performed the above 14 tests with
the parameter RANGE = 'A', 'N' and 'I', respectively.

The "sizes" are specified by an array NN(1:NSIZES); the value
of each element NN(j) specifies one size.
The "types" are specified by a logical array DOTYPE( 1:NTYPES );
if DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
This type is used for the matrix A which has half-bandwidth KA.
B is generated as a well-conditioned positive definite matrix
with half-bandwidth KB (<= KA).
Currently, the list of possible types for A is:

(1)  The zero matrix.
(2)  The identity matrix.

(3)  A diagonal matrix with evenly spaced entries
1, ..., ULP  and random signs.
(ULP = (first number larger than 1) - 1 )
(4)  A diagonal matrix with geometrically spaced entries
1, ..., ULP  and random signs.
(5)  A diagonal matrix with "clustered" entries
1, ULP, ..., ULP and random signs.

(6)  Same as (4), but multiplied by SQRT( overflow threshold )
(7)  Same as (4), but multiplied by SQRT( underflow threshold )

(8)  A matrix of the form  U* D U, where U is orthogonal and
D has evenly spaced entries 1, ..., ULP with random signs
on the diagonal.

(9)  A matrix of the form  U* D U, where U is orthogonal and
D has geometrically spaced entries 1, ..., ULP with random
signs on the diagonal.

(10) A matrix of the form  U* D U, where U is orthogonal and
D has "clustered" entries 1, ULP,..., ULP with random
signs on the diagonal.

(11) Same as (8), but multiplied by SQRT( overflow threshold )
(12) Same as (8), but multiplied by SQRT( underflow threshold )

(13) symmetric matrix with random entries chosen from (-1,1).
(14) Same as (13), but multiplied by SQRT( overflow threshold )
(15) Same as (13), but multiplied by SQRT( underflow threshold)

(16) Same as (8), but with KA = 1 and KB = 1
(17) Same as (8), but with KA = 2 and KB = 1
(18) Same as (8), but with KA = 2 and KB = 2
(19) Same as (8), but with KA = 3 and KB = 1
(20) Same as (8), but with KA = 3 and KB = 2
(21) Same as (8), but with KA = 3 and KB = 3```
```  NSIZES  INTEGER
The number of sizes of matrices to use.  If it is zero,
DDRVSG does nothing.  It must be at least zero.
Not modified.

NN      INTEGER array, dimension (NSIZES)
An array containing the sizes to be used for the matrices.
Zero values will be skipped.  The values must be at least
zero.
Not modified.

NTYPES  INTEGER
The number of elements in DOTYPE.   If it is zero, DDRVSG
does nothing.  It must be at least zero.  If it is MAXTYP+1
and NSIZES is 1, then an additional type, MAXTYP+1 is
defined, which is to use whatever matrix is in A.  This
is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
DOTYPE(MAXTYP+1) is .TRUE. .
Not modified.

DOTYPE  LOGICAL array, dimension (NTYPES)
If DOTYPE(j) is .TRUE., then for each size in NN a
matrix of that size and of type j will be generated.
If NTYPES is smaller than the maximum number of types
defined (PARAMETER MAXTYP), then types NTYPES+1 through
MAXTYP will not be generated.  If NTYPES is larger
than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES)
will be ignored.
Not modified.

ISEED   INTEGER array, dimension (4)
On entry ISEED specifies the seed of the random number
generator. The array elements should be between 0 and 4095;
if not they will be reduced mod 4096.  Also, ISEED(4) must
be odd.  The random number generator uses a linear
congruential sequence limited to small integers, and so
should produce machine independent random numbers. The
values of ISEED are changed on exit, and can be used in the
next call to DDRVSG to continue the same random number
sequence.
Modified.

THRESH  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.
Not modified.

NOUNIT  INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
Not modified.

A       DOUBLE PRECISION array, dimension (LDA , max(NN))
Used to hold the matrix whose eigenvalues are to be
computed.  On exit, A contains the last matrix actually
used.
Modified.

LDA     INTEGER
The leading dimension of A and AB.  It must be at
least 1 and at least max( NN ).
Not modified.

B       DOUBLE PRECISION array, dimension (LDB , max(NN))
Used to hold the symmetric positive definite matrix for
the generailzed problem.
On exit, B contains the last matrix actually
used.
Modified.

LDB     INTEGER
The leading dimension of B and BB.  It must be at
least 1 and at least max( NN ).
Not modified.

D       DOUBLE PRECISION array, dimension (max(NN))
The eigenvalues of A. On exit, the eigenvalues in D
correspond with the matrix in A.
Modified.

Z       DOUBLE PRECISION array, dimension (LDZ, max(NN))
The matrix of eigenvectors.
Modified.

LDZ     INTEGER
The leading dimension of Z.  It must be at least 1 and
at least max( NN ).
Not modified.

AB      DOUBLE PRECISION array, dimension (LDA, max(NN))
Workspace.
Modified.

BB      DOUBLE PRECISION array, dimension (LDB, max(NN))
Workspace.
Modified.

AP      DOUBLE PRECISION array, dimension (max(NN)**2)
Workspace.
Modified.

BP      DOUBLE PRECISION array, dimension (max(NN)**2)
Workspace.
Modified.

WORK    DOUBLE PRECISION array, dimension (NWORK)
Workspace.
Modified.

NWORK   INTEGER
The number of entries in WORK.  This must be at least
1+5*N+2*N*lg(N)+3*N**2 where N = max( NN(j) ) and
lg( N ) = smallest integer k such that 2**k >= N.
Not modified.

IWORK   INTEGER array, dimension (LIWORK)
Workspace.
Modified.

LIWORK  INTEGER
The number of entries in WORK.  This must be at least 6*N.
Not modified.

RESULT  DOUBLE PRECISION array, dimension (70)
The values computed by the 70 tests described above.
Modified.

INFO    INTEGER
If 0, then everything ran OK.
-1: NSIZES < 0
-2: Some NN(j) < 0
-3: NTYPES < 0
-5: THRESH < 0
-9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
-16: LDZ < 1 or LDZ < NMAX.
-21: NWORK too small.
-23: LIWORK too small.
If  DLATMR, SLATMS, DSYGV, DSPGV, DSBGV, SSYGVD, SSPGVD,
DSBGVD, DSYGVX, DSPGVX or SSBGVX returns an error code,
the absolute value of it is returned.
Modified.

----------------------------------------------------------------------

Some Local Variables and Parameters:
---- ----- --------- --- ----------
ZERO, ONE       Real 0 and 1.
MAXTYP          The number of types defined.
NTEST           The number of tests that have been run
on this matrix.
NTESTT          The total number of tests for this call.
NMAX            Largest value in NN.
NMATS           The number of matrices generated so far.
NERRS           The number of tests which have exceeded THRESH
so far (computed by DLAFTS).
COND, IMODE     Values to be passed to the matrix generators.
ANORM           Norm of A; passed to matrix generators.

OVFL, UNFL      Overflow and underflow thresholds.
ULP, ULPINV     Finest relative precision and its inverse.
RTOVFL, RTUNFL  Square roots of the previous 2 values.
The following four arrays decode JTYPE:
KTYPE(j)        The general type (1-10) for type "j".
KMODE(j)        The MODE value to be passed to the matrix
generator for type "j".
KMAGN(j)        The order of magnitude ( O(1),
O(overflow^(1/2) ), O(underflow^(1/2) )```

Definition at line 352 of file ddrvsg.f.

355 *
356 * -- LAPACK test routine --
357 * -- LAPACK is a software package provided by Univ. of Tennessee, --
358 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
359 *
360 * .. Scalar Arguments ..
361  INTEGER INFO, LDA, LDB, LDZ, LIWORK, NOUNIT, NSIZES,
362  \$ NTYPES, NWORK
363  DOUBLE PRECISION THRESH
364 * ..
365 * .. Array Arguments ..
366  LOGICAL DOTYPE( * )
367  INTEGER ISEED( 4 ), IWORK( * ), NN( * )
368  DOUBLE PRECISION A( LDA, * ), AB( LDA, * ), AP( * ),
369  \$ B( LDB, * ), BB( LDB, * ), BP( * ), D( * ),
370  \$ RESULT( * ), WORK( * ), Z( LDZ, * )
371 * ..
372 *
373 * =====================================================================
374 *
375 * .. Parameters ..
376  DOUBLE PRECISION ZERO, ONE, TEN
377  parameter( zero = 0.0d0, one = 1.0d0, ten = 10.0d0 )
378  INTEGER MAXTYP
379  parameter( maxtyp = 21 )
380 * ..
381 * .. Local Scalars ..
383  CHARACTER UPLO
384  INTEGER I, IBTYPE, IBUPLO, IINFO, IJ, IL, IMODE, ITEMP,
385  \$ ITYPE, IU, J, JCOL, JSIZE, JTYPE, KA, KA9, KB,
386  \$ KB9, M, MTYPES, N, NERRS, NMATS, NMAX, NTEST,
387  \$ NTESTT
388  DOUBLE PRECISION ABSTOL, ANINV, ANORM, COND, OVFL, RTOVFL,
389  \$ RTUNFL, ULP, ULPINV, UNFL, VL, VU
390 * ..
391 * .. Local Arrays ..
392  INTEGER IDUMMA( 1 ), IOLDSD( 4 ), ISEED2( 4 ),
393  \$ KMAGN( MAXTYP ), KMODE( MAXTYP ),
394  \$ KTYPE( MAXTYP )
395 * ..
396 * .. External Functions ..
397  LOGICAL LSAME
398  DOUBLE PRECISION DLAMCH, DLARND
399  EXTERNAL lsame, dlamch, dlarnd
400 * ..
401 * .. External Subroutines ..
402  EXTERNAL dlabad, dlacpy, dlafts, dlaset, dlasum, dlatmr,
405 * ..
406 * .. Intrinsic Functions ..
407  INTRINSIC abs, dble, max, min, sqrt
408 * ..
409 * .. Data statements ..
410  DATA ktype / 1, 2, 5*4, 5*5, 3*8, 6*9 /
411  DATA kmagn / 2*1, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 1,
412  \$ 2, 3, 6*1 /
413  DATA kmode / 2*0, 4, 3, 1, 4, 4, 4, 3, 1, 4, 4, 0,
414  \$ 0, 0, 6*4 /
415 * ..
416 * .. Executable Statements ..
417 *
418 * 1) Check for errors
419 *
420  ntestt = 0
421  info = 0
422 *
424  nmax = 0
425  DO 10 j = 1, nsizes
426  nmax = max( nmax, nn( j ) )
427  IF( nn( j ).LT.0 )
429  10 CONTINUE
430 *
431 * Check for errors
432 *
433  IF( nsizes.LT.0 ) THEN
434  info = -1
435  ELSE IF( badnn ) THEN
436  info = -2
437  ELSE IF( ntypes.LT.0 ) THEN
438  info = -3
439  ELSE IF( lda.LE.1 .OR. lda.LT.nmax ) THEN
440  info = -9
441  ELSE IF( ldz.LE.1 .OR. ldz.LT.nmax ) THEN
442  info = -16
443  ELSE IF( 2*max( nmax, 3 )**2.GT.nwork ) THEN
444  info = -21
445  ELSE IF( 2*max( nmax, 3 )**2.GT.liwork ) THEN
446  info = -23
447  END IF
448 *
449  IF( info.NE.0 ) THEN
450  CALL xerbla( 'DDRVSG', -info )
451  RETURN
452  END IF
453 *
454 * Quick return if possible
455 *
456  IF( nsizes.EQ.0 .OR. ntypes.EQ.0 )
457  \$ RETURN
458 *
459 * More Important constants
460 *
461  unfl = dlamch( 'Safe minimum' )
462  ovfl = dlamch( 'Overflow' )
463  CALL dlabad( unfl, ovfl )
464  ulp = dlamch( 'Epsilon' )*dlamch( 'Base' )
465  ulpinv = one / ulp
466  rtunfl = sqrt( unfl )
467  rtovfl = sqrt( ovfl )
468 *
469  DO 20 i = 1, 4
470  iseed2( i ) = iseed( i )
471  20 CONTINUE
472 *
473 * Loop over sizes, types
474 *
475  nerrs = 0
476  nmats = 0
477 *
478  DO 650 jsize = 1, nsizes
479  n = nn( jsize )
480  aninv = one / dble( max( 1, n ) )
481 *
482  IF( nsizes.NE.1 ) THEN
483  mtypes = min( maxtyp, ntypes )
484  ELSE
485  mtypes = min( maxtyp+1, ntypes )
486  END IF
487 *
488  ka9 = 0
489  kb9 = 0
490  DO 640 jtype = 1, mtypes
491  IF( .NOT.dotype( jtype ) )
492  \$ GO TO 640
493  nmats = nmats + 1
494  ntest = 0
495 *
496  DO 30 j = 1, 4
497  ioldsd( j ) = iseed( j )
498  30 CONTINUE
499 *
500 * 2) Compute "A"
501 *
502 * Control parameters:
503 *
504 * KMAGN KMODE KTYPE
505 * =1 O(1) clustered 1 zero
506 * =2 large clustered 2 identity
507 * =3 small exponential (none)
508 * =4 arithmetic diagonal, w/ eigenvalues
509 * =5 random log hermitian, w/ eigenvalues
510 * =6 random (none)
511 * =7 random diagonal
512 * =8 random hermitian
513 * =9 banded, w/ eigenvalues
514 *
515  IF( mtypes.GT.maxtyp )
516  \$ GO TO 90
517 *
518  itype = ktype( jtype )
519  imode = kmode( jtype )
520 *
521 * Compute norm
522 *
523  GO TO ( 40, 50, 60 )kmagn( jtype )
524 *
525  40 CONTINUE
526  anorm = one
527  GO TO 70
528 *
529  50 CONTINUE
530  anorm = ( rtovfl*ulp )*aninv
531  GO TO 70
532 *
533  60 CONTINUE
534  anorm = rtunfl*n*ulpinv
535  GO TO 70
536 *
537  70 CONTINUE
538 *
539  iinfo = 0
540  cond = ulpinv
541 *
542 * Special Matrices -- Identity & Jordan block
543 *
544  IF( itype.EQ.1 ) THEN
545 *
546 * Zero
547 *
548  ka = 0
549  kb = 0
550  CALL dlaset( 'Full', lda, n, zero, zero, a, lda )
551 *
552  ELSE IF( itype.EQ.2 ) THEN
553 *
554 * Identity
555 *
556  ka = 0
557  kb = 0
558  CALL dlaset( 'Full', lda, n, zero, zero, a, lda )
559  DO 80 jcol = 1, n
560  a( jcol, jcol ) = anorm
561  80 CONTINUE
562 *
563  ELSE IF( itype.EQ.4 ) THEN
564 *
565 * Diagonal Matrix, [Eigen]values Specified
566 *
567  ka = 0
568  kb = 0
569  CALL dlatms( n, n, 'S', iseed, 'S', work, imode, cond,
570  \$ anorm, 0, 0, 'N', a, lda, work( n+1 ),
571  \$ iinfo )
572 *
573  ELSE IF( itype.EQ.5 ) THEN
574 *
575 * symmetric, eigenvalues specified
576 *
577  ka = max( 0, n-1 )
578  kb = ka
579  CALL dlatms( n, n, 'S', iseed, 'S', work, imode, cond,
580  \$ anorm, n, n, 'N', a, lda, work( n+1 ),
581  \$ iinfo )
582 *
583  ELSE IF( itype.EQ.7 ) THEN
584 *
585 * Diagonal, random eigenvalues
586 *
587  ka = 0
588  kb = 0
589  CALL dlatmr( n, n, 'S', iseed, 'S', work, 6, one, one,
590  \$ 'T', 'N', work( n+1 ), 1, one,
591  \$ work( 2*n+1 ), 1, one, 'N', idumma, 0, 0,
592  \$ zero, anorm, 'NO', a, lda, iwork, iinfo )
593 *
594  ELSE IF( itype.EQ.8 ) THEN
595 *
596 * symmetric, random eigenvalues
597 *
598  ka = max( 0, n-1 )
599  kb = ka
600  CALL dlatmr( n, n, 'S', iseed, 'H', work, 6, one, one,
601  \$ 'T', 'N', work( n+1 ), 1, one,
602  \$ work( 2*n+1 ), 1, one, 'N', idumma, n, n,
603  \$ zero, anorm, 'NO', a, lda, iwork, iinfo )
604 *
605  ELSE IF( itype.EQ.9 ) THEN
606 *
607 * symmetric banded, eigenvalues specified
608 *
609 * The following values are used for the half-bandwidths:
610 *
611 * ka = 1 kb = 1
612 * ka = 2 kb = 1
613 * ka = 2 kb = 2
614 * ka = 3 kb = 1
615 * ka = 3 kb = 2
616 * ka = 3 kb = 3
617 *
618  kb9 = kb9 + 1
619  IF( kb9.GT.ka9 ) THEN
620  ka9 = ka9 + 1
621  kb9 = 1
622  END IF
623  ka = max( 0, min( n-1, ka9 ) )
624  kb = max( 0, min( n-1, kb9 ) )
625  CALL dlatms( n, n, 'S', iseed, 'S', work, imode, cond,
626  \$ anorm, ka, ka, 'N', a, lda, work( n+1 ),
627  \$ iinfo )
628 *
629  ELSE
630 *
631  iinfo = 1
632  END IF
633 *
634  IF( iinfo.NE.0 ) THEN
635  WRITE( nounit, fmt = 9999 )'Generator', iinfo, n, jtype,
636  \$ ioldsd
637  info = abs( iinfo )
638  RETURN
639  END IF
640 *
641  90 CONTINUE
642 *
643  abstol = unfl + unfl
644  IF( n.LE.1 ) THEN
645  il = 1
646  iu = n
647  ELSE
648  il = 1 + ( n-1 )*dlarnd( 1, iseed2 )
649  iu = 1 + ( n-1 )*dlarnd( 1, iseed2 )
650  IF( il.GT.iu ) THEN
651  itemp = il
652  il = iu
653  iu = itemp
654  END IF
655  END IF
656 *
657 * 3) Call DSYGV, DSPGV, DSBGV, SSYGVD, SSPGVD, SSBGVD,
658 * DSYGVX, DSPGVX, and DSBGVX, do tests.
659 *
660 * loop over the three generalized problems
661 * IBTYPE = 1: A*x = (lambda)*B*x
662 * IBTYPE = 2: A*B*x = (lambda)*x
663 * IBTYPE = 3: B*A*x = (lambda)*x
664 *
665  DO 630 ibtype = 1, 3
666 *
667 * loop over the setting UPLO
668 *
669  DO 620 ibuplo = 1, 2
670  IF( ibuplo.EQ.1 )
671  \$ uplo = 'U'
672  IF( ibuplo.EQ.2 )
673  \$ uplo = 'L'
674 *
675 * Generate random well-conditioned positive definite
676 * matrix B, of bandwidth not greater than that of A.
677 *
678  CALL dlatms( n, n, 'U', iseed, 'P', work, 5, ten, one,
679  \$ kb, kb, uplo, b, ldb, work( n+1 ),
680  \$ iinfo )
681 *
682 * Test DSYGV
683 *
684  ntest = ntest + 1
685 *
686  CALL dlacpy( ' ', n, n, a, lda, z, ldz )
687  CALL dlacpy( uplo, n, n, b, ldb, bb, ldb )
688 *
689  CALL dsygv( ibtype, 'V', uplo, n, z, ldz, bb, ldb, d,
690  \$ work, nwork, iinfo )
691  IF( iinfo.NE.0 ) THEN
692  WRITE( nounit, fmt = 9999 )'DSYGV(V,' // uplo //
693  \$ ')', iinfo, n, jtype, ioldsd
694  info = abs( iinfo )
695  IF( iinfo.LT.0 ) THEN
696  RETURN
697  ELSE
698  result( ntest ) = ulpinv
699  GO TO 100
700  END IF
701  END IF
702 *
703 * Do Test
704 *
705  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
706  \$ ldz, d, work, result( ntest ) )
707 *
708 * Test DSYGVD
709 *
710  ntest = ntest + 1
711 *
712  CALL dlacpy( ' ', n, n, a, lda, z, ldz )
713  CALL dlacpy( uplo, n, n, b, ldb, bb, ldb )
714 *
715  CALL dsygvd( ibtype, 'V', uplo, n, z, ldz, bb, ldb, d,
716  \$ work, nwork, iwork, liwork, iinfo )
717  IF( iinfo.NE.0 ) THEN
718  WRITE( nounit, fmt = 9999 )'DSYGVD(V,' // uplo //
719  \$ ')', iinfo, n, jtype, ioldsd
720  info = abs( iinfo )
721  IF( iinfo.LT.0 ) THEN
722  RETURN
723  ELSE
724  result( ntest ) = ulpinv
725  GO TO 100
726  END IF
727  END IF
728 *
729 * Do Test
730 *
731  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
732  \$ ldz, d, work, result( ntest ) )
733 *
734 * Test DSYGVX
735 *
736  ntest = ntest + 1
737 *
738  CALL dlacpy( ' ', n, n, a, lda, ab, lda )
739  CALL dlacpy( uplo, n, n, b, ldb, bb, ldb )
740 *
741  CALL dsygvx( ibtype, 'V', 'A', uplo, n, ab, lda, bb,
742  \$ ldb, vl, vu, il, iu, abstol, m, d, z,
743  \$ ldz, work, nwork, iwork( n+1 ), iwork,
744  \$ iinfo )
745  IF( iinfo.NE.0 ) THEN
746  WRITE( nounit, fmt = 9999 )'DSYGVX(V,A' // uplo //
747  \$ ')', iinfo, n, jtype, ioldsd
748  info = abs( iinfo )
749  IF( iinfo.LT.0 ) THEN
750  RETURN
751  ELSE
752  result( ntest ) = ulpinv
753  GO TO 100
754  END IF
755  END IF
756 *
757 * Do Test
758 *
759  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
760  \$ ldz, d, work, result( ntest ) )
761 *
762  ntest = ntest + 1
763 *
764  CALL dlacpy( ' ', n, n, a, lda, ab, lda )
765  CALL dlacpy( uplo, n, n, b, ldb, bb, ldb )
766 *
767 * since we do not know the exact eigenvalues of this
768 * eigenpair, we just set VL and VU as constants.
769 * It is quite possible that there are no eigenvalues
770 * in this interval.
771 *
772  vl = zero
773  vu = anorm
774  CALL dsygvx( ibtype, 'V', 'V', uplo, n, ab, lda, bb,
775  \$ ldb, vl, vu, il, iu, abstol, m, d, z,
776  \$ ldz, work, nwork, iwork( n+1 ), iwork,
777  \$ iinfo )
778  IF( iinfo.NE.0 ) THEN
779  WRITE( nounit, fmt = 9999 )'DSYGVX(V,V,' //
780  \$ uplo // ')', iinfo, n, jtype, ioldsd
781  info = abs( iinfo )
782  IF( iinfo.LT.0 ) THEN
783  RETURN
784  ELSE
785  result( ntest ) = ulpinv
786  GO TO 100
787  END IF
788  END IF
789 *
790 * Do Test
791 *
792  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
793  \$ ldz, d, work, result( ntest ) )
794 *
795  ntest = ntest + 1
796 *
797  CALL dlacpy( ' ', n, n, a, lda, ab, lda )
798  CALL dlacpy( uplo, n, n, b, ldb, bb, ldb )
799 *
800  CALL dsygvx( ibtype, 'V', 'I', uplo, n, ab, lda, bb,
801  \$ ldb, vl, vu, il, iu, abstol, m, d, z,
802  \$ ldz, work, nwork, iwork( n+1 ), iwork,
803  \$ iinfo )
804  IF( iinfo.NE.0 ) THEN
805  WRITE( nounit, fmt = 9999 )'DSYGVX(V,I,' //
806  \$ uplo // ')', iinfo, n, jtype, ioldsd
807  info = abs( iinfo )
808  IF( iinfo.LT.0 ) THEN
809  RETURN
810  ELSE
811  result( ntest ) = ulpinv
812  GO TO 100
813  END IF
814  END IF
815 *
816 * Do Test
817 *
818  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
819  \$ ldz, d, work, result( ntest ) )
820 *
821  100 CONTINUE
822 *
823 * Test DSPGV
824 *
825  ntest = ntest + 1
826 *
827 * Copy the matrices into packed storage.
828 *
829  IF( lsame( uplo, 'U' ) ) THEN
830  ij = 1
831  DO 120 j = 1, n
832  DO 110 i = 1, j
833  ap( ij ) = a( i, j )
834  bp( ij ) = b( i, j )
835  ij = ij + 1
836  110 CONTINUE
837  120 CONTINUE
838  ELSE
839  ij = 1
840  DO 140 j = 1, n
841  DO 130 i = j, n
842  ap( ij ) = a( i, j )
843  bp( ij ) = b( i, j )
844  ij = ij + 1
845  130 CONTINUE
846  140 CONTINUE
847  END IF
848 *
849  CALL dspgv( ibtype, 'V', uplo, n, ap, bp, d, z, ldz,
850  \$ work, iinfo )
851  IF( iinfo.NE.0 ) THEN
852  WRITE( nounit, fmt = 9999 )'DSPGV(V,' // uplo //
853  \$ ')', iinfo, n, jtype, ioldsd
854  info = abs( iinfo )
855  IF( iinfo.LT.0 ) THEN
856  RETURN
857  ELSE
858  result( ntest ) = ulpinv
859  GO TO 310
860  END IF
861  END IF
862 *
863 * Do Test
864 *
865  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
866  \$ ldz, d, work, result( ntest ) )
867 *
868 * Test DSPGVD
869 *
870  ntest = ntest + 1
871 *
872 * Copy the matrices into packed storage.
873 *
874  IF( lsame( uplo, 'U' ) ) THEN
875  ij = 1
876  DO 160 j = 1, n
877  DO 150 i = 1, j
878  ap( ij ) = a( i, j )
879  bp( ij ) = b( i, j )
880  ij = ij + 1
881  150 CONTINUE
882  160 CONTINUE
883  ELSE
884  ij = 1
885  DO 180 j = 1, n
886  DO 170 i = j, n
887  ap( ij ) = a( i, j )
888  bp( ij ) = b( i, j )
889  ij = ij + 1
890  170 CONTINUE
891  180 CONTINUE
892  END IF
893 *
894  CALL dspgvd( ibtype, 'V', uplo, n, ap, bp, d, z, ldz,
895  \$ work, nwork, iwork, liwork, iinfo )
896  IF( iinfo.NE.0 ) THEN
897  WRITE( nounit, fmt = 9999 )'DSPGVD(V,' // uplo //
898  \$ ')', iinfo, n, jtype, ioldsd
899  info = abs( iinfo )
900  IF( iinfo.LT.0 ) THEN
901  RETURN
902  ELSE
903  result( ntest ) = ulpinv
904  GO TO 310
905  END IF
906  END IF
907 *
908 * Do Test
909 *
910  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
911  \$ ldz, d, work, result( ntest ) )
912 *
913 * Test DSPGVX
914 *
915  ntest = ntest + 1
916 *
917 * Copy the matrices into packed storage.
918 *
919  IF( lsame( uplo, 'U' ) ) THEN
920  ij = 1
921  DO 200 j = 1, n
922  DO 190 i = 1, j
923  ap( ij ) = a( i, j )
924  bp( ij ) = b( i, j )
925  ij = ij + 1
926  190 CONTINUE
927  200 CONTINUE
928  ELSE
929  ij = 1
930  DO 220 j = 1, n
931  DO 210 i = j, n
932  ap( ij ) = a( i, j )
933  bp( ij ) = b( i, j )
934  ij = ij + 1
935  210 CONTINUE
936  220 CONTINUE
937  END IF
938 *
939  CALL dspgvx( ibtype, 'V', 'A', uplo, n, ap, bp, vl,
940  \$ vu, il, iu, abstol, m, d, z, ldz, work,
941  \$ iwork( n+1 ), iwork, info )
942  IF( iinfo.NE.0 ) THEN
943  WRITE( nounit, fmt = 9999 )'DSPGVX(V,A' // uplo //
944  \$ ')', iinfo, n, jtype, ioldsd
945  info = abs( iinfo )
946  IF( iinfo.LT.0 ) THEN
947  RETURN
948  ELSE
949  result( ntest ) = ulpinv
950  GO TO 310
951  END IF
952  END IF
953 *
954 * Do Test
955 *
956  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
957  \$ ldz, d, work, result( ntest ) )
958 *
959  ntest = ntest + 1
960 *
961 * Copy the matrices into packed storage.
962 *
963  IF( lsame( uplo, 'U' ) ) THEN
964  ij = 1
965  DO 240 j = 1, n
966  DO 230 i = 1, j
967  ap( ij ) = a( i, j )
968  bp( ij ) = b( i, j )
969  ij = ij + 1
970  230 CONTINUE
971  240 CONTINUE
972  ELSE
973  ij = 1
974  DO 260 j = 1, n
975  DO 250 i = j, n
976  ap( ij ) = a( i, j )
977  bp( ij ) = b( i, j )
978  ij = ij + 1
979  250 CONTINUE
980  260 CONTINUE
981  END IF
982 *
983  vl = zero
984  vu = anorm
985  CALL dspgvx( ibtype, 'V', 'V', uplo, n, ap, bp, vl,
986  \$ vu, il, iu, abstol, m, d, z, ldz, work,
987  \$ iwork( n+1 ), iwork, info )
988  IF( iinfo.NE.0 ) THEN
989  WRITE( nounit, fmt = 9999 )'DSPGVX(V,V' // uplo //
990  \$ ')', iinfo, n, jtype, ioldsd
991  info = abs( iinfo )
992  IF( iinfo.LT.0 ) THEN
993  RETURN
994  ELSE
995  result( ntest ) = ulpinv
996  GO TO 310
997  END IF
998  END IF
999 *
1000 * Do Test
1001 *
1002  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
1003  \$ ldz, d, work, result( ntest ) )
1004 *
1005  ntest = ntest + 1
1006 *
1007 * Copy the matrices into packed storage.
1008 *
1009  IF( lsame( uplo, 'U' ) ) THEN
1010  ij = 1
1011  DO 280 j = 1, n
1012  DO 270 i = 1, j
1013  ap( ij ) = a( i, j )
1014  bp( ij ) = b( i, j )
1015  ij = ij + 1
1016  270 CONTINUE
1017  280 CONTINUE
1018  ELSE
1019  ij = 1
1020  DO 300 j = 1, n
1021  DO 290 i = j, n
1022  ap( ij ) = a( i, j )
1023  bp( ij ) = b( i, j )
1024  ij = ij + 1
1025  290 CONTINUE
1026  300 CONTINUE
1027  END IF
1028 *
1029  CALL dspgvx( ibtype, 'V', 'I', uplo, n, ap, bp, vl,
1030  \$ vu, il, iu, abstol, m, d, z, ldz, work,
1031  \$ iwork( n+1 ), iwork, info )
1032  IF( iinfo.NE.0 ) THEN
1033  WRITE( nounit, fmt = 9999 )'DSPGVX(V,I' // uplo //
1034  \$ ')', iinfo, n, jtype, ioldsd
1035  info = abs( iinfo )
1036  IF( iinfo.LT.0 ) THEN
1037  RETURN
1038  ELSE
1039  result( ntest ) = ulpinv
1040  GO TO 310
1041  END IF
1042  END IF
1043 *
1044 * Do Test
1045 *
1046  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
1047  \$ ldz, d, work, result( ntest ) )
1048 *
1049  310 CONTINUE
1050 *
1051  IF( ibtype.EQ.1 ) THEN
1052 *
1053 * TEST DSBGV
1054 *
1055  ntest = ntest + 1
1056 *
1057 * Copy the matrices into band storage.
1058 *
1059  IF( lsame( uplo, 'U' ) ) THEN
1060  DO 340 j = 1, n
1061  DO 320 i = max( 1, j-ka ), j
1062  ab( ka+1+i-j, j ) = a( i, j )
1063  320 CONTINUE
1064  DO 330 i = max( 1, j-kb ), j
1065  bb( kb+1+i-j, j ) = b( i, j )
1066  330 CONTINUE
1067  340 CONTINUE
1068  ELSE
1069  DO 370 j = 1, n
1070  DO 350 i = j, min( n, j+ka )
1071  ab( 1+i-j, j ) = a( i, j )
1072  350 CONTINUE
1073  DO 360 i = j, min( n, j+kb )
1074  bb( 1+i-j, j ) = b( i, j )
1075  360 CONTINUE
1076  370 CONTINUE
1077  END IF
1078 *
1079  CALL dsbgv( 'V', uplo, n, ka, kb, ab, lda, bb, ldb,
1080  \$ d, z, ldz, work, iinfo )
1081  IF( iinfo.NE.0 ) THEN
1082  WRITE( nounit, fmt = 9999 )'DSBGV(V,' //
1083  \$ uplo // ')', iinfo, n, jtype, ioldsd
1084  info = abs( iinfo )
1085  IF( iinfo.LT.0 ) THEN
1086  RETURN
1087  ELSE
1088  result( ntest ) = ulpinv
1089  GO TO 620
1090  END IF
1091  END IF
1092 *
1093 * Do Test
1094 *
1095  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
1096  \$ ldz, d, work, result( ntest ) )
1097 *
1098 * TEST DSBGVD
1099 *
1100  ntest = ntest + 1
1101 *
1102 * Copy the matrices into band storage.
1103 *
1104  IF( lsame( uplo, 'U' ) ) THEN
1105  DO 400 j = 1, n
1106  DO 380 i = max( 1, j-ka ), j
1107  ab( ka+1+i-j, j ) = a( i, j )
1108  380 CONTINUE
1109  DO 390 i = max( 1, j-kb ), j
1110  bb( kb+1+i-j, j ) = b( i, j )
1111  390 CONTINUE
1112  400 CONTINUE
1113  ELSE
1114  DO 430 j = 1, n
1115  DO 410 i = j, min( n, j+ka )
1116  ab( 1+i-j, j ) = a( i, j )
1117  410 CONTINUE
1118  DO 420 i = j, min( n, j+kb )
1119  bb( 1+i-j, j ) = b( i, j )
1120  420 CONTINUE
1121  430 CONTINUE
1122  END IF
1123 *
1124  CALL dsbgvd( 'V', uplo, n, ka, kb, ab, lda, bb,
1125  \$ ldb, d, z, ldz, work, nwork, iwork,
1126  \$ liwork, iinfo )
1127  IF( iinfo.NE.0 ) THEN
1128  WRITE( nounit, fmt = 9999 )'DSBGVD(V,' //
1129  \$ uplo // ')', iinfo, n, jtype, ioldsd
1130  info = abs( iinfo )
1131  IF( iinfo.LT.0 ) THEN
1132  RETURN
1133  ELSE
1134  result( ntest ) = ulpinv
1135  GO TO 620
1136  END IF
1137  END IF
1138 *
1139 * Do Test
1140 *
1141  CALL dsgt01( ibtype, uplo, n, n, a, lda, b, ldb, z,
1142  \$ ldz, d, work, result( ntest ) )
1143 *
1144 * Test DSBGVX
1145 *
1146  ntest = ntest + 1
1147 *
1148 * Copy the matrices into band storage.
1149 *
1150  IF( lsame( uplo, 'U' ) ) THEN
1151  DO 460 j = 1, n
1152  DO 440 i = max( 1, j-ka ), j
1153  ab( ka+1+i-j, j ) = a( i, j )
1154  440 CONTINUE
1155  DO 450 i = max( 1, j-kb ), j
1156  bb( kb+1+i-j, j ) = b( i, j )
1157  450 CONTINUE
1158  460 CONTINUE
1159  ELSE
1160  DO 490 j = 1, n
1161  DO 470 i = j, min( n, j+ka )
1162  ab( 1+i-j, j ) = a( i, j )
1163  470 CONTINUE
1164  DO 480 i = j, min( n, j+kb )
1165  bb( 1+i-j, j ) = b( i, j )
1166  480 CONTINUE
1167  490 CONTINUE
1168  END IF
1169 *
1170  CALL dsbgvx( 'V', 'A', uplo, n, ka, kb, ab, lda,
1171  \$ bb, ldb, bp, max( 1, n ), vl, vu, il,
1172  \$ iu, abstol, m, d, z, ldz, work,
1173  \$ iwork( n+1 ), iwork, iinfo )
1174  IF( iinfo.NE.0 ) THEN
1175  WRITE( nounit, fmt = 9999 )'DSBGVX(V,A' //
1176  \$ uplo // ')', iinfo, n, jtype, ioldsd
1177  info = abs( iinfo )
1178  IF( iinfo.LT.0 ) THEN
1179  RETURN
1180  ELSE
1181  result( ntest ) = ulpinv
1182  GO TO 620
1183  END IF
1184  END IF
1185 *
1186 * Do Test
1187 *
1188  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
1189  \$ ldz, d, work, result( ntest ) )
1190 *
1191 *
1192  ntest = ntest + 1
1193 *
1194 * Copy the matrices into band storage.
1195 *
1196  IF( lsame( uplo, 'U' ) ) THEN
1197  DO 520 j = 1, n
1198  DO 500 i = max( 1, j-ka ), j
1199  ab( ka+1+i-j, j ) = a( i, j )
1200  500 CONTINUE
1201  DO 510 i = max( 1, j-kb ), j
1202  bb( kb+1+i-j, j ) = b( i, j )
1203  510 CONTINUE
1204  520 CONTINUE
1205  ELSE
1206  DO 550 j = 1, n
1207  DO 530 i = j, min( n, j+ka )
1208  ab( 1+i-j, j ) = a( i, j )
1209  530 CONTINUE
1210  DO 540 i = j, min( n, j+kb )
1211  bb( 1+i-j, j ) = b( i, j )
1212  540 CONTINUE
1213  550 CONTINUE
1214  END IF
1215 *
1216  vl = zero
1217  vu = anorm
1218  CALL dsbgvx( 'V', 'V', uplo, n, ka, kb, ab, lda,
1219  \$ bb, ldb, bp, max( 1, n ), vl, vu, il,
1220  \$ iu, abstol, m, d, z, ldz, work,
1221  \$ iwork( n+1 ), iwork, iinfo )
1222  IF( iinfo.NE.0 ) THEN
1223  WRITE( nounit, fmt = 9999 )'DSBGVX(V,V' //
1224  \$ uplo // ')', iinfo, n, jtype, ioldsd
1225  info = abs( iinfo )
1226  IF( iinfo.LT.0 ) THEN
1227  RETURN
1228  ELSE
1229  result( ntest ) = ulpinv
1230  GO TO 620
1231  END IF
1232  END IF
1233 *
1234 * Do Test
1235 *
1236  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
1237  \$ ldz, d, work, result( ntest ) )
1238 *
1239  ntest = ntest + 1
1240 *
1241 * Copy the matrices into band storage.
1242 *
1243  IF( lsame( uplo, 'U' ) ) THEN
1244  DO 580 j = 1, n
1245  DO 560 i = max( 1, j-ka ), j
1246  ab( ka+1+i-j, j ) = a( i, j )
1247  560 CONTINUE
1248  DO 570 i = max( 1, j-kb ), j
1249  bb( kb+1+i-j, j ) = b( i, j )
1250  570 CONTINUE
1251  580 CONTINUE
1252  ELSE
1253  DO 610 j = 1, n
1254  DO 590 i = j, min( n, j+ka )
1255  ab( 1+i-j, j ) = a( i, j )
1256  590 CONTINUE
1257  DO 600 i = j, min( n, j+kb )
1258  bb( 1+i-j, j ) = b( i, j )
1259  600 CONTINUE
1260  610 CONTINUE
1261  END IF
1262 *
1263  CALL dsbgvx( 'V', 'I', uplo, n, ka, kb, ab, lda,
1264  \$ bb, ldb, bp, max( 1, n ), vl, vu, il,
1265  \$ iu, abstol, m, d, z, ldz, work,
1266  \$ iwork( n+1 ), iwork, iinfo )
1267  IF( iinfo.NE.0 ) THEN
1268  WRITE( nounit, fmt = 9999 )'DSBGVX(V,I' //
1269  \$ uplo // ')', iinfo, n, jtype, ioldsd
1270  info = abs( iinfo )
1271  IF( iinfo.LT.0 ) THEN
1272  RETURN
1273  ELSE
1274  result( ntest ) = ulpinv
1275  GO TO 620
1276  END IF
1277  END IF
1278 *
1279 * Do Test
1280 *
1281  CALL dsgt01( ibtype, uplo, n, m, a, lda, b, ldb, z,
1282  \$ ldz, d, work, result( ntest ) )
1283 *
1284  END IF
1285 *
1286  620 CONTINUE
1287  630 CONTINUE
1288 *
1289 * End of Loop -- Check for RESULT(j) > THRESH
1290 *
1291  ntestt = ntestt + ntest
1292  CALL dlafts( 'DSG', n, n, jtype, ntest, result, ioldsd,
1293  \$ thresh, nounit, nerrs )
1294  640 CONTINUE
1295  650 CONTINUE
1296 *
1297 * Summary
1298 *
1299  CALL dlasum( 'DSG', nounit, nerrs, ntestt )
1300 *
1301  RETURN
1302 *
1303 * End of DDRVSG
1304 *
1305  9999 FORMAT( ' DDRVSG: ', a, ' returned INFO=', i6, '.', / 9x, 'N=',
1306  \$ i6, ', JTYPE=', i6, ', ISEED=(', 3( i5, ',' ), i5, ')' )
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
subroutine dlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: dlaset.f:110
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine dlasum(TYPE, IOUNIT, IE, NRUN)
DLASUM
Definition: dlasum.f:43
subroutine dlafts(TYPE, M, N, IMAT, NTESTS, RESULT, ISEED, THRESH, IOUNIT, IE)
DLAFTS
Definition: dlafts.f:99
subroutine dsgt01(ITYPE, UPLO, N, M, A, LDA, B, LDB, Z, LDZ, D, WORK, RESULT)
DSGT01
Definition: dsgt01.f:146
subroutine dlatmr(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, RSIGN, GRADE, DL, MODEL, CONDL, DR, MODER, CONDR, PIVTNG, IPIVOT, KL, KU, SPARSE, ANORM, PACK, A, LDA, IWORK, INFO)
DLATMR
Definition: dlatmr.f:471
double precision function dlarnd(IDIST, ISEED)
DLARND
Definition: dlarnd.f:73
subroutine dlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
DLATMS
Definition: dlatms.f:321
subroutine dspgvx(ITYPE, JOBZ, RANGE, UPLO, N, AP, BP, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
DSPGVX
Definition: dspgvx.f:272
subroutine dsbgv(JOBZ, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, W, Z, LDZ, WORK, INFO)
DSBGV
Definition: dsbgv.f:177
subroutine dspgv(ITYPE, JOBZ, UPLO, N, AP, BP, W, Z, LDZ, WORK, INFO)
DSPGV
Definition: dspgv.f:160
subroutine dsbgvd(JOBZ, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, W, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
DSBGVD
Definition: dsbgvd.f:227
subroutine dsbgvx(JOBZ, RANGE, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, Q, LDQ, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
DSBGVX
Definition: dsbgvx.f:294
subroutine dspgvd(ITYPE, JOBZ, UPLO, N, AP, BP, W, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
DSPGVD
Definition: dspgvd.f:210
subroutine dsygv(ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, INFO)
DSYGV
Definition: dsygv.f:175
subroutine dsygvx(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, IWORK, IFAIL, INFO)
DSYGVX
Definition: dsygvx.f:297
subroutine dsygvd(ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, LWORK, IWORK, LIWORK, INFO)
DSYGVD
Definition: dsygvd.f:227
Here is the call graph for this function:
Here is the caller graph for this function: