OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
dchkpb.f
Go to the documentation of this file.
1*> \brief \b DCHKPB
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8* Definition:
9* ===========
10*
11* SUBROUTINE DCHKPB( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
12* THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
13* XACT, WORK, RWORK, IWORK, NOUT )
14*
15* .. Scalar Arguments ..
16* LOGICAL TSTERR
17* INTEGER NMAX, NN, NNB, NNS, NOUT
18* DOUBLE PRECISION THRESH
19* ..
20* .. Array Arguments ..
21* LOGICAL DOTYPE( * )
22* INTEGER IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
23* DOUBLE PRECISION A( * ), AFAC( * ), AINV( * ), B( * ),
24* $ RWORK( * ), WORK( * ), X( * ), XACT( * )
25* ..
26*
27*
28*> \par Purpose:
29* =============
30*>
31*> \verbatim
32*>
33*> DCHKPB tests DPBTRF, -TRS, -RFS, and -CON.
34*> \endverbatim
35*
36* Arguments:
37* ==========
38*
39*> \param[in] DOTYPE
40*> \verbatim
41*> DOTYPE is LOGICAL array, dimension (NTYPES)
42*> The matrix types to be used for testing. Matrices of type j
43*> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
44*> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
45*> \endverbatim
46*>
47*> \param[in] NN
48*> \verbatim
49*> NN is INTEGER
50*> The number of values of N contained in the vector NVAL.
51*> \endverbatim
52*>
53*> \param[in] NVAL
54*> \verbatim
55*> NVAL is INTEGER array, dimension (NN)
56*> The values of the matrix dimension N.
57*> \endverbatim
58*>
59*> \param[in] NNB
60*> \verbatim
61*> NNB is INTEGER
62*> The number of values of NB contained in the vector NBVAL.
63*> \endverbatim
64*>
65*> \param[in] NBVAL
66*> \verbatim
67*> NBVAL is INTEGER array, dimension (NNB)
68*> The values of the blocksize NB.
69*> \endverbatim
70*>
71*> \param[in] NNS
72*> \verbatim
73*> NNS is INTEGER
74*> The number of values of NRHS contained in the vector NSVAL.
75*> \endverbatim
76*>
77*> \param[in] NSVAL
78*> \verbatim
79*> NSVAL is INTEGER array, dimension (NNS)
80*> The values of the number of right hand sides NRHS.
81*> \endverbatim
82*>
83*> \param[in] THRESH
84*> \verbatim
85*> THRESH is DOUBLE PRECISION
86*> The threshold value for the test ratios. A result is
87*> included in the output file if RESULT >= THRESH. To have
88*> every test ratio printed, use THRESH = 0.
89*> \endverbatim
90*>
91*> \param[in] TSTERR
92*> \verbatim
93*> TSTERR is LOGICAL
94*> Flag that indicates whether error exits are to be tested.
95*> \endverbatim
96*>
97*> \param[in] NMAX
98*> \verbatim
99*> NMAX is INTEGER
100*> The maximum value permitted for N, used in dimensioning the
101*> work arrays.
102*> \endverbatim
103*>
104*> \param[out] A
105*> \verbatim
106*> A is DOUBLE PRECISION array, dimension (NMAX*NMAX)
107*> \endverbatim
108*>
109*> \param[out] AFAC
110*> \verbatim
111*> AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)
112*> \endverbatim
113*>
114*> \param[out] AINV
115*> \verbatim
116*> AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
117*> \endverbatim
118*>
119*> \param[out] B
120*> \verbatim
121*> B is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
122*> where NSMAX is the largest entry in NSVAL.
123*> \endverbatim
124*>
125*> \param[out] X
126*> \verbatim
127*> X is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
128*> \endverbatim
129*>
130*> \param[out] XACT
131*> \verbatim
132*> XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
133*> \endverbatim
134*>
135*> \param[out] WORK
136*> \verbatim
137*> WORK is DOUBLE PRECISION array, dimension
138*> (NMAX*max(3,NSMAX))
139*> \endverbatim
140*>
141*> \param[out] RWORK
142*> \verbatim
143*> RWORK is DOUBLE PRECISION array, dimension
144*> (max(NMAX,2*NSMAX))
145*> \endverbatim
146*>
147*> \param[out] IWORK
148*> \verbatim
149*> IWORK is INTEGER array, dimension (NMAX)
150*> \endverbatim
151*>
152*> \param[in] NOUT
153*> \verbatim
154*> NOUT is INTEGER
155*> The unit number for output.
156*> \endverbatim
157*
158* Authors:
159* ========
160*
161*> \author Univ. of Tennessee
162*> \author Univ. of California Berkeley
163*> \author Univ. of Colorado Denver
164*> \author NAG Ltd.
165*
166*> \ingroup double_lin
167*
168* =====================================================================
169 SUBROUTINE dchkpb( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
170 $ THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
171 $ XACT, WORK, RWORK, IWORK, NOUT )
172*
173* -- LAPACK test routine --
174* -- LAPACK is a software package provided by Univ. of Tennessee, --
175* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
176*
177* .. Scalar Arguments ..
178 LOGICAL TSTERR
179 INTEGER NMAX, NN, NNB, NNS, NOUT
180 DOUBLE PRECISION THRESH
181* ..
182* .. Array Arguments ..
183 LOGICAL DOTYPE( * )
184 INTEGER IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
185 DOUBLE PRECISION A( * ), AFAC( * ), AINV( * ), B( * ),
186 $ rwork( * ), work( * ), x( * ), xact( * )
187* ..
188*
189* =====================================================================
190*
191* .. Parameters ..
192 DOUBLE PRECISION ONE, ZERO
193 PARAMETER ( ONE = 1.0d+0, zero = 0.0d+0 )
194 INTEGER NTYPES, NTESTS
195 parameter( ntypes = 8, ntests = 7 )
196 INTEGER NBW
197 parameter( nbw = 4 )
198* ..
199* .. Local Scalars ..
200 LOGICAL ZEROT
201 CHARACTER DIST, PACKIT, TYPE, UPLO, XTYPE
202 CHARACTER*3 PATH
203 INTEGER I, I1, I2, IKD, IMAT, IN, INB, INFO, IOFF,
204 $ irhs, iuplo, iw, izero, k, kd, kl, koff, ku,
205 $ lda, ldab, mode, n, nb, nerrs, nfail, nimat,
206 $ nkd, nrhs, nrun
207 DOUBLE PRECISION AINVNM, ANORM, CNDNUM, RCOND, RCONDC
208* ..
209* .. Local Arrays ..
210 INTEGER ISEED( 4 ), ISEEDY( 4 ), KDVAL( NBW )
211 DOUBLE PRECISION RESULT( NTESTS )
212* ..
213* .. External Functions ..
214 DOUBLE PRECISION DGET06, DLANGE, DLANSB
215 EXTERNAL DGET06, DLANGE, DLANSB
216* ..
217* .. External Subroutines ..
218 EXTERNAL alaerh, alahd, alasum, dcopy, derrpo, dget04,
219 $ dlacpy, dlarhs, dlaset, dlatb4, dlatms, dpbcon,
220 $ dpbrfs, dpbt01, dpbt02, dpbt05, dpbtrf, dpbtrs,
221 $ dswap, xlaenv
222* ..
223* .. Intrinsic Functions ..
224 INTRINSIC max, min
225* ..
226* .. Scalars in Common ..
227 LOGICAL LERR, OK
228 CHARACTER*32 SRNAMT
229 INTEGER INFOT, NUNIT
230* ..
231* .. Common blocks ..
232 COMMON / infoc / infot, nunit, ok, lerr
233 COMMON / srnamc / srnamt
234* ..
235* .. Data statements ..
236 DATA iseedy / 1988, 1989, 1990, 1991 /
237* ..
238* .. Executable Statements ..
239*
240* Initialize constants and the random number seed.
241*
242 path( 1: 1 ) = 'Double precision'
243 path( 2: 3 ) = 'PB'
244 nrun = 0
245 nfail = 0
246 nerrs = 0
247 DO 10 i = 1, 4
248 iseed( i ) = iseedy( i )
249 10 CONTINUE
250*
251* Test the error exits
252*
253 IF( tsterr )
254 $ CALL derrpo( path, nout )
255 infot = 0
256 CALL xlaenv( 2, 2 )
257 kdval( 1 ) = 0
258*
259* Do for each value of N in NVAL
260*
261 DO 90 in = 1, nn
262 n = nval( in )
263 lda = max( n, 1 )
264 xtype = 'n'
265*
266* Set limits on the number of loop iterations.
267*
268 NKD = MAX( 1, MIN( N, 4 ) )
269 NIMAT = NTYPES
270.EQ. IF( N0 )
271 $ NIMAT = 1
272*
273 KDVAL( 2 ) = N + ( N+1 ) / 4
274 KDVAL( 3 ) = ( 3*N-1 ) / 4
275 KDVAL( 4 ) = ( N+1 ) / 4
276*
277 DO 80 IKD = 1, NKD
278*
279* Do for KD = 0, (5*N+1)/4, (3N-1)/4, and (N+1)/4. This order
280* makes it easier to skip redundant values for small values
281* of N.
282*
283 KD = KDVAL( IKD )
284 LDAB = KD + 1
285*
286* Do first for UPLO = 'U', then for UPLO = 'L'
287*
288 DO 70 IUPLO = 1, 2
289 KOFF = 1
290.EQ. IF( IUPLO1 ) THEN
291 UPLO = 'u'
292 KOFF = MAX( 1, KD+2-N )
293 PACKIT = 'q'
294 ELSE
295 UPLO = 'l'
296 PACKIT = 'b'
297 END IF
298*
299 DO 60 IMAT = 1, NIMAT
300*
301* Do the tests only if DOTYPE( IMAT ) is true.
302*
303.NOT. IF( DOTYPE( IMAT ) )
304 $ GO TO 60
305*
306* Skip types 2, 3, or 4 if the matrix size is too small.
307*
308.GE..AND..LE. ZEROT = IMAT2 IMAT4
309.AND..LT. IF( ZEROT NIMAT-1 )
310 $ GO TO 60
311*
312.NOT..OR..NOT. IF( ZEROT DOTYPE( 1 ) ) THEN
313*
314* Set up parameters with DLATB4 and generate a test
315* matrix with DLATMS.
316*
317 CALL DLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM,
318 $ MODE, CNDNUM, DIST )
319*
320 SRNAMT = 'dlatms'
321 CALL DLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
322 $ CNDNUM, ANORM, KD, KD, PACKIT,
323 $ A( KOFF ), LDAB, WORK, INFO )
324*
325* Check error code from DLATMS.
326*
327.NE. IF( INFO0 ) THEN
328 CALL ALAERH( PATH, 'dlatms', INFO, 0, UPLO, N,
329 $ N, KD, KD, -1, IMAT, NFAIL, NERRS,
330 $ NOUT )
331 GO TO 60
332 END IF
333.GT. ELSE IF( IZERO0 ) THEN
334*
335* Use the same matrix for types 3 and 4 as for type
336* 2 by copying back the zeroed out column,
337*
338 IW = 2*LDA + 1
339.EQ. IF( IUPLO1 ) THEN
340 IOFF = ( IZERO-1 )*LDAB + KD + 1
341 CALL DCOPY( IZERO-I1, WORK( IW ), 1,
342 $ A( IOFF-IZERO+I1 ), 1 )
343 IW = IW + IZERO - I1
344 CALL DCOPY( I2-IZERO+1, WORK( IW ), 1,
345 $ A( IOFF ), MAX( LDAB-1, 1 ) )
346 ELSE
347 IOFF = ( I1-1 )*LDAB + 1
348 CALL DCOPY( IZERO-I1, WORK( IW ), 1,
349 $ A( IOFF+IZERO-I1 ),
350 $ MAX( LDAB-1, 1 ) )
351 IOFF = ( IZERO-1 )*LDAB + 1
352 IW = IW + IZERO - I1
353 CALL DCOPY( I2-IZERO+1, WORK( IW ), 1,
354 $ A( IOFF ), 1 )
355 END IF
356 END IF
357*
358* For types 2-4, zero one row and column of the matrix
359* to test that INFO is returned correctly.
360*
361 IZERO = 0
362 IF( ZEROT ) THEN
363.EQ. IF( IMAT2 ) THEN
364 IZERO = 1
365.EQ. ELSE IF( IMAT3 ) THEN
366 IZERO = N
367 ELSE
368 IZERO = N / 2 + 1
369 END IF
370*
371* Save the zeroed out row and column in WORK(*,3)
372*
373 IW = 2*LDA
374 DO 20 I = 1, MIN( 2*KD+1, N )
375 WORK( IW+I ) = ZERO
376 20 CONTINUE
377 IW = IW + 1
378 I1 = MAX( IZERO-KD, 1 )
379 I2 = MIN( IZERO+KD, N )
380*
381.EQ. IF( IUPLO1 ) THEN
382 IOFF = ( IZERO-1 )*LDAB + KD + 1
383 CALL DSWAP( IZERO-I1, A( IOFF-IZERO+I1 ), 1,
384 $ WORK( IW ), 1 )
385 IW = IW + IZERO - I1
386 CALL DSWAP( I2-IZERO+1, A( IOFF ),
387 $ MAX( LDAB-1, 1 ), WORK( IW ), 1 )
388 ELSE
389 IOFF = ( I1-1 )*LDAB + 1
390 CALL DSWAP( IZERO-I1, A( IOFF+IZERO-I1 ),
391 $ MAX( LDAB-1, 1 ), WORK( IW ), 1 )
392 IOFF = ( IZERO-1 )*LDAB + 1
393 IW = IW + IZERO - I1
394 CALL DSWAP( I2-IZERO+1, A( IOFF ), 1,
395 $ WORK( IW ), 1 )
396 END IF
397 END IF
398*
399* Do for each value of NB in NBVAL
400*
401 DO 50 INB = 1, NNB
402 NB = NBVAL( INB )
403 CALL XLAENV( 1, NB )
404*
405* Compute the L*L' or U'*U factorization of the band
406* matrix.
407*
408 CALL DLACPY( 'full', KD+1, N, A, LDAB, AFAC, LDAB )
409 SRNAMT = 'dpbtrf'
410 CALL DPBTRF( UPLO, N, KD, AFAC, LDAB, INFO )
411*
412* Check error code from DPBTRF.
413*
414.NE. IF( INFOIZERO ) THEN
415 CALL ALAERH( PATH, 'dpbtrf', INFO, IZERO, UPLO,
416 $ N, N, KD, KD, NB, IMAT, NFAIL,
417 $ NERRS, NOUT )
418 GO TO 50
419 END IF
420*
421* Skip the tests if INFO is not 0.
422*
423.NE. IF( INFO0 )
424 $ GO TO 50
425*
426*+ TEST 1
427* Reconstruct matrix from factors and compute
428* residual.
429*
430 CALL DLACPY( 'full', KD+1, N, AFAC, LDAB, AINV,
431 $ LDAB )
432 CALL DPBT01( UPLO, N, KD, A, LDAB, AINV, LDAB,
433 $ RWORK, RESULT( 1 ) )
434*
435* Print the test ratio if it is .GE. THRESH.
436*
437.GE. IF( RESULT( 1 )THRESH ) THEN
438.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
439 $ CALL ALAHD( NOUT, PATH )
440 WRITE( NOUT, FMT = 9999 )UPLO, N, KD, NB, IMAT,
441 $ 1, RESULT( 1 )
442 NFAIL = NFAIL + 1
443 END IF
444 NRUN = NRUN + 1
445*
446* Only do other tests if this is the first blocksize.
447*
448.GT. IF( INB1 )
449 $ GO TO 50
450*
451* Form the inverse of A so we can get a good estimate
452* of RCONDC = 1/(norm(A) * norm(inv(A))).
453*
454 CALL DLASET( 'full', N, N, ZERO, ONE, AINV, LDA )
455 SRNAMT = 'dpbtrs'
456 CALL DPBTRS( UPLO, N, KD, N, AFAC, LDAB, AINV, LDA,
457 $ INFO )
458*
459* Compute RCONDC = 1/(norm(A) * norm(inv(A))).
460*
461 ANORM = DLANSB( '1', UPLO, N, KD, A, LDAB, RWORK )
462 AINVNM = DLANGE( '1', N, N, AINV, LDA, RWORK )
463.LE..OR..LE. IF( ANORMZERO AINVNMZERO ) THEN
464 RCONDC = ONE
465 ELSE
466 RCONDC = ( ONE / ANORM ) / AINVNM
467 END IF
468*
469 DO 40 IRHS = 1, NNS
470 NRHS = NSVAL( IRHS )
471*
472*+ TEST 2
473* Solve and compute residual for A * X = B.
474*
475 SRNAMT = 'dlarhs'
476 CALL DLARHS( PATH, XTYPE, UPLO, ' ', N, N, KD,
477 $ KD, NRHS, A, LDAB, XACT, LDA, B,
478 $ LDA, ISEED, INFO )
479 CALL DLACPY( 'full', N, NRHS, B, LDA, X, LDA )
480*
481 SRNAMT = 'dpbtrs'
482 CALL DPBTRS( UPLO, N, KD, NRHS, AFAC, LDAB, X,
483 $ LDA, INFO )
484*
485* Check error code from DPBTRS.
486*
487.NE. IF( INFO0 )
488 $ CALL ALAERH( PATH, 'dpbtrs', INFO, 0, UPLO,
489 $ N, N, KD, KD, NRHS, IMAT, NFAIL,
490 $ NERRS, NOUT )
491*
492 CALL DLACPY( 'full', N, NRHS, B, LDA, WORK,
493 $ LDA )
494 CALL DPBT02( UPLO, N, KD, NRHS, A, LDAB, X, LDA,
495 $ WORK, LDA, RWORK, RESULT( 2 ) )
496*
497*+ TEST 3
498* Check solution from generated exact solution.
499*
500 CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
501 $ RESULT( 3 ) )
502*
503*+ TESTS 4, 5, and 6
504* Use iterative refinement to improve the solution.
505*
506 SRNAMT = 'dpbrfs'
507 CALL DPBRFS( UPLO, N, KD, NRHS, A, LDAB, AFAC,
508 $ LDAB, B, LDA, X, LDA, RWORK,
509 $ RWORK( NRHS+1 ), WORK, IWORK,
510 $ INFO )
511*
512* Check error code from DPBRFS.
513*
514.NE. IF( INFO0 )
515 $ CALL ALAERH( PATH, 'dpbrfs', INFO, 0, UPLO,
516 $ N, N, KD, KD, NRHS, IMAT, NFAIL,
517 $ NERRS, NOUT )
518*
519 CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
520 $ RESULT( 4 ) )
521 CALL DPBT05( UPLO, N, KD, NRHS, A, LDAB, B, LDA,
522 $ X, LDA, XACT, LDA, RWORK,
523 $ RWORK( NRHS+1 ), RESULT( 5 ) )
524*
525* Print information about the tests that did not
526* pass the threshold.
527*
528 DO 30 K = 2, 6
529.GE. IF( RESULT( K )THRESH ) THEN
530.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
531 $ CALL ALAHD( NOUT, PATH )
532 WRITE( NOUT, FMT = 9998 )UPLO, N, KD,
533 $ NRHS, IMAT, K, RESULT( K )
534 NFAIL = NFAIL + 1
535 END IF
536 30 CONTINUE
537 NRUN = NRUN + 5
538 40 CONTINUE
539*
540*+ TEST 7
541* Get an estimate of RCOND = 1/CNDNUM.
542*
543 SRNAMT = 'dpbcon'
544 CALL DPBCON( UPLO, N, KD, AFAC, LDAB, ANORM, RCOND,
545 $ WORK, IWORK, INFO )
546*
547* Check error code from DPBCON.
548*
549.NE. IF( INFO0 )
550 $ CALL ALAERH( PATH, 'dpbcon', INFO, 0, UPLO, N,
551 $ N, KD, KD, -1, IMAT, NFAIL, NERRS,
552 $ NOUT )
553*
554 RESULT( 7 ) = DGET06( RCOND, RCONDC )
555*
556* Print the test ratio if it is .GE. THRESH.
557*
558.GE. IF( RESULT( 7 )THRESH ) THEN
559.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
560 $ CALL ALAHD( NOUT, PATH )
561 WRITE( NOUT, FMT = 9997 )UPLO, N, KD, IMAT, 7,
562 $ RESULT( 7 )
563 NFAIL = NFAIL + 1
564 END IF
565 NRUN = NRUN + 1
566 50 CONTINUE
567 60 CONTINUE
568 70 CONTINUE
569 80 CONTINUE
570 90 CONTINUE
571*
572* Print a summary of the results.
573*
574 CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS )
575*
576 9999 FORMAT( ' uplo=''', A1, ''', n=', I5, ', kd=', I5, ', nb=', I4,
577 $ ', type ', I2, ', test ', I2, ', ratio= ', G12.5 )
578 9998 FORMAT( ' uplo=''', A1, ''', n=', I5, ', kd=', I5, ', nrhs=', I3,
579 $ ', type ', I2, ', test(', I2, ') = ', G12.5 )
580 9997 FORMAT( ' uplo=''', A1, ''', n=', I5, ', kd=', I5, ',', 10X,
581 $ ' type ', I2, ', test(', I2, ') = ', G12.5 )
582 RETURN
583*
584* End of DCHKPB
585*
586 END
dlacpy
subroutine dlacpy(uplo, m, n, a, lda, b, ldb)
DLACPY copies all or part of one two-dimensional array to another.
Definition dlacpy.f:103
dlaset
subroutine dlaset(uplo, m, n, alpha, beta, a, lda)
DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition dlaset.f:110
xlaenv
subroutine xlaenv(ispec, nvalue)
XLAENV
Definition xlaenv.f:81
alasum
subroutine alasum(type, nout, nfail, nrun, nerrs)
ALASUM
Definition alasum.f:73
alahd
subroutine alahd(iounit, path)
ALAHD
Definition alahd.f:107
alaerh
subroutine alaerh(path, subnam, info, infoe, opts, m, n, kl, ku, n5, imat, nfail, nerrs, nout)
ALAERH
Definition alaerh.f:147
dpbtrs
subroutine dpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
DPBTRS
Definition dpbtrs.f:121
dpbcon
subroutine dpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info)
DPBCON
Definition dpbcon.f:132
dpbrfs
subroutine dpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info)
DPBRFS
Definition dpbrfs.f:189
dpbtrf
subroutine dpbtrf(uplo, n, kd, ab, ldab, info)
DPBTRF
Definition dpbtrf.f:142
dswap
subroutine dswap(n, dx, incx, dy, incy)
DSWAP
Definition dswap.f:82
dcopy
subroutine dcopy(n, dx, incx, dy, incy)
DCOPY
Definition dcopy.f:82
dlarhs
subroutine dlarhs(path, xtype, uplo, trans, m, n, kl, ku, nrhs, a, lda, x, ldx, b, ldb, iseed, info)
DLARHS
Definition dlarhs.f:205
dpbt05
subroutine dpbt05(uplo, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, xact, ldxact, ferr, berr, reslts)
DPBT05
Definition dpbt05.f:171
dpbt02
subroutine dpbt02(uplo, n, kd, nrhs, a, lda, x, ldx, b, ldb, rwork, resid)
DPBT02
Definition dpbt02.f:136
dchkpb
subroutine dchkpb(dotype, nn, nval, nnb, nbval, nns, nsval, thresh, tsterr, nmax, a, afac, ainv, b, x, xact, work, rwork, iwork, nout)
DCHKPB
Definition dchkpb.f:172
dpbt01
subroutine dpbt01(uplo, n, kd, a, lda, afac, ldafac, rwork, resid)
DPBT01
Definition dpbt01.f:119
dlatb4
subroutine dlatb4(path, imat, m, n, type, kl, ku, anorm, mode, cndnum, dist)
DLATB4
Definition dlatb4.f:120
derrpo
subroutine derrpo(path, nunit)
DERRPO
Definition derrpo.f:55
dget04
subroutine dget04(n, nrhs, x, ldx, xact, ldxact, rcond, resid)
DGET04
Definition dget04.f:102
dlatms
subroutine dlatms(m, n, dist, iseed, sym, d, mode, cond, dmax, kl, ku, pack, a, lda, work, info)
DLATMS
Definition dlatms.f:321
min
#define min(a, b)
Definition macros.h:20
max
#define max(a, b)
Definition macros.h:21