LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
 All Files Functions Groups
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 *> CHP 10 List types on next line if 0 < NTYPES < 10
54 *> CSY 11 List types on next line if 0 < NTYPES < 11
55 *> CSR 11 List types on next line if 0 < NTYPES < 11
56 *> CSP 11 List types on next line if 0 < NTYPES < 11
57 *> CTR 18 List types on next line if 0 < NTYPES < 18
58 *> CTP 18 List types on next line if 0 < NTYPES < 18
59 *> CTB 17 List types on next line if 0 < NTYPES < 17
60 *> CQR 8 List types on next line if 0 < NTYPES < 8
61 *> CRQ 8 List types on next line if 0 < NTYPES < 8
62 *> CLQ 8 List types on next line if 0 < NTYPES < 8
63 *> CQL 8 List types on next line if 0 < NTYPES < 8
64 *> CQP 6 List types on next line if 0 < NTYPES < 6
65 *> CTZ 3 List types on next line if 0 < NTYPES < 3
66 *> CLS 6 List types on next line if 0 < NTYPES < 6
67 *> CEQ
68 *> CQT
69 *> CQX
70 *> \endverbatim
71 *
72 * Parameters:
73 * ==========
74 *
75 *> \verbatim
76 *> NMAX INTEGER
77 *> The maximum allowable value for M and N.
78 *>
79 *> MAXIN INTEGER
80 *> The number of different values that can be used for each of
81 *> M, N, NRHS, NB, NX and RANK
82 *>
83 *> MAXRHS INTEGER
84 *> The maximum number of right hand sides
85 *>
86 *> MATMAX INTEGER
87 *> The maximum number of matrix types to use for testing
88 *>
89 *> NIN INTEGER
90 *> The unit number for input
91 *>
92 *> NOUT INTEGER
93 *> The unit number for output
94 *> \endverbatim
95 *
96 * Authors:
97 * ========
98 *
99 *> \author Univ. of Tennessee
100 *> \author Univ. of California Berkeley
101 *> \author Univ. of Colorado Denver
102 *> \author NAG Ltd.
103 *
104 *> \date April 2012
105 *
106 *> \ingroup complex_lin
107 *
108 * =====================================================================
109  PROGRAM cchkaa
110 *
111 * -- LAPACK test routine (version 3.4.1) --
112 * -- LAPACK is a software package provided by Univ. of Tennessee, --
113 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
114 * April 2012
115 *
116 * =====================================================================
117 *
118 * .. Parameters ..
119  INTEGER nmax
120  parameter( nmax = 132 )
121  INTEGER maxin
122  parameter( maxin = 12 )
123  INTEGER maxrhs
124  parameter( maxrhs = 16 )
125  INTEGER matmax
126  parameter( matmax = 30 )
127  INTEGER nin, nout
128  parameter( nin = 5, nout = 6 )
129  INTEGER kdmax
130  parameter( kdmax = nmax+( nmax+1 ) / 4 )
131 * ..
132 * .. Local Scalars ..
133  LOGICAL fatal, tstchk, tstdrv, tsterr
134  CHARACTER c1
135  CHARACTER*2 c2
136  CHARACTER*3 path
137  CHARACTER*10 intstr
138  CHARACTER*72 aline
139  INTEGER i, ic, j, k, la, lafac, lda, nb, nm, nmats, nn,
140  $ nnb, nnb2, nns, nrhs, ntypes, nrank,
141  $ vers_major, vers_minor, vers_patch
142  REAL eps, s1, s2, threq, thresh
143 * ..
144 * .. Local Arrays ..
145  LOGICAL dotype( matmax )
146  INTEGER iwork( 25*nmax ), mval( maxin ),
147  $ nbval( maxin ), nbval2( maxin ),
148  $ nsval( maxin ), nval( maxin ), nxval( maxin ),
149  $ rankval( maxin ), piv( nmax )
150  REAL rwork( 150*nmax+2*maxrhs ), s( 2*nmax )
151  COMPLEX a( ( kdmax+1 )*nmax, 7 ), b( nmax*maxrhs, 4 ),
152  $ work( nmax, nmax+maxrhs+10 )
153 * ..
154 * .. External Functions ..
155  LOGICAL lsame, lsamen
156  REAL second, slamch
157  EXTERNAL lsame, lsamen, second, slamch
158 * ..
159 * .. External Subroutines ..
160  EXTERNAL alareq, cchkeq, cchkgb, cchkge, cchkgt, cchkhe,
163  $ cchksp, cchksy, cchktb, cchktp,
167  $ cchkqrtp
168 * ..
169 * .. Scalars in Common ..
170  LOGICAL lerr, ok
171  CHARACTER*32 srnamt
172  INTEGER infot, nunit
173 * ..
174 * .. Arrays in Common ..
175  INTEGER iparms( 100 )
176 * ..
177 * .. Common blocks ..
178  COMMON / claenv / iparms
179  COMMON / infoc / infot, nunit, ok, lerr
180  COMMON / srnamc / srnamt
181 * ..
182 * .. Data statements ..
183  DATA threq / 2.0 / , intstr / '0123456789' /
184 * ..
185 * .. Executable Statements ..
186 *
187  s1 = second( )
188  lda = nmax
189  fatal = .false.
190 *
191 * Read a dummy line.
192 *
193  READ( nin, fmt = * )
194 *
195 * Report values of parameters.
196 *
197  CALL ilaver( vers_major, vers_minor, vers_patch )
198  WRITE( nout, fmt = 9994 ) vers_major, vers_minor, vers_patch
199 *
200 * Read the values of M
201 *
202  READ( nin, fmt = * )nm
203  IF( nm.LT.1 ) THEN
204  WRITE( nout, fmt = 9996 )' NM ', nm, 1
205  nm = 0
206  fatal = .true.
207  ELSE IF( nm.GT.maxin ) THEN
208  WRITE( nout, fmt = 9995 )' NM ', nm, maxin
209  nm = 0
210  fatal = .true.
211  END IF
212  READ( nin, fmt = * )( mval( i ), i = 1, nm )
213  DO 10 i = 1, nm
214  IF( mval( i ).LT.0 ) THEN
215  WRITE( nout, fmt = 9996 )' M ', mval( i ), 0
216  fatal = .true.
217  ELSE IF( mval( i ).GT.nmax ) THEN
218  WRITE( nout, fmt = 9995 )' M ', mval( i ), nmax
219  fatal = .true.
220  END IF
221  10 CONTINUE
222  IF( nm.GT.0 )
223  $ WRITE( nout, fmt = 9993 )'M ', ( mval( i ), i = 1, nm )
224 *
225 * Read the values of N
226 *
227  READ( nin, fmt = * )nn
228  IF( nn.LT.1 ) THEN
229  WRITE( nout, fmt = 9996 )' NN ', nn, 1
230  nn = 0
231  fatal = .true.
232  ELSE IF( nn.GT.maxin ) THEN
233  WRITE( nout, fmt = 9995 )' NN ', nn, maxin
234  nn = 0
235  fatal = .true.
236  END IF
237  READ( nin, fmt = * )( nval( i ), i = 1, nn )
238  DO 20 i = 1, nn
239  IF( nval( i ).LT.0 ) THEN
240  WRITE( nout, fmt = 9996 )' N ', nval( i ), 0
241  fatal = .true.
242  ELSE IF( nval( i ).GT.nmax ) THEN
243  WRITE( nout, fmt = 9995 )' N ', nval( i ), nmax
244  fatal = .true.
245  END IF
246  20 CONTINUE
247  IF( nn.GT.0 )
248  $ WRITE( nout, fmt = 9993 )'N ', ( nval( i ), i = 1, nn )
249 *
250 * Read the values of NRHS
251 *
252  READ( nin, fmt = * )nns
253  IF( nns.LT.1 ) THEN
254  WRITE( nout, fmt = 9996 )' NNS', nns, 1
255  nns = 0
256  fatal = .true.
257  ELSE IF( nns.GT.maxin ) THEN
258  WRITE( nout, fmt = 9995 )' NNS', nns, maxin
259  nns = 0
260  fatal = .true.
261  END IF
262  READ( nin, fmt = * )( nsval( i ), i = 1, nns )
263  DO 30 i = 1, nns
264  IF( nsval( i ).LT.0 ) THEN
265  WRITE( nout, fmt = 9996 )'NRHS', nsval( i ), 0
266  fatal = .true.
267  ELSE IF( nsval( i ).GT.maxrhs ) THEN
268  WRITE( nout, fmt = 9995 )'NRHS', nsval( i ), maxrhs
269  fatal = .true.
270  END IF
271  30 CONTINUE
272  IF( nns.GT.0 )
273  $ WRITE( nout, fmt = 9993 )'NRHS', ( nsval( i ), i = 1, nns )
274 *
275 * Read the values of NB
276 *
277  READ( nin, fmt = * )nnb
278  IF( nnb.LT.1 ) THEN
279  WRITE( nout, fmt = 9996 )'NNB ', nnb, 1
280  nnb = 0
281  fatal = .true.
282  ELSE IF( nnb.GT.maxin ) THEN
283  WRITE( nout, fmt = 9995 )'NNB ', nnb, maxin
284  nnb = 0
285  fatal = .true.
286  END IF
287  READ( nin, fmt = * )( nbval( i ), i = 1, nnb )
288  DO 40 i = 1, nnb
289  IF( nbval( i ).LT.0 ) THEN
290  WRITE( nout, fmt = 9996 )' NB ', nbval( i ), 0
291  fatal = .true.
292  END IF
293  40 CONTINUE
294  IF( nnb.GT.0 )
295  $ WRITE( nout, fmt = 9993 )'NB ', ( nbval( i ), i = 1, nnb )
296 *
297 * Set NBVAL2 to be the set of unique values of NB
298 *
299  nnb2 = 0
300  DO 60 i = 1, nnb
301  nb = nbval( i )
302  DO 50 j = 1, nnb2
303  IF( nb.EQ.nbval2( j ) )
304  $ go to 60
305  50 CONTINUE
306  nnb2 = nnb2 + 1
307  nbval2( nnb2 ) = nb
308  60 CONTINUE
309 *
310 * Read the values of NX
311 *
312  READ( nin, fmt = * )( nxval( i ), i = 1, nnb )
313  DO 70 i = 1, nnb
314  IF( nxval( i ).LT.0 ) THEN
315  WRITE( nout, fmt = 9996 )' NX ', nxval( i ), 0
316  fatal = .true.
317  END IF
318  70 CONTINUE
319  IF( nnb.GT.0 )
320  $ WRITE( nout, fmt = 9993 )'NX ', ( nxval( i ), i = 1, nnb )
321 *
322 * Read the values of RANKVAL
323 *
324  READ( nin, fmt = * )nrank
325  IF( nn.LT.1 ) THEN
326  WRITE( nout, fmt = 9996 )' NRANK ', nrank, 1
327  nrank = 0
328  fatal = .true.
329  ELSE IF( nn.GT.maxin ) THEN
330  WRITE( nout, fmt = 9995 )' NRANK ', nrank, maxin
331  nrank = 0
332  fatal = .true.
333  END IF
334  READ( nin, fmt = * )( rankval( i ), i = 1, nrank )
335  DO i = 1, nrank
336  IF( rankval( i ).LT.0 ) THEN
337  WRITE( nout, fmt = 9996 )' RANK ', rankval( i ), 0
338  fatal = .true.
339  ELSE IF( rankval( i ).GT.100 ) THEN
340  WRITE( nout, fmt = 9995 )' RANK ', rankval( i ), 100
341  fatal = .true.
342  END IF
343  END DO
344  IF( nrank.GT.0 )
345  $ WRITE( nout, fmt = 9993 )'RANK % OF N',
346  $ ( rankval( i ), i = 1, nrank )
347 *
348 * Read the threshold value for the test ratios.
349 *
350  READ( nin, fmt = * )thresh
351  WRITE( nout, fmt = 9992 )thresh
352 *
353 * Read the flag that indicates whether to test the LAPACK routines.
354 *
355  READ( nin, fmt = * )tstchk
356 *
357 * Read the flag that indicates whether to test the driver routines.
358 *
359  READ( nin, fmt = * )tstdrv
360 *
361 * Read the flag that indicates whether to test the error exits.
362 *
363  READ( nin, fmt = * )tsterr
364 *
365  IF( fatal ) THEN
366  WRITE( nout, fmt = 9999 )
367  stop
368  END IF
369 *
370 * Calculate and print the machine dependent constants.
371 *
372  eps = slamch( 'Underflow threshold' )
373  WRITE( nout, fmt = 9991 )'underflow', eps
374  eps = slamch( 'Overflow threshold' )
375  WRITE( nout, fmt = 9991 )'overflow ', eps
376  eps = slamch( 'Epsilon' )
377  WRITE( nout, fmt = 9991 )'precision', eps
378  WRITE( nout, fmt = * )
379  nrhs = nsval( 1 )
380 *
381  80 CONTINUE
382 *
383 * Read a test path and the number of matrix types to use.
384 *
385  READ( nin, fmt = '(A72)', END = 140 )aline
386  path = aline( 1: 3 )
387  nmats = matmax
388  i = 3
389  90 CONTINUE
390  i = i + 1
391  IF( i.GT.72 )
392  $ go to 130
393  IF( aline( i: i ).EQ.' ' )
394  $ go to 90
395  nmats = 0
396  100 CONTINUE
397  c1 = aline( i: i )
398  DO 110 k = 1, 10
399  IF( c1.EQ.intstr( k: k ) ) THEN
400  ic = k - 1
401  go to 120
402  END IF
403  110 CONTINUE
404  go to 130
405  120 CONTINUE
406  nmats = nmats*10 + ic
407  i = i + 1
408  IF( i.GT.72 )
409  $ go to 130
410  go to 100
411  130 CONTINUE
412  c1 = path( 1: 1 )
413  c2 = path( 2: 3 )
414 *
415 * Check first character for correct precision.
416 *
417  IF( .NOT.lsame( c1, 'Complex precision' ) ) THEN
418  WRITE( nout, fmt = 9990 )path
419 *
420  ELSE IF( nmats.LE.0 ) THEN
421 *
422 * Check for a positive number of tests requested.
423 *
424  WRITE( nout, fmt = 9989 )path
425 *
426  ELSE IF( lsamen( 2, c2, 'GE' ) ) THEN
427 *
428 * GE: general matrices
429 *
430  ntypes = 11
431  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
432 *
433  IF( tstchk ) THEN
434  CALL cchkge( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
435  $ nsval, thresh, tsterr, lda, a( 1, 1 ),
436  $ a( 1, 2 ), a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
437  $ b( 1, 3 ), work, rwork, iwork, nout )
438  ELSE
439  WRITE( nout, fmt = 9989 )path
440  END IF
441 *
442  IF( tstdrv ) THEN
443  CALL cdrvge( dotype, nn, nval, nrhs, thresh, tsterr, lda,
444  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
445  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
446  $ rwork, iwork, nout )
447  ELSE
448  WRITE( nout, fmt = 9988 )path
449  END IF
450 *
451  ELSE IF( lsamen( 2, c2, 'GB' ) ) THEN
452 *
453 * GB: general banded matrices
454 *
455  la = ( 2*kdmax+1 )*nmax
456  lafac = ( 3*kdmax+1 )*nmax
457  ntypes = 8
458  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
459 *
460  IF( tstchk ) THEN
461  CALL cchkgb( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
462  $ nsval, thresh, tsterr, a( 1, 1 ), la,
463  $ a( 1, 3 ), lafac, b( 1, 1 ), b( 1, 2 ),
464  $ b( 1, 3 ), work, rwork, iwork, nout )
465  ELSE
466  WRITE( nout, fmt = 9989 )path
467  END IF
468 *
469  IF( tstdrv ) THEN
470  CALL cdrvgb( dotype, nn, nval, nrhs, thresh, tsterr,
471  $ a( 1, 1 ), la, a( 1, 3 ), lafac, a( 1, 6 ),
472  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s,
473  $ work, rwork, iwork, nout )
474  ELSE
475  WRITE( nout, fmt = 9988 )path
476  END IF
477 *
478  ELSE IF( lsamen( 2, c2, 'GT' ) ) THEN
479 *
480 * GT: general tridiagonal matrices
481 *
482  ntypes = 12
483  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
484 *
485  IF( tstchk ) THEN
486  CALL cchkgt( dotype, nn, nval, nns, nsval, thresh, tsterr,
487  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
488  $ b( 1, 3 ), work, rwork, iwork, nout )
489  ELSE
490  WRITE( nout, fmt = 9989 )path
491  END IF
492 *
493  IF( tstdrv ) THEN
494  CALL cdrvgt( dotype, nn, nval, nrhs, thresh, tsterr,
495  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
496  $ b( 1, 3 ), work, rwork, iwork, nout )
497  ELSE
498  WRITE( nout, fmt = 9988 )path
499  END IF
500 *
501  ELSE IF( lsamen( 2, c2, 'PO' ) ) THEN
502 *
503 * PO: positive definite matrices
504 *
505  ntypes = 9
506  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
507 *
508  IF( tstchk ) THEN
509  CALL cchkpo( dotype, nn, nval, nnb2, nbval2, nns, nsval,
510  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
511  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
512  $ work, rwork, nout )
513  ELSE
514  WRITE( nout, fmt = 9989 )path
515  END IF
516 *
517  IF( tstdrv ) THEN
518  CALL cdrvpo( dotype, nn, nval, nrhs, thresh, tsterr, lda,
519  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
520  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
521  $ rwork, nout )
522  ELSE
523  WRITE( nout, fmt = 9988 )path
524  END IF
525 *
526  ELSE IF( lsamen( 2, c2, 'PS' ) ) THEN
527 *
528 * PS: positive semi-definite matrices
529 *
530  ntypes = 9
531 *
532  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
533 *
534  IF( tstchk ) THEN
535  CALL cchkps( dotype, nn, nval, nnb2, nbval2, nrank,
536  $ rankval, thresh, tsterr, lda, a( 1, 1 ),
537  $ a( 1, 2 ), a( 1, 3 ), piv, work, rwork,
538  $ nout )
539  ELSE
540  WRITE( nout, fmt = 9989 )path
541  END IF
542 *
543  ELSE IF( lsamen( 2, c2, 'PP' ) ) THEN
544 *
545 * PP: positive definite packed matrices
546 *
547  ntypes = 9
548  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
549 *
550  IF( tstchk ) THEN
551  CALL cchkpp( dotype, nn, nval, nns, nsval, thresh, tsterr,
552  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
553  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
554  $ nout )
555  ELSE
556  WRITE( nout, fmt = 9989 )path
557  END IF
558 *
559  IF( tstdrv ) THEN
560  CALL cdrvpp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
561  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
562  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
563  $ rwork, nout )
564  ELSE
565  WRITE( nout, fmt = 9988 )path
566  END IF
567 *
568  ELSE IF( lsamen( 2, c2, 'PB' ) ) THEN
569 *
570 * PB: positive definite banded matrices
571 *
572  ntypes = 8
573  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
574 *
575  IF( tstchk ) THEN
576  CALL cchkpb( dotype, nn, nval, nnb2, nbval2, nns, nsval,
577  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
578  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
579  $ work, rwork, nout )
580  ELSE
581  WRITE( nout, fmt = 9989 )path
582  END IF
583 *
584  IF( tstdrv ) THEN
585  CALL cdrvpb( dotype, nn, nval, nrhs, thresh, tsterr, lda,
586  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
587  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
588  $ rwork, nout )
589  ELSE
590  WRITE( nout, fmt = 9988 )path
591  END IF
592 *
593  ELSE IF( lsamen( 2, c2, 'PT' ) ) THEN
594 *
595 * PT: positive definite tridiagonal matrices
596 *
597  ntypes = 12
598  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
599 *
600  IF( tstchk ) THEN
601  CALL cchkpt( dotype, nn, nval, nns, nsval, thresh, tsterr,
602  $ a( 1, 1 ), s, a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
603  $ b( 1, 3 ), work, rwork, nout )
604  ELSE
605  WRITE( nout, fmt = 9989 )path
606  END IF
607 *
608  IF( tstdrv ) THEN
609  CALL cdrvpt( dotype, nn, nval, nrhs, thresh, tsterr,
610  $ a( 1, 1 ), s, a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
611  $ b( 1, 3 ), work, rwork, nout )
612  ELSE
613  WRITE( nout, fmt = 9988 )path
614  END IF
615 *
616  ELSE IF( lsamen( 2, c2, 'HE' ) ) THEN
617 *
618 * HE: Hermitian indefinite matrices
619 *
620  ntypes = 10
621  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
622 *
623  IF( tstchk ) THEN
624  CALL cchkhe( dotype, nn, nval, nnb2, nbval2, nns, nsval,
625  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
626  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
627  $ work, rwork, iwork, nout )
628  ELSE
629  WRITE( nout, fmt = 9989 )path
630  END IF
631 *
632  IF( tstdrv ) THEN
633  CALL cdrvhe( dotype, nn, nval, nrhs, thresh, tsterr, lda,
634  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
635  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
636  $ nout )
637  ELSE
638  WRITE( nout, fmt = 9988 )path
639  END IF
640 *
641  ELSE IF( lsamen( 2, c2, 'HP' ) ) THEN
642 *
643 * HP: Hermitian indefinite packed matrices
644 *
645  ntypes = 10
646  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
647 *
648  IF( tstchk ) THEN
649  CALL cchkhp( dotype, nn, nval, nns, nsval, thresh, tsterr,
650  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
651  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
652  $ iwork, nout )
653  ELSE
654  WRITE( nout, fmt = 9989 )path
655  END IF
656 *
657  IF( tstdrv ) THEN
658  CALL cdrvhp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
659  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
660  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
661  $ nout )
662  ELSE
663  WRITE( nout, fmt = 9988 )path
664  END IF
665 *
666  ELSE IF( lsamen( 2, c2, 'SY' ) ) THEN
667 *
668 * SY: symmetric indefinite matrices,
669 * with partial (Bunch-Kaufman) pivoting algorithm
670 *
671  ntypes = 11
672  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
673 *
674  IF( tstchk ) THEN
675  CALL cchksy( dotype, nn, nval, nnb2, nbval2, nns, nsval,
676  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
677  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
678  $ work, rwork, iwork, nout )
679  ELSE
680  WRITE( nout, fmt = 9989 )path
681  END IF
682 *
683  IF( tstdrv ) THEN
684  CALL cdrvsy( dotype, nn, nval, nrhs, thresh, tsterr, lda,
685  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
686  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
687  $ nout )
688  ELSE
689  WRITE( nout, fmt = 9988 )path
690  END IF
691 *
692  ELSE IF( lsamen( 2, c2, 'SP' ) ) THEN
693 *
694 * SP: symmetric indefinite packed matrices,
695 * with partial (Bunch-Kaufman) pivoting algorithm
696 *
697  ntypes = 11
698  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
699 *
700  IF( tstchk ) THEN
701  CALL cchksp( dotype, nn, nval, nns, nsval, thresh, tsterr,
702  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
703  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
704  $ iwork, nout )
705  ELSE
706  WRITE( nout, fmt = 9989 )path
707  END IF
708 *
709  IF( tstdrv ) THEN
710  CALL cdrvsp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
711  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
712  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
713  $ nout )
714  ELSE
715  WRITE( nout, fmt = 9988 )path
716  END IF
717 *
718  ELSE IF( lsamen( 2, c2, 'TR' ) ) THEN
719 *
720 * TR: triangular matrices
721 *
722  ntypes = 18
723  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
724 *
725  IF( tstchk ) THEN
726  CALL cchktr( dotype, nn, nval, nnb2, nbval2, nns, nsval,
727  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
728  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
729  $ nout )
730  ELSE
731  WRITE( nout, fmt = 9989 )path
732  END IF
733 *
734  ELSE IF( lsamen( 2, c2, 'TP' ) ) THEN
735 *
736 * TP: triangular packed matrices
737 *
738  ntypes = 18
739  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
740 *
741  IF( tstchk ) THEN
742  CALL cchktp( dotype, nn, nval, nns, nsval, thresh, tsterr,
743  $ lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
744  $ b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
745  ELSE
746  WRITE( nout, fmt = 9989 )path
747  END IF
748 *
749  ELSE IF( lsamen( 2, c2, 'TB' ) ) THEN
750 *
751 * TB: triangular banded matrices
752 *
753  ntypes = 17
754  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
755 *
756  IF( tstchk ) THEN
757  CALL cchktb( dotype, nn, nval, nns, nsval, thresh, tsterr,
758  $ lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
759  $ b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
760  ELSE
761  WRITE( nout, fmt = 9989 )path
762  END IF
763 *
764  ELSE IF( lsamen( 2, c2, 'QR' ) ) THEN
765 *
766 * QR: QR factorization
767 *
768  ntypes = 8
769  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
770 *
771  IF( tstchk ) THEN
772  CALL cchkqr( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
773  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
774  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
775  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
776  $ work, rwork, iwork, nout )
777  ELSE
778  WRITE( nout, fmt = 9989 )path
779  END IF
780 *
781  ELSE IF( lsamen( 2, c2, 'LQ' ) ) THEN
782 *
783 * LQ: LQ factorization
784 *
785  ntypes = 8
786  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
787 *
788  IF( tstchk ) THEN
789  CALL cchklq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
790  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
791  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
792  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
793  $ work, rwork, iwork, nout )
794  ELSE
795  WRITE( nout, fmt = 9989 )path
796  END IF
797 *
798  ELSE IF( lsamen( 2, c2, 'QL' ) ) THEN
799 *
800 * QL: QL factorization
801 *
802  ntypes = 8
803  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
804 *
805  IF( tstchk ) THEN
806  CALL cchkql( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
807  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
808  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
809  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
810  $ work, rwork, nout )
811  ELSE
812  WRITE( nout, fmt = 9989 )path
813  END IF
814 
815 *
816  ELSE IF( lsamen( 2, c2, 'RQ' ) ) THEN
817 *
818 * RQ: RQ factorization
819 *
820  ntypes = 8
821  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
822 *
823  IF( tstchk ) THEN
824  CALL cchkrq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
825  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
826  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
827  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
828  $ work, rwork, iwork, nout )
829  ELSE
830  WRITE( nout, fmt = 9989 )path
831  END IF
832 *
833  ELSE IF( lsamen( 2, c2, 'EQ' ) ) THEN
834 *
835 * EQ: Equilibration routines for general and positive definite
836 * matrices (THREQ should be between 2 and 10)
837 *
838  IF( tstchk ) THEN
839  CALL cchkeq( threq, nout )
840  ELSE
841  WRITE( nout, fmt = 9989 )path
842  END IF
843 *
844  ELSE IF( lsamen( 2, c2, 'TZ' ) ) THEN
845 *
846 * TZ: Trapezoidal matrix
847 *
848  ntypes = 3
849  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
850 *
851  IF( tstchk ) THEN
852  CALL cchktz( dotype, nm, mval, nn, nval, thresh, tsterr,
853  $ a( 1, 1 ), a( 1, 2 ), s( 1 ),
854  $ b( 1, 1 ), work, rwork, nout )
855  ELSE
856  WRITE( nout, fmt = 9989 )path
857  END IF
858 *
859  ELSE IF( lsamen( 2, c2, 'QP' ) ) THEN
860 *
861 * QP: QR factorization with pivoting
862 *
863  ntypes = 6
864  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
865 *
866  IF( tstchk ) THEN
867  CALL cchkqp( dotype, nm, mval, nn, nval, thresh, tsterr,
868  $ a( 1, 1 ), a( 1, 2 ), s( 1 ),
869  $ b( 1, 1 ), work, rwork, iwork, nout )
870  CALL cchkq3( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
871  $ thresh, a( 1, 1 ), a( 1, 2 ), s( 1 ),
872  $ b( 1, 1 ), work, rwork, iwork, nout )
873  ELSE
874  WRITE( nout, fmt = 9989 )path
875  END IF
876 
877 *
878  ELSE IF( lsamen( 2, c2, 'LS' ) ) THEN
879 *
880 * LS: Least squares drivers
881 *
882  ntypes = 6
883  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
884 *
885  IF( tstdrv ) THEN
886  CALL cdrvls( dotype, nm, mval, nn, nval, nns, nsval, nnb,
887  $ nbval, nxval, thresh, tsterr, a( 1, 1 ),
888  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
889  $ s( 1 ), s( nmax+1 ), work, rwork, iwork,
890  $ nout )
891  ELSE
892  WRITE( nout, fmt = 9989 )path
893  END IF
894 *
895  ELSE IF( lsamen( 2, c2, 'QT' ) ) THEN
896 *
897 * QT: QRT routines for general matrices
898 *
899  IF( tstchk ) THEN
900  CALL cchkqrt( thresh, tsterr, nm, mval, nn, nval, nnb,
901  $ nbval, nout )
902  ELSE
903  WRITE( nout, fmt = 9989 )path
904  END IF
905 *
906  ELSE IF( lsamen( 2, c2, 'QX' ) ) THEN
907 *
908 * QX: QRT routines for triangular-pentagonal matrices
909 *
910  IF( tstchk ) THEN
911  CALL cchkqrtp( thresh, tsterr, nm, mval, nn, nval, nnb,
912  $ nbval, nout )
913  ELSE
914  WRITE( nout, fmt = 9989 )path
915  END IF
916 *
917  ELSE
918 *
919  WRITE( nout, fmt = 9990 )path
920  END IF
921 *
922 * Go back to get another input line.
923 *
924  go to 80
925 *
926 * Branch to this line when the last record is read.
927 *
928  140 CONTINUE
929  CLOSE ( nin )
930  s2 = second( )
931  WRITE( nout, fmt = 9998 )
932  WRITE( nout, fmt = 9997 )s2 - s1
933 *
934  9999 FORMAT( / ' Execution not attempted due to input errors' )
935  9998 FORMAT( / ' End of tests' )
936  9997 FORMAT( ' Total time used = ', f12.2, ' seconds', / )
937  9996 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be >=',
938  $ i6 )
939  9995 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be <=',
940  $ i6 )
941  9994 FORMAT( ' Tests of the COMPLEX LAPACK routines ',
942  $ / ' LAPACK VERSION ', i1, '.', i1, '.', i1,
943  $ / / ' The following parameter values will be used:' )
944  9993 FORMAT( 4x, a4, ': ', 10i6, / 11x, 10i6 )
945  9992 FORMAT( / ' Routines pass computational tests if test ratio is ',
946  $ 'less than', f8.2, / )
947  9991 FORMAT( ' Relative machine ', a, ' is taken to be', e16.6 )
948  9990 FORMAT( / 1x, a3, ': Unrecognized path name' )
949  9989 FORMAT( / 1x, a3, ' routines were not tested' )
950  9988 FORMAT( / 1x, a3, ' driver routines were not tested' )
951 *
952 * End of CCHKAA
953 *
954  END
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:200
subroutine cchktp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X, XACT, WORK, RWORK, NOUT)
CCHKTP
Definition: cchktp.f:150
subroutine cchkhp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKHP
Definition: cchkhp.f:163
subroutine cchkps(DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A, AFAC, PERM, PIV, WORK, RWORK, NOUT)
CCHKPS
Definition: cchkps.f:153
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
real function second()
SECOND Using ETIME
subroutine cdrvls(DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, RWORK, IWORK, NOUT)
CDRVLS
Definition: cdrvls.f:209
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:200
subroutine cchksp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKSP
Definition: cchksp.f:163
subroutine cchkqp(DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, RWORK, IWORK, NOUT)
CCHKQP
Definition: cchkqp.f:143
subroutine cdrvsy(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSY
Definition: cdrvsy.f:153
subroutine cchkqrtp(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKQRTP
Definition: cchkqrtp.f:102
subroutine cdrvpb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPB
Definition: cdrvpb.f:158
subroutine cchktz(DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, RWORK, NOUT)
CCHKTZ
Definition: cchktz.f:137
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:54
subroutine cchkgt(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CCHKGT
Definition: cchkgt.f:147
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:195
subroutine cdrvpt(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT)
CDRVPT
Definition: cdrvpt.f:140
subroutine cchkpp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKPP
Definition: cchkpp.f:158
subroutine alareq(PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT)
ALAREQ
Definition: alareq.f:91
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:163
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:172
subroutine cdrvhe(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHE
Definition: cdrvhe.f:153
subroutine cdrvgt(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVGT
Definition: cdrvgt.f:139
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:190
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:172
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:171
subroutine cchkq3(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S, TAU, WORK, RWORK, IWORK, NOUT)
CCHKQ3
Definition: cchkq3.f:157
subroutine cdrvhp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVHP
Definition: cdrvhp.f:156
subroutine cchkpt(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT)
CCHKPT
Definition: cchkpt.f:147
subroutine cchkeq(THRESH, NOUT)
CCHKEQ
Definition: cchkeq.f:55
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:195
subroutine cdrvsp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
CDRVSP
Definition: cdrvsp.f:156
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:167
logical function lsamen(N, CA, CB)
LSAMEN
Definition: lsamen.f:75
subroutine cchktb(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKTB
Definition: cchktb.f:149
subroutine cdrvpo(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPO
Definition: cdrvpo.f:158
program cchkaa
CCHKAA
Definition: cchkaa.f:109
subroutine cchktr(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AINV, B, X, XACT, WORK, RWORK, NOUT)
CCHKTR
Definition: cchktr.f:162
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:167
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:185
subroutine ilaver(VERS_MAJOR, VERS_MINOR, VERS_PATCH)
ILAVER returns the LAPACK version.
Definition: ilaver.f:49
subroutine cdrvpp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPP
Definition: cdrvpp.f:158
subroutine cchkqrt(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
CCHKQRT
Definition: cchkqrt.f:102