|       PROGRAM DBLAT2 | 
 | * | 
 | *  Test program for the DOUBLE PRECISION Level 2 Blas. | 
 | * | 
 | *  The program must be driven by a short data file. The first 18 records | 
 | *  of the file are read using list-directed input, the last 16 records | 
 | *  are read using the format ( A6, L2 ). An annotated example of a data | 
 | *  file can be obtained by deleting the first 3 characters from the | 
 | *  following 34 lines: | 
 | *  'DBLAT2.SUMM'     NAME OF SUMMARY OUTPUT FILE | 
 | *  6                 UNIT NUMBER OF SUMMARY FILE | 
 | *  'DBLAT2.SNAP'     NAME OF SNAPSHOT OUTPUT FILE | 
 | *  -1                UNIT NUMBER OF SNAPSHOT FILE (NOT USED IF .LT. 0) | 
 | *  F        LOGICAL FLAG, T TO REWIND SNAPSHOT FILE AFTER EACH RECORD. | 
 | *  F        LOGICAL FLAG, T TO STOP ON FAILURES. | 
 | *  T        LOGICAL FLAG, T TO TEST ERROR EXITS. | 
 | *  16.0     THRESHOLD VALUE OF TEST RATIO | 
 | *  6                 NUMBER OF VALUES OF N | 
 | *  0 1 2 3 5 9       VALUES OF N | 
 | *  4                 NUMBER OF VALUES OF K | 
 | *  0 1 2 4           VALUES OF K | 
 | *  4                 NUMBER OF VALUES OF INCX AND INCY | 
 | *  1 2 -1 -2         VALUES OF INCX AND INCY | 
 | *  3                 NUMBER OF VALUES OF ALPHA | 
 | *  0.0 1.0 0.7       VALUES OF ALPHA | 
 | *  3                 NUMBER OF VALUES OF BETA | 
 | *  0.0 1.0 0.9       VALUES OF BETA | 
 | *  DGEMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DGBMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSYMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSBMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSPMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DTRMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DTBMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DTPMV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DTRSV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DTBSV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DTPSV  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DGER   T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSYR   T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSPR   T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSYR2  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | *  DSPR2  T PUT F FOR NO TEST. SAME COLUMNS. | 
 | * | 
 | *     See: | 
 | * | 
 | *        Dongarra J. J., Du Croz J. J., Hammarling S.  and Hanson R. J.. | 
 | *        An  extended  set of Fortran  Basic Linear Algebra Subprograms. | 
 | * | 
 | *        Technical  Memoranda  Nos. 41 (revision 3) and 81,  Mathematics | 
 | *        and  Computer Science  Division,  Argonne  National Laboratory, | 
 | *        9700 South Cass Avenue, Argonne, Illinois 60439, US. | 
 | * | 
 | *        Or | 
 | * | 
 | *        NAG  Technical Reports TR3/87 and TR4/87,  Numerical Algorithms | 
 | *        Group  Ltd.,  NAG  Central  Office,  256  Banbury  Road, Oxford | 
 | *        OX2 7DE, UK,  and  Numerical Algorithms Group Inc.,  1101  31st | 
 | *        Street,  Suite 100,  Downers Grove,  Illinois 60515-1263,  USA. | 
 | * | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       INTEGER            NIN | 
 |       PARAMETER          ( NIN = 5 ) | 
 |       INTEGER            NSUBS | 
 |       PARAMETER          ( NSUBS = 16 ) | 
 |       DOUBLE PRECISION   ZERO, HALF, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0, ONE = 1.0D0 ) | 
 |       INTEGER            NMAX, INCMAX | 
 |       PARAMETER          ( NMAX = 65, INCMAX = 2 ) | 
 |       INTEGER            NINMAX, NIDMAX, NKBMAX, NALMAX, NBEMAX | 
 |       PARAMETER          ( NINMAX = 7, NIDMAX = 9, NKBMAX = 7, | 
 |      $                   NALMAX = 7, NBEMAX = 7 ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   EPS, ERR, THRESH | 
 |       INTEGER            I, ISNUM, J, N, NALF, NBET, NIDIM, NINC, NKB, | 
 |      $                   NOUT, NTRA | 
 |       LOGICAL            FATAL, LTESTT, REWI, SAME, SFATAL, TRACE, | 
 |      $                   TSTERR | 
 |       CHARACTER*1        TRANS | 
 |       CHARACTER*6        SNAMET | 
 |       CHARACTER*32       SNAPS, SUMMRY | 
 | *     .. Local Arrays .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), | 
 |      $                   ALF( NALMAX ), AS( NMAX*NMAX ), BET( NBEMAX ), | 
 |      $                   G( NMAX ), X( NMAX ), XS( NMAX*INCMAX ), | 
 |      $                   XX( NMAX*INCMAX ), Y( NMAX ), | 
 |      $                   YS( NMAX*INCMAX ), YT( NMAX ), | 
 |      $                   YY( NMAX*INCMAX ), Z( 2*NMAX ) | 
 |       INTEGER            IDIM( NIDMAX ), INC( NINMAX ), KB( NKBMAX ) | 
 |       LOGICAL            LTEST( NSUBS ) | 
 |       CHARACTER*6        SNAMES( NSUBS ) | 
 | *     .. External Functions .. | 
 |       DOUBLE PRECISION   DDIFF | 
 |       LOGICAL            LDE | 
 |       EXTERNAL           DDIFF, LDE | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DCHK1, DCHK2, DCHK3, DCHK4, DCHK5, DCHK6, | 
 |      $                   DCHKE, DMVCH | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX, MIN | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 |       CHARACTER*6        SRNAMT | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 |       COMMON             /SRNAMC/SRNAMT | 
 | *     .. Data statements .. | 
 |       DATA               SNAMES/'DGEMV ', 'DGBMV ', 'DSYMV ', 'DSBMV ', | 
 |      $                   'DSPMV ', 'DTRMV ', 'DTBMV ', 'DTPMV ', | 
 |      $                   'DTRSV ', 'DTBSV ', 'DTPSV ', 'DGER  ', | 
 |      $                   'DSYR  ', 'DSPR  ', 'DSYR2 ', 'DSPR2 '/ | 
 | *     .. Executable Statements .. | 
 | * | 
 | *     Read name and unit number for summary output file and open file. | 
 | * | 
 |       READ( NIN, FMT = * )SUMMRY | 
 |       READ( NIN, FMT = * )NOUT | 
 |       OPEN( NOUT, FILE = SUMMRY, STATUS = 'NEW' ) | 
 |       NOUTC = NOUT | 
 | * | 
 | *     Read name and unit number for snapshot output file and open file. | 
 | * | 
 |       READ( NIN, FMT = * )SNAPS | 
 |       READ( NIN, FMT = * )NTRA | 
 |       TRACE = NTRA.GE.0 | 
 |       IF( TRACE )THEN | 
 |          OPEN( NTRA, FILE = SNAPS, STATUS = 'NEW' ) | 
 |       END IF | 
 | *     Read the flag that directs rewinding of the snapshot file. | 
 |       READ( NIN, FMT = * )REWI | 
 |       REWI = REWI.AND.TRACE | 
 | *     Read the flag that directs stopping on any failure. | 
 |       READ( NIN, FMT = * )SFATAL | 
 | *     Read the flag that indicates whether error exits are to be tested. | 
 |       READ( NIN, FMT = * )TSTERR | 
 | *     Read the threshold value of the test ratio | 
 |       READ( NIN, FMT = * )THRESH | 
 | * | 
 | *     Read and check the parameter values for the tests. | 
 | * | 
 | *     Values of N | 
 |       READ( NIN, FMT = * )NIDIM | 
 |       IF( NIDIM.LT.1.OR.NIDIM.GT.NIDMAX )THEN | 
 |          WRITE( NOUT, FMT = 9997 )'N', NIDMAX | 
 |          GO TO 230 | 
 |       END IF | 
 |       READ( NIN, FMT = * )( IDIM( I ), I = 1, NIDIM ) | 
 |       DO 10 I = 1, NIDIM | 
 |          IF( IDIM( I ).LT.0.OR.IDIM( I ).GT.NMAX )THEN | 
 |             WRITE( NOUT, FMT = 9996 )NMAX | 
 |             GO TO 230 | 
 |          END IF | 
 |    10 CONTINUE | 
 | *     Values of K | 
 |       READ( NIN, FMT = * )NKB | 
 |       IF( NKB.LT.1.OR.NKB.GT.NKBMAX )THEN | 
 |          WRITE( NOUT, FMT = 9997 )'K', NKBMAX | 
 |          GO TO 230 | 
 |       END IF | 
 |       READ( NIN, FMT = * )( KB( I ), I = 1, NKB ) | 
 |       DO 20 I = 1, NKB | 
 |          IF( KB( I ).LT.0 )THEN | 
 |             WRITE( NOUT, FMT = 9995 ) | 
 |             GO TO 230 | 
 |          END IF | 
 |    20 CONTINUE | 
 | *     Values of INCX and INCY | 
 |       READ( NIN, FMT = * )NINC | 
 |       IF( NINC.LT.1.OR.NINC.GT.NINMAX )THEN | 
 |          WRITE( NOUT, FMT = 9997 )'INCX AND INCY', NINMAX | 
 |          GO TO 230 | 
 |       END IF | 
 |       READ( NIN, FMT = * )( INC( I ), I = 1, NINC ) | 
 |       DO 30 I = 1, NINC | 
 |          IF( INC( I ).EQ.0.OR.ABS( INC( I ) ).GT.INCMAX )THEN | 
 |             WRITE( NOUT, FMT = 9994 )INCMAX | 
 |             GO TO 230 | 
 |          END IF | 
 |    30 CONTINUE | 
 | *     Values of ALPHA | 
 |       READ( NIN, FMT = * )NALF | 
 |       IF( NALF.LT.1.OR.NALF.GT.NALMAX )THEN | 
 |          WRITE( NOUT, FMT = 9997 )'ALPHA', NALMAX | 
 |          GO TO 230 | 
 |       END IF | 
 |       READ( NIN, FMT = * )( ALF( I ), I = 1, NALF ) | 
 | *     Values of BETA | 
 |       READ( NIN, FMT = * )NBET | 
 |       IF( NBET.LT.1.OR.NBET.GT.NBEMAX )THEN | 
 |          WRITE( NOUT, FMT = 9997 )'BETA', NBEMAX | 
 |          GO TO 230 | 
 |       END IF | 
 |       READ( NIN, FMT = * )( BET( I ), I = 1, NBET ) | 
 | * | 
 | *     Report values of parameters. | 
 | * | 
 |       WRITE( NOUT, FMT = 9993 ) | 
 |       WRITE( NOUT, FMT = 9992 )( IDIM( I ), I = 1, NIDIM ) | 
 |       WRITE( NOUT, FMT = 9991 )( KB( I ), I = 1, NKB ) | 
 |       WRITE( NOUT, FMT = 9990 )( INC( I ), I = 1, NINC ) | 
 |       WRITE( NOUT, FMT = 9989 )( ALF( I ), I = 1, NALF ) | 
 |       WRITE( NOUT, FMT = 9988 )( BET( I ), I = 1, NBET ) | 
 |       IF( .NOT.TSTERR )THEN | 
 |          WRITE( NOUT, FMT = * ) | 
 |          WRITE( NOUT, FMT = 9980 ) | 
 |       END IF | 
 |       WRITE( NOUT, FMT = * ) | 
 |       WRITE( NOUT, FMT = 9999 )THRESH | 
 |       WRITE( NOUT, FMT = * ) | 
 | * | 
 | *     Read names of subroutines and flags which indicate | 
 | *     whether they are to be tested. | 
 | * | 
 |       DO 40 I = 1, NSUBS | 
 |          LTEST( I ) = .FALSE. | 
 |    40 CONTINUE | 
 |    50 READ( NIN, FMT = 9984, END = 80 )SNAMET, LTESTT | 
 |       DO 60 I = 1, NSUBS | 
 |          IF( SNAMET.EQ.SNAMES( I ) ) | 
 |      $      GO TO 70 | 
 |    60 CONTINUE | 
 |       WRITE( NOUT, FMT = 9986 )SNAMET | 
 |       STOP | 
 |    70 LTEST( I ) = LTESTT | 
 |       GO TO 50 | 
 | * | 
 |    80 CONTINUE | 
 |       CLOSE ( NIN ) | 
 | * | 
 | *     Compute EPS (the machine precision). | 
 | * | 
 |       EPS = ONE | 
 |    90 CONTINUE | 
 |       IF( DDIFF( ONE + EPS, ONE ).EQ.ZERO ) | 
 |      $   GO TO 100 | 
 |       EPS = HALF*EPS | 
 |       GO TO 90 | 
 |   100 CONTINUE | 
 |       EPS = EPS + EPS | 
 |       WRITE( NOUT, FMT = 9998 )EPS | 
 | * | 
 | *     Check the reliability of DMVCH using exact data. | 
 | * | 
 |       N = MIN( 32, NMAX ) | 
 |       DO 120 J = 1, N | 
 |          DO 110 I = 1, N | 
 |             A( I, J ) = MAX( I - J + 1, 0 ) | 
 |   110    CONTINUE | 
 |          X( J ) = J | 
 |          Y( J ) = ZERO | 
 |   120 CONTINUE | 
 |       DO 130 J = 1, N | 
 |          YY( J ) = J*( ( J + 1 )*J )/2 - ( ( J + 1 )*J*( J - 1 ) )/3 | 
 |   130 CONTINUE | 
 | *     YY holds the exact result. On exit from DMVCH YT holds | 
 | *     the result computed by DMVCH. | 
 |       TRANS = 'N' | 
 |       CALL DMVCH( TRANS, N, N, ONE, A, NMAX, X, 1, ZERO, Y, 1, YT, G, | 
 |      $            YY, EPS, ERR, FATAL, NOUT, .TRUE. ) | 
 |       SAME = LDE( YY, YT, N ) | 
 |       IF( .NOT.SAME.OR.ERR.NE.ZERO )THEN | 
 |          WRITE( NOUT, FMT = 9985 )TRANS, SAME, ERR | 
 |          STOP | 
 |       END IF | 
 |       TRANS = 'T' | 
 |       CALL DMVCH( TRANS, N, N, ONE, A, NMAX, X, -1, ZERO, Y, -1, YT, G, | 
 |      $            YY, EPS, ERR, FATAL, NOUT, .TRUE. ) | 
 |       SAME = LDE( YY, YT, N ) | 
 |       IF( .NOT.SAME.OR.ERR.NE.ZERO )THEN | 
 |          WRITE( NOUT, FMT = 9985 )TRANS, SAME, ERR | 
 |          STOP | 
 |       END IF | 
 | * | 
 | *     Test each subroutine in turn. | 
 | * | 
 |       DO 210 ISNUM = 1, NSUBS | 
 |          WRITE( NOUT, FMT = * ) | 
 |          IF( .NOT.LTEST( ISNUM ) )THEN | 
 | *           Subprogram is not to be tested. | 
 |             WRITE( NOUT, FMT = 9983 )SNAMES( ISNUM ) | 
 |          ELSE | 
 |             SRNAMT = SNAMES( ISNUM ) | 
 | *           Test error exits. | 
 |             IF( TSTERR )THEN | 
 |                CALL DCHKE( ISNUM, SNAMES( ISNUM ), NOUT ) | 
 |                WRITE( NOUT, FMT = * ) | 
 |             END IF | 
 | *           Test computations. | 
 |             INFOT = 0 | 
 |             OK = .TRUE. | 
 |             FATAL = .FALSE. | 
 |             GO TO ( 140, 140, 150, 150, 150, 160, 160, | 
 |      $              160, 160, 160, 160, 170, 180, 180, | 
 |      $              190, 190 )ISNUM | 
 | *           Test DGEMV, 01, and DGBMV, 02. | 
 |   140       CALL DCHK1( SNAMES( ISNUM ), EPS, THRESH, NOUT, NTRA, TRACE, | 
 |      $                  REWI, FATAL, NIDIM, IDIM, NKB, KB, NALF, ALF, | 
 |      $                  NBET, BET, NINC, INC, NMAX, INCMAX, A, AA, AS, | 
 |      $                  X, XX, XS, Y, YY, YS, YT, G ) | 
 |             GO TO 200 | 
 | *           Test DSYMV, 03, DSBMV, 04, and DSPMV, 05. | 
 |   150       CALL DCHK2( SNAMES( ISNUM ), EPS, THRESH, NOUT, NTRA, TRACE, | 
 |      $                  REWI, FATAL, NIDIM, IDIM, NKB, KB, NALF, ALF, | 
 |      $                  NBET, BET, NINC, INC, NMAX, INCMAX, A, AA, AS, | 
 |      $                  X, XX, XS, Y, YY, YS, YT, G ) | 
 |             GO TO 200 | 
 | *           Test DTRMV, 06, DTBMV, 07, DTPMV, 08, | 
 | *           DTRSV, 09, DTBSV, 10, and DTPSV, 11. | 
 |   160       CALL DCHK3( SNAMES( ISNUM ), EPS, THRESH, NOUT, NTRA, TRACE, | 
 |      $                  REWI, FATAL, NIDIM, IDIM, NKB, KB, NINC, INC, | 
 |      $                  NMAX, INCMAX, A, AA, AS, Y, YY, YS, YT, G, Z ) | 
 |             GO TO 200 | 
 | *           Test DGER, 12. | 
 |   170       CALL DCHK4( SNAMES( ISNUM ), EPS, THRESH, NOUT, NTRA, TRACE, | 
 |      $                  REWI, FATAL, NIDIM, IDIM, NALF, ALF, NINC, INC, | 
 |      $                  NMAX, INCMAX, A, AA, AS, X, XX, XS, Y, YY, YS, | 
 |      $                  YT, G, Z ) | 
 |             GO TO 200 | 
 | *           Test DSYR, 13, and DSPR, 14. | 
 |   180       CALL DCHK5( SNAMES( ISNUM ), EPS, THRESH, NOUT, NTRA, TRACE, | 
 |      $                  REWI, FATAL, NIDIM, IDIM, NALF, ALF, NINC, INC, | 
 |      $                  NMAX, INCMAX, A, AA, AS, X, XX, XS, Y, YY, YS, | 
 |      $                  YT, G, Z ) | 
 |             GO TO 200 | 
 | *           Test DSYR2, 15, and DSPR2, 16. | 
 |   190       CALL DCHK6( SNAMES( ISNUM ), EPS, THRESH, NOUT, NTRA, TRACE, | 
 |      $                  REWI, FATAL, NIDIM, IDIM, NALF, ALF, NINC, INC, | 
 |      $                  NMAX, INCMAX, A, AA, AS, X, XX, XS, Y, YY, YS, | 
 |      $                  YT, G, Z ) | 
 | * | 
 |   200       IF( FATAL.AND.SFATAL ) | 
 |      $         GO TO 220 | 
 |          END IF | 
 |   210 CONTINUE | 
 |       WRITE( NOUT, FMT = 9982 ) | 
 |       GO TO 240 | 
 | * | 
 |   220 CONTINUE | 
 |       WRITE( NOUT, FMT = 9981 ) | 
 |       GO TO 240 | 
 | * | 
 |   230 CONTINUE | 
 |       WRITE( NOUT, FMT = 9987 ) | 
 | * | 
 |   240 CONTINUE | 
 |       IF( TRACE ) | 
 |      $   CLOSE ( NTRA ) | 
 |       CLOSE ( NOUT ) | 
 |       STOP | 
 | * | 
 |  9999 FORMAT( ' ROUTINES PASS COMPUTATIONAL TESTS IF TEST RATIO IS LES', | 
 |      $      'S THAN', F8.2 ) | 
 |  9998 FORMAT( ' RELATIVE MACHINE PRECISION IS TAKEN TO BE', 1P, D9.1 ) | 
 |  9997 FORMAT( ' NUMBER OF VALUES OF ', A, ' IS LESS THAN 1 OR GREATER ', | 
 |      $      'THAN ', I2 ) | 
 |  9996 FORMAT( ' VALUE OF N IS LESS THAN 0 OR GREATER THAN ', I2 ) | 
 |  9995 FORMAT( ' VALUE OF K IS LESS THAN 0' ) | 
 |  9994 FORMAT( ' ABSOLUTE VALUE OF INCX OR INCY IS 0 OR GREATER THAN ', | 
 |      $      I2 ) | 
 |  9993 FORMAT( ' TESTS OF THE DOUBLE PRECISION LEVEL 2 BLAS', //' THE F', | 
 |      $      'OLLOWING PARAMETER VALUES WILL BE USED:' ) | 
 |  9992 FORMAT( '   FOR N              ', 9I6 ) | 
 |  9991 FORMAT( '   FOR K              ', 7I6 ) | 
 |  9990 FORMAT( '   FOR INCX AND INCY  ', 7I6 ) | 
 |  9989 FORMAT( '   FOR ALPHA          ', 7F6.1 ) | 
 |  9988 FORMAT( '   FOR BETA           ', 7F6.1 ) | 
 |  9987 FORMAT( ' AMEND DATA FILE OR INCREASE ARRAY SIZES IN PROGRAM', | 
 |      $      /' ******* TESTS ABANDONED *******' ) | 
 |  9986 FORMAT( ' SUBPROGRAM NAME ', A6, ' NOT RECOGNIZED', /' ******* T', | 
 |      $      'ESTS ABANDONED *******' ) | 
 |  9985 FORMAT( ' ERROR IN DMVCH -  IN-LINE DOT PRODUCTS ARE BEING EVALU', | 
 |      $      'ATED WRONGLY.', /' DMVCH WAS CALLED WITH TRANS = ', A1, | 
 |      $      ' AND RETURNED SAME = ', L1, ' AND ERR = ', F12.3, '.', / | 
 |      $   ' THIS MAY BE DUE TO FAULTS IN THE ARITHMETIC OR THE COMPILER.' | 
 |      $      , /' ******* TESTS ABANDONED *******' ) | 
 |  9984 FORMAT( A6, L2 ) | 
 |  9983 FORMAT( 1X, A6, ' WAS NOT TESTED' ) | 
 |  9982 FORMAT( /' END OF TESTS' ) | 
 |  9981 FORMAT( /' ******* FATAL ERROR - TESTS ABANDONED *******' ) | 
 |  9980 FORMAT( ' ERROR-EXITS WILL NOT BE TESTED' ) | 
 | * | 
 | *     End of DBLAT2. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHK1( SNAME, EPS, THRESH, NOUT, NTRA, TRACE, REWI, | 
 |      $                  FATAL, NIDIM, IDIM, NKB, KB, NALF, ALF, NBET, | 
 |      $                  BET, NINC, INC, NMAX, INCMAX, A, AA, AS, X, XX, | 
 |      $                  XS, Y, YY, YS, YT, G ) | 
 | * | 
 | *  Tests DGEMV and DGBMV. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, HALF | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   EPS, THRESH | 
 |       INTEGER            INCMAX, NALF, NBET, NIDIM, NINC, NKB, NMAX, | 
 |      $                   NOUT, NTRA | 
 |       LOGICAL            FATAL, REWI, TRACE | 
 |       CHARACTER*6        SNAME | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ), | 
 |      $                   AS( NMAX*NMAX ), BET( NBET ), G( NMAX ), | 
 |      $                   X( NMAX ), XS( NMAX*INCMAX ), | 
 |      $                   XX( NMAX*INCMAX ), Y( NMAX ), | 
 |      $                   YS( NMAX*INCMAX ), YT( NMAX ), | 
 |      $                   YY( NMAX*INCMAX ) | 
 |       INTEGER            IDIM( NIDIM ), INC( NINC ), KB( NKB ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ALPHA, ALS, BETA, BLS, ERR, ERRMAX, TRANSL | 
 |       INTEGER            I, IA, IB, IC, IKU, IM, IN, INCX, INCXS, INCY, | 
 |      $                   INCYS, IX, IY, KL, KLS, KU, KUS, LAA, LDA, | 
 |      $                   LDAS, LX, LY, M, ML, MS, N, NARGS, NC, ND, NK, | 
 |      $                   NL, NS | 
 |       LOGICAL            BANDED, FULL, NULL, RESET, SAME, TRAN | 
 |       CHARACTER*1        TRANS, TRANSS | 
 |       CHARACTER*3        ICH | 
 | *     .. Local Arrays .. | 
 |       LOGICAL            ISAME( 13 ) | 
 | *     .. External Functions .. | 
 |       LOGICAL            LDE, LDERES | 
 |       EXTERNAL           LDE, LDERES | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DGBMV, DGEMV, DMAKE, DMVCH | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX, MIN | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Data statements .. | 
 |       DATA               ICH/'NTC'/ | 
 | *     .. Executable Statements .. | 
 |       FULL = SNAME( 3: 3 ).EQ.'E' | 
 |       BANDED = SNAME( 3: 3 ).EQ.'B' | 
 | *     Define the number of arguments. | 
 |       IF( FULL )THEN | 
 |          NARGS = 11 | 
 |       ELSE IF( BANDED )THEN | 
 |          NARGS = 13 | 
 |       END IF | 
 | * | 
 |       NC = 0 | 
 |       RESET = .TRUE. | 
 |       ERRMAX = ZERO | 
 | * | 
 |       DO 120 IN = 1, NIDIM | 
 |          N = IDIM( IN ) | 
 |          ND = N/2 + 1 | 
 | * | 
 |          DO 110 IM = 1, 2 | 
 |             IF( IM.EQ.1 ) | 
 |      $         M = MAX( N - ND, 0 ) | 
 |             IF( IM.EQ.2 ) | 
 |      $         M = MIN( N + ND, NMAX ) | 
 | * | 
 |             IF( BANDED )THEN | 
 |                NK = NKB | 
 |             ELSE | 
 |                NK = 1 | 
 |             END IF | 
 |             DO 100 IKU = 1, NK | 
 |                IF( BANDED )THEN | 
 |                   KU = KB( IKU ) | 
 |                   KL = MAX( KU - 1, 0 ) | 
 |                ELSE | 
 |                   KU = N - 1 | 
 |                   KL = M - 1 | 
 |                END IF | 
 | *              Set LDA to 1 more than minimum value if room. | 
 |                IF( BANDED )THEN | 
 |                   LDA = KL + KU + 1 | 
 |                ELSE | 
 |                   LDA = M | 
 |                END IF | 
 |                IF( LDA.LT.NMAX ) | 
 |      $            LDA = LDA + 1 | 
 | *              Skip tests if not enough room. | 
 |                IF( LDA.GT.NMAX ) | 
 |      $            GO TO 100 | 
 |                LAA = LDA*N | 
 |                NULL = N.LE.0.OR.M.LE.0 | 
 | * | 
 | *              Generate the matrix A. | 
 | * | 
 |                TRANSL = ZERO | 
 |                CALL DMAKE( SNAME( 2: 3 ), ' ', ' ', M, N, A, NMAX, AA, | 
 |      $                     LDA, KL, KU, RESET, TRANSL ) | 
 | * | 
 |                DO 90 IC = 1, 3 | 
 |                   TRANS = ICH( IC: IC ) | 
 |                   TRAN = TRANS.EQ.'T'.OR.TRANS.EQ.'C' | 
 | * | 
 |                   IF( TRAN )THEN | 
 |                      ML = N | 
 |                      NL = M | 
 |                   ELSE | 
 |                      ML = M | 
 |                      NL = N | 
 |                   END IF | 
 | * | 
 |                   DO 80 IX = 1, NINC | 
 |                      INCX = INC( IX ) | 
 |                      LX = ABS( INCX )*NL | 
 | * | 
 | *                    Generate the vector X. | 
 | * | 
 |                      TRANSL = HALF | 
 |                      CALL DMAKE( 'GE', ' ', ' ', 1, NL, X, 1, XX, | 
 |      $                           ABS( INCX ), 0, NL - 1, RESET, TRANSL ) | 
 |                      IF( NL.GT.1 )THEN | 
 |                         X( NL/2 ) = ZERO | 
 |                         XX( 1 + ABS( INCX )*( NL/2 - 1 ) ) = ZERO | 
 |                      END IF | 
 | * | 
 |                      DO 70 IY = 1, NINC | 
 |                         INCY = INC( IY ) | 
 |                         LY = ABS( INCY )*ML | 
 | * | 
 |                         DO 60 IA = 1, NALF | 
 |                            ALPHA = ALF( IA ) | 
 | * | 
 |                            DO 50 IB = 1, NBET | 
 |                               BETA = BET( IB ) | 
 | * | 
 | *                             Generate the vector Y. | 
 | * | 
 |                               TRANSL = ZERO | 
 |                               CALL DMAKE( 'GE', ' ', ' ', 1, ML, Y, 1, | 
 |      $                                    YY, ABS( INCY ), 0, ML - 1, | 
 |      $                                    RESET, TRANSL ) | 
 | * | 
 |                               NC = NC + 1 | 
 | * | 
 | *                             Save every datum before calling the | 
 | *                             subroutine. | 
 | * | 
 |                               TRANSS = TRANS | 
 |                               MS = M | 
 |                               NS = N | 
 |                               KLS = KL | 
 |                               KUS = KU | 
 |                               ALS = ALPHA | 
 |                               DO 10 I = 1, LAA | 
 |                                  AS( I ) = AA( I ) | 
 |    10                         CONTINUE | 
 |                               LDAS = LDA | 
 |                               DO 20 I = 1, LX | 
 |                                  XS( I ) = XX( I ) | 
 |    20                         CONTINUE | 
 |                               INCXS = INCX | 
 |                               BLS = BETA | 
 |                               DO 30 I = 1, LY | 
 |                                  YS( I ) = YY( I ) | 
 |    30                         CONTINUE | 
 |                               INCYS = INCY | 
 | * | 
 | *                             Call the subroutine. | 
 | * | 
 |                               IF( FULL )THEN | 
 |                                  IF( TRACE ) | 
 |      $                              WRITE( NTRA, FMT = 9994 )NC, SNAME, | 
 |      $                              TRANS, M, N, ALPHA, LDA, INCX, BETA, | 
 |      $                              INCY | 
 |                                  IF( REWI ) | 
 |      $                              REWIND NTRA | 
 |                                  CALL DGEMV( TRANS, M, N, ALPHA, AA, | 
 |      $                                       LDA, XX, INCX, BETA, YY, | 
 |      $                                       INCY ) | 
 |                               ELSE IF( BANDED )THEN | 
 |                                  IF( TRACE ) | 
 |      $                              WRITE( NTRA, FMT = 9995 )NC, SNAME, | 
 |      $                              TRANS, M, N, KL, KU, ALPHA, LDA, | 
 |      $                              INCX, BETA, INCY | 
 |                                  IF( REWI ) | 
 |      $                              REWIND NTRA | 
 |                                  CALL DGBMV( TRANS, M, N, KL, KU, ALPHA, | 
 |      $                                       AA, LDA, XX, INCX, BETA, | 
 |      $                                       YY, INCY ) | 
 |                               END IF | 
 | * | 
 | *                             Check if error-exit was taken incorrectly. | 
 | * | 
 |                               IF( .NOT.OK )THEN | 
 |                                  WRITE( NOUT, FMT = 9993 ) | 
 |                                  FATAL = .TRUE. | 
 |                                  GO TO 130 | 
 |                               END IF | 
 | * | 
 | *                             See what data changed inside subroutines. | 
 | * | 
 |                               ISAME( 1 ) = TRANS.EQ.TRANSS | 
 |                               ISAME( 2 ) = MS.EQ.M | 
 |                               ISAME( 3 ) = NS.EQ.N | 
 |                               IF( FULL )THEN | 
 |                                  ISAME( 4 ) = ALS.EQ.ALPHA | 
 |                                  ISAME( 5 ) = LDE( AS, AA, LAA ) | 
 |                                  ISAME( 6 ) = LDAS.EQ.LDA | 
 |                                  ISAME( 7 ) = LDE( XS, XX, LX ) | 
 |                                  ISAME( 8 ) = INCXS.EQ.INCX | 
 |                                  ISAME( 9 ) = BLS.EQ.BETA | 
 |                                  IF( NULL )THEN | 
 |                                     ISAME( 10 ) = LDE( YS, YY, LY ) | 
 |                                  ELSE | 
 |                                     ISAME( 10 ) = LDERES( 'GE', ' ', 1, | 
 |      $                                            ML, YS, YY, | 
 |      $                                            ABS( INCY ) ) | 
 |                                  END IF | 
 |                                  ISAME( 11 ) = INCYS.EQ.INCY | 
 |                               ELSE IF( BANDED )THEN | 
 |                                  ISAME( 4 ) = KLS.EQ.KL | 
 |                                  ISAME( 5 ) = KUS.EQ.KU | 
 |                                  ISAME( 6 ) = ALS.EQ.ALPHA | 
 |                                  ISAME( 7 ) = LDE( AS, AA, LAA ) | 
 |                                  ISAME( 8 ) = LDAS.EQ.LDA | 
 |                                  ISAME( 9 ) = LDE( XS, XX, LX ) | 
 |                                  ISAME( 10 ) = INCXS.EQ.INCX | 
 |                                  ISAME( 11 ) = BLS.EQ.BETA | 
 |                                  IF( NULL )THEN | 
 |                                     ISAME( 12 ) = LDE( YS, YY, LY ) | 
 |                                  ELSE | 
 |                                     ISAME( 12 ) = LDERES( 'GE', ' ', 1, | 
 |      $                                            ML, YS, YY, | 
 |      $                                            ABS( INCY ) ) | 
 |                                  END IF | 
 |                                  ISAME( 13 ) = INCYS.EQ.INCY | 
 |                               END IF | 
 | * | 
 | *                             If data was incorrectly changed, report | 
 | *                             and return. | 
 | * | 
 |                               SAME = .TRUE. | 
 |                               DO 40 I = 1, NARGS | 
 |                                  SAME = SAME.AND.ISAME( I ) | 
 |                                  IF( .NOT.ISAME( I ) ) | 
 |      $                              WRITE( NOUT, FMT = 9998 )I | 
 |    40                         CONTINUE | 
 |                               IF( .NOT.SAME )THEN | 
 |                                  FATAL = .TRUE. | 
 |                                  GO TO 130 | 
 |                               END IF | 
 | * | 
 |                               IF( .NOT.NULL )THEN | 
 | * | 
 | *                                Check the result. | 
 | * | 
 |                                  CALL DMVCH( TRANS, M, N, ALPHA, A, | 
 |      $                                       NMAX, X, INCX, BETA, Y, | 
 |      $                                       INCY, YT, G, YY, EPS, ERR, | 
 |      $                                       FATAL, NOUT, .TRUE. ) | 
 |                                  ERRMAX = MAX( ERRMAX, ERR ) | 
 | *                                If got really bad answer, report and | 
 | *                                return. | 
 |                                  IF( FATAL ) | 
 |      $                              GO TO 130 | 
 |                               ELSE | 
 | *                                Avoid repeating tests with M.le.0 or | 
 | *                                N.le.0. | 
 |                                  GO TO 110 | 
 |                               END IF | 
 | * | 
 |    50                      CONTINUE | 
 | * | 
 |    60                   CONTINUE | 
 | * | 
 |    70                CONTINUE | 
 | * | 
 |    80             CONTINUE | 
 | * | 
 |    90          CONTINUE | 
 | * | 
 |   100       CONTINUE | 
 | * | 
 |   110    CONTINUE | 
 | * | 
 |   120 CONTINUE | 
 | * | 
 | *     Report result. | 
 | * | 
 |       IF( ERRMAX.LT.THRESH )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SNAME, NC | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9997 )SNAME, NC, ERRMAX | 
 |       END IF | 
 |       GO TO 140 | 
 | * | 
 |   130 CONTINUE | 
 |       WRITE( NOUT, FMT = 9996 )SNAME | 
 |       IF( FULL )THEN | 
 |          WRITE( NOUT, FMT = 9994 )NC, SNAME, TRANS, M, N, ALPHA, LDA, | 
 |      $      INCX, BETA, INCY | 
 |       ELSE IF( BANDED )THEN | 
 |          WRITE( NOUT, FMT = 9995 )NC, SNAME, TRANS, M, N, KL, KU, | 
 |      $      ALPHA, LDA, INCX, BETA, INCY | 
 |       END IF | 
 | * | 
 |   140 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE COMPUTATIONAL TESTS (', I6, ' CALL', | 
 |      $      'S)' ) | 
 |  9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', I2, ' WAS CH', | 
 |      $      'ANGED INCORRECTLY *******' ) | 
 |  9997 FORMAT( ' ', A6, ' COMPLETED THE COMPUTATIONAL TESTS (', I6, ' C', | 
 |      $      'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', F8.2, | 
 |      $      ' - SUSPECT *******' ) | 
 |  9996 FORMAT( ' ******* ', A6, ' FAILED ON CALL NUMBER:' ) | 
 |  9995 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', 4( I3, ',' ), F4.1, | 
 |      $      ', A,', I3, ', X,', I2, ',', F4.1, ', Y,', I2, ') .' ) | 
 |  9994 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', 2( I3, ',' ), F4.1, | 
 |      $      ', A,', I3, ', X,', I2, ',', F4.1, ', Y,', I2, | 
 |      $      ')         .' ) | 
 |  9993 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *', | 
 |      $      '******' ) | 
 | * | 
 | *     End of DCHK1. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHK2( SNAME, EPS, THRESH, NOUT, NTRA, TRACE, REWI, | 
 |      $                  FATAL, NIDIM, IDIM, NKB, KB, NALF, ALF, NBET, | 
 |      $                  BET, NINC, INC, NMAX, INCMAX, A, AA, AS, X, XX, | 
 |      $                  XS, Y, YY, YS, YT, G ) | 
 | * | 
 | *  Tests DSYMV, DSBMV and DSPMV. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, HALF | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   EPS, THRESH | 
 |       INTEGER            INCMAX, NALF, NBET, NIDIM, NINC, NKB, NMAX, | 
 |      $                   NOUT, NTRA | 
 |       LOGICAL            FATAL, REWI, TRACE | 
 |       CHARACTER*6        SNAME | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ), | 
 |      $                   AS( NMAX*NMAX ), BET( NBET ), G( NMAX ), | 
 |      $                   X( NMAX ), XS( NMAX*INCMAX ), | 
 |      $                   XX( NMAX*INCMAX ), Y( NMAX ), | 
 |      $                   YS( NMAX*INCMAX ), YT( NMAX ), | 
 |      $                   YY( NMAX*INCMAX ) | 
 |       INTEGER            IDIM( NIDIM ), INC( NINC ), KB( NKB ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ALPHA, ALS, BETA, BLS, ERR, ERRMAX, TRANSL | 
 |       INTEGER            I, IA, IB, IC, IK, IN, INCX, INCXS, INCY, | 
 |      $                   INCYS, IX, IY, K, KS, LAA, LDA, LDAS, LX, LY, | 
 |      $                   N, NARGS, NC, NK, NS | 
 |       LOGICAL            BANDED, FULL, NULL, PACKED, RESET, SAME | 
 |       CHARACTER*1        UPLO, UPLOS | 
 |       CHARACTER*2        ICH | 
 | *     .. Local Arrays .. | 
 |       LOGICAL            ISAME( 13 ) | 
 | *     .. External Functions .. | 
 |       LOGICAL            LDE, LDERES | 
 |       EXTERNAL           LDE, LDERES | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DMAKE, DMVCH, DSBMV, DSPMV, DSYMV | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Data statements .. | 
 |       DATA               ICH/'UL'/ | 
 | *     .. Executable Statements .. | 
 |       FULL = SNAME( 3: 3 ).EQ.'Y' | 
 |       BANDED = SNAME( 3: 3 ).EQ.'B' | 
 |       PACKED = SNAME( 3: 3 ).EQ.'P' | 
 | *     Define the number of arguments. | 
 |       IF( FULL )THEN | 
 |          NARGS = 10 | 
 |       ELSE IF( BANDED )THEN | 
 |          NARGS = 11 | 
 |       ELSE IF( PACKED )THEN | 
 |          NARGS = 9 | 
 |       END IF | 
 | * | 
 |       NC = 0 | 
 |       RESET = .TRUE. | 
 |       ERRMAX = ZERO | 
 | * | 
 |       DO 110 IN = 1, NIDIM | 
 |          N = IDIM( IN ) | 
 | * | 
 |          IF( BANDED )THEN | 
 |             NK = NKB | 
 |          ELSE | 
 |             NK = 1 | 
 |          END IF | 
 |          DO 100 IK = 1, NK | 
 |             IF( BANDED )THEN | 
 |                K = KB( IK ) | 
 |             ELSE | 
 |                K = N - 1 | 
 |             END IF | 
 | *           Set LDA to 1 more than minimum value if room. | 
 |             IF( BANDED )THEN | 
 |                LDA = K + 1 | 
 |             ELSE | 
 |                LDA = N | 
 |             END IF | 
 |             IF( LDA.LT.NMAX ) | 
 |      $         LDA = LDA + 1 | 
 | *           Skip tests if not enough room. | 
 |             IF( LDA.GT.NMAX ) | 
 |      $         GO TO 100 | 
 |             IF( PACKED )THEN | 
 |                LAA = ( N*( N + 1 ) )/2 | 
 |             ELSE | 
 |                LAA = LDA*N | 
 |             END IF | 
 |             NULL = N.LE.0 | 
 | * | 
 |             DO 90 IC = 1, 2 | 
 |                UPLO = ICH( IC: IC ) | 
 | * | 
 | *              Generate the matrix A. | 
 | * | 
 |                TRANSL = ZERO | 
 |                CALL DMAKE( SNAME( 2: 3 ), UPLO, ' ', N, N, A, NMAX, AA, | 
 |      $                     LDA, K, K, RESET, TRANSL ) | 
 | * | 
 |                DO 80 IX = 1, NINC | 
 |                   INCX = INC( IX ) | 
 |                   LX = ABS( INCX )*N | 
 | * | 
 | *                 Generate the vector X. | 
 | * | 
 |                   TRANSL = HALF | 
 |                   CALL DMAKE( 'GE', ' ', ' ', 1, N, X, 1, XX, | 
 |      $                        ABS( INCX ), 0, N - 1, RESET, TRANSL ) | 
 |                   IF( N.GT.1 )THEN | 
 |                      X( N/2 ) = ZERO | 
 |                      XX( 1 + ABS( INCX )*( N/2 - 1 ) ) = ZERO | 
 |                   END IF | 
 | * | 
 |                   DO 70 IY = 1, NINC | 
 |                      INCY = INC( IY ) | 
 |                      LY = ABS( INCY )*N | 
 | * | 
 |                      DO 60 IA = 1, NALF | 
 |                         ALPHA = ALF( IA ) | 
 | * | 
 |                         DO 50 IB = 1, NBET | 
 |                            BETA = BET( IB ) | 
 | * | 
 | *                          Generate the vector Y. | 
 | * | 
 |                            TRANSL = ZERO | 
 |                            CALL DMAKE( 'GE', ' ', ' ', 1, N, Y, 1, YY, | 
 |      $                                 ABS( INCY ), 0, N - 1, RESET, | 
 |      $                                 TRANSL ) | 
 | * | 
 |                            NC = NC + 1 | 
 | * | 
 | *                          Save every datum before calling the | 
 | *                          subroutine. | 
 | * | 
 |                            UPLOS = UPLO | 
 |                            NS = N | 
 |                            KS = K | 
 |                            ALS = ALPHA | 
 |                            DO 10 I = 1, LAA | 
 |                               AS( I ) = AA( I ) | 
 |    10                      CONTINUE | 
 |                            LDAS = LDA | 
 |                            DO 20 I = 1, LX | 
 |                               XS( I ) = XX( I ) | 
 |    20                      CONTINUE | 
 |                            INCXS = INCX | 
 |                            BLS = BETA | 
 |                            DO 30 I = 1, LY | 
 |                               YS( I ) = YY( I ) | 
 |    30                      CONTINUE | 
 |                            INCYS = INCY | 
 | * | 
 | *                          Call the subroutine. | 
 | * | 
 |                            IF( FULL )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9993 )NC, SNAME, | 
 |      $                           UPLO, N, ALPHA, LDA, INCX, BETA, INCY | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DSYMV( UPLO, N, ALPHA, AA, LDA, XX, | 
 |      $                                    INCX, BETA, YY, INCY ) | 
 |                            ELSE IF( BANDED )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9994 )NC, SNAME, | 
 |      $                           UPLO, N, K, ALPHA, LDA, INCX, BETA, | 
 |      $                           INCY | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DSBMV( UPLO, N, K, ALPHA, AA, LDA, | 
 |      $                                    XX, INCX, BETA, YY, INCY ) | 
 |                            ELSE IF( PACKED )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9995 )NC, SNAME, | 
 |      $                           UPLO, N, ALPHA, INCX, BETA, INCY | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DSPMV( UPLO, N, ALPHA, AA, XX, INCX, | 
 |      $                                    BETA, YY, INCY ) | 
 |                            END IF | 
 | * | 
 | *                          Check if error-exit was taken incorrectly. | 
 | * | 
 |                            IF( .NOT.OK )THEN | 
 |                               WRITE( NOUT, FMT = 9992 ) | 
 |                               FATAL = .TRUE. | 
 |                               GO TO 120 | 
 |                            END IF | 
 | * | 
 | *                          See what data changed inside subroutines. | 
 | * | 
 |                            ISAME( 1 ) = UPLO.EQ.UPLOS | 
 |                            ISAME( 2 ) = NS.EQ.N | 
 |                            IF( FULL )THEN | 
 |                               ISAME( 3 ) = ALS.EQ.ALPHA | 
 |                               ISAME( 4 ) = LDE( AS, AA, LAA ) | 
 |                               ISAME( 5 ) = LDAS.EQ.LDA | 
 |                               ISAME( 6 ) = LDE( XS, XX, LX ) | 
 |                               ISAME( 7 ) = INCXS.EQ.INCX | 
 |                               ISAME( 8 ) = BLS.EQ.BETA | 
 |                               IF( NULL )THEN | 
 |                                  ISAME( 9 ) = LDE( YS, YY, LY ) | 
 |                               ELSE | 
 |                                  ISAME( 9 ) = LDERES( 'GE', ' ', 1, N, | 
 |      $                                        YS, YY, ABS( INCY ) ) | 
 |                               END IF | 
 |                               ISAME( 10 ) = INCYS.EQ.INCY | 
 |                            ELSE IF( BANDED )THEN | 
 |                               ISAME( 3 ) = KS.EQ.K | 
 |                               ISAME( 4 ) = ALS.EQ.ALPHA | 
 |                               ISAME( 5 ) = LDE( AS, AA, LAA ) | 
 |                               ISAME( 6 ) = LDAS.EQ.LDA | 
 |                               ISAME( 7 ) = LDE( XS, XX, LX ) | 
 |                               ISAME( 8 ) = INCXS.EQ.INCX | 
 |                               ISAME( 9 ) = BLS.EQ.BETA | 
 |                               IF( NULL )THEN | 
 |                                  ISAME( 10 ) = LDE( YS, YY, LY ) | 
 |                               ELSE | 
 |                                  ISAME( 10 ) = LDERES( 'GE', ' ', 1, N, | 
 |      $                                         YS, YY, ABS( INCY ) ) | 
 |                               END IF | 
 |                               ISAME( 11 ) = INCYS.EQ.INCY | 
 |                            ELSE IF( PACKED )THEN | 
 |                               ISAME( 3 ) = ALS.EQ.ALPHA | 
 |                               ISAME( 4 ) = LDE( AS, AA, LAA ) | 
 |                               ISAME( 5 ) = LDE( XS, XX, LX ) | 
 |                               ISAME( 6 ) = INCXS.EQ.INCX | 
 |                               ISAME( 7 ) = BLS.EQ.BETA | 
 |                               IF( NULL )THEN | 
 |                                  ISAME( 8 ) = LDE( YS, YY, LY ) | 
 |                               ELSE | 
 |                                  ISAME( 8 ) = LDERES( 'GE', ' ', 1, N, | 
 |      $                                        YS, YY, ABS( INCY ) ) | 
 |                               END IF | 
 |                               ISAME( 9 ) = INCYS.EQ.INCY | 
 |                            END IF | 
 | * | 
 | *                          If data was incorrectly changed, report and | 
 | *                          return. | 
 | * | 
 |                            SAME = .TRUE. | 
 |                            DO 40 I = 1, NARGS | 
 |                               SAME = SAME.AND.ISAME( I ) | 
 |                               IF( .NOT.ISAME( I ) ) | 
 |      $                           WRITE( NOUT, FMT = 9998 )I | 
 |    40                      CONTINUE | 
 |                            IF( .NOT.SAME )THEN | 
 |                               FATAL = .TRUE. | 
 |                               GO TO 120 | 
 |                            END IF | 
 | * | 
 |                            IF( .NOT.NULL )THEN | 
 | * | 
 | *                             Check the result. | 
 | * | 
 |                               CALL DMVCH( 'N', N, N, ALPHA, A, NMAX, X, | 
 |      $                                    INCX, BETA, Y, INCY, YT, G, | 
 |      $                                    YY, EPS, ERR, FATAL, NOUT, | 
 |      $                                    .TRUE. ) | 
 |                               ERRMAX = MAX( ERRMAX, ERR ) | 
 | *                             If got really bad answer, report and | 
 | *                             return. | 
 |                               IF( FATAL ) | 
 |      $                           GO TO 120 | 
 |                            ELSE | 
 | *                             Avoid repeating tests with N.le.0 | 
 |                               GO TO 110 | 
 |                            END IF | 
 | * | 
 |    50                   CONTINUE | 
 | * | 
 |    60                CONTINUE | 
 | * | 
 |    70             CONTINUE | 
 | * | 
 |    80          CONTINUE | 
 | * | 
 |    90       CONTINUE | 
 | * | 
 |   100    CONTINUE | 
 | * | 
 |   110 CONTINUE | 
 | * | 
 | *     Report result. | 
 | * | 
 |       IF( ERRMAX.LT.THRESH )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SNAME, NC | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9997 )SNAME, NC, ERRMAX | 
 |       END IF | 
 |       GO TO 130 | 
 | * | 
 |   120 CONTINUE | 
 |       WRITE( NOUT, FMT = 9996 )SNAME | 
 |       IF( FULL )THEN | 
 |          WRITE( NOUT, FMT = 9993 )NC, SNAME, UPLO, N, ALPHA, LDA, INCX, | 
 |      $      BETA, INCY | 
 |       ELSE IF( BANDED )THEN | 
 |          WRITE( NOUT, FMT = 9994 )NC, SNAME, UPLO, N, K, ALPHA, LDA, | 
 |      $      INCX, BETA, INCY | 
 |       ELSE IF( PACKED )THEN | 
 |          WRITE( NOUT, FMT = 9995 )NC, SNAME, UPLO, N, ALPHA, INCX, | 
 |      $      BETA, INCY | 
 |       END IF | 
 | * | 
 |   130 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE COMPUTATIONAL TESTS (', I6, ' CALL', | 
 |      $      'S)' ) | 
 |  9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', I2, ' WAS CH', | 
 |      $      'ANGED INCORRECTLY *******' ) | 
 |  9997 FORMAT( ' ', A6, ' COMPLETED THE COMPUTATIONAL TESTS (', I6, ' C', | 
 |      $      'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', F8.2, | 
 |      $      ' - SUSPECT *******' ) | 
 |  9996 FORMAT( ' ******* ', A6, ' FAILED ON CALL NUMBER:' ) | 
 |  9995 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', I3, ',', F4.1, ', AP', | 
 |      $      ', X,', I2, ',', F4.1, ', Y,', I2, ')                .' ) | 
 |  9994 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', 2( I3, ',' ), F4.1, | 
 |      $      ', A,', I3, ', X,', I2, ',', F4.1, ', Y,', I2, | 
 |      $      ')         .' ) | 
 |  9993 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', I3, ',', F4.1, ', A,', | 
 |      $      I3, ', X,', I2, ',', F4.1, ', Y,', I2, ')             .' ) | 
 |  9992 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *', | 
 |      $      '******' ) | 
 | * | 
 | *     End of DCHK2. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHK3( SNAME, EPS, THRESH, NOUT, NTRA, TRACE, REWI, | 
 |      $                  FATAL, NIDIM, IDIM, NKB, KB, NINC, INC, NMAX, | 
 |      $                  INCMAX, A, AA, AS, X, XX, XS, XT, G, Z ) | 
 | * | 
 | *  Tests DTRMV, DTBMV, DTPMV, DTRSV, DTBSV and DTPSV. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, HALF, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0, ONE = 1.0D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   EPS, THRESH | 
 |       INTEGER            INCMAX, NIDIM, NINC, NKB, NMAX, NOUT, NTRA | 
 |       LOGICAL            FATAL, REWI, TRACE | 
 |       CHARACTER*6        SNAME | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), | 
 |      $                   AS( NMAX*NMAX ), G( NMAX ), X( NMAX ), | 
 |      $                   XS( NMAX*INCMAX ), XT( NMAX ), | 
 |      $                   XX( NMAX*INCMAX ), Z( NMAX ) | 
 |       INTEGER            IDIM( NIDIM ), INC( NINC ), KB( NKB ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ERR, ERRMAX, TRANSL | 
 |       INTEGER            I, ICD, ICT, ICU, IK, IN, INCX, INCXS, IX, K, | 
 |      $                   KS, LAA, LDA, LDAS, LX, N, NARGS, NC, NK, NS | 
 |       LOGICAL            BANDED, FULL, NULL, PACKED, RESET, SAME | 
 |       CHARACTER*1        DIAG, DIAGS, TRANS, TRANSS, UPLO, UPLOS | 
 |       CHARACTER*2        ICHD, ICHU | 
 |       CHARACTER*3        ICHT | 
 | *     .. Local Arrays .. | 
 |       LOGICAL            ISAME( 13 ) | 
 | *     .. External Functions .. | 
 |       LOGICAL            LDE, LDERES | 
 |       EXTERNAL           LDE, LDERES | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DMAKE, DMVCH, DTBMV, DTBSV, DTPMV, DTPSV, | 
 |      $                   DTRMV, DTRSV | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Data statements .. | 
 |       DATA               ICHU/'UL'/, ICHT/'NTC'/, ICHD/'UN'/ | 
 | *     .. Executable Statements .. | 
 |       FULL = SNAME( 3: 3 ).EQ.'R' | 
 |       BANDED = SNAME( 3: 3 ).EQ.'B' | 
 |       PACKED = SNAME( 3: 3 ).EQ.'P' | 
 | *     Define the number of arguments. | 
 |       IF( FULL )THEN | 
 |          NARGS = 8 | 
 |       ELSE IF( BANDED )THEN | 
 |          NARGS = 9 | 
 |       ELSE IF( PACKED )THEN | 
 |          NARGS = 7 | 
 |       END IF | 
 | * | 
 |       NC = 0 | 
 |       RESET = .TRUE. | 
 |       ERRMAX = ZERO | 
 | *     Set up zero vector for DMVCH. | 
 |       DO 10 I = 1, NMAX | 
 |          Z( I ) = ZERO | 
 |    10 CONTINUE | 
 | * | 
 |       DO 110 IN = 1, NIDIM | 
 |          N = IDIM( IN ) | 
 | * | 
 |          IF( BANDED )THEN | 
 |             NK = NKB | 
 |          ELSE | 
 |             NK = 1 | 
 |          END IF | 
 |          DO 100 IK = 1, NK | 
 |             IF( BANDED )THEN | 
 |                K = KB( IK ) | 
 |             ELSE | 
 |                K = N - 1 | 
 |             END IF | 
 | *           Set LDA to 1 more than minimum value if room. | 
 |             IF( BANDED )THEN | 
 |                LDA = K + 1 | 
 |             ELSE | 
 |                LDA = N | 
 |             END IF | 
 |             IF( LDA.LT.NMAX ) | 
 |      $         LDA = LDA + 1 | 
 | *           Skip tests if not enough room. | 
 |             IF( LDA.GT.NMAX ) | 
 |      $         GO TO 100 | 
 |             IF( PACKED )THEN | 
 |                LAA = ( N*( N + 1 ) )/2 | 
 |             ELSE | 
 |                LAA = LDA*N | 
 |             END IF | 
 |             NULL = N.LE.0 | 
 | * | 
 |             DO 90 ICU = 1, 2 | 
 |                UPLO = ICHU( ICU: ICU ) | 
 | * | 
 |                DO 80 ICT = 1, 3 | 
 |                   TRANS = ICHT( ICT: ICT ) | 
 | * | 
 |                   DO 70 ICD = 1, 2 | 
 |                      DIAG = ICHD( ICD: ICD ) | 
 | * | 
 | *                    Generate the matrix A. | 
 | * | 
 |                      TRANSL = ZERO | 
 |                      CALL DMAKE( SNAME( 2: 3 ), UPLO, DIAG, N, N, A, | 
 |      $                           NMAX, AA, LDA, K, K, RESET, TRANSL ) | 
 | * | 
 |                      DO 60 IX = 1, NINC | 
 |                         INCX = INC( IX ) | 
 |                         LX = ABS( INCX )*N | 
 | * | 
 | *                       Generate the vector X. | 
 | * | 
 |                         TRANSL = HALF | 
 |                         CALL DMAKE( 'GE', ' ', ' ', 1, N, X, 1, XX, | 
 |      $                              ABS( INCX ), 0, N - 1, RESET, | 
 |      $                              TRANSL ) | 
 |                         IF( N.GT.1 )THEN | 
 |                            X( N/2 ) = ZERO | 
 |                            XX( 1 + ABS( INCX )*( N/2 - 1 ) ) = ZERO | 
 |                         END IF | 
 | * | 
 |                         NC = NC + 1 | 
 | * | 
 | *                       Save every datum before calling the subroutine. | 
 | * | 
 |                         UPLOS = UPLO | 
 |                         TRANSS = TRANS | 
 |                         DIAGS = DIAG | 
 |                         NS = N | 
 |                         KS = K | 
 |                         DO 20 I = 1, LAA | 
 |                            AS( I ) = AA( I ) | 
 |    20                   CONTINUE | 
 |                         LDAS = LDA | 
 |                         DO 30 I = 1, LX | 
 |                            XS( I ) = XX( I ) | 
 |    30                   CONTINUE | 
 |                         INCXS = INCX | 
 | * | 
 | *                       Call the subroutine. | 
 | * | 
 |                         IF( SNAME( 4: 5 ).EQ.'MV' )THEN | 
 |                            IF( FULL )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9993 )NC, SNAME, | 
 |      $                           UPLO, TRANS, DIAG, N, LDA, INCX | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DTRMV( UPLO, TRANS, DIAG, N, AA, LDA, | 
 |      $                                    XX, INCX ) | 
 |                            ELSE IF( BANDED )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9994 )NC, SNAME, | 
 |      $                           UPLO, TRANS, DIAG, N, K, LDA, INCX | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DTBMV( UPLO, TRANS, DIAG, N, K, AA, | 
 |      $                                    LDA, XX, INCX ) | 
 |                            ELSE IF( PACKED )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9995 )NC, SNAME, | 
 |      $                           UPLO, TRANS, DIAG, N, INCX | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DTPMV( UPLO, TRANS, DIAG, N, AA, XX, | 
 |      $                                    INCX ) | 
 |                            END IF | 
 |                         ELSE IF( SNAME( 4: 5 ).EQ.'SV' )THEN | 
 |                            IF( FULL )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9993 )NC, SNAME, | 
 |      $                           UPLO, TRANS, DIAG, N, LDA, INCX | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DTRSV( UPLO, TRANS, DIAG, N, AA, LDA, | 
 |      $                                    XX, INCX ) | 
 |                            ELSE IF( BANDED )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9994 )NC, SNAME, | 
 |      $                           UPLO, TRANS, DIAG, N, K, LDA, INCX | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DTBSV( UPLO, TRANS, DIAG, N, K, AA, | 
 |      $                                    LDA, XX, INCX ) | 
 |                            ELSE IF( PACKED )THEN | 
 |                               IF( TRACE ) | 
 |      $                           WRITE( NTRA, FMT = 9995 )NC, SNAME, | 
 |      $                           UPLO, TRANS, DIAG, N, INCX | 
 |                               IF( REWI ) | 
 |      $                           REWIND NTRA | 
 |                               CALL DTPSV( UPLO, TRANS, DIAG, N, AA, XX, | 
 |      $                                    INCX ) | 
 |                            END IF | 
 |                         END IF | 
 | * | 
 | *                       Check if error-exit was taken incorrectly. | 
 | * | 
 |                         IF( .NOT.OK )THEN | 
 |                            WRITE( NOUT, FMT = 9992 ) | 
 |                            FATAL = .TRUE. | 
 |                            GO TO 120 | 
 |                         END IF | 
 | * | 
 | *                       See what data changed inside subroutines. | 
 | * | 
 |                         ISAME( 1 ) = UPLO.EQ.UPLOS | 
 |                         ISAME( 2 ) = TRANS.EQ.TRANSS | 
 |                         ISAME( 3 ) = DIAG.EQ.DIAGS | 
 |                         ISAME( 4 ) = NS.EQ.N | 
 |                         IF( FULL )THEN | 
 |                            ISAME( 5 ) = LDE( AS, AA, LAA ) | 
 |                            ISAME( 6 ) = LDAS.EQ.LDA | 
 |                            IF( NULL )THEN | 
 |                               ISAME( 7 ) = LDE( XS, XX, LX ) | 
 |                            ELSE | 
 |                               ISAME( 7 ) = LDERES( 'GE', ' ', 1, N, XS, | 
 |      $                                     XX, ABS( INCX ) ) | 
 |                            END IF | 
 |                            ISAME( 8 ) = INCXS.EQ.INCX | 
 |                         ELSE IF( BANDED )THEN | 
 |                            ISAME( 5 ) = KS.EQ.K | 
 |                            ISAME( 6 ) = LDE( AS, AA, LAA ) | 
 |                            ISAME( 7 ) = LDAS.EQ.LDA | 
 |                            IF( NULL )THEN | 
 |                               ISAME( 8 ) = LDE( XS, XX, LX ) | 
 |                            ELSE | 
 |                               ISAME( 8 ) = LDERES( 'GE', ' ', 1, N, XS, | 
 |      $                                     XX, ABS( INCX ) ) | 
 |                            END IF | 
 |                            ISAME( 9 ) = INCXS.EQ.INCX | 
 |                         ELSE IF( PACKED )THEN | 
 |                            ISAME( 5 ) = LDE( AS, AA, LAA ) | 
 |                            IF( NULL )THEN | 
 |                               ISAME( 6 ) = LDE( XS, XX, LX ) | 
 |                            ELSE | 
 |                               ISAME( 6 ) = LDERES( 'GE', ' ', 1, N, XS, | 
 |      $                                     XX, ABS( INCX ) ) | 
 |                            END IF | 
 |                            ISAME( 7 ) = INCXS.EQ.INCX | 
 |                         END IF | 
 | * | 
 | *                       If data was incorrectly changed, report and | 
 | *                       return. | 
 | * | 
 |                         SAME = .TRUE. | 
 |                         DO 40 I = 1, NARGS | 
 |                            SAME = SAME.AND.ISAME( I ) | 
 |                            IF( .NOT.ISAME( I ) ) | 
 |      $                        WRITE( NOUT, FMT = 9998 )I | 
 |    40                   CONTINUE | 
 |                         IF( .NOT.SAME )THEN | 
 |                            FATAL = .TRUE. | 
 |                            GO TO 120 | 
 |                         END IF | 
 | * | 
 |                         IF( .NOT.NULL )THEN | 
 |                            IF( SNAME( 4: 5 ).EQ.'MV' )THEN | 
 | * | 
 | *                             Check the result. | 
 | * | 
 |                               CALL DMVCH( TRANS, N, N, ONE, A, NMAX, X, | 
 |      $                                    INCX, ZERO, Z, INCX, XT, G, | 
 |      $                                    XX, EPS, ERR, FATAL, NOUT, | 
 |      $                                    .TRUE. ) | 
 |                            ELSE IF( SNAME( 4: 5 ).EQ.'SV' )THEN | 
 | * | 
 | *                             Compute approximation to original vector. | 
 | * | 
 |                               DO 50 I = 1, N | 
 |                                  Z( I ) = XX( 1 + ( I - 1 )* | 
 |      $                                    ABS( INCX ) ) | 
 |                                  XX( 1 + ( I - 1 )*ABS( INCX ) ) | 
 |      $                              = X( I ) | 
 |    50                         CONTINUE | 
 |                               CALL DMVCH( TRANS, N, N, ONE, A, NMAX, Z, | 
 |      $                                    INCX, ZERO, X, INCX, XT, G, | 
 |      $                                    XX, EPS, ERR, FATAL, NOUT, | 
 |      $                                    .FALSE. ) | 
 |                            END IF | 
 |                            ERRMAX = MAX( ERRMAX, ERR ) | 
 | *                          If got really bad answer, report and return. | 
 |                            IF( FATAL ) | 
 |      $                        GO TO 120 | 
 |                         ELSE | 
 | *                          Avoid repeating tests with N.le.0. | 
 |                            GO TO 110 | 
 |                         END IF | 
 | * | 
 |    60                CONTINUE | 
 | * | 
 |    70             CONTINUE | 
 | * | 
 |    80          CONTINUE | 
 | * | 
 |    90       CONTINUE | 
 | * | 
 |   100    CONTINUE | 
 | * | 
 |   110 CONTINUE | 
 | * | 
 | *     Report result. | 
 | * | 
 |       IF( ERRMAX.LT.THRESH )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SNAME, NC | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9997 )SNAME, NC, ERRMAX | 
 |       END IF | 
 |       GO TO 130 | 
 | * | 
 |   120 CONTINUE | 
 |       WRITE( NOUT, FMT = 9996 )SNAME | 
 |       IF( FULL )THEN | 
 |          WRITE( NOUT, FMT = 9993 )NC, SNAME, UPLO, TRANS, DIAG, N, LDA, | 
 |      $      INCX | 
 |       ELSE IF( BANDED )THEN | 
 |          WRITE( NOUT, FMT = 9994 )NC, SNAME, UPLO, TRANS, DIAG, N, K, | 
 |      $      LDA, INCX | 
 |       ELSE IF( PACKED )THEN | 
 |          WRITE( NOUT, FMT = 9995 )NC, SNAME, UPLO, TRANS, DIAG, N, INCX | 
 |       END IF | 
 | * | 
 |   130 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE COMPUTATIONAL TESTS (', I6, ' CALL', | 
 |      $      'S)' ) | 
 |  9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', I2, ' WAS CH', | 
 |      $      'ANGED INCORRECTLY *******' ) | 
 |  9997 FORMAT( ' ', A6, ' COMPLETED THE COMPUTATIONAL TESTS (', I6, ' C', | 
 |      $      'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', F8.2, | 
 |      $      ' - SUSPECT *******' ) | 
 |  9996 FORMAT( ' ******* ', A6, ' FAILED ON CALL NUMBER:' ) | 
 |  9995 FORMAT( 1X, I6, ': ', A6, '(', 3( '''', A1, ''',' ), I3, ', AP, ', | 
 |      $      'X,', I2, ')                        .' ) | 
 |  9994 FORMAT( 1X, I6, ': ', A6, '(', 3( '''', A1, ''',' ), 2( I3, ',' ), | 
 |      $      ' A,', I3, ', X,', I2, ')                 .' ) | 
 |  9993 FORMAT( 1X, I6, ': ', A6, '(', 3( '''', A1, ''',' ), I3, ', A,', | 
 |      $      I3, ', X,', I2, ')                     .' ) | 
 |  9992 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *', | 
 |      $      '******' ) | 
 | * | 
 | *     End of DCHK3. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHK4( SNAME, EPS, THRESH, NOUT, NTRA, TRACE, REWI, | 
 |      $                  FATAL, NIDIM, IDIM, NALF, ALF, NINC, INC, NMAX, | 
 |      $                  INCMAX, A, AA, AS, X, XX, XS, Y, YY, YS, YT, G, | 
 |      $                  Z ) | 
 | * | 
 | *  Tests DGER. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, HALF, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0, ONE = 1.0D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   EPS, THRESH | 
 |       INTEGER            INCMAX, NALF, NIDIM, NINC, NMAX, NOUT, NTRA | 
 |       LOGICAL            FATAL, REWI, TRACE | 
 |       CHARACTER*6        SNAME | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ), | 
 |      $                   AS( NMAX*NMAX ), G( NMAX ), X( NMAX ), | 
 |      $                   XS( NMAX*INCMAX ), XX( NMAX*INCMAX ), | 
 |      $                   Y( NMAX ), YS( NMAX*INCMAX ), YT( NMAX ), | 
 |      $                   YY( NMAX*INCMAX ), Z( NMAX ) | 
 |       INTEGER            IDIM( NIDIM ), INC( NINC ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ALPHA, ALS, ERR, ERRMAX, TRANSL | 
 |       INTEGER            I, IA, IM, IN, INCX, INCXS, INCY, INCYS, IX, | 
 |      $                   IY, J, LAA, LDA, LDAS, LX, LY, M, MS, N, NARGS, | 
 |      $                   NC, ND, NS | 
 |       LOGICAL            NULL, RESET, SAME | 
 | *     .. Local Arrays .. | 
 |       DOUBLE PRECISION   W( 1 ) | 
 |       LOGICAL            ISAME( 13 ) | 
 | *     .. External Functions .. | 
 |       LOGICAL            LDE, LDERES | 
 |       EXTERNAL           LDE, LDERES | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DGER, DMAKE, DMVCH | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX, MIN | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Executable Statements .. | 
 | *     Define the number of arguments. | 
 |       NARGS = 9 | 
 | * | 
 |       NC = 0 | 
 |       RESET = .TRUE. | 
 |       ERRMAX = ZERO | 
 | * | 
 |       DO 120 IN = 1, NIDIM | 
 |          N = IDIM( IN ) | 
 |          ND = N/2 + 1 | 
 | * | 
 |          DO 110 IM = 1, 2 | 
 |             IF( IM.EQ.1 ) | 
 |      $         M = MAX( N - ND, 0 ) | 
 |             IF( IM.EQ.2 ) | 
 |      $         M = MIN( N + ND, NMAX ) | 
 | * | 
 | *           Set LDA to 1 more than minimum value if room. | 
 |             LDA = M | 
 |             IF( LDA.LT.NMAX ) | 
 |      $         LDA = LDA + 1 | 
 | *           Skip tests if not enough room. | 
 |             IF( LDA.GT.NMAX ) | 
 |      $         GO TO 110 | 
 |             LAA = LDA*N | 
 |             NULL = N.LE.0.OR.M.LE.0 | 
 | * | 
 |             DO 100 IX = 1, NINC | 
 |                INCX = INC( IX ) | 
 |                LX = ABS( INCX )*M | 
 | * | 
 | *              Generate the vector X. | 
 | * | 
 |                TRANSL = HALF | 
 |                CALL DMAKE( 'GE', ' ', ' ', 1, M, X, 1, XX, ABS( INCX ), | 
 |      $                     0, M - 1, RESET, TRANSL ) | 
 |                IF( M.GT.1 )THEN | 
 |                   X( M/2 ) = ZERO | 
 |                   XX( 1 + ABS( INCX )*( M/2 - 1 ) ) = ZERO | 
 |                END IF | 
 | * | 
 |                DO 90 IY = 1, NINC | 
 |                   INCY = INC( IY ) | 
 |                   LY = ABS( INCY )*N | 
 | * | 
 | *                 Generate the vector Y. | 
 | * | 
 |                   TRANSL = ZERO | 
 |                   CALL DMAKE( 'GE', ' ', ' ', 1, N, Y, 1, YY, | 
 |      $                        ABS( INCY ), 0, N - 1, RESET, TRANSL ) | 
 |                   IF( N.GT.1 )THEN | 
 |                      Y( N/2 ) = ZERO | 
 |                      YY( 1 + ABS( INCY )*( N/2 - 1 ) ) = ZERO | 
 |                   END IF | 
 | * | 
 |                   DO 80 IA = 1, NALF | 
 |                      ALPHA = ALF( IA ) | 
 | * | 
 | *                    Generate the matrix A. | 
 | * | 
 |                      TRANSL = ZERO | 
 |                      CALL DMAKE( SNAME( 2: 3 ), ' ', ' ', M, N, A, NMAX, | 
 |      $                           AA, LDA, M - 1, N - 1, RESET, TRANSL ) | 
 | * | 
 |                      NC = NC + 1 | 
 | * | 
 | *                    Save every datum before calling the subroutine. | 
 | * | 
 |                      MS = M | 
 |                      NS = N | 
 |                      ALS = ALPHA | 
 |                      DO 10 I = 1, LAA | 
 |                         AS( I ) = AA( I ) | 
 |    10                CONTINUE | 
 |                      LDAS = LDA | 
 |                      DO 20 I = 1, LX | 
 |                         XS( I ) = XX( I ) | 
 |    20                CONTINUE | 
 |                      INCXS = INCX | 
 |                      DO 30 I = 1, LY | 
 |                         YS( I ) = YY( I ) | 
 |    30                CONTINUE | 
 |                      INCYS = INCY | 
 | * | 
 | *                    Call the subroutine. | 
 | * | 
 |                      IF( TRACE ) | 
 |      $                  WRITE( NTRA, FMT = 9994 )NC, SNAME, M, N, | 
 |      $                  ALPHA, INCX, INCY, LDA | 
 |                      IF( REWI ) | 
 |      $                  REWIND NTRA | 
 |                      CALL DGER( M, N, ALPHA, XX, INCX, YY, INCY, AA, | 
 |      $                          LDA ) | 
 | * | 
 | *                    Check if error-exit was taken incorrectly. | 
 | * | 
 |                      IF( .NOT.OK )THEN | 
 |                         WRITE( NOUT, FMT = 9993 ) | 
 |                         FATAL = .TRUE. | 
 |                         GO TO 140 | 
 |                      END IF | 
 | * | 
 | *                    See what data changed inside subroutine. | 
 | * | 
 |                      ISAME( 1 ) = MS.EQ.M | 
 |                      ISAME( 2 ) = NS.EQ.N | 
 |                      ISAME( 3 ) = ALS.EQ.ALPHA | 
 |                      ISAME( 4 ) = LDE( XS, XX, LX ) | 
 |                      ISAME( 5 ) = INCXS.EQ.INCX | 
 |                      ISAME( 6 ) = LDE( YS, YY, LY ) | 
 |                      ISAME( 7 ) = INCYS.EQ.INCY | 
 |                      IF( NULL )THEN | 
 |                         ISAME( 8 ) = LDE( AS, AA, LAA ) | 
 |                      ELSE | 
 |                         ISAME( 8 ) = LDERES( 'GE', ' ', M, N, AS, AA, | 
 |      $                               LDA ) | 
 |                      END IF | 
 |                      ISAME( 9 ) = LDAS.EQ.LDA | 
 | * | 
 | *                    If data was incorrectly changed, report and return. | 
 | * | 
 |                      SAME = .TRUE. | 
 |                      DO 40 I = 1, NARGS | 
 |                         SAME = SAME.AND.ISAME( I ) | 
 |                         IF( .NOT.ISAME( I ) ) | 
 |      $                     WRITE( NOUT, FMT = 9998 )I | 
 |    40                CONTINUE | 
 |                      IF( .NOT.SAME )THEN | 
 |                         FATAL = .TRUE. | 
 |                         GO TO 140 | 
 |                      END IF | 
 | * | 
 |                      IF( .NOT.NULL )THEN | 
 | * | 
 | *                       Check the result column by column. | 
 | * | 
 |                         IF( INCX.GT.0 )THEN | 
 |                            DO 50 I = 1, M | 
 |                               Z( I ) = X( I ) | 
 |    50                      CONTINUE | 
 |                         ELSE | 
 |                            DO 60 I = 1, M | 
 |                               Z( I ) = X( M - I + 1 ) | 
 |    60                      CONTINUE | 
 |                         END IF | 
 |                         DO 70 J = 1, N | 
 |                            IF( INCY.GT.0 )THEN | 
 |                               W( 1 ) = Y( J ) | 
 |                            ELSE | 
 |                               W( 1 ) = Y( N - J + 1 ) | 
 |                            END IF | 
 |                            CALL DMVCH( 'N', M, 1, ALPHA, Z, NMAX, W, 1, | 
 |      $                                 ONE, A( 1, J ), 1, YT, G, | 
 |      $                                 AA( 1 + ( J - 1 )*LDA ), EPS, | 
 |      $                                 ERR, FATAL, NOUT, .TRUE. ) | 
 |                            ERRMAX = MAX( ERRMAX, ERR ) | 
 | *                          If got really bad answer, report and return. | 
 |                            IF( FATAL ) | 
 |      $                        GO TO 130 | 
 |    70                   CONTINUE | 
 |                      ELSE | 
 | *                       Avoid repeating tests with M.le.0 or N.le.0. | 
 |                         GO TO 110 | 
 |                      END IF | 
 | * | 
 |    80             CONTINUE | 
 | * | 
 |    90          CONTINUE | 
 | * | 
 |   100       CONTINUE | 
 | * | 
 |   110    CONTINUE | 
 | * | 
 |   120 CONTINUE | 
 | * | 
 | *     Report result. | 
 | * | 
 |       IF( ERRMAX.LT.THRESH )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SNAME, NC | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9997 )SNAME, NC, ERRMAX | 
 |       END IF | 
 |       GO TO 150 | 
 | * | 
 |   130 CONTINUE | 
 |       WRITE( NOUT, FMT = 9995 )J | 
 | * | 
 |   140 CONTINUE | 
 |       WRITE( NOUT, FMT = 9996 )SNAME | 
 |       WRITE( NOUT, FMT = 9994 )NC, SNAME, M, N, ALPHA, INCX, INCY, LDA | 
 | * | 
 |   150 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE COMPUTATIONAL TESTS (', I6, ' CALL', | 
 |      $      'S)' ) | 
 |  9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', I2, ' WAS CH', | 
 |      $      'ANGED INCORRECTLY *******' ) | 
 |  9997 FORMAT( ' ', A6, ' COMPLETED THE COMPUTATIONAL TESTS (', I6, ' C', | 
 |      $      'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', F8.2, | 
 |      $      ' - SUSPECT *******' ) | 
 |  9996 FORMAT( ' ******* ', A6, ' FAILED ON CALL NUMBER:' ) | 
 |  9995 FORMAT( '      THESE ARE THE RESULTS FOR COLUMN ', I3 ) | 
 |  9994 FORMAT( 1X, I6, ': ', A6, '(', 2( I3, ',' ), F4.1, ', X,', I2, | 
 |      $      ', Y,', I2, ', A,', I3, ')                  .' ) | 
 |  9993 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *', | 
 |      $      '******' ) | 
 | * | 
 | *     End of DCHK4. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHK5( SNAME, EPS, THRESH, NOUT, NTRA, TRACE, REWI, | 
 |      $                  FATAL, NIDIM, IDIM, NALF, ALF, NINC, INC, NMAX, | 
 |      $                  INCMAX, A, AA, AS, X, XX, XS, Y, YY, YS, YT, G, | 
 |      $                  Z ) | 
 | * | 
 | *  Tests DSYR and DSPR. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, HALF, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0, ONE = 1.0D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   EPS, THRESH | 
 |       INTEGER            INCMAX, NALF, NIDIM, NINC, NMAX, NOUT, NTRA | 
 |       LOGICAL            FATAL, REWI, TRACE | 
 |       CHARACTER*6        SNAME | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ), | 
 |      $                   AS( NMAX*NMAX ), G( NMAX ), X( NMAX ), | 
 |      $                   XS( NMAX*INCMAX ), XX( NMAX*INCMAX ), | 
 |      $                   Y( NMAX ), YS( NMAX*INCMAX ), YT( NMAX ), | 
 |      $                   YY( NMAX*INCMAX ), Z( NMAX ) | 
 |       INTEGER            IDIM( NIDIM ), INC( NINC ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ALPHA, ALS, ERR, ERRMAX, TRANSL | 
 |       INTEGER            I, IA, IC, IN, INCX, INCXS, IX, J, JA, JJ, LAA, | 
 |      $                   LDA, LDAS, LJ, LX, N, NARGS, NC, NS | 
 |       LOGICAL            FULL, NULL, PACKED, RESET, SAME, UPPER | 
 |       CHARACTER*1        UPLO, UPLOS | 
 |       CHARACTER*2        ICH | 
 | *     .. Local Arrays .. | 
 |       DOUBLE PRECISION   W( 1 ) | 
 |       LOGICAL            ISAME( 13 ) | 
 | *     .. External Functions .. | 
 |       LOGICAL            LDE, LDERES | 
 |       EXTERNAL           LDE, LDERES | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DMAKE, DMVCH, DSPR, DSYR | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Data statements .. | 
 |       DATA               ICH/'UL'/ | 
 | *     .. Executable Statements .. | 
 |       FULL = SNAME( 3: 3 ).EQ.'Y' | 
 |       PACKED = SNAME( 3: 3 ).EQ.'P' | 
 | *     Define the number of arguments. | 
 |       IF( FULL )THEN | 
 |          NARGS = 7 | 
 |       ELSE IF( PACKED )THEN | 
 |          NARGS = 6 | 
 |       END IF | 
 | * | 
 |       NC = 0 | 
 |       RESET = .TRUE. | 
 |       ERRMAX = ZERO | 
 | * | 
 |       DO 100 IN = 1, NIDIM | 
 |          N = IDIM( IN ) | 
 | *        Set LDA to 1 more than minimum value if room. | 
 |          LDA = N | 
 |          IF( LDA.LT.NMAX ) | 
 |      $      LDA = LDA + 1 | 
 | *        Skip tests if not enough room. | 
 |          IF( LDA.GT.NMAX ) | 
 |      $      GO TO 100 | 
 |          IF( PACKED )THEN | 
 |             LAA = ( N*( N + 1 ) )/2 | 
 |          ELSE | 
 |             LAA = LDA*N | 
 |          END IF | 
 | * | 
 |          DO 90 IC = 1, 2 | 
 |             UPLO = ICH( IC: IC ) | 
 |             UPPER = UPLO.EQ.'U' | 
 | * | 
 |             DO 80 IX = 1, NINC | 
 |                INCX = INC( IX ) | 
 |                LX = ABS( INCX )*N | 
 | * | 
 | *              Generate the vector X. | 
 | * | 
 |                TRANSL = HALF | 
 |                CALL DMAKE( 'GE', ' ', ' ', 1, N, X, 1, XX, ABS( INCX ), | 
 |      $                     0, N - 1, RESET, TRANSL ) | 
 |                IF( N.GT.1 )THEN | 
 |                   X( N/2 ) = ZERO | 
 |                   XX( 1 + ABS( INCX )*( N/2 - 1 ) ) = ZERO | 
 |                END IF | 
 | * | 
 |                DO 70 IA = 1, NALF | 
 |                   ALPHA = ALF( IA ) | 
 |                   NULL = N.LE.0.OR.ALPHA.EQ.ZERO | 
 | * | 
 | *                 Generate the matrix A. | 
 | * | 
 |                   TRANSL = ZERO | 
 |                   CALL DMAKE( SNAME( 2: 3 ), UPLO, ' ', N, N, A, NMAX, | 
 |      $                        AA, LDA, N - 1, N - 1, RESET, TRANSL ) | 
 | * | 
 |                   NC = NC + 1 | 
 | * | 
 | *                 Save every datum before calling the subroutine. | 
 | * | 
 |                   UPLOS = UPLO | 
 |                   NS = N | 
 |                   ALS = ALPHA | 
 |                   DO 10 I = 1, LAA | 
 |                      AS( I ) = AA( I ) | 
 |    10             CONTINUE | 
 |                   LDAS = LDA | 
 |                   DO 20 I = 1, LX | 
 |                      XS( I ) = XX( I ) | 
 |    20             CONTINUE | 
 |                   INCXS = INCX | 
 | * | 
 | *                 Call the subroutine. | 
 | * | 
 |                   IF( FULL )THEN | 
 |                      IF( TRACE ) | 
 |      $                  WRITE( NTRA, FMT = 9993 )NC, SNAME, UPLO, N, | 
 |      $                  ALPHA, INCX, LDA | 
 |                      IF( REWI ) | 
 |      $                  REWIND NTRA | 
 |                      CALL DSYR( UPLO, N, ALPHA, XX, INCX, AA, LDA ) | 
 |                   ELSE IF( PACKED )THEN | 
 |                      IF( TRACE ) | 
 |      $                  WRITE( NTRA, FMT = 9994 )NC, SNAME, UPLO, N, | 
 |      $                  ALPHA, INCX | 
 |                      IF( REWI ) | 
 |      $                  REWIND NTRA | 
 |                      CALL DSPR( UPLO, N, ALPHA, XX, INCX, AA ) | 
 |                   END IF | 
 | * | 
 | *                 Check if error-exit was taken incorrectly. | 
 | * | 
 |                   IF( .NOT.OK )THEN | 
 |                      WRITE( NOUT, FMT = 9992 ) | 
 |                      FATAL = .TRUE. | 
 |                      GO TO 120 | 
 |                   END IF | 
 | * | 
 | *                 See what data changed inside subroutines. | 
 | * | 
 |                   ISAME( 1 ) = UPLO.EQ.UPLOS | 
 |                   ISAME( 2 ) = NS.EQ.N | 
 |                   ISAME( 3 ) = ALS.EQ.ALPHA | 
 |                   ISAME( 4 ) = LDE( XS, XX, LX ) | 
 |                   ISAME( 5 ) = INCXS.EQ.INCX | 
 |                   IF( NULL )THEN | 
 |                      ISAME( 6 ) = LDE( AS, AA, LAA ) | 
 |                   ELSE | 
 |                      ISAME( 6 ) = LDERES( SNAME( 2: 3 ), UPLO, N, N, AS, | 
 |      $                            AA, LDA ) | 
 |                   END IF | 
 |                   IF( .NOT.PACKED )THEN | 
 |                      ISAME( 7 ) = LDAS.EQ.LDA | 
 |                   END IF | 
 | * | 
 | *                 If data was incorrectly changed, report and return. | 
 | * | 
 |                   SAME = .TRUE. | 
 |                   DO 30 I = 1, NARGS | 
 |                      SAME = SAME.AND.ISAME( I ) | 
 |                      IF( .NOT.ISAME( I ) ) | 
 |      $                  WRITE( NOUT, FMT = 9998 )I | 
 |    30             CONTINUE | 
 |                   IF( .NOT.SAME )THEN | 
 |                      FATAL = .TRUE. | 
 |                      GO TO 120 | 
 |                   END IF | 
 | * | 
 |                   IF( .NOT.NULL )THEN | 
 | * | 
 | *                    Check the result column by column. | 
 | * | 
 |                      IF( INCX.GT.0 )THEN | 
 |                         DO 40 I = 1, N | 
 |                            Z( I ) = X( I ) | 
 |    40                   CONTINUE | 
 |                      ELSE | 
 |                         DO 50 I = 1, N | 
 |                            Z( I ) = X( N - I + 1 ) | 
 |    50                   CONTINUE | 
 |                      END IF | 
 |                      JA = 1 | 
 |                      DO 60 J = 1, N | 
 |                         W( 1 ) = Z( J ) | 
 |                         IF( UPPER )THEN | 
 |                            JJ = 1 | 
 |                            LJ = J | 
 |                         ELSE | 
 |                            JJ = J | 
 |                            LJ = N - J + 1 | 
 |                         END IF | 
 |                         CALL DMVCH( 'N', LJ, 1, ALPHA, Z( JJ ), LJ, W, | 
 |      $                              1, ONE, A( JJ, J ), 1, YT, G, | 
 |      $                              AA( JA ), EPS, ERR, FATAL, NOUT, | 
 |      $                              .TRUE. ) | 
 |                         IF( FULL )THEN | 
 |                            IF( UPPER )THEN | 
 |                               JA = JA + LDA | 
 |                            ELSE | 
 |                               JA = JA + LDA + 1 | 
 |                            END IF | 
 |                         ELSE | 
 |                            JA = JA + LJ | 
 |                         END IF | 
 |                         ERRMAX = MAX( ERRMAX, ERR ) | 
 | *                       If got really bad answer, report and return. | 
 |                         IF( FATAL ) | 
 |      $                     GO TO 110 | 
 |    60                CONTINUE | 
 |                   ELSE | 
 | *                    Avoid repeating tests if N.le.0. | 
 |                      IF( N.LE.0 ) | 
 |      $                  GO TO 100 | 
 |                   END IF | 
 | * | 
 |    70          CONTINUE | 
 | * | 
 |    80       CONTINUE | 
 | * | 
 |    90    CONTINUE | 
 | * | 
 |   100 CONTINUE | 
 | * | 
 | *     Report result. | 
 | * | 
 |       IF( ERRMAX.LT.THRESH )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SNAME, NC | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9997 )SNAME, NC, ERRMAX | 
 |       END IF | 
 |       GO TO 130 | 
 | * | 
 |   110 CONTINUE | 
 |       WRITE( NOUT, FMT = 9995 )J | 
 | * | 
 |   120 CONTINUE | 
 |       WRITE( NOUT, FMT = 9996 )SNAME | 
 |       IF( FULL )THEN | 
 |          WRITE( NOUT, FMT = 9993 )NC, SNAME, UPLO, N, ALPHA, INCX, LDA | 
 |       ELSE IF( PACKED )THEN | 
 |          WRITE( NOUT, FMT = 9994 )NC, SNAME, UPLO, N, ALPHA, INCX | 
 |       END IF | 
 | * | 
 |   130 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE COMPUTATIONAL TESTS (', I6, ' CALL', | 
 |      $      'S)' ) | 
 |  9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', I2, ' WAS CH', | 
 |      $      'ANGED INCORRECTLY *******' ) | 
 |  9997 FORMAT( ' ', A6, ' COMPLETED THE COMPUTATIONAL TESTS (', I6, ' C', | 
 |      $      'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', F8.2, | 
 |      $      ' - SUSPECT *******' ) | 
 |  9996 FORMAT( ' ******* ', A6, ' FAILED ON CALL NUMBER:' ) | 
 |  9995 FORMAT( '      THESE ARE THE RESULTS FOR COLUMN ', I3 ) | 
 |  9994 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', I3, ',', F4.1, ', X,', | 
 |      $      I2, ', AP)                           .' ) | 
 |  9993 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', I3, ',', F4.1, ', X,', | 
 |      $      I2, ', A,', I3, ')                        .' ) | 
 |  9992 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *', | 
 |      $      '******' ) | 
 | * | 
 | *     End of DCHK5. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHK6( SNAME, EPS, THRESH, NOUT, NTRA, TRACE, REWI, | 
 |      $                  FATAL, NIDIM, IDIM, NALF, ALF, NINC, INC, NMAX, | 
 |      $                  INCMAX, A, AA, AS, X, XX, XS, Y, YY, YS, YT, G, | 
 |      $                  Z ) | 
 | * | 
 | *  Tests DSYR2 and DSPR2. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, HALF, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, HALF = 0.5D0, ONE = 1.0D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   EPS, THRESH | 
 |       INTEGER            INCMAX, NALF, NIDIM, NINC, NMAX, NOUT, NTRA | 
 |       LOGICAL            FATAL, REWI, TRACE | 
 |       CHARACTER*6        SNAME | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ), | 
 |      $                   AS( NMAX*NMAX ), G( NMAX ), X( NMAX ), | 
 |      $                   XS( NMAX*INCMAX ), XX( NMAX*INCMAX ), | 
 |      $                   Y( NMAX ), YS( NMAX*INCMAX ), YT( NMAX ), | 
 |      $                   YY( NMAX*INCMAX ), Z( NMAX, 2 ) | 
 |       INTEGER            IDIM( NIDIM ), INC( NINC ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ALPHA, ALS, ERR, ERRMAX, TRANSL | 
 |       INTEGER            I, IA, IC, IN, INCX, INCXS, INCY, INCYS, IX, | 
 |      $                   IY, J, JA, JJ, LAA, LDA, LDAS, LJ, LX, LY, N, | 
 |      $                   NARGS, NC, NS | 
 |       LOGICAL            FULL, NULL, PACKED, RESET, SAME, UPPER | 
 |       CHARACTER*1        UPLO, UPLOS | 
 |       CHARACTER*2        ICH | 
 | *     .. Local Arrays .. | 
 |       DOUBLE PRECISION   W( 2 ) | 
 |       LOGICAL            ISAME( 13 ) | 
 | *     .. External Functions .. | 
 |       LOGICAL            LDE, LDERES | 
 |       EXTERNAL           LDE, LDERES | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           DMAKE, DMVCH, DSPR2, DSYR2 | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Data statements .. | 
 |       DATA               ICH/'UL'/ | 
 | *     .. Executable Statements .. | 
 |       FULL = SNAME( 3: 3 ).EQ.'Y' | 
 |       PACKED = SNAME( 3: 3 ).EQ.'P' | 
 | *     Define the number of arguments. | 
 |       IF( FULL )THEN | 
 |          NARGS = 9 | 
 |       ELSE IF( PACKED )THEN | 
 |          NARGS = 8 | 
 |       END IF | 
 | * | 
 |       NC = 0 | 
 |       RESET = .TRUE. | 
 |       ERRMAX = ZERO | 
 | * | 
 |       DO 140 IN = 1, NIDIM | 
 |          N = IDIM( IN ) | 
 | *        Set LDA to 1 more than minimum value if room. | 
 |          LDA = N | 
 |          IF( LDA.LT.NMAX ) | 
 |      $      LDA = LDA + 1 | 
 | *        Skip tests if not enough room. | 
 |          IF( LDA.GT.NMAX ) | 
 |      $      GO TO 140 | 
 |          IF( PACKED )THEN | 
 |             LAA = ( N*( N + 1 ) )/2 | 
 |          ELSE | 
 |             LAA = LDA*N | 
 |          END IF | 
 | * | 
 |          DO 130 IC = 1, 2 | 
 |             UPLO = ICH( IC: IC ) | 
 |             UPPER = UPLO.EQ.'U' | 
 | * | 
 |             DO 120 IX = 1, NINC | 
 |                INCX = INC( IX ) | 
 |                LX = ABS( INCX )*N | 
 | * | 
 | *              Generate the vector X. | 
 | * | 
 |                TRANSL = HALF | 
 |                CALL DMAKE( 'GE', ' ', ' ', 1, N, X, 1, XX, ABS( INCX ), | 
 |      $                     0, N - 1, RESET, TRANSL ) | 
 |                IF( N.GT.1 )THEN | 
 |                   X( N/2 ) = ZERO | 
 |                   XX( 1 + ABS( INCX )*( N/2 - 1 ) ) = ZERO | 
 |                END IF | 
 | * | 
 |                DO 110 IY = 1, NINC | 
 |                   INCY = INC( IY ) | 
 |                   LY = ABS( INCY )*N | 
 | * | 
 | *                 Generate the vector Y. | 
 | * | 
 |                   TRANSL = ZERO | 
 |                   CALL DMAKE( 'GE', ' ', ' ', 1, N, Y, 1, YY, | 
 |      $                        ABS( INCY ), 0, N - 1, RESET, TRANSL ) | 
 |                   IF( N.GT.1 )THEN | 
 |                      Y( N/2 ) = ZERO | 
 |                      YY( 1 + ABS( INCY )*( N/2 - 1 ) ) = ZERO | 
 |                   END IF | 
 | * | 
 |                   DO 100 IA = 1, NALF | 
 |                      ALPHA = ALF( IA ) | 
 |                      NULL = N.LE.0.OR.ALPHA.EQ.ZERO | 
 | * | 
 | *                    Generate the matrix A. | 
 | * | 
 |                      TRANSL = ZERO | 
 |                      CALL DMAKE( SNAME( 2: 3 ), UPLO, ' ', N, N, A, | 
 |      $                           NMAX, AA, LDA, N - 1, N - 1, RESET, | 
 |      $                           TRANSL ) | 
 | * | 
 |                      NC = NC + 1 | 
 | * | 
 | *                    Save every datum before calling the subroutine. | 
 | * | 
 |                      UPLOS = UPLO | 
 |                      NS = N | 
 |                      ALS = ALPHA | 
 |                      DO 10 I = 1, LAA | 
 |                         AS( I ) = AA( I ) | 
 |    10                CONTINUE | 
 |                      LDAS = LDA | 
 |                      DO 20 I = 1, LX | 
 |                         XS( I ) = XX( I ) | 
 |    20                CONTINUE | 
 |                      INCXS = INCX | 
 |                      DO 30 I = 1, LY | 
 |                         YS( I ) = YY( I ) | 
 |    30                CONTINUE | 
 |                      INCYS = INCY | 
 | * | 
 | *                    Call the subroutine. | 
 | * | 
 |                      IF( FULL )THEN | 
 |                         IF( TRACE ) | 
 |      $                     WRITE( NTRA, FMT = 9993 )NC, SNAME, UPLO, N, | 
 |      $                     ALPHA, INCX, INCY, LDA | 
 |                         IF( REWI ) | 
 |      $                     REWIND NTRA | 
 |                         CALL DSYR2( UPLO, N, ALPHA, XX, INCX, YY, INCY, | 
 |      $                              AA, LDA ) | 
 |                      ELSE IF( PACKED )THEN | 
 |                         IF( TRACE ) | 
 |      $                     WRITE( NTRA, FMT = 9994 )NC, SNAME, UPLO, N, | 
 |      $                     ALPHA, INCX, INCY | 
 |                         IF( REWI ) | 
 |      $                     REWIND NTRA | 
 |                         CALL DSPR2( UPLO, N, ALPHA, XX, INCX, YY, INCY, | 
 |      $                              AA ) | 
 |                      END IF | 
 | * | 
 | *                    Check if error-exit was taken incorrectly. | 
 | * | 
 |                      IF( .NOT.OK )THEN | 
 |                         WRITE( NOUT, FMT = 9992 ) | 
 |                         FATAL = .TRUE. | 
 |                         GO TO 160 | 
 |                      END IF | 
 | * | 
 | *                    See what data changed inside subroutines. | 
 | * | 
 |                      ISAME( 1 ) = UPLO.EQ.UPLOS | 
 |                      ISAME( 2 ) = NS.EQ.N | 
 |                      ISAME( 3 ) = ALS.EQ.ALPHA | 
 |                      ISAME( 4 ) = LDE( XS, XX, LX ) | 
 |                      ISAME( 5 ) = INCXS.EQ.INCX | 
 |                      ISAME( 6 ) = LDE( YS, YY, LY ) | 
 |                      ISAME( 7 ) = INCYS.EQ.INCY | 
 |                      IF( NULL )THEN | 
 |                         ISAME( 8 ) = LDE( AS, AA, LAA ) | 
 |                      ELSE | 
 |                         ISAME( 8 ) = LDERES( SNAME( 2: 3 ), UPLO, N, N, | 
 |      $                               AS, AA, LDA ) | 
 |                      END IF | 
 |                      IF( .NOT.PACKED )THEN | 
 |                         ISAME( 9 ) = LDAS.EQ.LDA | 
 |                      END IF | 
 | * | 
 | *                    If data was incorrectly changed, report and return. | 
 | * | 
 |                      SAME = .TRUE. | 
 |                      DO 40 I = 1, NARGS | 
 |                         SAME = SAME.AND.ISAME( I ) | 
 |                         IF( .NOT.ISAME( I ) ) | 
 |      $                     WRITE( NOUT, FMT = 9998 )I | 
 |    40                CONTINUE | 
 |                      IF( .NOT.SAME )THEN | 
 |                         FATAL = .TRUE. | 
 |                         GO TO 160 | 
 |                      END IF | 
 | * | 
 |                      IF( .NOT.NULL )THEN | 
 | * | 
 | *                       Check the result column by column. | 
 | * | 
 |                         IF( INCX.GT.0 )THEN | 
 |                            DO 50 I = 1, N | 
 |                               Z( I, 1 ) = X( I ) | 
 |    50                      CONTINUE | 
 |                         ELSE | 
 |                            DO 60 I = 1, N | 
 |                               Z( I, 1 ) = X( N - I + 1 ) | 
 |    60                      CONTINUE | 
 |                         END IF | 
 |                         IF( INCY.GT.0 )THEN | 
 |                            DO 70 I = 1, N | 
 |                               Z( I, 2 ) = Y( I ) | 
 |    70                      CONTINUE | 
 |                         ELSE | 
 |                            DO 80 I = 1, N | 
 |                               Z( I, 2 ) = Y( N - I + 1 ) | 
 |    80                      CONTINUE | 
 |                         END IF | 
 |                         JA = 1 | 
 |                         DO 90 J = 1, N | 
 |                            W( 1 ) = Z( J, 2 ) | 
 |                            W( 2 ) = Z( J, 1 ) | 
 |                            IF( UPPER )THEN | 
 |                               JJ = 1 | 
 |                               LJ = J | 
 |                            ELSE | 
 |                               JJ = J | 
 |                               LJ = N - J + 1 | 
 |                            END IF | 
 |                            CALL DMVCH( 'N', LJ, 2, ALPHA, Z( JJ, 1 ), | 
 |      $                                 NMAX, W, 1, ONE, A( JJ, J ), 1, | 
 |      $                                 YT, G, AA( JA ), EPS, ERR, FATAL, | 
 |      $                                 NOUT, .TRUE. ) | 
 |                            IF( FULL )THEN | 
 |                               IF( UPPER )THEN | 
 |                                  JA = JA + LDA | 
 |                               ELSE | 
 |                                  JA = JA + LDA + 1 | 
 |                               END IF | 
 |                            ELSE | 
 |                               JA = JA + LJ | 
 |                            END IF | 
 |                            ERRMAX = MAX( ERRMAX, ERR ) | 
 | *                          If got really bad answer, report and return. | 
 |                            IF( FATAL ) | 
 |      $                        GO TO 150 | 
 |    90                   CONTINUE | 
 |                      ELSE | 
 | *                       Avoid repeating tests with N.le.0. | 
 |                         IF( N.LE.0 ) | 
 |      $                     GO TO 140 | 
 |                      END IF | 
 | * | 
 |   100             CONTINUE | 
 | * | 
 |   110          CONTINUE | 
 | * | 
 |   120       CONTINUE | 
 | * | 
 |   130    CONTINUE | 
 | * | 
 |   140 CONTINUE | 
 | * | 
 | *     Report result. | 
 | * | 
 |       IF( ERRMAX.LT.THRESH )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SNAME, NC | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9997 )SNAME, NC, ERRMAX | 
 |       END IF | 
 |       GO TO 170 | 
 | * | 
 |   150 CONTINUE | 
 |       WRITE( NOUT, FMT = 9995 )J | 
 | * | 
 |   160 CONTINUE | 
 |       WRITE( NOUT, FMT = 9996 )SNAME | 
 |       IF( FULL )THEN | 
 |          WRITE( NOUT, FMT = 9993 )NC, SNAME, UPLO, N, ALPHA, INCX, | 
 |      $      INCY, LDA | 
 |       ELSE IF( PACKED )THEN | 
 |          WRITE( NOUT, FMT = 9994 )NC, SNAME, UPLO, N, ALPHA, INCX, INCY | 
 |       END IF | 
 | * | 
 |   170 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE COMPUTATIONAL TESTS (', I6, ' CALL', | 
 |      $      'S)' ) | 
 |  9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', I2, ' WAS CH', | 
 |      $      'ANGED INCORRECTLY *******' ) | 
 |  9997 FORMAT( ' ', A6, ' COMPLETED THE COMPUTATIONAL TESTS (', I6, ' C', | 
 |      $      'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', F8.2, | 
 |      $      ' - SUSPECT *******' ) | 
 |  9996 FORMAT( ' ******* ', A6, ' FAILED ON CALL NUMBER:' ) | 
 |  9995 FORMAT( '      THESE ARE THE RESULTS FOR COLUMN ', I3 ) | 
 |  9994 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', I3, ',', F4.1, ', X,', | 
 |      $      I2, ', Y,', I2, ', AP)                     .' ) | 
 |  9993 FORMAT( 1X, I6, ': ', A6, '(''', A1, ''',', I3, ',', F4.1, ', X,', | 
 |      $      I2, ', Y,', I2, ', A,', I3, ')                  .' ) | 
 |  9992 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *', | 
 |      $      '******' ) | 
 | * | 
 | *     End of DCHK6. | 
 | * | 
 |       END | 
 |       SUBROUTINE DCHKE( ISNUM, SRNAMT, NOUT ) | 
 | * | 
 | *  Tests the error exits from the Level 2 Blas. | 
 | *  Requires a special version of the error-handling routine XERBLA. | 
 | *  ALPHA, BETA, A, X and Y should not need to be defined. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       INTEGER            ISNUM, NOUT | 
 |       CHARACTER*6        SRNAMT | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUTC | 
 |       LOGICAL            LERR, OK | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ALPHA, BETA | 
 | *     .. Local Arrays .. | 
 |       DOUBLE PRECISION   A( 1, 1 ), X( 1 ), Y( 1 ) | 
 | *     .. External Subroutines .. | 
 |       EXTERNAL           CHKXER, DGBMV, DGEMV, DGER, DSBMV, DSPMV, DSPR, | 
 |      $                   DSPR2, DSYMV, DSYR, DSYR2, DTBMV, DTBSV, DTPMV, | 
 |      $                   DTPSV, DTRMV, DTRSV | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUTC, OK, LERR | 
 | *     .. Executable Statements .. | 
 | *     OK is set to .FALSE. by the special version of XERBLA or by CHKXER | 
 | *     if anything is wrong. | 
 |       OK = .TRUE. | 
 | *     LERR is set to .TRUE. by the special version of XERBLA each time | 
 | *     it is called, and is then tested and re-set by CHKXER. | 
 |       LERR = .FALSE. | 
 |       GO TO ( 10, 20, 30, 40, 50, 60, 70, 80, | 
 |      $        90, 100, 110, 120, 130, 140, 150, | 
 |      $        160 )ISNUM | 
 |    10 INFOT = 1 | 
 |       CALL DGEMV( '/', 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DGEMV( 'N', -1, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DGEMV( 'N', 0, -1, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 6 | 
 |       CALL DGEMV( 'N', 2, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 8 | 
 |       CALL DGEMV( 'N', 0, 0, ALPHA, A, 1, X, 0, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 11 | 
 |       CALL DGEMV( 'N', 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    20 INFOT = 1 | 
 |       CALL DGBMV( '/', 0, 0, 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DGBMV( 'N', -1, 0, 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DGBMV( 'N', 0, -1, 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DGBMV( 'N', 0, 0, -1, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DGBMV( 'N', 2, 0, 0, -1, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 8 | 
 |       CALL DGBMV( 'N', 0, 0, 1, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 10 | 
 |       CALL DGBMV( 'N', 0, 0, 0, 0, ALPHA, A, 1, X, 0, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 13 | 
 |       CALL DGBMV( 'N', 0, 0, 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    30 INFOT = 1 | 
 |       CALL DSYMV( '/', 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSYMV( 'U', -1, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DSYMV( 'U', 2, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DSYMV( 'U', 0, ALPHA, A, 1, X, 0, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 10 | 
 |       CALL DSYMV( 'U', 0, ALPHA, A, 1, X, 1, BETA, Y, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    40 INFOT = 1 | 
 |       CALL DSBMV( '/', 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSBMV( 'U', -1, 0, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DSBMV( 'U', 0, -1, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 6 | 
 |       CALL DSBMV( 'U', 0, 1, ALPHA, A, 1, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 8 | 
 |       CALL DSBMV( 'U', 0, 0, ALPHA, A, 1, X, 0, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 11 | 
 |       CALL DSBMV( 'U', 0, 0, ALPHA, A, 1, X, 1, BETA, Y, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    50 INFOT = 1 | 
 |       CALL DSPMV( '/', 0, ALPHA, A, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSPMV( 'U', -1, ALPHA, A, X, 1, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 6 | 
 |       CALL DSPMV( 'U', 0, ALPHA, A, X, 0, BETA, Y, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 9 | 
 |       CALL DSPMV( 'U', 0, ALPHA, A, X, 1, BETA, Y, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    60 INFOT = 1 | 
 |       CALL DTRMV( '/', 'N', 'N', 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DTRMV( 'U', '/', 'N', 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DTRMV( 'U', 'N', '/', 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DTRMV( 'U', 'N', 'N', -1, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 6 | 
 |       CALL DTRMV( 'U', 'N', 'N', 2, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 8 | 
 |       CALL DTRMV( 'U', 'N', 'N', 0, A, 1, X, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    70 INFOT = 1 | 
 |       CALL DTBMV( '/', 'N', 'N', 0, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DTBMV( 'U', '/', 'N', 0, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DTBMV( 'U', 'N', '/', 0, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DTBMV( 'U', 'N', 'N', -1, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DTBMV( 'U', 'N', 'N', 0, -1, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DTBMV( 'U', 'N', 'N', 0, 1, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 9 | 
 |       CALL DTBMV( 'U', 'N', 'N', 0, 0, A, 1, X, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    80 INFOT = 1 | 
 |       CALL DTPMV( '/', 'N', 'N', 0, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DTPMV( 'U', '/', 'N', 0, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DTPMV( 'U', 'N', '/', 0, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DTPMV( 'U', 'N', 'N', -1, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DTPMV( 'U', 'N', 'N', 0, A, X, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |    90 INFOT = 1 | 
 |       CALL DTRSV( '/', 'N', 'N', 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DTRSV( 'U', '/', 'N', 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DTRSV( 'U', 'N', '/', 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DTRSV( 'U', 'N', 'N', -1, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 6 | 
 |       CALL DTRSV( 'U', 'N', 'N', 2, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 8 | 
 |       CALL DTRSV( 'U', 'N', 'N', 0, A, 1, X, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   100 INFOT = 1 | 
 |       CALL DTBSV( '/', 'N', 'N', 0, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DTBSV( 'U', '/', 'N', 0, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DTBSV( 'U', 'N', '/', 0, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DTBSV( 'U', 'N', 'N', -1, 0, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DTBSV( 'U', 'N', 'N', 0, -1, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DTBSV( 'U', 'N', 'N', 0, 1, A, 1, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 9 | 
 |       CALL DTBSV( 'U', 'N', 'N', 0, 0, A, 1, X, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   110 INFOT = 1 | 
 |       CALL DTPSV( '/', 'N', 'N', 0, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DTPSV( 'U', '/', 'N', 0, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 3 | 
 |       CALL DTPSV( 'U', 'N', '/', 0, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 4 | 
 |       CALL DTPSV( 'U', 'N', 'N', -1, A, X, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DTPSV( 'U', 'N', 'N', 0, A, X, 0 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   120 INFOT = 1 | 
 |       CALL DGER( -1, 0, ALPHA, X, 1, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DGER( 0, -1, ALPHA, X, 1, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DGER( 0, 0, ALPHA, X, 0, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DGER( 0, 0, ALPHA, X, 1, Y, 0, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 9 | 
 |       CALL DGER( 2, 0, ALPHA, X, 1, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   130 INFOT = 1 | 
 |       CALL DSYR( '/', 0, ALPHA, X, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSYR( 'U', -1, ALPHA, X, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DSYR( 'U', 0, ALPHA, X, 0, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DSYR( 'U', 2, ALPHA, X, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   140 INFOT = 1 | 
 |       CALL DSPR( '/', 0, ALPHA, X, 1, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSPR( 'U', -1, ALPHA, X, 1, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DSPR( 'U', 0, ALPHA, X, 0, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   150 INFOT = 1 | 
 |       CALL DSYR2( '/', 0, ALPHA, X, 1, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSYR2( 'U', -1, ALPHA, X, 1, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DSYR2( 'U', 0, ALPHA, X, 0, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DSYR2( 'U', 0, ALPHA, X, 1, Y, 0, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 9 | 
 |       CALL DSYR2( 'U', 2, ALPHA, X, 1, Y, 1, A, 1 ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       GO TO 170 | 
 |   160 INFOT = 1 | 
 |       CALL DSPR2( '/', 0, ALPHA, X, 1, Y, 1, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 2 | 
 |       CALL DSPR2( 'U', -1, ALPHA, X, 1, Y, 1, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 5 | 
 |       CALL DSPR2( 'U', 0, ALPHA, X, 0, Y, 1, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 |       INFOT = 7 | 
 |       CALL DSPR2( 'U', 0, ALPHA, X, 1, Y, 0, A ) | 
 |       CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 | * | 
 |   170 IF( OK )THEN | 
 |          WRITE( NOUT, FMT = 9999 )SRNAMT | 
 |       ELSE | 
 |          WRITE( NOUT, FMT = 9998 )SRNAMT | 
 |       END IF | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ', A6, ' PASSED THE TESTS OF ERROR-EXITS' ) | 
 |  9998 FORMAT( ' ******* ', A6, ' FAILED THE TESTS OF ERROR-EXITS *****', | 
 |      $      '**' ) | 
 | * | 
 | *     End of DCHKE. | 
 | * | 
 |       END | 
 |       SUBROUTINE DMAKE( TYPE, UPLO, DIAG, M, N, A, NMAX, AA, LDA, KL, | 
 |      $                  KU, RESET, TRANSL ) | 
 | * | 
 | *  Generates values for an M by N matrix A within the bandwidth | 
 | *  defined by KL and KU. | 
 | *  Stores the values in the array AA in the data structure required | 
 | *  by the routine, with unwanted elements set to rogue value. | 
 | * | 
 | *  TYPE is 'GE', 'GB', 'SY', 'SB', 'SP', 'TR', 'TB' OR 'TP'. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, ONE = 1.0D0 ) | 
 |       DOUBLE PRECISION   ROGUE | 
 |       PARAMETER          ( ROGUE = -1.0D10 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   TRANSL | 
 |       INTEGER            KL, KU, LDA, M, N, NMAX | 
 |       LOGICAL            RESET | 
 |       CHARACTER*1        DIAG, UPLO | 
 |       CHARACTER*2        TYPE | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, * ), AA( * ) | 
 | *     .. Local Scalars .. | 
 |       INTEGER            I, I1, I2, I3, IBEG, IEND, IOFF, J, KK | 
 |       LOGICAL            GEN, LOWER, SYM, TRI, UNIT, UPPER | 
 | *     .. External Functions .. | 
 |       DOUBLE PRECISION   DBEG | 
 |       EXTERNAL           DBEG | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          MAX, MIN | 
 | *     .. Executable Statements .. | 
 |       GEN = TYPE( 1: 1 ).EQ.'G' | 
 |       SYM = TYPE( 1: 1 ).EQ.'S' | 
 |       TRI = TYPE( 1: 1 ).EQ.'T' | 
 |       UPPER = ( SYM.OR.TRI ).AND.UPLO.EQ.'U' | 
 |       LOWER = ( SYM.OR.TRI ).AND.UPLO.EQ.'L' | 
 |       UNIT = TRI.AND.DIAG.EQ.'U' | 
 | * | 
 | *     Generate data in array A. | 
 | * | 
 |       DO 20 J = 1, N | 
 |          DO 10 I = 1, M | 
 |             IF( GEN.OR.( UPPER.AND.I.LE.J ).OR.( LOWER.AND.I.GE.J ) ) | 
 |      $          THEN | 
 |                IF( ( I.LE.J.AND.J - I.LE.KU ).OR. | 
 |      $             ( I.GE.J.AND.I - J.LE.KL ) )THEN | 
 |                   A( I, J ) = DBEG( RESET ) + TRANSL | 
 |                ELSE | 
 |                   A( I, J ) = ZERO | 
 |                END IF | 
 |                IF( I.NE.J )THEN | 
 |                   IF( SYM )THEN | 
 |                      A( J, I ) = A( I, J ) | 
 |                   ELSE IF( TRI )THEN | 
 |                      A( J, I ) = ZERO | 
 |                   END IF | 
 |                END IF | 
 |             END IF | 
 |    10    CONTINUE | 
 |          IF( TRI ) | 
 |      $      A( J, J ) = A( J, J ) + ONE | 
 |          IF( UNIT ) | 
 |      $      A( J, J ) = ONE | 
 |    20 CONTINUE | 
 | * | 
 | *     Store elements in array AS in data structure required by routine. | 
 | * | 
 |       IF( TYPE.EQ.'GE' )THEN | 
 |          DO 50 J = 1, N | 
 |             DO 30 I = 1, M | 
 |                AA( I + ( J - 1 )*LDA ) = A( I, J ) | 
 |    30       CONTINUE | 
 |             DO 40 I = M + 1, LDA | 
 |                AA( I + ( J - 1 )*LDA ) = ROGUE | 
 |    40       CONTINUE | 
 |    50    CONTINUE | 
 |       ELSE IF( TYPE.EQ.'GB' )THEN | 
 |          DO 90 J = 1, N | 
 |             DO 60 I1 = 1, KU + 1 - J | 
 |                AA( I1 + ( J - 1 )*LDA ) = ROGUE | 
 |    60       CONTINUE | 
 |             DO 70 I2 = I1, MIN( KL + KU + 1, KU + 1 + M - J ) | 
 |                AA( I2 + ( J - 1 )*LDA ) = A( I2 + J - KU - 1, J ) | 
 |    70       CONTINUE | 
 |             DO 80 I3 = I2, LDA | 
 |                AA( I3 + ( J - 1 )*LDA ) = ROGUE | 
 |    80       CONTINUE | 
 |    90    CONTINUE | 
 |       ELSE IF( TYPE.EQ.'SY'.OR.TYPE.EQ.'TR' )THEN | 
 |          DO 130 J = 1, N | 
 |             IF( UPPER )THEN | 
 |                IBEG = 1 | 
 |                IF( UNIT )THEN | 
 |                   IEND = J - 1 | 
 |                ELSE | 
 |                   IEND = J | 
 |                END IF | 
 |             ELSE | 
 |                IF( UNIT )THEN | 
 |                   IBEG = J + 1 | 
 |                ELSE | 
 |                   IBEG = J | 
 |                END IF | 
 |                IEND = N | 
 |             END IF | 
 |             DO 100 I = 1, IBEG - 1 | 
 |                AA( I + ( J - 1 )*LDA ) = ROGUE | 
 |   100       CONTINUE | 
 |             DO 110 I = IBEG, IEND | 
 |                AA( I + ( J - 1 )*LDA ) = A( I, J ) | 
 |   110       CONTINUE | 
 |             DO 120 I = IEND + 1, LDA | 
 |                AA( I + ( J - 1 )*LDA ) = ROGUE | 
 |   120       CONTINUE | 
 |   130    CONTINUE | 
 |       ELSE IF( TYPE.EQ.'SB'.OR.TYPE.EQ.'TB' )THEN | 
 |          DO 170 J = 1, N | 
 |             IF( UPPER )THEN | 
 |                KK = KL + 1 | 
 |                IBEG = MAX( 1, KL + 2 - J ) | 
 |                IF( UNIT )THEN | 
 |                   IEND = KL | 
 |                ELSE | 
 |                   IEND = KL + 1 | 
 |                END IF | 
 |             ELSE | 
 |                KK = 1 | 
 |                IF( UNIT )THEN | 
 |                   IBEG = 2 | 
 |                ELSE | 
 |                   IBEG = 1 | 
 |                END IF | 
 |                IEND = MIN( KL + 1, 1 + M - J ) | 
 |             END IF | 
 |             DO 140 I = 1, IBEG - 1 | 
 |                AA( I + ( J - 1 )*LDA ) = ROGUE | 
 |   140       CONTINUE | 
 |             DO 150 I = IBEG, IEND | 
 |                AA( I + ( J - 1 )*LDA ) = A( I + J - KK, J ) | 
 |   150       CONTINUE | 
 |             DO 160 I = IEND + 1, LDA | 
 |                AA( I + ( J - 1 )*LDA ) = ROGUE | 
 |   160       CONTINUE | 
 |   170    CONTINUE | 
 |       ELSE IF( TYPE.EQ.'SP'.OR.TYPE.EQ.'TP' )THEN | 
 |          IOFF = 0 | 
 |          DO 190 J = 1, N | 
 |             IF( UPPER )THEN | 
 |                IBEG = 1 | 
 |                IEND = J | 
 |             ELSE | 
 |                IBEG = J | 
 |                IEND = N | 
 |             END IF | 
 |             DO 180 I = IBEG, IEND | 
 |                IOFF = IOFF + 1 | 
 |                AA( IOFF ) = A( I, J ) | 
 |                IF( I.EQ.J )THEN | 
 |                   IF( UNIT ) | 
 |      $               AA( IOFF ) = ROGUE | 
 |                END IF | 
 |   180       CONTINUE | 
 |   190    CONTINUE | 
 |       END IF | 
 |       RETURN | 
 | * | 
 | *     End of DMAKE. | 
 | * | 
 |       END | 
 |       SUBROUTINE DMVCH( TRANS, M, N, ALPHA, A, NMAX, X, INCX, BETA, Y, | 
 |      $                  INCY, YT, G, YY, EPS, ERR, FATAL, NOUT, MV ) | 
 | * | 
 | *  Checks the results of the computational tests. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Parameters .. | 
 |       DOUBLE PRECISION   ZERO, ONE | 
 |       PARAMETER          ( ZERO = 0.0D0, ONE = 1.0D0 ) | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   ALPHA, BETA, EPS, ERR | 
 |       INTEGER            INCX, INCY, M, N, NMAX, NOUT | 
 |       LOGICAL            FATAL, MV | 
 |       CHARACTER*1        TRANS | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   A( NMAX, * ), G( * ), X( * ), Y( * ), YT( * ), | 
 |      $                   YY( * ) | 
 | *     .. Local Scalars .. | 
 |       DOUBLE PRECISION   ERRI | 
 |       INTEGER            I, INCXL, INCYL, IY, J, JX, KX, KY, ML, NL | 
 |       LOGICAL            TRAN | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          ABS, MAX, SQRT | 
 | *     .. Executable Statements .. | 
 |       TRAN = TRANS.EQ.'T'.OR.TRANS.EQ.'C' | 
 |       IF( TRAN )THEN | 
 |          ML = N | 
 |          NL = M | 
 |       ELSE | 
 |          ML = M | 
 |          NL = N | 
 |       END IF | 
 |       IF( INCX.LT.0 )THEN | 
 |          KX = NL | 
 |          INCXL = -1 | 
 |       ELSE | 
 |          KX = 1 | 
 |          INCXL = 1 | 
 |       END IF | 
 |       IF( INCY.LT.0 )THEN | 
 |          KY = ML | 
 |          INCYL = -1 | 
 |       ELSE | 
 |          KY = 1 | 
 |          INCYL = 1 | 
 |       END IF | 
 | * | 
 | *     Compute expected result in YT using data in A, X and Y. | 
 | *     Compute gauges in G. | 
 | * | 
 |       IY = KY | 
 |       DO 30 I = 1, ML | 
 |          YT( IY ) = ZERO | 
 |          G( IY ) = ZERO | 
 |          JX = KX | 
 |          IF( TRAN )THEN | 
 |             DO 10 J = 1, NL | 
 |                YT( IY ) = YT( IY ) + A( J, I )*X( JX ) | 
 |                G( IY ) = G( IY ) + ABS( A( J, I )*X( JX ) ) | 
 |                JX = JX + INCXL | 
 |    10       CONTINUE | 
 |          ELSE | 
 |             DO 20 J = 1, NL | 
 |                YT( IY ) = YT( IY ) + A( I, J )*X( JX ) | 
 |                G( IY ) = G( IY ) + ABS( A( I, J )*X( JX ) ) | 
 |                JX = JX + INCXL | 
 |    20       CONTINUE | 
 |          END IF | 
 |          YT( IY ) = ALPHA*YT( IY ) + BETA*Y( IY ) | 
 |          G( IY ) = ABS( ALPHA )*G( IY ) + ABS( BETA*Y( IY ) ) | 
 |          IY = IY + INCYL | 
 |    30 CONTINUE | 
 | * | 
 | *     Compute the error ratio for this result. | 
 | * | 
 |       ERR = ZERO | 
 |       DO 40 I = 1, ML | 
 |          ERRI = ABS( YT( I ) - YY( 1 + ( I - 1 )*ABS( INCY ) ) )/EPS | 
 |          IF( G( I ).NE.ZERO ) | 
 |      $      ERRI = ERRI/G( I ) | 
 |          ERR = MAX( ERR, ERRI ) | 
 |          IF( ERR*SQRT( EPS ).GE.ONE ) | 
 |      $      GO TO 50 | 
 |    40 CONTINUE | 
 | *     If the loop completes, all results are at least half accurate. | 
 |       GO TO 70 | 
 | * | 
 | *     Report fatal error. | 
 | * | 
 |    50 FATAL = .TRUE. | 
 |       WRITE( NOUT, FMT = 9999 ) | 
 |       DO 60 I = 1, ML | 
 |          IF( MV )THEN | 
 |             WRITE( NOUT, FMT = 9998 )I, YT( I ), | 
 |      $         YY( 1 + ( I - 1 )*ABS( INCY ) ) | 
 |          ELSE | 
 |             WRITE( NOUT, FMT = 9998 )I, | 
 |      $         YY( 1 + ( I - 1 )*ABS( INCY ) ), YT( I ) | 
 |          END IF | 
 |    60 CONTINUE | 
 | * | 
 |    70 CONTINUE | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ******* FATAL ERROR - COMPUTED RESULT IS LESS THAN HAL', | 
 |      $      'F ACCURATE *******', /'           EXPECTED RESULT   COMPU', | 
 |      $      'TED RESULT' ) | 
 |  9998 FORMAT( 1X, I7, 2G18.6 ) | 
 | * | 
 | *     End of DMVCH. | 
 | * | 
 |       END | 
 |       LOGICAL FUNCTION LDE( RI, RJ, LR ) | 
 | * | 
 | *  Tests if two arrays are identical. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       INTEGER            LR | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   RI( * ), RJ( * ) | 
 | *     .. Local Scalars .. | 
 |       INTEGER            I | 
 | *     .. Executable Statements .. | 
 |       DO 10 I = 1, LR | 
 |          IF( RI( I ).NE.RJ( I ) ) | 
 |      $      GO TO 20 | 
 |    10 CONTINUE | 
 |       LDE = .TRUE. | 
 |       GO TO 30 | 
 |    20 CONTINUE | 
 |       LDE = .FALSE. | 
 |    30 RETURN | 
 | * | 
 | *     End of LDE. | 
 | * | 
 |       END | 
 |       LOGICAL FUNCTION LDERES( TYPE, UPLO, M, N, AA, AS, LDA ) | 
 | * | 
 | *  Tests if selected elements in two arrays are equal. | 
 | * | 
 | *  TYPE is 'GE', 'SY' or 'SP'. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       INTEGER            LDA, M, N | 
 |       CHARACTER*1        UPLO | 
 |       CHARACTER*2        TYPE | 
 | *     .. Array Arguments .. | 
 |       DOUBLE PRECISION   AA( LDA, * ), AS( LDA, * ) | 
 | *     .. Local Scalars .. | 
 |       INTEGER            I, IBEG, IEND, J | 
 |       LOGICAL            UPPER | 
 | *     .. Executable Statements .. | 
 |       UPPER = UPLO.EQ.'U' | 
 |       IF( TYPE.EQ.'GE' )THEN | 
 |          DO 20 J = 1, N | 
 |             DO 10 I = M + 1, LDA | 
 |                IF( AA( I, J ).NE.AS( I, J ) ) | 
 |      $            GO TO 70 | 
 |    10       CONTINUE | 
 |    20    CONTINUE | 
 |       ELSE IF( TYPE.EQ.'SY' )THEN | 
 |          DO 50 J = 1, N | 
 |             IF( UPPER )THEN | 
 |                IBEG = 1 | 
 |                IEND = J | 
 |             ELSE | 
 |                IBEG = J | 
 |                IEND = N | 
 |             END IF | 
 |             DO 30 I = 1, IBEG - 1 | 
 |                IF( AA( I, J ).NE.AS( I, J ) ) | 
 |      $            GO TO 70 | 
 |    30       CONTINUE | 
 |             DO 40 I = IEND + 1, LDA | 
 |                IF( AA( I, J ).NE.AS( I, J ) ) | 
 |      $            GO TO 70 | 
 |    40       CONTINUE | 
 |    50    CONTINUE | 
 |       END IF | 
 | * | 
 |    60 CONTINUE | 
 |       LDERES = .TRUE. | 
 |       GO TO 80 | 
 |    70 CONTINUE | 
 |       LDERES = .FALSE. | 
 |    80 RETURN | 
 | * | 
 | *     End of LDERES. | 
 | * | 
 |       END | 
 |       DOUBLE PRECISION FUNCTION DBEG( RESET ) | 
 | * | 
 | *  Generates random numbers uniformly distributed between -0.5 and 0.5. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       LOGICAL            RESET | 
 | *     .. Local Scalars .. | 
 |       INTEGER            I, IC, MI | 
 | *     .. Save statement .. | 
 |       SAVE               I, IC, MI | 
 | *     .. Intrinsic Functions .. | 
 |       INTRINSIC          DBLE | 
 | *     .. Executable Statements .. | 
 |       IF( RESET )THEN | 
 | *        Initialize local variables. | 
 |          MI = 891 | 
 |          I = 7 | 
 |          IC = 0 | 
 |          RESET = .FALSE. | 
 |       END IF | 
 | * | 
 | *     The sequence of values of I is bounded between 1 and 999. | 
 | *     If initial I = 1,2,3,6,7 or 9, the period will be 50. | 
 | *     If initial I = 4 or 8, the period will be 25. | 
 | *     If initial I = 5, the period will be 10. | 
 | *     IC is used to break up the period by skipping 1 value of I in 6. | 
 | * | 
 |       IC = IC + 1 | 
 |    10 I = I*MI | 
 |       I = I - 1000*( I/1000 ) | 
 |       IF( IC.GE.5 )THEN | 
 |          IC = 0 | 
 |          GO TO 10 | 
 |       END IF | 
 |       DBEG = DBLE( I - 500 )/1001.0D0 | 
 |       RETURN | 
 | * | 
 | *     End of DBEG. | 
 | * | 
 |       END | 
 |       DOUBLE PRECISION FUNCTION DDIFF( X, Y ) | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       DOUBLE PRECISION   X, Y | 
 | *     .. Executable Statements .. | 
 |       DDIFF = X - Y | 
 |       RETURN | 
 | * | 
 | *     End of DDIFF. | 
 | * | 
 |       END | 
 |       SUBROUTINE CHKXER( SRNAMT, INFOT, NOUT, LERR, OK ) | 
 | * | 
 | *  Tests whether XERBLA has detected an error when it should. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       INTEGER            INFOT, NOUT | 
 |       LOGICAL            LERR, OK | 
 |       CHARACTER*6        SRNAMT | 
 | *     .. Executable Statements .. | 
 |       IF( .NOT.LERR )THEN | 
 |          WRITE( NOUT, FMT = 9999 )INFOT, SRNAMT | 
 |          OK = .FALSE. | 
 |       END IF | 
 |       LERR = .FALSE. | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ***** ILLEGAL VALUE OF PARAMETER NUMBER ', I2, ' NOT D', | 
 |      $      'ETECTED BY ', A6, ' *****' ) | 
 | * | 
 | *     End of CHKXER. | 
 | * | 
 |       END | 
 |       SUBROUTINE XERBLA( SRNAME, INFO ) | 
 | * | 
 | *  This is a special version of XERBLA to be used only as part of | 
 | *  the test program for testing error exits from the Level 2 BLAS | 
 | *  routines. | 
 | * | 
 | *  XERBLA  is an error handler for the Level 2 BLAS routines. | 
 | * | 
 | *  It is called by the Level 2 BLAS routines if an input parameter is | 
 | *  invalid. | 
 | * | 
 | *  Auxiliary routine for test program for Level 2 Blas. | 
 | * | 
 | *  -- Written on 10-August-1987. | 
 | *     Richard Hanson, Sandia National Labs. | 
 | *     Jeremy Du Croz, NAG Central Office. | 
 | * | 
 | *     .. Scalar Arguments .. | 
 |       INTEGER            INFO | 
 |       CHARACTER*6        SRNAME | 
 | *     .. Scalars in Common .. | 
 |       INTEGER            INFOT, NOUT | 
 |       LOGICAL            LERR, OK | 
 |       CHARACTER*6        SRNAMT | 
 | *     .. Common blocks .. | 
 |       COMMON             /INFOC/INFOT, NOUT, OK, LERR | 
 |       COMMON             /SRNAMC/SRNAMT | 
 | *     .. Executable Statements .. | 
 |       LERR = .TRUE. | 
 |       IF( INFO.NE.INFOT )THEN | 
 |          IF( INFOT.NE.0 )THEN | 
 |             WRITE( NOUT, FMT = 9999 )INFO, INFOT | 
 |          ELSE | 
 |             WRITE( NOUT, FMT = 9997 )INFO | 
 |          END IF | 
 |          OK = .FALSE. | 
 |       END IF | 
 |       IF( SRNAME.NE.SRNAMT )THEN | 
 |          WRITE( NOUT, FMT = 9998 )SRNAME, SRNAMT | 
 |          OK = .FALSE. | 
 |       END IF | 
 |       RETURN | 
 | * | 
 |  9999 FORMAT( ' ******* XERBLA WAS CALLED WITH INFO = ', I6, ' INSTEAD', | 
 |      $      ' OF ', I2, ' *******' ) | 
 |  9998 FORMAT( ' ******* XERBLA WAS CALLED WITH SRNAME = ', A6, ' INSTE', | 
 |      $      'AD OF ', A6, ' *******' ) | 
 |  9997 FORMAT( ' ******* XERBLA WAS CALLED WITH INFO = ', I6, | 
 |      $      ' *******' ) | 
 | * | 
 | *     End of XERBLA | 
 | * | 
 |       END | 
 |  |