1       PROGRAM SCHKAA
  2 *
  3 *  -- LAPACK test routine (version 3.1.1) --
  4 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
  5 *     January 2007
  6 *
  7 *  Purpose
  8 *  =======
  9 *
 10 *  SCHKAA is the main test program for the REAL LAPACK
 11 *  linear equation routines
 12 *
 13 *  The program must be driven by a short data file. The first 14 records
 14 *  specify problem dimensions and program options using list-directed
 15 *  input.  The remaining lines specify the LAPACK test paths and the
 16 *  number of matrix types to use in testing.  An annotated example of a
 17 *  data file can be obtained by deleting the first 3 characters from the
 18 *  following 36 lines:
 19 *  Data file for testing REAL LAPACK linear eqn. routines
 20 *  7                      Number of values of M
 21 *  0 1 2 3 5 10 16        Values of M (row dimension)
 22 *  7                      Number of values of N
 23 *  0 1 2 3 5 10 16        Values of N (column dimension)
 24 *  1                      Number of values of NRHS
 25 *  2                      Values of NRHS (number of right hand sides)
 26 *  5                      Number of values of NB
 27 *  1 3 3 3 20             Values of NB (the blocksize)
 28 *  1 0 5 9 1              Values of NX (crossover point)
 29 *  3                      Number of values of RANK
 30 *  30 50 90               Values of rank (as a % of N)
 31 *  20.0                   Threshold value of test ratio
 32 *  T                      Put T to test the LAPACK routines
 33 *  T                      Put T to test the driver routines
 34 *  T                      Put T to test the error exits
 35 *  SGE   11               List types on next line if 0 < NTYPES < 11
 36 *  SGB    8               List types on next line if 0 < NTYPES <  8
 37 *  SGT   12               List types on next line if 0 < NTYPES < 12
 38 *  SPO    9               List types on next line if 0 < NTYPES <  9
 39 *  SPS    9               List types on next line if 0 < NTYPES <  9
 40 *  SPP    9               List types on next line if 0 < NTYPES <  9
 41 *  SPB    8               List types on next line if 0 < NTYPES <  8
 42 *  SPT   12               List types on next line if 0 < NTYPES < 12
 43 *  SSY   10               List types on next line if 0 < NTYPES < 10
 44 *  SSP   10               List types on next line if 0 < NTYPES < 10
 45 *  STR   18               List types on next line if 0 < NTYPES < 18
 46 *  STP   18               List types on next line if 0 < NTYPES < 18
 47 *  STB   17               List types on next line if 0 < NTYPES < 17
 48 *  SQR    8               List types on next line if 0 < NTYPES <  8
 49 *  SRQ    8               List types on next line if 0 < NTYPES <  8
 50 *  SLQ    8               List types on next line if 0 < NTYPES <  8
 51 *  SQL    8               List types on next line if 0 < NTYPES <  8
 52 *  SQP    6               List types on next line if 0 < NTYPES <  6
 53 *  STZ    3               List types on next line if 0 < NTYPES <  3
 54 *  SLS    6               List types on next line if 0 < NTYPES <  6
 55 *  SEQ
 56 *
 57 *  Internal Parameters
 58 *  ===================
 59 *
 60 *  NMAX    INTEGER
 61 *          The maximum allowable value for N
 62 *
 63 *  MAXIN   INTEGER
 64 *          The number of different values that can be used for each of
 65 *          M, N, NRHS, NB, and NX
 66 *
 67 *  MAXRHS  INTEGER
 68 *          The maximum number of right hand sides
 69 *
 70 *  NIN     INTEGER
 71 *          The unit number for input
 72 *
 73 *  NOUT    INTEGER
 74 *          The unit number for output
 75 *
 76 *  =====================================================================
 77 *
 78 *     .. Parameters ..
 79       INTEGER            NMAX
 80       PARAMETER          ( NMAX = 132 )
 81       INTEGER            MAXIN
 82       PARAMETER          ( MAXIN = 12 )
 83       INTEGER            MAXRHS
 84       PARAMETER          ( MAXRHS = 16 )
 85       INTEGER            MATMAX
 86       PARAMETER          ( MATMAX = 30 )
 87       INTEGER            NIN, NOUT
 88       PARAMETER          ( NIN = 5, NOUT = 6 )
 89       INTEGER            KDMAX
 90       PARAMETER          ( KDMAX = NMAX+( NMAX+1 ) / 4 )
 91 *     ..
 92 *     .. Local Scalars ..
 93       LOGICAL            FATAL, TSTCHK, TSTDRV, TSTERR
 94       CHARACTER          C1
 95       CHARACTER*2        C2
 96       CHARACTER*3        PATH
 97       CHARACTER*10       INTSTR
 98       CHARACTER*72       ALINE
 99       INTEGER            I, IC, J, K, LA, LAFAC, LDA, NB, NM, NMATS, NN,
