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