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