LAPACK  3.8.0
LAPACK: Linear Algebra PACKage
schkaa.f
Go to the documentation of this file.
1 *> \brief \b SCHKAA
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 SCHKAA
12 *
13 *
14 *> \par Purpose:
15 * =============
16 *>
17 *> \verbatim
18 *>
19 *> SCHKAA is the main test program for the REAL LAPACK
20 *> linear equation 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 40 lines:
28 *> Data file for testing REAL LAPACK linear eqn. 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 *> 20.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 *> SGE 11 List types on next line if 0 < NTYPES < 11
45 *> SGB 8 List types on next line if 0 < NTYPES < 8
46 *> SGT 12 List types on next line if 0 < NTYPES < 12
47 *> SPO 9 List types on next line if 0 < NTYPES < 9
48 *> SPS 9 List types on next line if 0 < NTYPES < 9
49 *> SPP 9 List types on next line if 0 < NTYPES < 9
50 *> SPB 8 List types on next line if 0 < NTYPES < 8
51 *> SPT 12 List types on next line if 0 < NTYPES < 12
52 *> SSY 10 List types on next line if 0 < NTYPES < 10
53 *> SSR 10 List types on next line if 0 < NTYPES < 10
54 *> SSK 10 List types on next line if 0 < NTYPES < 10
55 *> SSA 10 List types on next line if 0 < NTYPES < 10
56 *> SS2 10 List types on next line if 0 < NTYPES < 10
57 *> SSP 10 List types on next line if 0 < NTYPES < 10
58 *> STR 18 List types on next line if 0 < NTYPES < 18
59 *> STP 18 List types on next line if 0 < NTYPES < 18
60 *> STB 17 List types on next line if 0 < NTYPES < 17
61 *> SQR 8 List types on next line if 0 < NTYPES < 8
62 *> SRQ 8 List types on next line if 0 < NTYPES < 8
63 *> SLQ 8 List types on next line if 0 < NTYPES < 8
64 *> SQL 8 List types on next line if 0 < NTYPES < 8
65 *> SQP 6 List types on next line if 0 < NTYPES < 6
66 *> STZ 3 List types on next line if 0 < NTYPES < 3
67 *> SLS 6 List types on next line if 0 < NTYPES < 6
68 *> SEQ
69 *> SQT
70 *> SQX
71 *> \endverbatim
72 *
73 * Parameters:
74 * ==========
75 *
76 *> \verbatim
77 *> NMAX INTEGER
78 *> The maximum allowable value for M and N.
79 *>
80 *> MAXIN INTEGER
81 *> The number of different values that can be used for each of
82 *> M, N, NRHS, NB, NX and RANK
83 *>
84 *> MAXRHS INTEGER
85 *> The maximum number of right hand sides
86 *>
87 *> MATMAX INTEGER
88 *> The maximum number of matrix types to use for testing
89 *>
90 *> NIN INTEGER
91 *> The unit number for input
92 *>
93 *> NOUT INTEGER
94 *> The unit number for output
95 *> \endverbatim
96 *
97 * Authors:
98 * ========
99 *
100 *> \author Univ. of Tennessee
101 *> \author Univ. of California Berkeley
102 *> \author Univ. of Colorado Denver
103 *> \author NAG Ltd.
104 *
105 *> \date April 2012
106 *
107 *> \ingroup single_lin
108 *
109 * =====================================================================
110  PROGRAM schkaa
111 *
112 * -- LAPACK test routine (version 3.8.0) --
113 * -- LAPACK is a software package provided by Univ. of Tennessee, --
114 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
115 * April 2012
116 *
117 * =====================================================================
118 *
119 * .. Parameters ..
120  INTEGER NMAX
121  parameter( nmax = 132 )
122  INTEGER MAXIN
123  parameter( maxin = 12 )
124  INTEGER MAXRHS
125  parameter( maxrhs = 16 )
126  INTEGER MATMAX
127  parameter( matmax = 30 )
128  INTEGER NIN, NOUT
129  parameter( nin = 5, nout = 6 )
130  INTEGER KDMAX
131  parameter( kdmax = nmax+( nmax+1 ) / 4 )
132 * ..
133 * .. Local Scalars ..
134  LOGICAL FATAL, TSTCHK, TSTDRV, TSTERR
135  CHARACTER C1
136  CHARACTER*2 C2
137  CHARACTER*3 PATH
138  CHARACTER*10 INTSTR
139  CHARACTER*72 ALINE
140  INTEGER I, IC, J, K, LA, LAFAC, LDA, NB, NM, NMATS, NN,
141  $ nnb, nnb2, nns, nrhs, ntypes, nrank,
142  $ vers_major, vers_minor, vers_patch
143  REAL EPS, S1, S2, THREQ, THRESH
144 * ..
145 * .. Local Arrays ..
146  LOGICAL DOTYPE( matmax )
147  INTEGER IWORK( 25*nmax ), MVAL( maxin ),
148  $ nbval( maxin ), nbval2( maxin ),
149  $ nsval( maxin ), nval( maxin ), nxval( maxin ),
150  $ rankval( maxin ), piv( nmax )
151  REAL A( ( kdmax+1 )*nmax, 7 ), B( nmax*maxrhs, 4 ),
152  $ e( nmax ), rwork( 5*nmax+2*maxrhs ),
153  $ s( 2*nmax ), work( nmax, nmax+maxrhs+30 )
154 * ..
155 * .. External Functions ..
156  LOGICAL LSAME, LSAMEN
157  REAL SECOND, SLAMCH
158  EXTERNAL lsame, lsamen, second, slamch
159 * ..
160 * .. External Subroutines ..
161  EXTERNAL alareq, schkeq, schkgb, schkge, schkgt, schklq,
169  $ schklqt, schktsqr
170 * ..
171 * .. Scalars in Common ..
172  LOGICAL LERR, OK
173  CHARACTER*32 SRNAMT
174  INTEGER INFOT, NUNIT
175 * ..
176 * .. Arrays in Common ..
177  INTEGER IPARMS( 100 )
178 * ..
179 * .. Common blocks ..
180  COMMON / claenv / iparms
181  COMMON / infoc / infot, nunit, ok, lerr
182  COMMON / srnamc / srnamt
183 * ..
184 * .. Data statements ..
185  DATA threq / 2.0e0 / , intstr / '0123456789' /
186 * ..
187 * .. Executable Statements ..
188 *
189  s1 = second( )
190  lda = nmax
191  fatal = .false.
192 *
193 * Read a dummy line.
194 *
195  READ( nin, fmt = * )
196 *
197 * Report values of parameters.
198 *
199  CALL ilaver( vers_major, vers_minor, vers_patch )
200  WRITE( nout, fmt = 9994 ) vers_major, vers_minor, vers_patch
201 *
202 * Read the values of M
203 *
204  READ( nin, fmt = * )nm
205  IF( nm.LT.1 ) THEN
206  WRITE( nout, fmt = 9996 )' NM ', nm, 1
207  nm = 0
208  fatal = .true.
209  ELSE IF( nm.GT.maxin ) THEN
210  WRITE( nout, fmt = 9995 )' NM ', nm, maxin
211  nm = 0
212  fatal = .true.
213  END IF
214  READ( nin, fmt = * )( mval( i ), i = 1, nm )
215  DO 10 i = 1, nm
216  IF( mval( i ).LT.0 ) THEN
217  WRITE( nout, fmt = 9996 )' M ', mval( i ), 0
218  fatal = .true.
219  ELSE IF( mval( i ).GT.nmax ) THEN
220  WRITE( nout, fmt = 9995 )' M ', mval( i ), nmax
221  fatal = .true.
222  END IF
223  10 CONTINUE
224  IF( nm.GT.0 )
225  $ WRITE( nout, fmt = 9993 )'M ', ( mval( i ), i = 1, nm )
226 *
227 * Read the values of N
228 *
229  READ( nin, fmt = * )nn
230  IF( nn.LT.1 ) THEN
231  WRITE( nout, fmt = 9996 )' NN ', nn, 1
232  nn = 0
233  fatal = .true.
234  ELSE IF( nn.GT.maxin ) THEN
235  WRITE( nout, fmt = 9995 )' NN ', nn, maxin
236  nn = 0
237  fatal = .true.
238  END IF
239  READ( nin, fmt = * )( nval( i ), i = 1, nn )
240  DO 20 i = 1, nn
241  IF( nval( i ).LT.0 ) THEN
242  WRITE( nout, fmt = 9996 )' N ', nval( i ), 0
243  fatal = .true.
244  ELSE IF( nval( i ).GT.nmax ) THEN
245  WRITE( nout, fmt = 9995 )' N ', nval( i ), nmax
246  fatal = .true.
247  END IF
248  20 CONTINUE
249  IF( nn.GT.0 )
250  $ WRITE( nout, fmt = 9993 )'N ', ( nval( i ), i = 1, nn )
251 *
252 * Read the values of NRHS
253 *
254  READ( nin, fmt = * )nns
255  IF( nns.LT.1 ) THEN
256  WRITE( nout, fmt = 9996 )' NNS', nns, 1
257  nns = 0
258  fatal = .true.
259  ELSE IF( nns.GT.maxin ) THEN
260  WRITE( nout, fmt = 9995 )' NNS', nns, maxin
261  nns = 0
262  fatal = .true.
263  END IF
264  READ( nin, fmt = * )( nsval( i ), i = 1, nns )
265  DO 30 i = 1, nns
266  IF( nsval( i ).LT.0 ) THEN
267  WRITE( nout, fmt = 9996 )'NRHS', nsval( i ), 0
268  fatal = .true.
269  ELSE IF( nsval( i ).GT.maxrhs ) THEN
270  WRITE( nout, fmt = 9995 )'NRHS', nsval( i ), maxrhs
271  fatal = .true.
272  END IF
273  30 CONTINUE
274  IF( nns.GT.0 )
275  $ WRITE( nout, fmt = 9993 )'NRHS', ( nsval( i ), i = 1, nns )
276 *
277 * Read the values of NB
278 *
279  READ( nin, fmt = * )nnb
280  IF( nnb.LT.1 ) THEN
281  WRITE( nout, fmt = 9996 )'NNB ', nnb, 1
282  nnb = 0
283  fatal = .true.
284  ELSE IF( nnb.GT.maxin ) THEN
285  WRITE( nout, fmt = 9995 )'NNB ', nnb, maxin
286  nnb = 0
287  fatal = .true.
288  END IF
289  READ( nin, fmt = * )( nbval( i ), i = 1, nnb )
290  DO 40 i = 1, nnb
291  IF( nbval( i ).LT.0 ) THEN
292  WRITE( nout, fmt = 9996 )' NB ', nbval( i ), 0
293  fatal = .true.
294  END IF
295  40 CONTINUE
296  IF( nnb.GT.0 )
297  $ WRITE( nout, fmt = 9993 )'NB ', ( nbval( i ), i = 1, nnb )
298 *
299 * Set NBVAL2 to be the set of unique values of NB
300 *
301  nnb2 = 0
302  DO 60 i = 1, nnb
303  nb = nbval( i )
304  DO 50 j = 1, nnb2
305  IF( nb.EQ.nbval2( j ) )
306  $ GO TO 60
307  50 CONTINUE
308  nnb2 = nnb2 + 1
309  nbval2( nnb2 ) = nb
310  60 CONTINUE
311 *
312 * Read the values of NX
313 *
314  READ( nin, fmt = * )( nxval( i ), i = 1, nnb )
315  DO 70 i = 1, nnb
316  IF( nxval( i ).LT.0 ) THEN
317  WRITE( nout, fmt = 9996 )' NX ', nxval( i ), 0
318  fatal = .true.
319  END IF
320  70 CONTINUE
321  IF( nnb.GT.0 )
322  $ WRITE( nout, fmt = 9993 )'NX ', ( nxval( i ), i = 1, nnb )
323 *
324 * Read the values of RANKVAL
325 *
326  READ( nin, fmt = * )nrank
327  IF( nn.LT.1 ) THEN
328  WRITE( nout, fmt = 9996 )' NRANK ', nrank, 1
329  nrank = 0
330  fatal = .true.
331  ELSE IF( nn.GT.maxin ) THEN
332  WRITE( nout, fmt = 9995 )' NRANK ', nrank, maxin
333  nrank = 0
334  fatal = .true.
335  END IF
336  READ( nin, fmt = * )( rankval( i ), i = 1, nrank )
337  DO i = 1, nrank
338  IF( rankval( i ).LT.0 ) THEN
339  WRITE( nout, fmt = 9996 )' RANK ', rankval( i ), 0
340  fatal = .true.
341  ELSE IF( rankval( i ).GT.100 ) THEN
342  WRITE( nout, fmt = 9995 )' RANK ', rankval( i ), 100
343  fatal = .true.
344  END IF
345  END DO
346  IF( nrank.GT.0 )
347  $ WRITE( nout, fmt = 9993 )'RANK % OF N',
348  $ ( rankval( i ), i = 1, nrank )
349 *
350 * Read the threshold value for the test ratios.
351 *
352  READ( nin, fmt = * )thresh
353  WRITE( nout, fmt = 9992 )thresh
354 *
355 * Read the flag that indicates whether to test the LAPACK routines.
356 *
357  READ( nin, fmt = * )tstchk
358 *
359 * Read the flag that indicates whether to test the driver routines.
360 *
361  READ( nin, fmt = * )tstdrv
362 *
363 * Read the flag that indicates whether to test the error exits.
364 *
365  READ( nin, fmt = * )tsterr
366 *
367  IF( fatal ) THEN
368  WRITE( nout, fmt = 9999 )
369  stop
370  END IF
371 *
372 * Calculate and print the machine dependent constants.
373 *
374  eps = slamch( 'Underflow threshold' )
375  WRITE( nout, fmt = 9991 )'underflow', eps
376  eps = slamch( 'Overflow threshold' )
377  WRITE( nout, fmt = 9991 )'overflow ', eps
378  eps = slamch( 'Epsilon' )
379  WRITE( nout, fmt = 9991 )'precision', eps
380  WRITE( nout, fmt = * )
381 *
382  80 CONTINUE
383 *
384 * Read a test path and the number of matrix types to use.
385 *
386  READ( nin, fmt = '(A72)', end = 140 )aline
387  path = aline( 1: 3 )
388  nmats = matmax
389  i = 3
390  90 CONTINUE
391  i = i + 1
392  IF( i.GT.72 ) THEN
393  nmats = matmax
394  GO TO 130
395  END IF
396  IF( aline( i: i ).EQ.' ' )
397  $ GO TO 90
398  nmats = 0
399  100 CONTINUE
400  c1 = aline( i: i )
401  DO 110 k = 1, 10
402  IF( c1.EQ.intstr( k: k ) ) THEN
403  ic = k - 1
404  GO TO 120
405  END IF
406  110 CONTINUE
407  GO TO 130
408  120 CONTINUE
409  nmats = nmats*10 + ic
410  i = i + 1
411  IF( i.GT.72 )
412  $ GO TO 130
413  GO TO 100
414  130 CONTINUE
415  c1 = path( 1: 1 )
416  c2 = path( 2: 3 )
417  nrhs = nsval( 1 )
418 *
419 * Check first character for correct precision.
420 *
421  IF( .NOT.lsame( c1, 'Single precision' ) ) THEN
422  WRITE( nout, fmt = 9990 )path
423 *
424  ELSE IF( nmats.LE.0 ) THEN
425 *
426 * Check for a positive number of tests requested.
427 *
428  WRITE( nout, fmt = 9989 )path
429 *
430  ELSE IF( lsamen( 2, c2, 'GE' ) ) THEN
431 *
432 * GE: general matrices
433 *
434  ntypes = 11
435  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
436 *
437  IF( tstchk ) THEN
438  CALL schkge( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
439  $ nsval, thresh, tsterr, lda, a( 1, 1 ),
440  $ a( 1, 2 ), a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
441  $ b( 1, 3 ), work, rwork, iwork, nout )
442  ELSE
443  WRITE( nout, fmt = 9989 )path
444  END IF
445 *
446  IF( tstdrv ) THEN
447  CALL sdrvge( dotype, nn, nval, nrhs, thresh, tsterr, lda,
448  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
449  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
450  $ rwork, iwork, nout )
451  ELSE
452  WRITE( nout, fmt = 9988 )path
453  END IF
454 *
455  ELSE IF( lsamen( 2, c2, 'GB' ) ) THEN
456 *
457 * GB: general banded matrices
458 *
459  la = ( 2*kdmax+1 )*nmax
460  lafac = ( 3*kdmax+1 )*nmax
461  ntypes = 8
462  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
463 *
464  IF( tstchk ) THEN
465  CALL schkgb( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
466  $ nsval, thresh, tsterr, a( 1, 1 ), la,
467  $ a( 1, 3 ), lafac, b( 1, 1 ), b( 1, 2 ),
468  $ b( 1, 3 ), work, rwork, iwork, nout )
469  ELSE
470  WRITE( nout, fmt = 9989 )path
471  END IF
472 *
473  IF( tstdrv ) THEN
474  CALL sdrvgb( dotype, nn, nval, nrhs, thresh, tsterr,
475  $ a( 1, 1 ), la, a( 1, 3 ), lafac, a( 1, 6 ),
476  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s,
477  $ work, rwork, iwork, nout )
478  ELSE
479  WRITE( nout, fmt = 9988 )path
480  END IF
481 *
482  ELSE IF( lsamen( 2, c2, 'GT' ) ) THEN
483 *
484 * GT: general tridiagonal matrices
485 *
486  ntypes = 12
487  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
488 *
489  IF( tstchk ) THEN
490  CALL schkgt( dotype, nn, nval, nns, nsval, thresh, tsterr,
491  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
492  $ b( 1, 3 ), work, rwork, iwork, nout )
493  ELSE
494  WRITE( nout, fmt = 9989 )path
495  END IF
496 *
497  IF( tstdrv ) THEN
498  CALL sdrvgt( dotype, nn, nval, nrhs, thresh, tsterr,
499  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
500  $ b( 1, 3 ), work, rwork, iwork, nout )
501  ELSE
502  WRITE( nout, fmt = 9988 )path
503  END IF
504 *
505  ELSE IF( lsamen( 2, c2, 'PO' ) ) THEN
506 *
507 * PO: positive definite matrices
508 *
509  ntypes = 9
510  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
511 *
512  IF( tstchk ) THEN
513  CALL schkpo( dotype, nn, nval, nnb2, nbval2, nns, nsval,
514  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
515  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
516  $ work, rwork, iwork, nout )
517  ELSE
518  WRITE( nout, fmt = 9989 )path
519  END IF
520 *
521  IF( tstdrv ) THEN
522  CALL sdrvpo( dotype, nn, nval, nrhs, thresh, tsterr, lda,
523  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
524  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
525  $ rwork, iwork, nout )
526  ELSE
527  WRITE( nout, fmt = 9988 )path
528  END IF
529 *
530  ELSE IF( lsamen( 2, c2, 'PS' ) ) THEN
531 *
532 * PS: positive semi-definite matrices
533 *
534  ntypes = 9
535 *
536  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
537 *
538  IF( tstchk ) THEN
539  CALL schkps( dotype, nn, nval, nnb2, nbval2, nrank,
540  $ rankval, thresh, tsterr, lda, a( 1, 1 ),
541  $ a( 1, 2 ), a( 1, 3 ), piv, work, rwork,
542  $ nout )
543  ELSE
544  WRITE( nout, fmt = 9989 )path
545  END IF
546 *
547  ELSE IF( lsamen( 2, c2, 'PP' ) ) THEN
548 *
549 * PP: positive definite packed matrices
550 *
551  ntypes = 9
552  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
553 *
554  IF( tstchk ) THEN
555  CALL schkpp( dotype, nn, nval, nns, nsval, thresh, tsterr,
556  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
557  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
558  $ iwork, nout )
559  ELSE
560  WRITE( nout, fmt = 9989 )path
561  END IF
562 *
563  IF( tstdrv ) THEN
564  CALL sdrvpp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
565  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
566  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
567  $ rwork, iwork, nout )
568  ELSE
569  WRITE( nout, fmt = 9988 )path
570  END IF
571 *
572  ELSE IF( lsamen( 2, c2, 'PB' ) ) THEN
573 *
574 * PB: positive definite banded matrices
575 *
576  ntypes = 8
577  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
578 *
579  IF( tstchk ) THEN
580  CALL schkpb( dotype, nn, nval, nnb2, nbval2, nns, nsval,
581  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
582  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
583  $ work, rwork, iwork, nout )
584  ELSE
585  WRITE( nout, fmt = 9989 )path
586  END IF
587 *
588  IF( tstdrv ) THEN
589  CALL sdrvpb( dotype, nn, nval, nrhs, thresh, tsterr, lda,
590  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
591  $ b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
592  $ rwork, iwork, nout )
593  ELSE
594  WRITE( nout, fmt = 9988 )path
595  END IF
596 *
597  ELSE IF( lsamen( 2, c2, 'PT' ) ) THEN
598 *
599 * PT: positive definite tridiagonal matrices
600 *
601  ntypes = 12
602  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
603 *
604  IF( tstchk ) THEN
605  CALL schkpt( dotype, nn, nval, nns, nsval, thresh, tsterr,
606  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
607  $ b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
608  ELSE
609  WRITE( nout, fmt = 9989 )path
610  END IF
611 *
612  IF( tstdrv ) THEN
613  CALL sdrvpt( dotype, nn, nval, nrhs, thresh, tsterr,
614  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
615  $ b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
616  ELSE
617  WRITE( nout, fmt = 9988 )path
618  END IF
619 *
620  ELSE IF( lsamen( 2, c2, 'SY' ) ) THEN
621 *
622 * SY: symmetric indefinite matrices,
623 * with partial (Bunch-Kaufman) pivoting algorithm
624 *
625  ntypes = 10
626  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
627 *
628  IF( tstchk ) THEN
629  CALL schksy( dotype, nn, nval, nnb2, nbval2, nns, nsval,
630  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
631  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
632  $ work, rwork, iwork, nout )
633  ELSE
634  WRITE( nout, fmt = 9989 )path
635  END IF
636 *
637  IF( tstdrv ) THEN
638  CALL sdrvsy( dotype, nn, nval, nrhs, thresh, tsterr, lda,
639  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
640  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
641  $ nout )
642  ELSE
643  WRITE( nout, fmt = 9988 )path
644  END IF
645 *
646  ELSE IF( lsamen( 2, c2, 'SR' ) ) THEN
647 *
648 * SR: symmetric indefinite matrices,
649 * with bounded Bunch-Kaufman (rook) pivoting algorithm
650 *
651  ntypes = 10
652  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
653 *
654  IF( tstchk ) THEN
655  CALL schksy_rook(dotype, nn, nval, nnb2, nbval2, nns, nsval,
656  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
657  $ a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
658  $ work, rwork, iwork, nout )
659  ELSE
660  WRITE( nout, fmt = 9989 )path
661  END IF
662 *
663  IF( tstdrv ) THEN
664  CALL sdrvsy_rook( dotype, nn, nval, nrhs, thresh, tsterr,
665  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
666  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
667  $ work, rwork, iwork, nout )
668  ELSE
669  WRITE( nout, fmt = 9988 )path
670  END IF
671 *
672  ELSE IF( lsamen( 2, c2, 'SK' ) ) THEN
673 *
674 * SK: symmetric indefinite matrices,
675 * with bounded Bunch-Kaufman (rook) pivoting algorithm,
676 * differnet matrix storage format than SR path version.
677 *
678  ntypes = 10
679  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
680 *
681  IF( tstchk ) THEN
682  CALL schksy_rk( dotype, nn, nval, nnb2, nbval2, nns, nsval,
683  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
684  $ e, a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
685  $ b( 1, 3 ), work, rwork, iwork, nout )
686  ELSE
687  WRITE( nout, fmt = 9989 )path
688  END IF
689 *
690  IF( tstdrv ) THEN
691  CALL sdrvsy_rk( dotype, nn, nval, nrhs, thresh, tsterr,
692  $ lda, a( 1, 1 ), a( 1, 2 ), e, a( 1, 3 ),
693  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
694  $ work, rwork, iwork, nout )
695  ELSE
696  WRITE( nout, fmt = 9988 )path
697  END IF
698 *
699  ELSE IF( lsamen( 2, c2, 'SA' ) ) THEN
700 *
701 * SA: symmetric indefinite matrices,
702 * with partial (Aasen's) pivoting algorithm
703 *
704  ntypes = 10
705  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
706 *
707  IF( tstchk ) THEN
708  CALL schksy_aa( dotype, nn, nval, nnb2, nbval2, nns,
709  $ nsval, thresh, tsterr, lda,
710  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
711  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
712  $ work, rwork, iwork, nout )
713  ELSE
714  WRITE( nout, fmt = 9989 )path
715  END IF
716 *
717  IF( tstdrv ) THEN
718  CALL sdrvsy_aa( dotype, nn, nval, nrhs, thresh, tsterr,
719  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
720  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
721  $ work, rwork, iwork, nout )
722  ELSE
723  WRITE( nout, fmt = 9988 )path
724  END IF
725 *
726  ELSE IF( lsamen( 2, c2, 'S2' ) ) THEN
727 *
728 * SA: symmetric indefinite matrices,
729 * with partial (Aasen's) pivoting algorithm
730 *
731  ntypes = 10
732  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
733 *
734  IF( tstchk ) THEN
735  CALL schksy_aa_2stage( dotype, nn, nval, nnb2, nbval2,
736  $ nns, nsval, thresh, tsterr, lda,
737  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
738  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
739  $ work, rwork, iwork, nout )
740  ELSE
741  WRITE( nout, fmt = 9989 )path
742  END IF
743 *
744  IF( tstdrv ) THEN
745  CALL sdrvsy_aa_2stage(
746  $ dotype, nn, nval, nrhs, thresh, tsterr,
747  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
748  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
749  $ work, rwork, iwork, nout )
750  ELSE
751  WRITE( nout, fmt = 9988 )path
752  END IF
753 *
754  ELSE IF( lsamen( 2, c2, 'SP' ) ) THEN
755 *
756 * SP: symmetric indefinite packed matrices,
757 * with partial (Bunch-Kaufman) pivoting algorithm
758 *
759  ntypes = 10
760  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
761 *
762  IF( tstchk ) THEN
763  CALL schksp( dotype, nn, nval, nns, nsval, thresh, tsterr,
764  $ lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
765  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
766  $ iwork, nout )
767  ELSE
768  WRITE( nout, fmt = 9989 )path
769  END IF
770 *
771  IF( tstdrv ) THEN
772  CALL sdrvsp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
773  $ a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
774  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
775  $ nout )
776  ELSE
777  WRITE( nout, fmt = 9988 )path
778  END IF
779 *
780  ELSE IF( lsamen( 2, c2, 'TR' ) ) THEN
781 *
782 * TR: triangular matrices
783 *
784  ntypes = 18
785  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
786 *
787  IF( tstchk ) THEN
788  CALL schktr( dotype, nn, nval, nnb2, nbval2, nns, nsval,
789  $ thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
790  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
791  $ iwork, nout )
792  ELSE
793  WRITE( nout, fmt = 9989 )path
794  END IF
795 *
796  ELSE IF( lsamen( 2, c2, 'TP' ) ) THEN
797 *
798 * TP: triangular packed matrices
799 *
800  ntypes = 18
801  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
802 *
803  IF( tstchk ) THEN
804  CALL schktp( dotype, nn, nval, nns, nsval, thresh, tsterr,
805  $ lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
806  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
807  $ nout )
808  ELSE
809  WRITE( nout, fmt = 9989 )path
810  END IF
811 *
812  ELSE IF( lsamen( 2, c2, 'TB' ) ) THEN
813 *
814 * TB: triangular banded matrices
815 *
816  ntypes = 17
817  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
818 *
819  IF( tstchk ) THEN
820  CALL schktb( dotype, nn, nval, nns, nsval, thresh, tsterr,
821  $ lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
822  $ b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
823  $ nout )
824  ELSE
825  WRITE( nout, fmt = 9989 )path
826  END IF
827 *
828  ELSE IF( lsamen( 2, c2, 'QR' ) ) THEN
829 *
830 * QR: QR factorization
831 *
832  ntypes = 8
833  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
834 *
835  IF( tstchk ) THEN
836  CALL schkqr( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
837  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
838  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
839  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
840  $ work, rwork, iwork, nout )
841  ELSE
842  WRITE( nout, fmt = 9989 )path
843  END IF
844 *
845  ELSE IF( lsamen( 2, c2, 'LQ' ) ) THEN
846 *
847 * LQ: LQ factorization
848 *
849  ntypes = 8
850  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
851 *
852  IF( tstchk ) THEN
853  CALL schklq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
854  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
855  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
856  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
857  $ work, rwork, nout )
858  ELSE
859  WRITE( nout, fmt = 9989 )path
860  END IF
861 *
862  ELSE IF( lsamen( 2, c2, 'QL' ) ) THEN
863 *
864 * QL: QL factorization
865 *
866  ntypes = 8
867  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
868 *
869  IF( tstchk ) THEN
870  CALL schkql( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
871  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
872  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
873  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
874  $ work, rwork, nout )
875  ELSE
876  WRITE( nout, fmt = 9989 )path
877  END IF
878 *
879  ELSE IF( lsamen( 2, c2, 'RQ' ) ) THEN
880 *
881 * RQ: RQ factorization
882 *
883  ntypes = 8
884  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
885 *
886  IF( tstchk ) THEN
887  CALL schkrq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
888  $ nrhs, thresh, tsterr, nmax, a( 1, 1 ),
889  $ a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
890  $ b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
891  $ work, rwork, iwork, nout )
892  ELSE
893  WRITE( nout, fmt = 9989 )path
894  END IF
895 *
896  ELSE IF( lsamen( 2, c2, 'QP' ) ) THEN
897 *
898 * QP: QR factorization with pivoting
899 *
900  ntypes = 6
901  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
902 *
903  IF( tstchk ) THEN
904  CALL schkq3( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
905  $ thresh, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
906  $ b( 1, 3 ), work, iwork, nout )
907  ELSE
908  WRITE( nout, fmt = 9989 )path
909  END IF
910 *
911  ELSE IF( lsamen( 2, c2, 'TZ' ) ) THEN
912 *
913 * TZ: Trapezoidal matrix
914 *
915  ntypes = 3
916  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
917 *
918  IF( tstchk ) THEN
919  CALL schktz( dotype, nm, mval, nn, nval, thresh, tsterr,
920  $ a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
921  $ b( 1, 3 ), work, nout )
922  ELSE
923  WRITE( nout, fmt = 9989 )path
924  END IF
925 *
926  ELSE IF( lsamen( 2, c2, 'LS' ) ) THEN
927 *
928 * LS: Least squares drivers
929 *
930  ntypes = 6
931  CALL alareq( path, nmats, dotype, ntypes, nin, nout )
932 *
933  IF( tstdrv ) THEN
934  CALL sdrvls( dotype, nm, mval, nn, nval, nns, nsval, nnb,
935  $ nbval, nxval, thresh, tsterr, a( 1, 1 ),
936  $ a( 1, 2 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
937  $ rwork, rwork( nmax+1 ), nout )
938  ELSE
939  WRITE( nout, fmt = 9988 )path
940  END IF
941 *
942  ELSE IF( lsamen( 2, c2, 'EQ' ) ) THEN
943 *
944 * EQ: Equilibration routines for general and positive definite
945 * matrices (THREQ should be between 2 and 10)
946 *
947  IF( tstchk ) THEN
948  CALL schkeq( threq, nout )
949  ELSE
950  WRITE( nout, fmt = 9989 )path
951  END IF
952 *
953  ELSE IF( lsamen( 2, c2, 'QT' ) ) THEN
954 *
955 * QT: QRT routines for general matrices
956 *
957  IF( tstchk ) THEN
958  CALL schkqrt( thresh, tsterr, nm, mval, nn, nval, nnb,
959  $ nbval, nout )
960  ELSE
961  WRITE( nout, fmt = 9989 )path
962  END IF
963 *
964  ELSE IF( lsamen( 2, c2, 'QX' ) ) THEN
965 *
966 * QX: QRT routines for triangular-pentagonal matrices
967 *
968  IF( tstchk ) THEN
969  CALL schkqrtp( thresh, tsterr, nm, mval, nn, nval, nnb,
970  $ nbval, nout )
971  ELSE
972  WRITE( nout, fmt = 9989 )path
973  END IF
974 *
975  ELSE IF( lsamen( 2, c2, 'TQ' ) ) THEN
976 *
977 * TQ: LQT routines for general matrices
978 *
979  IF( tstchk ) THEN
980  CALL schklqt( thresh, tsterr, nm, mval, nn, nval, nnb,
981  $ nbval, nout )
982  ELSE
983  WRITE( nout, fmt = 9989 )path
984  END IF
985 *
986  ELSE IF( lsamen( 2, c2, 'XQ' ) ) THEN
987 *
988 * XQ: LQT routines for triangular-pentagonal matrices
989 *
990  IF( tstchk ) THEN
991  CALL schklqtp( thresh, tsterr, nm, mval, nn, nval, nnb,
992  $ nbval, nout )
993  ELSE
994  WRITE( nout, fmt = 9989 )path
995  END IF
996 *
997  ELSE IF( lsamen( 2, c2, 'TS' ) ) THEN
998 *
999 * TS: QR routines for tall-skinny matrices
1000 *
1001  IF( tstchk ) THEN
1002  CALL schktsqr( thresh, tsterr, nm, mval, nn, nval, nnb,
1003  $ nbval, nout )
1004  ELSE
1005  WRITE( nout, fmt = 9989 )path
1006  END IF
1007 *
1008  ELSE
1009 *
1010  WRITE( nout, fmt = 9990 )path
1011  END IF
1012 *
1013 * Go back to get another input line.
1014 *
1015  GO TO 80
1016 *
1017 * Branch to this line when the last record is read.
1018 *
1019  140 CONTINUE
1020  CLOSE ( nin )
1021  s2 = second( )
1022  WRITE( nout, fmt = 9998 )
1023  WRITE( nout, fmt = 9997 )s2 - s1
1024 *
1025  9999 FORMAT( / ' Execution not attempted due to input errors' )
1026  9998 FORMAT( / ' End of tests' )
1027  9997 FORMAT( ' Total time used = ', f12.2, ' seconds', / )
1028  9996 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be >=',
1029  $ i6 )
1030  9995 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be <=',
1031  $ i6 )
1032  9994 FORMAT( ' Tests of the REAL LAPACK routines ',
1033  $ / ' LAPACK VERSION ', i1, '.', i1, '.', i1,
1034  $ / / ' The following parameter values will be used:' )
1035  9993 FORMAT( 4x, a4, ': ', 10i6, / 11x, 10i6 )
1036  9992 FORMAT( / ' Routines pass computational tests if test ratio is ',
1037  $ 'less than', f8.2, / )
1038  9991 FORMAT( ' Relative machine ', a, ' is taken to be', e16.6 )
1039  9990 FORMAT( / 1x, a3, ': Unrecognized path name' )
1040  9989 FORMAT( / 1x, a3, ' routines were not tested' )
1041  9988 FORMAT( / 1x, a3, ' driver routines were not tested' )
1042 *
1043 * End of SCHKAA
1044 *
1045  END
subroutine schkgt(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKGT
Definition: schkgt.f:148
subroutine schkql(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
SCHKQL
Definition: schkql.f:198
subroutine sdrvpb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
SDRVPB
Definition: sdrvpb.f:166
subroutine schkrq(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)
SCHKRQ
Definition: schkrq.f:203
program schkaa
SCHKAA
Definition: schkaa.f:110
subroutine sdrvsy_aa(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVSY_AA
Definition: sdrvsy_aa.f:154
subroutine schkpo(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKPO
Definition: schkpo.f:174
subroutine sdrvsy(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVSY
Definition: sdrvsy.f:154
subroutine schkpt(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT)
SCHKPT
Definition: schkpt.f:148
subroutine schkgb(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A, LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKGB
Definition: schkgb.f:193
subroutine sdrvsy_rook(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVSY_ROOK
Definition: sdrvsy_rook.f:155
subroutine schksy_aa_2stage(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSY_AA_2STAGE
subroutine sdrvpp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
SDRVPP
Definition: sdrvpp.f:169
subroutine schktb(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKTB
Definition: schktb.f:157
subroutine schkeq(THRESH, NOUT)
SCHKEQ
Definition: schkeq.f:56
subroutine sdrvgb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
SDRVGB
Definition: sdrvgb.f:174
subroutine schkpp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKPP
Definition: schkpp.f:165
subroutine schktr(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKTR
Definition: schktr.f:169
subroutine schkps(DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A, AFAC, PERM, PIV, WORK, RWORK, NOUT)
SCHKPS
Definition: schkps.f:156
subroutine schktz(DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, NOUT)
SCHKTZ
Definition: schktz.f:134
subroutine sdrvsy_aa_2stage(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVSY_AA_2STAGE
subroutine schktsqr(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
SCHKQRT
Definition: schktsqr.f:104
subroutine schklq(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
SCHKLQ
Definition: schklq.f:198
subroutine schksy_aa(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSY_AA
Definition: schksy_aa.f:172
subroutine sdrvgt(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVGT
Definition: sdrvgt.f:141
subroutine schklqtp(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
SCHKLQTP
Definition: schklqtp.f:104
subroutine sdrvge(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
SDRVGE
Definition: sdrvge.f:166
subroutine schkq3(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S, TAU, WORK, IWORK, NOUT)
SCHKQ3
Definition: schkq3.f:155
subroutine sdrvsy_rk(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, E, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVSY_RK
Definition: sdrvsy_rk.f:158
subroutine schksy(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSY
Definition: schksy.f:172
subroutine schkqrt(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
SCHKQRT
Definition: schkqrt.f:102
subroutine schksp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSP
Definition: schksp.f:165
subroutine schklqt(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
SCHKLQT
Definition: schklqt.f:104
subroutine schkqr(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)
SCHKQR
Definition: schkqr.f:203
subroutine ilaver(VERS_MAJOR, VERS_MINOR, VERS_PATCH)
ILAVER returns the LAPACK version.
Definition: ilaver.f:50
subroutine sdrvpt(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT)
SDRVPT
Definition: sdrvpt.f:142
subroutine sdrvsp(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SDRVSP
Definition: sdrvsp.f:158
subroutine schksy_rook(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSY_ROOK
Definition: schksy_rook.f:173
subroutine schkpb(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKPB
Definition: schkpb.f:174
subroutine schktp(DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKTP
Definition: schktp.f:159
subroutine alareq(PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT)
ALAREQ
Definition: alareq.f:92
subroutine schkqrtp(THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
SCHKQRTP
Definition: schkqrtp.f:104
subroutine sdrvls(DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, NOUT)
SDRVLS
Definition: sdrvls.f:194
subroutine schksy_rk(DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, E, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSY_RK
Definition: schksy_rk.f:178
subroutine sdrvpo(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
SDRVPO
Definition: sdrvpo.f:166
subroutine schkge(DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKGE
Definition: schkge.f:187