100      $                   NNB, NNB2, NNS, NRHS, NTYPES, NRANK,
101      $                   VERS_MAJOR, VERS_MINOR, VERS_PATCH
102       REAL               EPS, S1, S2, THREQ, THRESH
103 *     ..
104 *     .. Local Arrays ..
105       LOGICAL            DOTYPE( MATMAX )
106       INTEGER            IWORK( 25*NMAX ), MVAL( MAXIN ),
107      $                   NBVAL( MAXIN ), NBVAL2( MAXIN ),
108      $                   NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ),
109      $                   RANKVAL( MAXIN ), PIV( NMAX )
110       REAL               A( ( KDMAX+1 )*NMAX, 7 ), B( NMAX*MAXRHS, 4 ),
111      $                   RWORK( 5*NMAX+2*MAXRHS ), S( 2*NMAX ),
112      $                   WORK( NMAX, NMAX+MAXRHS+30 )
113 *     ..
114 *     .. External Functions ..
115       LOGICAL            LSAME, LSAMEN
116       REAL               SECOND, SLAMCH
117       EXTERNAL           LSAME, LSAMEN, SECOND, SLAMCH
118 *     ..
119 *     .. External Subroutines ..
120       EXTERNAL           ALAREQ, SCHKEQ, SCHKGB, SCHKGE, SCHKGT, SCHKLQ,
121      $                   SCHKPB, SCHKPO, SCHKPS, SCHKPP, SCHKPT, SCHKQ3,
122      $                   SCHKQL, SCHKQP, SCHKQR, SCHKRQ, SCHKSP, SCHKSY,
123      $                   SCHKTB, SCHKTP, SCHKTR, SCHKTZ, SDRVGB, SDRVGE,
124      $                   SDRVGT, SDRVLS, SDRVPB, SDRVPO, SDRVPP, SDRVPT,
125      $                   SDRVSP, SDRVSY, ILAVER
126 *     ..
127 *     .. Scalars in Common ..
128       LOGICAL            LERR, OK
129       CHARACTER*32       SRNAMT
130       INTEGER            INFOT, NUNIT
131 *     ..
132 *     .. Arrays in Common ..
133       INTEGER            IPARMS( 100 )
134 *     ..
135 *     .. Common blocks ..
136       COMMON             / CLAENV / IPARMS
137       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
138       COMMON             / SRNAMC / SRNAMT
139 *     ..
140 *     .. Data statements ..
141       DATA               THREQ / 2.0E0 / , INTSTR / '0123456789' /
142 *     ..
143 *     .. Executable Statements ..
144 *
145       S1 = SECOND( )
146       LDA = NMAX
147       FATAL = .FALSE.
148 *
149 *     Read a dummy line.
150 *
151       READ( NIN, FMT = * )
152 *
153 *     Report values of parameters.
154 *
155       CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH )
156       WRITE( NOUT, FMT = 9994 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH
157 *
158 *     Read the values of M
159 *
160       READ( NIN, FMT = * )NM
161       IF( NM.LT.1 ) THEN
162          WRITE( NOUT, FMT = 9996 )' NM ', NM, 1
163          NM = 0
164          FATAL = .TRUE.
165       ELSE IF( NM.GT.MAXIN ) THEN
166          WRITE( NOUT, FMT = 9995 )' NM ', NM, MAXIN
167          NM = 0
168          FATAL = .TRUE.
169       END IF
170       READ( NIN, FMT = * )( MVAL( I ), I = 1, NM )
171       DO 10 I = 1, NM
172          IF( MVAL( I ).LT.0 ) THEN
173             WRITE( NOUT, FMT = 9996 )' M  ', MVAL( I ), 0
174             FATAL = .TRUE.
175          ELSE IF( MVAL( I ).GT.NMAX ) THEN
176             WRITE( NOUT, FMT = 9995 )' M  ', MVAL( I ), NMAX
177             FATAL = .TRUE.
178          END IF
179    10 CONTINUE
180       IF( NM.GT.0 )
181      $   WRITE( NOUT, FMT = 9993 )'M   ', ( MVAL( I ), I = 1, NM )
182 *
183 *     Read the values of N
184 *
185       READ( NIN, FMT = * )NN
186       IF( NN.LT.1 ) THEN
187          WRITE( NOUT, FMT = 9996 )' NN ', NN, 1
188          NN = 0
189          FATAL = .TRUE.
190       ELSE IF( NN.GT.MAXIN ) THEN
191          WRITE( NOUT, FMT = 9995 )' NN ', NN, MAXIN
192          NN = 0
193          FATAL = .TRUE.
194       END IF
195       READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
196       DO 20 I = 1, NN
197          IF( NVAL( I ).LT.0 ) THEN
198             WRITE( NOUT, FMT = 9996 )' N  ', NVAL( I ), 0
199             FATAL = .TRUE.
200          ELSE IF( NVAL( I ).GT.NMAX ) THEN
201             WRITE( NOUT, FMT = 9995 )' N  ', NVAL( I ), NMAX
202             FATAL = .TRUE.
203          END IF
204    20 CONTINUE
205       IF( NN.GT.0 )
206      $   WRITE( NOUT, FMT = 9993 )'N   ', ( NVAL( I ), I = 1, NN )
207 *
208 *     Read the values of NRHS
209 *
210       READ( NIN, FMT = * )NNS
211       IF( NNS.LT.1 ) THEN
212          WRITE( NOUT, FMT = 9996 )' NNS', NNS, 1
213          NNS = 0
214          FATAL = .TRUE.
215       ELSE IF( NNS.GT.MAXIN ) THEN
216          WRITE( NOUT, FMT = 9995 )' NNS', NNS, MAXIN
217          NNS = 0
218          FATAL = .TRUE.
219       END IF
220       READ( NIN, FMT = * )( NSVAL( I ), I = 1, NNS )
221       DO 30 I = 1, NNS
222          IF( NSVAL( I ).LT.0 ) THEN
223             WRITE( NOUT, FMT = 9996 )'NRHS', NSVAL( I ), 0
224             FATAL = .TRUE.
225          ELSE IF( NSVAL( I ).GT.MAXRHS ) THEN
226             WRITE( NOUT, FMT = 9995 )'NRHS', NSVAL( I ), MAXRHS
227             FATAL = .TRUE.
228          END IF
229    30 CONTINUE
230       IF( NNS.GT.0 )
231      $   WRITE( NOUT, FMT = 9993 )'NRHS', ( NSVAL( I ), I = 1, NNS )
232 *
233 *     Read the values of NB
234 *
235       READ( NIN, FMT = * )NNB
236       IF( NNB.LT.1 ) THEN
237          WRITE( NOUT, FMT = 9996 )'NNB ', NNB, 1
238          NNB = 0
239          FATAL = .TRUE.
240       ELSE IF( NNB.GT.MAXIN ) THEN
241          WRITE( NOUT, FMT = 9995 )'NNB ', NNB, MAXIN
242          NNB = 0
243          FATAL = .TRUE.
244       END IF
245       READ( NIN, FMT = * )( NBVAL( I ), I = 1, NNB )
246       DO 40 I = 1, NNB
247          IF( NBVAL( I ).LT.0 ) THEN
248             WRITE( NOUT, FMT = 9996 )' NB ', NBVAL( I ), 0
249             FATAL = .TRUE.
250          END IF
251    40 CONTINUE
252       IF( NNB.GT.0 )
253      $   WRITE( NOUT, FMT = 9993 )'NB  ', ( NBVAL( I ), I = 1, NNB )
254 *
255 *     Set NBVAL2 to be the set of unique values of NB
256 *
257       NNB2 = 0
258       DO 60 I = 1, NNB
259          NB = NBVAL( I )
260          DO 50 J = 1, NNB2
261             IF( NB.EQ.NBVAL2( J ) )
262      $         GO TO 60
263    50    CONTINUE
264          NNB2 = NNB2 + 1
265          NBVAL2( NNB2 ) = NB
266    60 CONTINUE
267 *
268 *     Read the values of NX
269 *
270       READ( NIN, FMT = * )( NXVAL( I ), I = 1, NNB )
271       DO 70 I = 1, NNB
272          IF( NXVAL( I ).LT.0 ) THEN
273             WRITE( NOUT, FMT = 9996 )' NX ', NXVAL( I ), 0
274             FATAL = .TRUE.
275          END IF
276    70 CONTINUE
277       IF( NNB.GT.0 )
278      $   WRITE( NOUT, FMT = 9993 )'NX  ', ( NXVAL( I ), I = 1, NNB )
279 *
280 *     Read the values of RANKVAL
281 *
282       READ( NIN, FMT = * )NRANK
283       IF( NN.LT.1 ) THEN
284          WRITE( NOUT, FMT = 9996 )' NRANK ', NRANK, 1
285          NRANK = 0
286          FATAL = .TRUE.
287       ELSE IF( NN.GT.MAXIN ) THEN
288          WRITE( NOUT, FMT = 9995 )' NRANK ', NRANK, MAXIN
289          NRANK = 0
290          FATAL = .TRUE.
291       END IF
292       READ( NIN, FMT = * )( RANKVAL( I ), I = 1, NRANK )
293       DO I = 1, NRANK
294          IF( RANKVAL( I ).LT.0 ) THEN
295             WRITE( NOUT, FMT = 9996 )' RANK  ', RANKVAL( I ), 0
296             FATAL = .TRUE.
297          ELSE IF( RANKVAL( I ).GT.100 ) THEN
298             WRITE( NOUT, FMT = 9995 )' RANK  ', RANKVAL( I ), 100
299             FATAL = .TRUE.
300          END IF
301       END DO
302       IF( NRANK.GT.0 )
303      $   WRITE( NOUT, FMT = 9993 )'RANK % OF N',
304      $   ( RANKVAL( I ), I = 1, NRANK )
305 *
306 *     Read the threshold value for the test ratios.
307 *
308       READ( NIN, FMT = * )THRESH
309       WRITE( NOUT, FMT = 9992 )THRESH
310 *
311 *     Read the flag that indicates whether to test the LAPACK routines.
312 *
313       READ( NIN, FMT = * )TSTCHK
314 *
315 *     Read the flag that indicates whether to test the driver routines.
316 *
317       READ( NIN, FMT = * )TSTDRV
318 *
319 *     Read the flag that indicates whether to test the error exits.
320 *
321       READ( NIN, FMT = * )TSTERR
322 *
323       IF( FATAL ) THEN
324          WRITE( NOUT, FMT = 9999 )
325          STOP
326       END IF
327 *
328 *     Calculate and print the machine dependent constants.
329 *
330       EPS = SLAMCH( 'Underflow threshold' )
331       WRITE( NOUT, FMT = 9991 )'underflow', EPS
332       EPS = SLAMCH( 'Overflow threshold' )
333       WRITE( NOUT, FMT = 9991 )'overflow ', EPS
334       EPS = SLAMCH( 'Epsilon' )
335       WRITE( NOUT, FMT = 9991 )'precision', EPS
336       WRITE( NOUT, FMT = * )
337 *
338    80 CONTINUE
339 *
340 *     Read a test path and the number of matrix types to use.
341 *
342       READ( NIN, FMT = '(A72)'END = 140 )ALINE
343       PATH = ALINE( 13 )
344       NMATS = MATMAX
345       I = 3
346    90 CONTINUE
347       I = I + 1
348       IF( I.GT.72 ) THEN
349          NMATS = MATMAX
350          GO TO 130
351       END IF
352       IF( ALINE( I: I ).EQ.' ' )
353      $   GO TO 90
354       NMATS = 0
355   100 CONTINUE
356       C1 = ALINE( I: I )
357       DO 110 K = 110
358          IF( C1.EQ.INTSTR( K: K ) ) THEN
359             IC = K - 1
360             GO TO 120
361          END IF
362   110 CONTINUE
363       GO TO 130
364   120 CONTINUE
365       NMATS = NMATS*10 + IC
366       I = I + 1
367       IF( I.GT.72 )
368      $   GO TO 130
369       GO TO 100
370   130 CONTINUE
371       C1 = PATH( 11 )
372       C2 = PATH( 23 )
373       NRHS = NSVAL( 1 )
374 *
375 *     Check first character for correct precision.
376 *
377       IF.NOT.LSAME( C1, 'Single precision' ) ) THEN
378          WRITE( NOUT, FMT = 9990 )PATH
379 *
380       ELSE IF( NMATS.LE.0 ) THEN
381 *
382 *        Check for a positive number of tests requested.
383 *
384          WRITE( NOUT, FMT = 9989 )PATH
385 *
386       ELSE IF( LSAMEN( 2, C2, 'GE' ) ) THEN
387 *
388 *        GE:  general matrices
389 *
390          NTYPES = 11
391          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
392 *
393          IF( TSTCHK ) THEN
394             CALL SCHKGE( DOTYPE, NM, MVAL, NN, NVAL, NNB2, NBVAL2, NNS,
395      $                   NSVAL, THRESH, TSTERR, LDA, A( 11 ),
396      $                   A( 12 ), A( 13 ), B( 11 ), B( 12 ),
397      $                   B( 13 ), WORK, RWORK, IWORK, NOUT )
398          ELSE
399             WRITE( NOUT, FMT = 9989 )PATH
400          END IF
401 *
402          IF( TSTDRV ) THEN
403             CALL SDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
404      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
405      $                   B( 12 ), B( 13 ), B( 14 ), S, WORK,
406      $                   RWORK, IWORK, NOUT )
407          ELSE
408             WRITE( NOUT, FMT = 9988 )PATH
409          END IF
410 *
411       ELSE IF( LSAMEN( 2, C2, 'GB' ) ) THEN
412 *
413 *        GB:  general banded matrices
414 *
415          LA = ( 2*KDMAX+1 )*NMAX
416          LAFAC = ( 3*KDMAX+1 )*NMAX
417          NTYPES = 8
418          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
419 *
420          IF( TSTCHK ) THEN
421             CALL SCHKGB( DOTYPE, NM, MVAL, NN, NVAL, NNB2, NBVAL2, NNS,
422      $                   NSVAL, THRESH, TSTERR, A( 11 ), LA,
423      $                   A( 13 ), LAFAC, B( 11 ), B( 12 ),
424      $                   B( 13 ), WORK, RWORK, IWORK, NOUT )
425          ELSE
426             WRITE( NOUT, FMT = 9989 )PATH
427          END IF
428 *
429          IF( TSTDRV ) THEN
430             CALL SDRVGB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
431      $                   A( 11 ), LA, A( 13 ), LAFAC, A( 16 ),
432      $                   B( 11 ), B( 12 ), B( 13 ), B( 14 ), S,
433      $                   WORK, RWORK, IWORK, NOUT )
434          ELSE
435             WRITE( NOUT, FMT = 9988 )PATH
436          END IF
437 *
438       ELSE IF( LSAMEN( 2, C2, 'GT' ) ) THEN
439 *
440 *        GT:  general tridiagonal matrices
441 *
442          NTYPES = 12
443          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
444 *
445          IF( TSTCHK ) THEN
446             CALL SCHKGT( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
447      $                   A( 11 ), A( 12 ), B( 11 ), B( 12 ),
448      $                   B( 13 ), WORK, RWORK, IWORK, NOUT )
449          ELSE
450             WRITE( NOUT, FMT = 9989 )PATH
451          END IF
452 *
453          IF( TSTDRV ) THEN
454             CALL SDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
455      $                   A( 11 ), A( 12 ), B( 11 ), B( 12 ),
456      $                   B( 13 ), WORK, RWORK, IWORK, NOUT )
457          ELSE
458             WRITE( NOUT, FMT = 9988 )PATH
459          END IF
460 *
461       ELSE IF( LSAMEN( 2, C2, 'PO' ) ) THEN
462 *
463 *        PO:  positive definite matrices
464 *
465          NTYPES = 9
466          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
467 *
468          IF( TSTCHK ) THEN
469             CALL SCHKPO( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
470      $                   THRESH, TSTERR, LDA, A( 11 ), A( 12 ),
471      $                   A( 13 ), B( 11 ), B( 12 ), B( 13 ),
472      $                   WORK, RWORK, IWORK, NOUT )
473          ELSE
474             WRITE( NOUT, FMT = 9989 )PATH
475          END IF
476 *
477          IF( TSTDRV ) THEN
478             CALL SDRVPO( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
479      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
480      $                   B( 12 ), B( 13 ), B( 14 ), S, WORK,
481      $                   RWORK, IWORK, NOUT )
482          ELSE
483             WRITE( NOUT, FMT = 9988 )PATH
484          END IF
485 *
486       ELSE IF( LSAMEN( 2, C2, 'PS' ) ) THEN
487 *
488 *        PS:  positive semi-definite matrices
489 *
490          NTYPES = 9
491 *
492          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
493 *
494          IF( TSTCHK ) THEN
495             CALL SCHKPS( DOTYPE, NN, NVAL, NNB2, NBVAL2, NRANK,
496      $                   RANKVAL, THRESH, TSTERR, LDA, A( 11 ),
497      $                   A( 12 ), A( 13 ), PIV, WORK, RWORK,
498      $                   NOUT )
499          ELSE
500             WRITE( NOUT, FMT = 9989 )PATH
501          END IF
502 *
503       ELSE IF( LSAMEN( 2, C2, 'PP' ) ) THEN
504 *
505 *        PP:  positive definite packed matrices
506 *
507          NTYPES = 9
508          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
509 *
510          IF( TSTCHK ) THEN
511             CALL SCHKPP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
512      $                   LDA, A( 11 ), A( 12 ), A( 13 ),
513      $                   B( 11 ), B( 12 ), B( 13 ), WORK, RWORK,
514      $                   IWORK, NOUT )
515          ELSE
516             WRITE( NOUT, FMT = 9989 )PATH
517          END IF
518 *
519          IF( TSTDRV ) THEN
520             CALL SDRVPP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
521      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
522      $                   B( 12 ), B( 13 ), B( 14 ), S, WORK,
523      $                   RWORK, IWORK, NOUT )
524          ELSE
525             WRITE( NOUT, FMT = 9988 )PATH
526          END IF
527 *
528       ELSE IF( LSAMEN( 2, C2, 'PB' ) ) THEN
529 *
530 *        PB:  positive definite banded matrices
531 *
532          NTYPES = 8
533          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
534 *
535          IF( TSTCHK ) THEN
536             CALL SCHKPB( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
537      $                   THRESH, TSTERR, LDA, A( 11 ), A( 12 ),
538      $                   A( 13 ), B( 11 ), B( 12 ), B( 13 ),
539      $                   WORK, RWORK, IWORK, NOUT )
540          ELSE
541             WRITE( NOUT, FMT = 9989 )PATH
542          END IF
543 *
544          IF( TSTDRV ) THEN
545             CALL SDRVPB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
546      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
547      $                   B( 12 ), B( 13 ), B( 14 ), S, WORK,
548      $                   RWORK, IWORK, NOUT )
549          ELSE
550             WRITE( NOUT, FMT = 9988 )PATH
551          END IF
552 *
553       ELSE IF( LSAMEN( 2, C2, 'PT' ) ) THEN
554 *
555 *        PT:  positive definite tridiagonal matrices
556 *
557          NTYPES = 12
558          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
559 *
560          IF( TSTCHK ) THEN
561             CALL SCHKPT( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
562      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
563      $                   B( 12 ), B( 13 ), WORK, RWORK, NOUT )
564          ELSE
565             WRITE( NOUT, FMT = 9989 )PATH
566          END IF
567 *
568          IF( TSTDRV ) THEN
569             CALL SDRVPT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
570      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
571      $                   B( 12 ), B( 13 ), WORK, RWORK, NOUT )
572          ELSE
573             WRITE( NOUT, FMT = 9988 )PATH
574          END IF
575 *
576       ELSE IF( LSAMEN( 2, C2, 'SY' ) ) THEN
577 *
578 *        SY:  symmetric indefinite matrices
579 *
580          NTYPES = 10
581          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
582 *
583          IF( TSTCHK ) THEN
584             CALL SCHKSY( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
585      $                   THRESH, TSTERR, LDA, A( 11 ), A( 12 ),
586      $                   A( 13 ), B( 11 ), B( 12 ), B( 13 ),
587      $                   WORK, RWORK, IWORK, NOUT )
588          ELSE
589             WRITE( NOUT, FMT = 9989 )PATH
590          END IF
591 *
592          IF( TSTDRV ) THEN
593             CALL SDRVSY( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
594      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
595      $                   B( 12 ), B( 13 ), WORK, RWORK, IWORK,
596      $                   NOUT )
597          ELSE
598             WRITE( NOUT, FMT = 9988 )PATH
599          END IF
600 *
601       ELSE IF( LSAMEN( 2, C2, 'SP' ) ) THEN
602 *
603 *        SP:  symmetric indefinite packed matrices
604 *
605          NTYPES = 10
606          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
607 *
608          IF( TSTCHK ) THEN
609             CALL SCHKSP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
610      $                   LDA, A( 11 ), A( 12 ), A( 13 ),
611      $                   B( 11 ), B( 12 ), B( 13 ), WORK, RWORK,
612      $                   IWORK, NOUT )
613          ELSE
614             WRITE( NOUT, FMT = 9989 )PATH
615          END IF
616 *
617          IF( TSTDRV ) THEN
618             CALL SDRVSP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
619      $                   A( 11 ), A( 12 ), A( 13 ), B( 11 ),
620      $                   B( 12 ), B( 13 ), WORK, RWORK, IWORK,
621      $                   NOUT )
622          ELSE
623             WRITE( NOUT, FMT = 9988 )PATH
624          END IF
625 *
626       ELSE IF( LSAMEN( 2, C2, 'TR' ) ) THEN
627 *
628 *        TR:  triangular matrices
629 *
630          NTYPES = 18
631          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
632 *
633          IF( TSTCHK ) THEN
634             CALL SCHKTR( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
635      $                   THRESH, TSTERR, LDA, A( 11 ), A( 12 ),
636      $                   B( 11 ), B( 12 ), B( 13 ), WORK, RWORK,
637      $                   IWORK, NOUT )
638          ELSE
639             WRITE( NOUT, FMT = 9989 )PATH
640          END IF
641 *
642       ELSE IF( LSAMEN( 2, C2, 'TP' ) ) THEN
643 *
644 *        TP:  triangular packed matrices
645 *
646          NTYPES = 18
647          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
648 *
649          IF( TSTCHK ) THEN
650             CALL SCHKTP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
651      $                   LDA, A( 11 ), A( 12 ), B( 11 ),
652      $                   B( 12 ), B( 13 ), WORK, RWORK, IWORK,
653      $                   NOUT )
654          ELSE
655             WRITE( NOUT, FMT = 9989 )PATH
656          END IF
657 *
658       ELSE IF( LSAMEN( 2, C2, 'TB' ) ) THEN
659 *
660 *        TB:  triangular banded matrices
661 *
662          NTYPES = 17
663          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
664 *
665          IF( TSTCHK ) THEN
666             CALL SCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
667      $                   LDA, A( 11 ), A( 12 ), B( 11 ),
668      $                   B( 12 ), B( 13 ), WORK, RWORK, IWORK,
669      $                   NOUT )
670          ELSE
671             WRITE( NOUT, FMT = 9989 )PATH
672          END IF
673 *
674       ELSE IF( LSAMEN( 2, C2, 'QR' ) ) THEN
675 *
676 *        QR:  QR factorization
677 *
678          NTYPES = 8
679          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
680 *
681          IF( TSTCHK ) THEN
682             CALL SCHKQR( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
683      $                   NRHS, THRESH, TSTERR, NMAX, A( 11 ),
684      $                   A( 12 ), A( 13 ), A( 14 ), A( 15 ),
685      $                   B( 11 ), B( 12 ), B( 13 ), B( 14 ),
686      $                   WORK, RWORK, IWORK, NOUT )
687          ELSE
688             WRITE( NOUT, FMT = 9989 )PATH
689          END IF
690 *
691       ELSE IF( LSAMEN( 2, C2, 'LQ' ) ) THEN
692 *
693 *        LQ:  LQ factorization
694 *
695          NTYPES = 8
696          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
697 *
698          IF( TSTCHK ) THEN
699             CALL SCHKLQ( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
700      $                   NRHS, THRESH, TSTERR, NMAX, A( 11 ),
701      $                   A( 12 ), A( 13 ), A( 14 ), A( 15 ),
702      $                   B( 11 ), B( 12 ), B( 13 ), B( 14 ),
703      $                   WORK, RWORK, IWORK, NOUT )
704          ELSE
705             WRITE( NOUT, FMT = 9989 )PATH
706          END IF
707 *
708       ELSE IF( LSAMEN( 2, C2, 'QL' ) ) THEN
709 *
710 *        QL:  QL factorization
711 *
712          NTYPES = 8
713          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
714 *
715          IF( TSTCHK ) THEN
716             CALL SCHKQL( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
717      $                   NRHS, THRESH, TSTERR, NMAX, A( 11 ),
718      $                   A( 12 ), A( 13 ), A( 14 ), A( 15 ),
719      $                   B( 11 ), B( 12 ), B( 13 ), B( 14 ),
720      $                   WORK, RWORK, IWORK, NOUT )
721          ELSE
722             WRITE( NOUT, FMT = 9989 )PATH
723          END IF
724 *
725       ELSE IF( LSAMEN( 2, C2, 'RQ' ) ) THEN
726 *
727 *        RQ:  RQ factorization
728 *
729          NTYPES = 8
730          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
731 *
732          IF( TSTCHK ) THEN
733             CALL SCHKRQ( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
734      $                   NRHS, THRESH, TSTERR, NMAX, A( 11 ),
735      $                   A( 12 ), A( 13 ), A( 14 ), A( 15 ),
736      $                   B( 11 ), B( 12 ), B( 13 ), B( 14 ),
737      $                   WORK, RWORK, IWORK, NOUT )
738          ELSE
739             WRITE( NOUT, FMT = 9989 )PATH
740          END IF
741 *
742       ELSE IF( LSAMEN( 2, C2, 'QP' ) ) THEN
743 *
744 *        QP:  QR factorization with pivoting
745 *
746          NTYPES = 6
747          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
748 *
749          IF( TSTCHK ) THEN
750             CALL SCHKQP( DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR,
751      $                   A( 11 ), A( 12 ), B( 11 ), B( 12 ),
752      $                   B( 13 ), WORK, IWORK, NOUT )
753             CALL SCHKQ3( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
754      $                   THRESH, A( 11 ), A( 12 ), B( 11 ),
755      $                   B( 12 ), B( 13 ), WORK, IWORK, NOUT )
756          ELSE
757             WRITE( NOUT, FMT = 9989 )PATH
758          END IF
759 *
760       ELSE IF( LSAMEN( 2, C2, 'TZ' ) ) THEN
761 *
762 *        TZ:  Trapezoidal matrix
763 *
764          NTYPES = 3
765          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
766 *
767          IF( TSTCHK ) THEN
768             CALL SCHKTZ( DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR,
769      $                   A( 11 ), A( 12 ), B( 11 ), B( 12 ),
770      $                   B( 13 ), WORK, NOUT )
771          ELSE
772             WRITE( NOUT, FMT = 9989 )PATH
773          END IF
774 *
775       ELSE IF( LSAMEN( 2, C2, 'LS' ) ) THEN
776 *
777 *        LS:  Least squares drivers
778 *
779          NTYPES = 6
780          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
781 *
782          IF( TSTDRV ) THEN
783             CALL SDRVLS( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
784      $                   NBVAL, NXVAL, THRESH, TSTERR, A( 11 ),
785      $                   A( 12 ), B( 11 ), B( 12 ), B( 13 ),
786      $                   RWORK, RWORK( NMAX+1 ), WORK, IWORK, NOUT )
787          ELSE
788             WRITE( NOUT, FMT = 9988 )PATH
789          END IF
790 *
791       ELSE IF( LSAMEN( 2, C2, 'EQ' ) ) THEN
792 *
793 *        EQ:  Equilibration routines for general and positive definite
794 *             matrices (THREQ should be between 2 and 10)
795 *
796          IF( TSTCHK ) THEN
797             CALL SCHKEQ( THREQ, NOUT )
798          ELSE
799             WRITE( NOUT, FMT = 9989 )PATH
800          END IF
801 *
802       ELSE
803 *
804          WRITE( NOUT, FMT = 9990 )PATH
805       END IF
806 *
807 *     Go back to get another input line.
808 *
809       GO TO 80
810 *
811 *     Branch to this line when the last record is read.
812 *
813   140 CONTINUE
814       CLOSE ( NIN )
815       S2 = SECOND( )
816       WRITE( NOUT, FMT = 9998 )
817       WRITE( NOUT, FMT = 9997 )S2 - S1
818 *
819  9999 FORMAT/ ' Execution not attempted due to input errors' )
820  9998 FORMAT/ ' End of tests' )
821  9997 FORMAT' Total time used = 'F12.2' seconds'/ )
822  9996 FORMAT' Invalid input value: ', A4, '=', I6, '; must be >=',
823      $      I6 )
824  9995 FORMAT' Invalid input value: ', A4, '=', I6, '; must be <=',
825      $      I6 )
826  9994 FORMAT' Tests of the REAL LAPACK routines ',
827      $      / ' LAPACK VERSION ', I1, '.', I1, '.', I1,
828      $      / / ' The following parameter values will be used:' )
829  9993 FORMAT4X, A4, ':  ', 10I6, / 11X, 10I6 )
830  9992 FORMAT/ ' Routines pass computational tests if test ratio is ',
831      $      'less than'F8.2/ )
832  9991 FORMAT' Relative machine ', A, ' is taken to be'E16.6 )
833  9990 FORMAT/ 1X, A3, ':  Unrecognized path name' )
834  9989 FORMAT/ 1X, A3, ' routines were not tested' )
835  9988 FORMAT/ 1X, A3, ' driver routines were not tested' )
836 *
837 *     End of SCHKAA
838 *
839       END