LAPACK  3.8.0
LAPACK: Linear Algebra PACKage
cchkaa.f
Go to the documentation of this file.
1 *> \brief \b CCHKAA
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 * Definition:
9 * ===========
10 *
11 * PROGRAM CCHKAA
12 *
13 *
14 *> \par Purpose:
15 * =============
16 *>
17 *> \verbatim
18 *>
19 *> CCHKAA is the main test program for the COMPLEX linear equation
20 *> routines.
21 *>
22 *> The program must be driven by a short data file. The first 15 records
23 *> (not including the first comment line) specify problem dimensions
24 *> and program options using list-directed input. The remaining lines
25 *> specify the LAPACK test paths and the number of matrix types to use
26 *> in testing. An annotated example of a data file can be obtained by
27 *> deleting the first 3 characters from the following 42 lines:
28 *> Data file for testing COMPLEX LAPACK linear equation routines
29 *> 7 Number of values of M
30 *> 0 1 2 3 5 10 16 Values of M (row dimension)
31 *> 7 Number of values of N
32 *> 0 1 2 3 5 10 16 Values of N (column dimension)
33 *> 1 Number of values of NRHS
34 *> 2 Values of NRHS (number of right hand sides)
35 *> 5 Number of values of NB
36 *> 1 3 3 3 20 Values of NB (the blocksize)
37 *> 1 0 5 9 1 Values of NX (crossover point)
38 *> 3 Number of values of RANK
39 *> 30 50 90 Values of rank (as a % of N)
40 *> 30.0 Threshold value of test ratio
41 *> T Put T to test the LAPACK routines
42 *> T Put T to test the driver routines
43 *> T Put T to test the error exits
44 *> CGE 11 List types on next line if 0 < NTYPES < 11
45 *> CGB 8 List types on next line if 0 < NTYPES < 8
46 *> CGT 12 List types on next line if 0 < NTYPES < 12
47 *> CPO 9 List types on next line if 0 < NTYPES < 9
48 *> CPO 9 List types on next line if 0 < NTYPES < 9
49 *> CPP 9 List types on next line if 0 < NTYPES < 9
50 *> CPB 8 List types on next line if 0 < NTYPES < 8
51 *> CPT 12 List types on next line if 0 < NTYPES < 12
52 *> CHE 10 List types on next line if 0 < NTYPES < 10
53 *> CHR 10 List types on next line if 0 < NTYPES < 10
54 *> CHK 10 List types on next line if 0 < NTYPES < 10
55 *> CHA 10 List types on next line if 0 < NTYPES < 10
56 *> CH2 10 List types on next line if 0 < NTYPES < 10
57 *> CSA 11 List types on next line if 0 < NTYPES < 10
58 *> CS2 11 List types on next line if 0 < NTYPES < 10
59 *> CHP 10 List types on next line if 0 < NTYPES < 10
60 *> CSY 11 List types on next line if 0 < NTYPES < 11
61 *> CSK 11 List types on next line if 0 < NTYPES < 11
62 *> CSR 11 List types on next line if 0 < NTYPES < 11
63 *> CSP 11 List types on next line if 0 < NTYPES < 11
64 *> CTR 18 List types on next line if 0 < NTYPES < 18
65 *> CTP 18 List types on next line if 0 < NTYPES < 18
66 *> CTB 17 List types on next line if 0 < NTYPES < 17
67 *> CQR 8 List types on next line if 0 < NTYPES < 8
68 *> CRQ 8 List types on next line if 0 < NTYPES < 8
69 *> CLQ 8 List types on next line if 0 < NTYPES < 8
70 *> CQL 8 List types on next line if 0 < NTYPES < 8
71 *> CQP 6 List types on next line if 0 < NTYPES < 6
72 *> CTZ 3 List types on next line if 0 < NTYPES < 3
73 *> CLS 6 List types on next line if 0 < NTYPES < 6
74 *> CEQ
75 *> CQT
76 *> CQX
77 *> \endverbatim
78 *
79 * Parameters:
80 * ==========
81 *
82 *> \verbatim
83 *> NMAX INTEGER
84 *> The maximum allowable value for M and N.
85 *>
86 *> MAXIN INTEGER
87 *> The number of different values that can be used for each of
88 *> M, N, NRHS, NB, NX and RANK
89 *>
90 *> MAXRHS INTEGER
91 *> The maximum number of right hand sides
92 *>
93 *> MATMAX INTEGER
94 *> The maximum number of matrix types to use for testing
95 *>
96 *> NIN INTEGER
97 *> The unit number for input
98 *>
99 *> NOUT INTEGER
100 *> The unit number for output
101 *> \endverbatim
102 *
103 * Authors:
104 * ========
105 *
106 *> \author Univ. of Tennessee
107 *> \author Univ. of California Berkeley
108 *> \author Univ. of Colorado Denver
109 *> \author NAG Ltd.
110 *
111 *> \date November 2017
112 *
113 *> \ingroup complex_lin
114 *
115 * =====================================================================
116  PROGRAM cchkaa
117 *
118 * -- LAPACK test routine (version 3.8.0) --
119 * -- LAPACK is a software package provided by Univ. of Tennessee, --
120 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
121 * November 2017
122 *
123 * =====================================================================
124 *
125 * .. Parameters ..
126  INTEGER NMAX
127  parameter( nmax = 132 )
128  INTEGER MAXIN
129  parameter( maxin = 12 )
130  INTEGER MAXRHS
131  parameter( maxrhs = 16 )
132  INTEGER MATMAX
133  parameter( matmax = 30 )
134  INTEGER NIN, NOUT
135  parameter( nin = 5, nout = 6 )
136  INTEGER KDMAX
137  parameter( kdmax = nmax+( nmax+1 ) / 4 )
138 * ..
139 * .. Local Scalars ..
140  LOGICAL FATAL, TSTCHK, TSTDRV, TSTERR
141  CHARACTER C1
142  CHARACTER*2 C2
143  CHARACTER*3 PATH
144  CHARACTER*10 INTSTR
145  CHARACTER*72 ALINE
146  INTEGER I, IC, J, K, LA, LAFAC, LDA, NB, NM, NMATS, NN,
147  $ nnb, nnb2, nns, nrhs, ntypes, nrank,
148  $ vers_major, vers_minor, vers_patch
149  REAL EPS, S1, S2, THREQ, THRESH
150 * ..
151 * .. Local Arrays ..
152  LOGICAL DOTYPE( matmax )
153  INTEGER IWORK( 25*nmax ), MVAL( maxin ),
154  $ nbval( maxin ), nbval2( maxin ),
155  $ nsval( maxin ), nval( maxin ), nxval( maxin ),
156  $ rankval( maxin ), piv( nmax )
157  REAL RWORK( 150*nmax+2*maxrhs ), S( 2*nmax )
158  COMPLEX A( ( kdmax+1 )*nmax, 7 ), B( nmax*maxrhs, 4 ),
159  $ e( nmax ), work( nmax, nmax+maxrhs+10 )
160 * ..
161 * .. External Functions ..
162  LOGICAL LSAME, LSAMEN
163  REAL SECOND, SLAMCH
164  EXTERNAL lsame, lsamen, second, slamch
165 * ..
166 * .. External Subroutines ..
167  EXTERNAL alareq, cchkeq, cchkgb, cchkge, cchkgt, cchkhe,
177 * ..
178 * .. Scalars in Common ..
179  LOGICAL LERR, OK
180  CHARACTER*32 SRNAMT
181  INTEGER INFOT, NUNIT
182 * ..
183 * .. Arrays in Common ..
184  INTEGER IPARMS( 100 )
185 * ..
186 * .. Common blocks ..
187  COMMON / claenv / iparms
188  COMMON / infoc / infot, nunit, ok, lerr
189  COMMON / srnamc / srnamt
190 * ..
191 * .. Data statements ..
192  DATA threq / 2.0 / , intstr / '0123456789' /
193 * ..
194 * .. Executable Statements ..
195 *
196  s1 = second( )
197  lda = nmax
198  fatal = .false.
199 *
200 * Read a dummy line.
201 *
202  READ( nin, fmt = * )
203 *
204 * Report values of parameters.
205 *
206  CALL ilaver( vers_major, vers_minor, vers_patch )
207  WRITE( nout, fmt = 9994 ) vers_major, vers_minor, vers_patch
208 *
209 * Read the values of M
210 *
211  READ( nin, fmt = * )nm
212  IF( nm.LT.1 ) THEN
213  WRITE( nout, fmt = 9996 )' NM ', nm, 1
214  nm = 0
215  fatal = .true.
216  ELSE IF( nm.GT.maxin ) THEN
217  WRITE( nout, fmt = 9995 )' NM ', nm, maxin
218  nm = 0
219  fatal = .true.
220  END IF
221  READ( nin, fmt = * )( mval( i ), i = 1, nm )
222  DO 10 i = 1, nm
223  IF( mval( i ).LT.0 ) THEN
224  WRITE( nout, fmt = 9996 )' M ', mval( i ), 0
225  fatal = .true.
226  ELSE IF( mval( i ).GT.nmax ) THEN
227  WRITE( nout, fmt = 9995 )' M ', mval( i ), nmax
228  fatal = .true.
229  END IF
230  10 CONTINUE
231  IF( nm.GT.0 )
232  $ WRITE( nout, fmt = 9993 )'M ', ( mval( i ), i = 1, nm )
233 *
234 * Read the values of N
235 *
236  READ( nin, fmt = * )nn
237  IF( nn.LT.1 ) THEN
238  WRITE( nout, fmt = 9996 )' NN ', nn, 1
239  nn = 0
240  fatal = .true.
241  ELSE IF( nn.GT.maxin ) THEN
242  WRITE( nout, fmt = 9995 )' NN ', nn, maxin
243  nn = 0
244  fatal = .true.
245  END IF
246  READ( nin, fmt = * )( nval( i ), i = 1, nn )
247  DO 20 i = 1, nn
248  IF( nval( i ).LT.0 ) THEN
249  WRITE( nout, fmt = 9996 )' N ', nval( i ), 0
250  fatal = .true.
251  ELSE IF( nval( i ).GT.nmax ) THEN
252  WRITE( nout, fmt = 9995 )' N ', nval( i ), nmax
253  fatal = .true.
254  END IF
255  20 CONTINUE
256  IF( nn.GT.0 )
257  $ WRITE( nout, fmt = 9993 )'N ', ( nval( i ), i = 1, nn )
258 *
259 * Read the values of NRHS
260 *
261  READ( nin, fmt = * )nns
262  IF( nns.LT.1 ) THEN
263  WRITE( nout, fmt = 9996 )' NNS', nns, 1
264  nns = 0
265  fatal = .true.
266  ELSE IF( nns.GT.maxin ) THEN
267  WRITE( nout, fmt = 9995 )' NNS', nns, maxin
268  nns = 0
269  fatal = .true.
270  END IF
271  READ( nin, fmt = * )( nsval( i ), i = 1, nns )
272  DO 30 i = 1, nns
273  IF( nsval( i ).LT.0 ) THEN
274  WRITE( nout, fmt = 9996 )'NRHS', nsval( i ), 0
275  fatal = .true.
276  ELSE IF( nsval( i ).GT.maxrhs ) THEN
277  WRITE( nout, fmt = 9995 )'NRHS', nsval( i ), maxrhs
278  fatal = .true.
279  END IF
280  30 CONTINUE
281  IF( nns.GT.0 )
282  $ WRITE( nout, fmt = 9993 )'NRHS', ( nsval( i ), i = 1, nns )
283 *
284 * Read the values of NB
285 *
286  READ( nin, fmt = * )nnb
287  IF( nnb.LT.1 ) THEN
288  WRITE( nout, fmt = 9996 )'NNB ', nnb, 1
289  nnb = 0
290  fatal = .true.
291  ELSE IF( nnb.GT.maxin ) THEN
292  WRITE( nout, fmt = 9995 )'NNB ', nnb, maxin
293  nnb = 0
294  fatal = .true.
295  END IF
296  READ( nin, fmt = * )( nbval( i ), i = 1, nnb )
297  DO 40 i = 1, nnb
298  IF( nbval( i ).LT.0 ) THEN
299  WRITE( nout, fmt = 9996 )' NB ', nbval( i ), 0
300  fatal = .true.
301  END IF
302  40 CONTINUE
303  IF( nnb.GT.0 )
304  $ WRITE( nout, fmt = 9993 )'NB ', ( nbval( i ), i = 1, nnb )
305 *
306 * Set NBVAL2 to be the set of unique values of NB
307 *
308  nnb2 = 0
309  DO 60 i = 1, nnb
310  nb = nbval( i )
311  DO 50 j = 1, nnb2
312  IF( nb.EQ.nbval2( j ) )
313  $ GO TO 60
314  50 CONTINUE
315  nnb2 = nnb2 + 1
316  nbval2( nnb2 ) = nb
317  60 CONTINUE
318 *
319 * Read the values of NX
320 *
321  READ( nin, fmt = * )( nxval( i ), i = 1, nnb )
322  DO 70 i = 1, nnb
323  IF( nxval( i ).LT.0 ) THEN
324  WRITE( nout, fmt = 9996 )' NX ', nxval( i ), 0
325  fatal = .true.
326  END IF
327  70 CONTINUE
328  IF( nnb.GT.0 )
329  $ WRITE( nout, fmt = 9993 )'NX ', ( nxval( i ), i = 1, nnb )
330 *
331 * Read the values of RANKVAL
332 *
333  READ( nin, fmt = * )nrank
334  IF( nn.LT.1 ) THEN
335  WRITE( nout, fmt = 9996 )' NRANK ', nrank, 1
336  nrank = 0
337  fatal = .true.
338  ELSE IF( nn.GT.maxin ) THEN
339  WRITE( nout, fmt = 9995 )' NRANK ', nrank, maxin
340  nrank = 0
341  fatal = .true.
342  END IF
343  READ( nin, fmt = * )( rankval( i ), i = 1, nrank )
344  DO i = 1, nrank
345  IF( rankval( i ).LT.0 ) THEN
346  WRITE( nout, fmt = 9996 )' RANK ', rankval( i ), 0
347  fatal = .true.
348  ELSE IF( rankval( i ).GT.100 ) THEN
349  WRITE( nout, fmt = 9995 )' RANK ', rankval( i ), 100
350  fatal = .true.
351  END IF
352  END DO
353  IF( nrank.GT.0 )
354  $ WRITE( nout, fmt = 9993 )'RANK % OF N',
355  $ ( rankval( i ), i = 1, nrank )
356 *
357 * Read the threshold value for the test ratios.
358 *
359  READ( nin, fmt = * )thresh
360  WRITE( nout, fmt = 9992 )thresh
361 *
362 * Read the flag that indicates whether to test the LAPACK routines.
363 *
364  READ( nin, fmt = * )tstchk
365 *
366 * Read the flag that indicates whether to test the driver routines.
367 *
368  READ( nin, fmt = * )tstdrv
369 *
370 * Read the flag that indicates whether to test the error exits.
371 *
372  READ( nin, fmt = * )tsterr
373 *
374  IF( fatal ) THEN
375  WRITE( nout, fmt = 9999 )
376  stop
377  END IF
378 *
379 * Calculate and print the machine dependent constants.
380 *
381  eps = slamch( 'Underflow threshold' )
382  WRITE( nout, fmt = 9991 )'underflow', eps
383  eps = slamch( 'Overflow threshold' )
384  WRITE( nout, fmt = 9991 )'overflow ', eps
385  eps = slamch( 'Epsilon' )
386  WRITE( nout, fmt = 9991 )'precision', eps
387  WRITE( nout, fmt = * )
388  nrhs = nsval( 1 )
389 *
390  80 CONTINUE
391 *
392 * Read a test path and the number of matrix types to use.
393 *
394  READ( nin, fmt = '(A72)', end = 140 )aline
395  path = aline( 1: 3 )
396  nmats = matmax
397  i = 3
398  90 CONTINUE
399  i = i + 1
400  IF( i.GT.72 )
401  $ GO TO 130
402  IF( aline( i: i ).EQ.' ' )
403  $ GO TO 90
404  nmats = 0
405  100 CONTINUE
406  c1 = aline( i: i )
407  DO 110 k = 1, 10
408  IF( c1.EQ.intstr( k: k ) ) THEN
409  ic = k - 1
410  GO TO 120
411  END IF
412  110 CONTINUE
413  GO TO 130
414  120 CONTINUE
415  nmats = nmats*10 + ic
416  i = i + 1
417  IF( i.GT.72 )
418  $ GO TO 130
419  GO TO 100
420  130 CONTINUE
421  c1 = path( 1: 1 )
422  c2 = path( 2: 3 )
423 *
424 * Check first character for correct precision.
425 *
426  IF( .NOT.lsame( c1, 'Complex precision' ) ) THEN
427  WRITE( nout, fmt = 9990 )path
428 *
429  ELSE IF( nmats.LE.0 ) THEN
430 *
431 * Check for a positive number of tests requested.
432 *
433  WRITE( nout, fmt = 9989 )path
434 *
435  ELSE IF( lsamen( 2, c2, 'GE' ) ) THEN
436 *
437 * GE: general matrices
438 *
439  ntypes = 11
440  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
441 *
442  IF( tstchk ) THEN
443  CALL cchkge( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
444  $ nsval, thresh, tsterr, lda, a( 1, 1 ),
445  $ a( 1, 2 ), a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
446  $ b( 1, 3 ), work, rwork, iwork, nout )
447  ELSE
448  WRITE( nout, fmt = 9989 )path
449  END IF
450 *
451  IF( tstdrv ) THEN
452  CALL cdrvge( dotype, nn, nval, nrhs, thresh, tsterr, lda,
453  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
454  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
455  $ rwork, iwork, nout )
456  ELSE
457  WRITE( nout, fmt = 9988 )path
458  END IF
459 *
460  ELSE IF( lsamen( 2, c2, 'GB' ) ) THEN
461 *
462 * GB: general banded matrices
463 *
464  la = ( 2*kdmax+1 )*nmax
465  lafac = ( 3*kdmax+1 )*nmax
466  ntypes = 8
467  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
468 *
469  IF( tstchk ) THEN
470  CALL cchkgb( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
471  $ nsval, thresh, tsterr, a( 1, 1 ), la,
472  $ a( 1, 3 ), lafac, b( 1, 1 ), b( 1, 2 ),
473  $ b( 1, 3 ), work, rwork, iwork, nout )
474  ELSE
475  WRITE( nout, fmt = 9989 )path
476  END IF
477 *
478  IF( tstdrv ) THEN
479  CALL cdrvgb( dotype, nn, nval, nrhs, thresh, tsterr,
480  $ a( 1, 1 ), la, a( 1, 3 ), lafac, a( 1, 6 ),
481  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s,
482  $ work, rwork, iwork, nout )
483  ELSE
484  WRITE( nout, fmt = 9988 )path
485  END IF
486 *
487  ELSE IF( lsamen( 2, c2, 'GT' ) ) THEN
488 *
489 * GT: general tridiagonal matrices
490 *
491  ntypes = 12
492  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
493 *
494  IF( tstchk ) THEN
495  CALL cchkgt( dotype, nn, nval, nns, nsval, thresh, tsterr,
496  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
497  $ b( 1, 3 ), work, rwork, iwork, nout )
498  ELSE
499  WRITE( nout, fmt = 9989 )path
500  END IF
501 *
502  IF( tstdrv ) THEN
503  CALL cdrvgt( dotype, nn, nval, nrhs, thresh, tsterr,
504  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
505  $ b( 1, 3 ), work, rwork, iwork, nout )
506  ELSE
507  WRITE( nout, fmt = 9988 )path
508  END IF
509 *
510  ELSE IF( lsamen( 2, c2, 'PO' ) ) THEN
511 *
512 * PO: positive definite matrices
513 *
514  ntypes = 9
515  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
516 *
517  IF( tstchk ) THEN
518  CALL cchkpo( dotype, nn, nval, nnb2, nbval2, nns, nsval,
519  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
520  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
521  $ work, rwork, nout )
522  ELSE
523  WRITE( nout, fmt = 9989 )path
524  END IF
525 *
526  IF( tstdrv ) THEN
527  CALL cdrvpo( dotype, nn, nval, nrhs, thresh, tsterr, lda,
528  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
529  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
530  $ rwork, nout )
531  ELSE
532  WRITE( nout, fmt = 9988 )path
533  END IF
534 *
535  ELSE IF( lsamen( 2, c2, 'PS' ) ) THEN
536 *
537 * PS: positive semi-definite matrices
538 *
539  ntypes = 9
540 *
541  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
542 *
543  IF( tstchk ) THEN
544  CALL cchkps( dotype, nn, nval, nnb2, nbval2, nrank,
545  $ rankval, thresh, tsterr, lda, a( 1, 1 ),
546  $ a( 1, 2 ), a( 1, 3 ), piv, work, rwork,
547  $ nout )
548  ELSE
549  WRITE( nout, fmt = 9989 )path
550  END IF
551 *
552  ELSE IF( lsamen( 2, c2, 'PP' ) ) THEN
553 *
554 * PP: positive definite packed matrices
555 *
556  ntypes = 9
557  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
558 *
559  IF( tstchk ) THEN
560  CALL cchkpp( dotype, nn, nval, nns, nsval, thresh, tsterr,
561  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
562  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
563  $ nout )
564  ELSE
565  WRITE( nout, fmt = 9989 )path
566  END IF
567 *
568  IF( tstdrv ) THEN
569  CALL cdrvpp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
570  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
571  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
572  $ rwork, nout )
573  ELSE
574  WRITE( nout, fmt = 9988 )path
575  END IF
576 *
577  ELSE IF( lsamen( 2, c2, 'PB' ) ) THEN
578 *
579 * PB: positive definite banded matrices
580 *
581  ntypes = 8
582  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
583 *
584  IF( tstchk ) THEN
585  CALL cchkpb( dotype, nn, nval, nnb2, nbval2, nns, nsval,
586  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
587  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
588  $ work, rwork, nout )
589  ELSE
590  WRITE( nout, fmt = 9989 )path
591  END IF
592 *
593  IF( tstdrv ) THEN
594  CALL cdrvpb( dotype, nn, nval, nrhs, thresh, tsterr, lda,
595  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
596  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
597  $ rwork, nout )
598  ELSE
599  WRITE( nout, fmt = 9988 )path
600  END IF
601 *
602  ELSE IF( lsamen( 2, c2, 'PT' ) ) THEN
603 *
604 * PT: positive definite tridiagonal matrices
605 *
606  ntypes = 12
607  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
608 *
609  IF( tstchk ) THEN
610  CALL cchkpt( dotype, nn, nval, nns, nsval, thresh, tsterr,
611  $ a( 1, 1 ), s, a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
612  $ b( 1, 3 ), work, rwork, nout )
613  ELSE
614  WRITE( nout, fmt = 9989 )path
615  END IF
616 *
617  IF( tstdrv ) THEN
618  CALL cdrvpt( dotype, nn, nval, nrhs, thresh, tsterr,
619  $ a( 1, 1 ), s, a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
620  $ b( 1, 3 ), work, rwork, nout )
621  ELSE
622  WRITE( nout, fmt = 9988 )path
623  END IF
624 *
625  ELSE IF( lsamen( 2, c2, 'HE' ) ) THEN
626 *
627 * HE: Hermitian indefinite matrices,
628 * with partial (Bunch-Kaufman) pivoting algorithm
629 *
630  ntypes = 10
631  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
632 *
633  IF( tstchk ) THEN
634  CALL cchkhe( dotype, nn, nval, nnb2, nbval2, nns, nsval,
635  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
636  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
637  $ work, rwork, iwork, nout )
638  ELSE
639  WRITE( nout, fmt = 9989 )path
640  END IF
641 *
642  IF( tstdrv ) THEN
643  CALL cdrvhe( dotype, nn, nval, nrhs, thresh, tsterr, lda,
644  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
645  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
646  $ nout )
647  ELSE
648  WRITE( nout, fmt = 9988 )path
649  END IF
650 *
651  ELSE IF( lsamen( 2, c2, 'HR' ) ) THEN
652 *
653 * HR: Hermitian indefinite matrices,
654 * with bounded Bunch-Kaufman (rook) pivoting algorithm
655 *
656  ntypes = 10
657  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
658 *
659  IF( tstchk ) THEN
660  CALL cchkhe_rook(dotype, nn, nval, nnb2, nbval2, nns, nsval,
661  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
662  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
663  $ work, rwork, iwork, nout )
664  ELSE
665  WRITE( nout, fmt = 9989 )path
666  END IF
667 *
668  IF( tstdrv ) THEN
669  CALL cdrvhe_rook( dotype, nn, nval, nrhs, thresh, tsterr,
670  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
671  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
672  $ rwork, iwork, nout )
673  ELSE
674  WRITE( nout, fmt = 9988 )path
675  END IF
676 *
677  ELSE IF( lsamen( 2, c2, 'HK' ) ) THEN
678 *
679 * HK: Hermitian indefinite matrices,
680 * with bounded Bunch-Kaufman (rook) pivoting algorithm,
681 * differnet matrix storage format than HR path version.
682 *
683  ntypes = 10
684  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
685 *
686  IF( tstchk ) THEN
687  CALL cchkhe_rk( dotype, nn, nval, nnb2, nbval2, nns, nsval,
688  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
689  $ e, a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
690  $ b( 1, 3 ), work, rwork, iwork, nout )
691  ELSE
692  WRITE( nout, fmt = 9989 )path
693  END IF
694 *
695  IF( tstdrv ) THEN
696  CALL cdrvhe_rk( dotype, nn, nval, nrhs, thresh, tsterr,
697  $ lda, a( 1, 1 ), a( 1, 2 ), e, a( 1, 3 ),
698  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
699  $ rwork, iwork, nout )
700  ELSE
701  WRITE( nout, fmt = 9988 )path
702  END IF
703 *
704  ELSE IF( lsamen( 2, c2, 'HA' ) ) THEN
705 *
706 * HA: Hermitian matrices,
707 * Aasen Algorithm
708 *
709  ntypes = 10
710  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
711 *
712  IF( tstchk ) THEN
713  CALL cchkhe_aa( dotype, nn, nval, nnb2, nbval2, nns,
714  $ nsval, thresh, tsterr, lda,
715  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
716  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
717  $ work, rwork, iwork, nout )
718  ELSE
719  WRITE( nout, fmt = 9989 )path
720  END IF
721 *
722  IF( tstdrv ) THEN
723  CALL cdrvhe_aa( dotype, nn, nval, nrhs, thresh, tsterr,
724  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
725  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
726  $ work, rwork, iwork, nout )
727  ELSE
728  WRITE( nout, fmt = 9988 )path
729  END IF
730 *
731  ELSE IF( lsamen( 2, c2, 'H2' ) ) THEN
732 *
733 * H2: Hermitian matrices,
734 * with partial (Aasen's) pivoting algorithm
735 *
736  ntypes = 10
737  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
738 *
739  IF( tstchk ) THEN
740  CALL cchkhe_aa_2stage( dotype, nn, nval, nnb2, nbval2,
741  $ nns, nsval, thresh, tsterr, lda,
742  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
743  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
744  $ work, rwork, iwork, nout )
745  ELSE
746  WRITE( nout, fmt = 9989 )path
747  END IF
748 *
749  IF( tstdrv ) THEN
750  CALL cdrvhe_aa_2stage(
751  $ dotype, nn, nval, nrhs, thresh, tsterr,
752  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
753  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
754  $ work, rwork, iwork, nout )
755  ELSE
756  WRITE( nout, fmt = 9988 )path
757  END IF
758 *
759  ELSE IF( lsamen( 2, c2, 'HP' ) ) THEN
760 *
761 * HP: Hermitian indefinite packed matrices,
762 * with partial (Bunch-Kaufman) pivoting algorithm
763 *
764  ntypes = 10
765  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
766 *
767  IF( tstchk ) THEN
768  CALL cchkhp( dotype, nn, nval, nns, nsval, thresh, tsterr,
769  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
770  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
771  $ iwork, nout )
772  ELSE
773  WRITE( nout, fmt = 9989 )path
774  END IF
775 *
776  IF( tstdrv ) THEN
777  CALL cdrvhp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
778  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
779  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
780  $ nout )
781  ELSE
782  WRITE( nout, fmt = 9988 )path
783  END IF
784 *
785  ELSE IF( lsamen( 2, c2, 'SY' ) ) THEN
786 *
787 * SY: symmetric indefinite matrices,
788 * with partial (Bunch-Kaufman) pivoting algorithm
789 *
790  ntypes = 11
791  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
792 *
793  IF( tstchk ) THEN
794  CALL cchksy( dotype, nn, nval, nnb2, nbval2, nns, nsval,
795  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
796  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
797  $ work, rwork, iwork, nout )
798  ELSE
799  WRITE( nout, fmt = 9989 )path
800  END IF
801 *
802  IF( tstdrv ) THEN
803  CALL cdrvsy( dotype, nn, nval, nrhs, thresh, tsterr, lda,
804  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
805  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
806  $ nout )
807  ELSE
808  WRITE( nout, fmt = 9988 )path
809  END IF
810 *
811  ELSE IF( lsamen( 2, c2, 'SR' ) ) THEN
812 *
813 * SR: symmetric indefinite matrices,
814 * with bounded Bunch-Kaufman (rook) pivoting algorithm
815 *
816  ntypes = 11
817  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
818 *
819  IF( tstchk ) THEN
820  CALL cchksy_rook(dotype, nn, nval, nnb2, nbval2, nns, nsval,
821  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
822  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
823  $ work, rwork, iwork, nout )
824  ELSE
825  WRITE( nout, fmt = 9989 )path
826  END IF
827 *
828  IF( tstdrv ) THEN
829  CALL cdrvsy_rook( dotype, nn, nval, nrhs, thresh, tsterr,
830  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
831  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
832  $ rwork, iwork, nout )
833  ELSE
834  WRITE( nout, fmt = 9988 )path
835  END IF
836 *
837  ELSE IF( lsamen( 2, c2, 'SK' ) ) THEN
838 *
839 * SK: symmetric indefinite matrices,
840 * with bounded Bunch-Kaufman (rook) pivoting algorithm,
841 * differnet matrix storage format than SR path version.
842 *
843  ntypes = 11
844  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
845 *
846  IF( tstchk ) THEN
847  CALL cchksy_rk( dotype, nn, nval, nnb2, nbval2, nns, nsval,
848  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
849  $ e, a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
850  $ b( 1, 3 ), work, rwork, iwork, nout )
851  ELSE
852  WRITE( nout, fmt = 9989 )path
853  END IF
854 *
855  IF( tstdrv ) THEN
856  CALL cdrvsy_rk( dotype, nn, nval, nrhs, thresh, tsterr,
857  $ lda, a( 1, 1 ), a( 1, 2 ), e, a( 1, 3 ),
858  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
859  $ rwork, iwork, nout )
860  ELSE
861  WRITE( nout, fmt = 9988 )path
862  END IF
863 *
864  ELSE IF( lsamen( 2, c2, 'SA' ) ) THEN
865 *
866 * SA: symmetric indefinite matrices with Aasen's algorithm,
867 *
868  ntypes = 11
869  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
870 *
871  IF( tstchk ) THEN
872  CALL cchksy_aa( dotype, nn, nval, nnb2, nbval2, nns, nsval,
873  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
874  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
875  $ b( 1, 3 ), work, rwork, iwork, nout )
876  ELSE
877  WRITE( nout, fmt = 9989 )path
878  END IF
879 *
880  IF( tstdrv ) THEN
881  CALL cdrvsy_aa( dotype, nn, nval, nrhs, thresh, tsterr,
882  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
883  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
884  $ rwork, iwork, nout )
885  ELSE
886  WRITE( nout, fmt = 9988 )path
887  END IF
888 *
889  ELSE IF( lsamen( 2, c2, 'S2' ) ) THEN
890 *
891 * S2: symmetric indefinite matrices with Aasen's algorithm
892 * 2 stage
893 *
894  ntypes = 11
895  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
896 *
897  IF( tstchk ) THEN
898  CALL cchksy_aa_2stage( dotype, nn, nval, nnb2, nbval2, nns,
899  $ nsval, thresh, tsterr, lda,
900  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
901  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
902  $ work, rwork, iwork, nout )
903  ELSE
904  WRITE( nout, fmt = 9989 )path
905  END IF
906 *
907  IF( tstdrv ) THEN
908  CALL cdrvsy_aa_2stage(
909  $ dotype, nn, nval, nrhs, thresh, tsterr,
910  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
911  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
912  $ rwork, iwork, nout )
913  ELSE
914  WRITE( nout, fmt = 9988 )path
915  END IF
916 *
917  ELSE IF( lsamen( 2, c2, 'SP' ) ) THEN
918 *
919 * SP: symmetric indefinite packed matrices,
920 * with partial (Bunch-Kaufman) pivoting algorithm
921 *
922  ntypes = 11
923  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
924 *
925  IF( tstchk ) THEN
926  CALL cchksp( dotype, nn, nval, nns, nsval, thresh, tsterr,
927  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
928  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
929  $ iwork, nout )
930  ELSE
931  WRITE( nout, fmt = 9989 )path
932  END IF
933 *
934  IF( tstdrv ) THEN
935  CALL cdrvsp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
936  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
937  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
938  $ nout )
939  ELSE
940  WRITE( nout, fmt = 9988 )path
941  END IF
942 *
943  ELSE IF( lsamen( 2, c2, 'TR' ) ) THEN
944 *
945 * TR: triangular matrices
946 *
947  ntypes = 18
948  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
949 *
950  IF( tstchk ) THEN
951  CALL cchktr( dotype, nn, nval, nnb2, nbval2, nns, nsval,
952  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
953  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
954  $ nout )
955  ELSE
956  WRITE( nout, fmt = 9989 )path
957  END IF
958 *
959  ELSE IF( lsamen( 2, c2, 'TP' ) ) THEN
960 *
961 * TP: triangular packed matrices
962 *
963  ntypes = 18
964  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
965 *
966  IF( tstchk ) THEN
967  CALL cchktp( dotype, nn, nval, nns, nsval, thresh, tsterr,
968  $ lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
969  $ b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
970  ELSE
971  WRITE( nout, fmt = 9989 )path
972  END IF
973 *
974  ELSE IF( lsamen( 2, c2, 'TB' ) ) THEN
975 *
976 * TB: triangular banded matrices
977 *
978  ntypes = 17
979  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
980 *
981  IF( tstchk ) THEN
982  CALL cchktb( dotype, nn, nval, nns, nsval, thresh, tsterr,
983  $ lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
984  $ b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
985  ELSE
986  WRITE( nout, fmt = 9989 )path
987  END IF
988 *
989  ELSE IF( lsamen( 2, c2, 'QR' ) ) THEN
990 *
991 * QR: QR factorization
992 *
993  ntypes = 8
994  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
995 *
996  IF( tstchk ) THEN
997  CALL cchkqr( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
998  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
999  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
1000  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
1001  $ work, rwork, iwork, nout )
1002  ELSE
1003  WRITE( nout, fmt = 9989 )path
1004  END IF
1005 *
1006  ELSE IF( lsamen( 2, c2, 'LQ' ) ) THEN
1007 *
1008 * LQ: LQ factorization
1009 *
1010  ntypes = 8
1011  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
1012 *
1013  IF( tstchk ) THEN
1014  CALL cchklq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
1015  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
1016  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
1017  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
1018  $ work, rwork, nout )
1019  ELSE
1020  WRITE( nout, fmt = 9989 )path
1021  END IF
1022 *
1023  ELSE IF( lsamen( 2, c2, 'QL' ) ) THEN
1024 *
1025 * QL: QL factorization
1026 *
1027  ntypes = 8
1028  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
1029 *
1030  IF( tstchk ) THEN
1031  CALL cchkql( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
1032  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
1033  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
1034  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
1035  $ work, rwork, nout )
1036  ELSE
1037  WRITE( nout, fmt = 9989 )path
1038  END IF
1039 *
1040  ELSE IF( lsamen( 2, c2, 'RQ' ) ) THEN
1041 *
1042 * RQ: RQ factorization
1043 *
1044  ntypes = 8
1045  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
1046 *
1047  IF( tstchk ) THEN
1048  CALL cchkrq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
1049  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
1050  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
1051  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
1052  $ work, rwork, iwork, nout )
1053  ELSE
1054  WRITE( nout, fmt = 9989 )path
1055  END IF
1056 *
1057  ELSE IF( lsamen( 2, c2, 'EQ' ) ) THEN
1058 *
1059 * EQ: Equilibration routines for general and positive definite
1060 * matrices (THREQ should be between 2 and 10)
1061 *
1062  IF( tstchk ) THEN
1063  CALL cchkeq( threq, nout )
1064  ELSE
1065  WRITE( nout, fmt = 9989 )path
1066  END IF
1067 *
1068  ELSE IF( lsamen( 2, c2, 'TZ' ) ) THEN
1069 *
1070 * TZ: Trapezoidal matrix
1071 *
1072  ntypes = 3
1073  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
1074 *
1075  IF( tstchk ) THEN
1076  CALL cchktz( dotype, nm, mval, nn, nval, thresh, tsterr,
1077  $ a( 1, 1 ), a( 1, 2 ), s( 1 ),
1078  $ b( 1, 1 ), work, rwork, nout )
1079  ELSE
1080  WRITE( nout, fmt = 9989 )path
1081  END IF
1082 *
1083  ELSE IF( lsamen( 2, c2, 'QP' ) ) THEN
1084 *
1085 * QP: QR factorization with pivoting
1086 *
1087  ntypes = 6
1088  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
1089 *
1090  IF( tstchk ) THEN
1091  CALL cchkq3( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
1092  $ thresh, a( 1, 1 ), a( 1, 2 ), s( 1 ),
1093  $ b( 1, 1 ), work, rwork, iwork, nout )
1094  ELSE
1095  WRITE( nout, fmt = 9989 )path
1096  END IF
1097 *
1098  ELSE IF( lsamen( 2, c2, 'LS' ) ) THEN
1099 *
1100 * LS: Least squares drivers
1101 *
1102  ntypes = 6
1103  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
1104 *
1105  IF( tstdrv ) THEN
1106  CALL cdrvls( dotype, nm, mval, nn, nval, nns, nsval, nnb,
1107  $ nbval, nxval, thresh, tsterr, a( 1, 1 ),
1108  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
1109  $ s( 1 ), s( nmax+1 ), nout )
1110  ELSE
1111  WRITE( nout, fmt = 9989 )path
1112  END IF
1113 *
1114  ELSE IF( lsamen( 2, c2, 'QT' ) ) THEN
1115 *
1116 * QT: QRT routines for general matrices
1117 *
1118  IF( tstchk ) THEN
1119  CALL cchkqrt( thresh, tsterr, nm, mval, nn, nval, nnb,
1120  $ nbval, nout )
1121  ELSE
1122  WRITE( nout, fmt = 9989 )path
1123  END IF
1124 *
1125  ELSE IF( lsamen( 2, c2, 'QX' ) ) THEN
1126 *
1127 * QX: QRT routines for triangular-pentagonal matrices
1128 *
1129  IF( tstchk ) THEN
1130  CALL cchkqrtp( thresh, tsterr, nm, mval, nn, nval, nnb,
1131  $ nbval, nout )
1132  ELSE
1133  WRITE( nout, fmt = 9989 )path
1134  END IF
1135 *
1136  ELSE IF( lsamen( 2, c2, 'TQ' ) ) THEN
1137 *
1138 * TQ: LQT routines for general matrices
1139 *
1140  IF( tstchk ) THEN
1141  CALL cchklqt( thresh, tsterr, nm, mval, nn, nval, nnb,
1142  $ nbval, nout )
1143  ELSE
1144  WRITE( nout, fmt = 9989 )path
1145  END IF
1146 *
1147  ELSE IF( lsamen( 2, c2, 'XQ' ) ) THEN
1148 *
1149 * XQ: LQT routines for triangular-pentagonal matrices
1150 *
1151  IF( tstchk ) THEN
1152  CALL cchklqtp( thresh, tsterr, nm, mval, nn, nval, nnb,
1153  $ nbval, nout )
1154  ELSE
1155  WRITE( nout, fmt = 9989 )path
1156  END IF
1157 *
1158  ELSE IF( lsamen( 2, c2, 'TS' ) ) THEN
1159 *
1160 * TS: QR routines for tall-skinny matrices
1161 *
1162  IF( tstchk ) THEN
1163  CALL cchktsqr( thresh, tsterr, nm, mval, nn, nval, nnb,
1164  $ nbval, nout )
1165  ELSE
1166  WRITE( nout, fmt = 9989 )path
1167  END IF
1168 *
1169  ELSE
1170 *
1171  WRITE( nout, fmt = 9990 )path
1172  END IF
1173 *
1174 * Go back to get another input line.
1175 *
1176  GO TO 80
1177 *
1178 * Branch to this line when the last record is read.
1179 *
1180  140 CONTINUE
1181  CLOSE ( nin )
1182  s2 = second( )
1183  WRITE( nout, fmt = 9998 )
1184  WRITE( nout, fmt = 9997 )s2 - s1
1185 *
1186  9999 FORMAT( / ' Execution not attempted due to input errors' )
1187  9998 FORMAT( / ' End of tests' )
1188  9997 FORMAT( ' Total time used = ', f12.2, ' seconds', / )
1189  9996 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be >=',
1190  $ i6 )
1191  9995 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be <=',
1192  $ i6 )
1193  9994 FORMAT( ' Tests of the COMPLEX LAPACK routines ',
1194  $ / ' LAPACK VERSION ', i1, '.', i1, '.', i1,
1195  $ / / ' The following parameter values will be used:' )
1196  9993 FORMAT( 4x, a4, ': ', 10i6, / 11x, 10i6 )
1197  9992 FORMAT( / ' Routines pass computational tests if test ratio is ',
1198  $ 'less than', f8.2, / )
1199  9991 FORMAT( ' Relative machine ', a, ' is taken to be', e16.6 )
1200  9990 FORMAT( / 1x, a3, ': Unrecognized path name' )
1201  9989 FORMAT( / 1x, a3, ' routines were not tested' )
1202  9988 FORMAT( / 1x, a3, ' driver routines were not tested' )
1203 *
1204 * End of CCHKAA
1205 *
1206  END
subroutine cchksy_rook(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSY_ROOK
Definition: cchksy_rook.f:174
subroutine cchktb(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKTB
Definition: cchktb.f:151
subroutine cdrvhe_aa(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHE_AA
Definition: cdrvhe_aa.f:155
subroutine cchkhe_aa_2stage(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHE_AA_2STAGE
subroutine cchkps(DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A, AFAC, PERM, PIV, WORK, RWORK, NOUT)
CCHKPS
Definition: cchkps.f:156
subroutine cdrvpp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPP
Definition: cdrvpp.f:161
subroutine cchksy_aa(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSY_AA
Definition: cchksy_aa.f:174
subroutine cdrvhe_aa_2stage(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHE_AA_2STAGE
subroutine cchkqrtp(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKQRTP
Definition: cchkqrtp.f:104
subroutine cdrvsy_rook(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSY_ROOK
Definition: cdrvsy_rook.f:154
subroutine cdrvls(DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, NOUT)
CDRVLS
Definition: cdrvls.f:194
subroutine cdrvpo(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPO
Definition: cdrvpo.f:161
subroutine cdrvpb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPB
Definition: cdrvpb.f:161
subroutine cchksy(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSY
Definition: cchksy.f:173
subroutine cdrvhe_rk(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, E, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHE_RK
Definition: cdrvhe_rk.f:160
subroutine cchkeq(THRESH, NOUT)
CCHKEQ
Definition: cchkeq.f:56
subroutine cchkgt(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKGT
Definition: cchkgt.f:149
subroutine alareq(PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT)
ALAREQ
Definition: alareq.f:92
subroutine cchklqt(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKLQT
Definition: cchklqt.f:104
subroutine cchktp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X, XACT, WORK, RWORK, NOUT)
CCHKTP
Definition: cchktp.f:153
subroutine cdrvge(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
CDRVGE
Definition: cdrvge.f:166
subroutine cchktsqr(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKQRT
Definition: cchktsqr.f:104
program cchkaa
CCHKAA
Definition: cchkaa.f:116
subroutine cdrvsy_aa(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSY_AA
Definition: cdrvsy_aa.f:157
subroutine cchkpt(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT)
CCHKPT
Definition: cchkpt.f:149
subroutine cchksy_rk(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, E, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSY_RK
Definition: cchksy_rk.f:179
subroutine cchkhp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHP
Definition: cchkhp.f:166
subroutine cchkhe_rook(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHE_ROOK
Definition: cchkhe_rook.f:174
subroutine cdrvsy(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSY
Definition: cdrvsy.f:155
subroutine cdrvgt(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVGT
Definition: cdrvgt.f:141
subroutine cchktz(DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, RWORK, NOUT)
CCHKTZ
Definition: cchktz.f:139
subroutine cdrvhe(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHE
Definition: cdrvhe.f:155
subroutine ilaver(VERS_MAJOR, VERS_MINOR, VERS_PATCH)
ILAVER returns the LAPACK version.
Definition: ilaver.f:50
subroutine cdrvsy_rk(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, E, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSY_RK
Definition: cdrvsy_rk.f:158
subroutine cdrvpt(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT)
CDRVPT
Definition: cdrvpt.f:142
subroutine cchkql(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
CCHKQL
Definition: cchkql.f:198
subroutine cchkpo(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKPO
Definition: cchkpo.f:170
subroutine cdrvhp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHP
Definition: cdrvhp.f:159
subroutine cdrvsp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSP
Definition: cdrvsp.f:159
subroutine cchkqr(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AR, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT)
CCHKQR
Definition: cchkqr.f:203
subroutine cchktr(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKTR
Definition: cchktr.f:165
subroutine cchkpp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKPP
Definition: cchkpp.f:161
subroutine cchklqtp(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKLQTP
Definition: cchklqtp.f:104
subroutine cchkgb(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A, LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKGB
Definition: cchkgb.f:193
subroutine cchksp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSP
Definition: cchksp.f:166
subroutine cchkpb(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKPB
Definition: cchkpb.f:170
subroutine cchkge(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKGE
Definition: cchkge.f:188
subroutine cdrvhe_rook(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHE_ROOK
Definition: cdrvhe_rook.f:155
subroutine cdrvsy_aa_2stage(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSY_AA_2STAGE
subroutine cchkhe(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHE
Definition: cchkhe.f:173
subroutine cchkqrt(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKQRT
Definition: cchkqrt.f:104
subroutine cchksy_aa_2stage(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSY_AA_2STAGE
subroutine cchkrq(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AR, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT)
CCHKRQ
Definition: cchkrq.f:203
subroutine cchkhe_aa(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHE_AA
Definition: cchkhe_aa.f:174
subroutine cchklq(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
CCHKLQ
Definition: cchklq.f:198
subroutine cdrvgb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
CDRVGB
Definition: cdrvgb.f:174
subroutine cchkq3(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S, TAU, WORK, RWORK, IWORK, NOUT)
CCHKQ3
Definition: cchkq3.f:160
subroutine cchkhe_rk(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, E, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHE_RK
Definition: cchkhe_rk.f:179