LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
ddrvsyx.f
Go to the documentation of this file.
1*> \brief \b DDRVSYX
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 DDRVSY( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
12* A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK,
13* NOUT )
14*
15* .. Scalar Arguments ..
16* LOGICAL TSTERR
17* INTEGER NMAX, NN, NOUT, NRHS
18* DOUBLE PRECISION THRESH
19* ..
20* .. Array Arguments ..
21* LOGICAL DOTYPE( * )
22* INTEGER IWORK( * ), 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*> DDRVSY tests the driver routines DSYSV, -SVX, and -SVXX.
34*>
35*> Note that this file is used only when the XBLAS are available,
36*> otherwise ddrvsy.f defines this subroutine.
37*> \endverbatim
38*
39* Arguments:
40* ==========
41*
42*> \param[in] DOTYPE
43*> \verbatim
44*> DOTYPE is LOGICAL array, dimension (NTYPES)
45*> The matrix types to be used for testing. Matrices of type j
46*> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
47*> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
48*> \endverbatim
49*>
50*> \param[in] NN
51*> \verbatim
52*> NN is INTEGER
53*> The number of values of N contained in the vector NVAL.
54*> \endverbatim
55*>
56*> \param[in] NVAL
57*> \verbatim
58*> NVAL is INTEGER array, dimension (NN)
59*> The values of the matrix dimension N.
60*> \endverbatim
61*>
62*> \param[in] NRHS
63*> \verbatim
64*> NRHS is INTEGER
65*> The number of right hand side vectors to be generated for
66*> each linear system.
67*> \endverbatim
68*>
69*> \param[in] THRESH
70*> \verbatim
71*> THRESH is DOUBLE PRECISION
72*> The threshold value for the test ratios. A result is
73*> included in the output file if RESULT >= THRESH. To have
74*> every test ratio printed, use THRESH = 0.
75*> \endverbatim
76*>
77*> \param[in] TSTERR
78*> \verbatim
79*> TSTERR is LOGICAL
80*> Flag that indicates whether error exits are to be tested.
81*> \endverbatim
82*>
83*> \param[in] NMAX
84*> \verbatim
85*> NMAX is INTEGER
86*> The maximum value permitted for N, used in dimensioning the
87*> work arrays.
88*> \endverbatim
89*>
90*> \param[out] A
91*> \verbatim
92*> A is DOUBLE PRECISION array, dimension (NMAX*NMAX)
93*> \endverbatim
94*>
95*> \param[out] AFAC
96*> \verbatim
97*> AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)
98*> \endverbatim
99*>
100*> \param[out] AINV
101*> \verbatim
102*> AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
103*> \endverbatim
104*>
105*> \param[out] B
106*> \verbatim
107*> B is DOUBLE PRECISION array, dimension (NMAX*NRHS)
108*> \endverbatim
109*>
110*> \param[out] X
111*> \verbatim
112*> X is DOUBLE PRECISION array, dimension (NMAX*NRHS)
113*> \endverbatim
114*>
115*> \param[out] XACT
116*> \verbatim
117*> XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS)
118*> \endverbatim
119*>
120*> \param[out] WORK
121*> \verbatim
122*> WORK is DOUBLE PRECISION array, dimension
123*> (NMAX*max(2,NRHS))
124*> \endverbatim
125*>
126*> \param[out] RWORK
127*> \verbatim
128*> RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
129*> \endverbatim
130*>
131*> \param[out] IWORK
132*> \verbatim
133*> IWORK is INTEGER array, dimension (2*NMAX)
134*> \endverbatim
135*>
136*> \param[in] NOUT
137*> \verbatim
138*> NOUT is INTEGER
139*> The unit number for output.
140*> \endverbatim
141*
142* Authors:
143* ========
144*
145*> \author Univ. of Tennessee
146*> \author Univ. of California Berkeley
147*> \author Univ. of Colorado Denver
148*> \author NAG Ltd.
149*
150*> \ingroup double_lin
151*
152* =====================================================================
153 SUBROUTINE ddrvsy( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
154 $ A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK,
155 $ NOUT )
156*
157* -- LAPACK test routine --
158* -- LAPACK is a software package provided by Univ. of Tennessee, --
159* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
160*
161* .. Scalar Arguments ..
162 LOGICAL TSTERR
163 INTEGER NMAX, NN, NOUT, NRHS
164 DOUBLE PRECISION THRESH
165* ..
166* .. Array Arguments ..
167 LOGICAL DOTYPE( * )
168 INTEGER IWORK( * ), NVAL( * )
169 DOUBLE PRECISION A( * ), AFAC( * ), AINV( * ), B( * ),
170 $ rwork( * ), work( * ), x( * ), xact( * )
171* ..
172*
173* =====================================================================
174*
175* .. Parameters ..
176 DOUBLE PRECISION ONE, ZERO
177 PARAMETER ( ONE = 1.0d+0, zero = 0.0d+0 )
178 INTEGER NTYPES, NTESTS
179 parameter( ntypes = 10, ntests = 6 )
180 INTEGER NFACT
181 parameter( nfact = 2 )
182* ..
183* .. Local Scalars ..
184 LOGICAL ZEROT
185 CHARACTER DIST, EQUED, FACT, TYPE, UPLO, XTYPE
186 CHARACTER*3 PATH
187 INTEGER I, I1, I2, IFACT, IMAT, IN, INFO, IOFF, IUPLO,
188 $ izero, j, k, k1, kl, ku, lda, lwork, mode, n,
189 $ nb, nbmin, nerrs, nfail, nimat, nrun, nt,
190 $ n_err_bnds
191 DOUBLE PRECISION AINVNM, ANORM, CNDNUM, RCOND, RCONDC,
192 $ RPVGRW_SVXX
193* ..
194* .. Local Arrays ..
195 CHARACTER FACTS( NFACT ), UPLOS( 2 )
196 INTEGER ISEED( 4 ), ISEEDY( 4 )
197 DOUBLE PRECISION RESULT( NTESTS ), BERR( NRHS ),
198 $ errbnds_n( nrhs, 3 ), errbnds_c( nrhs, 3 )
199* ..
200* .. External Functions ..
201 DOUBLE PRECISION DGET06, DLANSY
202 EXTERNAL DGET06, DLANSY
203* ..
204* .. External Subroutines ..
205 EXTERNAL aladhd, alaerh, alasvm, derrvx, dget04, dlacpy,
208 $ dsysvxx
209* ..
210* .. Scalars in Common ..
211 LOGICAL LERR, OK
212 CHARACTER*32 SRNAMT
213 INTEGER INFOT, NUNIT
214* ..
215* .. Common blocks ..
216 COMMON / infoc / infot, nunit, ok, lerr
217 COMMON / srnamc / srnamt
218* ..
219* .. Intrinsic Functions ..
220 INTRINSIC max, min
221* ..
222* .. Data statements ..
223 DATA iseedy / 1988, 1989, 1990, 1991 /
224 DATA uplos / 'U', 'L' / , facts / 'F', 'N' /
225* ..
226* .. Executable Statements ..
227*
228* Initialize constants and the random number seed.
229*
230 path( 1: 1 ) = 'Double precision'
231 path( 2: 3 ) = 'SY'
232 nrun = 0
233 nfail = 0
234 nerrs = 0
235 DO 10 i = 1, 4
236 iseed( i ) = iseedy( i )
237 10 CONTINUE
238 lwork = max( 2*nmax, nmax*nrhs )
239*
240* Test the error exits
241*
242 IF( tsterr )
243 $ CALL derrvx( path, nout )
244 infot = 0
245*
246* Set the block size and minimum block size for testing.
247*
248 nb = 1
249 nbmin = 2
250 CALL xlaenv( 1, nb )
251 CALL xlaenv( 2, nbmin )
252*
253* Do for each value of N in NVAL
254*
255 DO 180 in = 1, nn
256 n = nval( in )
257 lda = max( n, 1 )
258 xtype = 'N'
259 nimat = ntypes
260 IF( n.LE.0 )
261 $ nimat = 1
262*
263 DO 170 imat = 1, nimat
264*
265* Do the tests only if DOTYPE( IMAT ) is true.
266*
267 IF( .NOT.dotype( imat ) )
268 $ GO TO 170
269*
270* Skip types 3, 4, 5, or 6 if the matrix size is too small.
271*
272 zerot = imat.GE.3 .AND. imat.LE.6
273 IF( zerot .AND. n.LT.imat-2 )
274 $ GO TO 170
275*
276* Do first for UPLO = 'U', then for UPLO = 'L'
277*
278 DO 160 iuplo = 1, 2
279 uplo = uplos( iuplo )
280*
281* Set up parameters with DLATB4 and generate a test matrix
282* with DLATMS.
283*
284 CALL dlatb4( path, imat, n, n, TYPE, kl, ku, anorm, mode,
285 $ cndnum, dist )
286*
287 srnamt = 'DLATMS'
288 CALL dlatms( n, n, dist, iseed, TYPE, rwork, mode,
289 $ cndnum, anorm, kl, ku, uplo, a, lda, work,
290 $ info )
291*
292* Check error code from DLATMS.
293*
294 IF( info.NE.0 ) THEN
295 CALL alaerh( path, 'DLATMS', info, 0, uplo, n, n, -1,
296 $ -1, -1, imat, nfail, nerrs, nout )
297 GO TO 160
298 END IF
299*
300* For types 3-6, zero one or more rows and columns of the
301* matrix to test that INFO is returned correctly.
302*
303 IF( zerot ) THEN
304 IF( imat.EQ.3 ) THEN
305 izero = 1
306 ELSE IF( imat.EQ.4 ) THEN
307 izero = n
308 ELSE
309 izero = n / 2 + 1
310 END IF
311*
312 IF( imat.LT.6 ) THEN
313*
314* Set row and column IZERO to zero.
315*
316 IF( iuplo.EQ.1 ) THEN
317 ioff = ( izero-1 )*lda
318 DO 20 i = 1, izero - 1
319 a( ioff+i ) = zero
320 20 CONTINUE
321 ioff = ioff + izero
322 DO 30 i = izero, n
323 a( ioff ) = zero
324 ioff = ioff + lda
325 30 CONTINUE
326 ELSE
327 ioff = izero
328 DO 40 i = 1, izero - 1
329 a( ioff ) = zero
330 ioff = ioff + lda
331 40 CONTINUE
332 ioff = ioff - izero
333 DO 50 i = izero, n
334 a( ioff+i ) = zero
335 50 CONTINUE
336 END IF
337 ELSE
338 ioff = 0
339 IF( iuplo.EQ.1 ) THEN
340*
341* Set the first IZERO rows and columns to zero.
342*
343 DO 70 j = 1, n
344 i2 = min( j, izero )
345 DO 60 i = 1, i2
346 a( ioff+i ) = zero
347 60 CONTINUE
348 ioff = ioff + lda
349 70 CONTINUE
350 ELSE
351*
352* Set the last IZERO rows and columns to zero.
353*
354 DO 90 j = 1, n
355 i1 = max( j, izero )
356 DO 80 i = i1, n
357 a( ioff+i ) = zero
358 80 CONTINUE
359 ioff = ioff + lda
360 90 CONTINUE
361 END IF
362 END IF
363 ELSE
364 izero = 0
365 END IF
366*
367 DO 150 ifact = 1, nfact
368*
369* Do first for FACT = 'F', then for other values.
370*
371 fact = facts( ifact )
372*
373* Compute the condition number for comparison with
374* the value returned by DSYSVX.
375*
376 IF( zerot ) THEN
377 IF( ifact.EQ.1 )
378 $ GO TO 150
379 rcondc = zero
380*
381 ELSE IF( ifact.EQ.1 ) THEN
382*
383* Compute the 1-norm of A.
384*
385 anorm = dlansy( '1', uplo, n, a, lda, rwork )
386*
387* Factor the matrix A.
388*
389 CALL dlacpy( uplo, n, n, a, lda, afac, lda )
390 CALL dsytrf( uplo, n, afac, lda, iwork, work,
391 $ lwork, info )
392*
393* Compute inv(A) and take its norm.
394*
395 CALL dlacpy( uplo, n, n, afac, lda, ainv, lda )
396 lwork = (n+nb+1)*(nb+3)
397 CALL dsytri2( uplo, n, ainv, lda, iwork, work,
398 $ lwork, info )
399 ainvnm = dlansy( '1', uplo, n, ainv, lda, rwork )
400*
401* Compute the 1-norm condition number of A.
402*
403 IF( anorm.LE.zero .OR. ainvnm.LE.zero ) THEN
404 rcondc = one
405 ELSE
406 rcondc = ( one / anorm ) / ainvnm
407 END IF
408 END IF
409*
410* Form an exact solution and set the right hand side.
411*
412 srnamt = 'DLARHS'
413 CALL dlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
414 $ nrhs, a, lda, xact, lda, b, lda, iseed,
415 $ info )
416 xtype = 'C'
417*
418* --- Test DSYSV ---
419*
420 IF( ifact.EQ.2 ) THEN
421 CALL dlacpy( uplo, n, n, a, lda, afac, lda )
422 CALL dlacpy( 'Full', n, nrhs, b, lda, x, lda )
423*
424* Factor the matrix and solve the system using DSYSV.
425*
426 srnamt = 'DSYSV '
427 CALL dsysv( uplo, n, nrhs, afac, lda, iwork, x,
428 $ lda, work, lwork, info )
429*
430* Adjust the expected value of INFO to account for
431* pivoting.
432*
433 k = izero
434 IF( k.GT.0 ) THEN
435 100 CONTINUE
436 IF( iwork( k ).LT.0 ) THEN
437 IF( iwork( k ).NE.-k ) THEN
438 k = -iwork( k )
439 GO TO 100
440 END IF
441 ELSE IF( iwork( k ).NE.k ) THEN
442 k = iwork( k )
443 GO TO 100
444 END IF
445 END IF
446*
447* Check error code from DSYSV .
448*
449 IF( info.NE.k ) THEN
450 CALL alaerh( path, 'DSYSV ', info, k, uplo, n,
451 $ n, -1, -1, nrhs, imat, nfail,
452 $ nerrs, nout )
453 GO TO 120
454 ELSE IF( info.NE.0 ) THEN
455 GO TO 120
456 END IF
457*
458* Reconstruct matrix from factors and compute
459* residual.
460*
461 CALL dsyt01( uplo, n, a, lda, afac, lda, iwork,
462 $ ainv, lda, rwork, result( 1 ) )
463*
464* Compute residual of the computed solution.
465*
466 CALL dlacpy( 'Full', n, nrhs, b, lda, work, lda )
467 CALL dpot02( uplo, n, nrhs, a, lda, x, lda, work,
468 $ lda, rwork, result( 2 ) )
469*
470* Check solution from generated exact solution.
471*
472 CALL dget04( n, nrhs, x, lda, xact, lda, rcondc,
473 $ result( 3 ) )
474 nt = 3
475*
476* Print information about the tests that did not pass
477* the threshold.
478*
479 DO 110 k = 1, nt
480 IF( result( k ).GE.thresh ) THEN
481 IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
482 $ CALL aladhd( nout, path )
483 WRITE( nout, fmt = 9999 )'DSYSV ', uplo, n,
484 $ imat, k, result( k )
485 nfail = nfail + 1
486 END IF
487 110 CONTINUE
488 nrun = nrun + nt
489 120 CONTINUE
490 END IF
491*
492* --- Test DSYSVX ---
493*
494 IF( ifact.EQ.2 )
495 $ CALL dlaset( uplo, n, n, zero, zero, afac, lda )
496 CALL dlaset( 'Full', n, nrhs, zero, zero, x, lda )
497*
498* Solve the system and compute the condition number and
499* error bounds using DSYSVX.
500*
501 srnamt = 'DSYSVX'
502 CALL dsysvx( fact, uplo, n, nrhs, a, lda, afac, lda,
503 $ iwork, b, lda, x, lda, rcond, rwork,
504 $ rwork( nrhs+1 ), work, lwork,
505 $ iwork( n+1 ), info )
506*
507* Adjust the expected value of INFO to account for
508* pivoting.
509*
510 k = izero
511 IF( k.GT.0 ) THEN
512 130 CONTINUE
513 IF( iwork( k ).LT.0 ) THEN
514 IF( iwork( k ).NE.-k ) THEN
515 k = -iwork( k )
516 GO TO 130
517 END IF
518 ELSE IF( iwork( k ).NE.k ) THEN
519 k = iwork( k )
520 GO TO 130
521 END IF
522 END IF
523*
524* Check the error code from DSYSVX.
525*
526 IF( info.NE.k ) THEN
527 CALL alaerh( path, 'DSYSVX', info, k, fact // uplo,
528 $ n, n, -1, -1, nrhs, imat, nfail,
529 $ nerrs, nout )
530 GO TO 150
531 END IF
532*
533 IF( info.EQ.0 ) THEN
534 IF( ifact.GE.2 ) THEN
535*
536* Reconstruct matrix from factors and compute
537* residual.
538*
539 CALL dsyt01( uplo, n, a, lda, afac, lda, iwork,
540 $ ainv, lda, rwork( 2*nrhs+1 ),
541 $ result( 1 ) )
542 k1 = 1
543 ELSE
544 k1 = 2
545 END IF
546*
547* Compute residual of the computed solution.
548*
549 CALL dlacpy( 'Full', n, nrhs, b, lda, work, lda )
550 CALL dpot02( uplo, n, nrhs, a, lda, x, lda, work,
551 $ lda, rwork( 2*nrhs+1 ), result( 2 ) )
552*
553* Check solution from generated exact solution.
554*
555 CALL dget04( n, nrhs, x, lda, xact, lda, rcondc,
556 $ result( 3 ) )
557*
558* Check the error bounds from iterative refinement.
559*
560 CALL dpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
561 $ xact, lda, rwork, rwork( nrhs+1 ),
562 $ result( 4 ) )
563 ELSE
564 k1 = 6
565 END IF
566*
567* Compare RCOND from DSYSVX with the computed value
568* in RCONDC.
569*
570 result( 6 ) = dget06( rcond, rcondc )
571*
572* Print information about the tests that did not pass
573* the threshold.
574*
575 DO 140 k = k1, 6
576 IF( result( k ).GE.thresh ) THEN
577 IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
578 $ CALL aladhd( nout, path )
579 WRITE( nout, fmt = 9998 )'DSYSVX', fact, uplo,
580 $ n, imat, k, result( k )
581 nfail = nfail + 1
582 END IF
583 140 CONTINUE
584 nrun = nrun + 7 - k1
585*
586* --- Test DSYSVXX ---
587*
588* Restore the matrices A and B.
589*
590 IF( ifact.EQ.2 )
591 $ CALL dlaset( uplo, n, n, zero, zero, afac, lda )
592 CALL dlaset( 'Full', n, nrhs, zero, zero, x, lda )
593*
594* Solve the system and compute the condition number
595* and error bounds using DSYSVXX.
596*
597 srnamt = 'DSYSVXX'
598 n_err_bnds = 3
599 equed = 'N'
600 CALL dsysvxx( fact, uplo, n, nrhs, a, lda, afac,
601 $ lda, iwork, equed, work( n+1 ), b, lda, x,
602 $ lda, rcond, rpvgrw_svxx, berr, n_err_bnds,
603 $ errbnds_n, errbnds_c, 0, zero, work,
604 $ iwork( n+1 ), info )
605*
606* Adjust the expected value of INFO to account for
607* pivoting.
608*
609 k = izero
610 IF( k.GT.0 ) THEN
611 135 CONTINUE
612 IF( iwork( k ).LT.0 ) THEN
613 IF( iwork( k ).NE.-k ) THEN
614 k = -iwork( k )
615 GO TO 135
616 END IF
617 ELSE IF( iwork( k ).NE.k ) THEN
618 k = iwork( k )
619 GO TO 135
620 END IF
621 END IF
622*
623* Check the error code from DSYSVXX.
624*
625 IF( info.NE.k .AND. info.LE.n ) THEN
626 CALL alaerh( path, 'DSYSVXX', info, k,
627 $ fact // uplo, n, n, -1, -1, nrhs, imat, nfail,
628 $ nerrs, nout )
629 GO TO 150
630 END IF
631*
632 IF( info.EQ.0 ) THEN
633 IF( ifact.GE.2 ) THEN
634*
635* Reconstruct matrix from factors and compute
636* residual.
637*
638 CALL dsyt01( uplo, n, a, lda, afac, lda, iwork,
639 $ ainv, lda, rwork(2*nrhs+1),
640 $ result( 1 ) )
641 k1 = 1
642 ELSE
643 k1 = 2
644 END IF
645*
646* Compute residual of the computed solution.
647*
648 CALL dlacpy( 'Full', n, nrhs, b, lda, work, lda )
649 CALL dpot02( uplo, n, nrhs, a, lda, x, lda, work,
650 $ lda, rwork( 2*nrhs+1 ), result( 2 ) )
651*
652* Check solution from generated exact solution.
653*
654 CALL dget04( n, nrhs, x, lda, xact, lda, rcondc,
655 $ result( 3 ) )
656*
657* Check the error bounds from iterative refinement.
658*
659 CALL dpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
660 $ xact, lda, rwork, rwork( nrhs+1 ),
661 $ result( 4 ) )
662 ELSE
663 k1 = 6
664 END IF
665*
666* Compare RCOND from DSYSVXX with the computed value
667* in RCONDC.
668*
669 result( 6 ) = dget06( rcond, rcondc )
670*
671* Print information about the tests that did not pass
672* the threshold.
673*
674 DO 85 k = k1, 6
675 IF( result( k ).GE.thresh ) THEN
676 IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
677 $ CALL aladhd( nout, path )
678 WRITE( nout, fmt = 9998 )'DSYSVXX',
679 $ fact, uplo, n, imat, k,
680 $ result( k )
681 nfail = nfail + 1
682 END IF
683 85 CONTINUE
684 nrun = nrun + 7 - k1
685*
686 150 CONTINUE
687*
688 160 CONTINUE
689 170 CONTINUE
690 180 CONTINUE
691*
692* Print a summary of the results.
693*
694 CALL alasvm( path, nout, nfail, nrun, nerrs )
695*
696
697* Test Error Bounds from DSYSVXX
698
699 CALL debchvxx(thresh, path)
700
701 9999 FORMAT( 1x, a, ', UPLO=''', a1, ''', N =', i5, ', type ', i2,
702 $ ', test ', i2, ', ratio =', g12.5 )
703 9998 FORMAT( 1x, a, ', FACT=''', a1, ''', UPLO=''', a1, ''', N =', i5,
704 $ ', type ', i2, ', test ', i2, ', ratio =', g12.5 )
705 RETURN
706*
707* End of DDRVSYX
708*
709 END
subroutine alasvm(type, nout, nfail, nrun, nerrs)
ALASVM
Definition alasvm.f:73
subroutine dlarhs(path, xtype, uplo, trans, m, n, kl, ku, nrhs, a, lda, x, ldx, b, ldb, iseed, info)
DLARHS
Definition dlarhs.f:205
subroutine xlaenv(ispec, nvalue)
XLAENV
Definition xlaenv.f:81
subroutine aladhd(iounit, path)
ALADHD
Definition aladhd.f:90
subroutine alaerh(path, subnam, info, infoe, opts, m, n, kl, ku, n5, imat, nfail, nerrs, nout)
ALAERH
Definition alaerh.f:147
subroutine ddrvsy(dotype, nn, nval, nrhs, thresh, tsterr, nmax, a, afac, ainv, b, x, xact, work, rwork, iwork, nout)
DDRVSY
Definition ddrvsy.f:152
subroutine debchvxx(thresh, path)
DEBCHVXX
Definition debchvxx.f:96
subroutine derrvx(path, nunit)
DERRVX
Definition derrvx.f:55
subroutine dget04(n, nrhs, x, ldx, xact, ldxact, rcond, resid)
DGET04
Definition dget04.f:102
subroutine dlatb4(path, imat, m, n, type, kl, ku, anorm, mode, cndnum, dist)
DLATB4
Definition dlatb4.f:120
subroutine dlatms(m, n, dist, iseed, sym, d, mode, cond, dmax, kl, ku, pack, a, lda, work, info)
DLATMS
Definition dlatms.f:321
subroutine dpot02(uplo, n, nrhs, a, lda, x, ldx, b, ldb, rwork, resid)
DPOT02
Definition dpot02.f:127
subroutine dpot05(uplo, n, nrhs, a, lda, b, ldb, x, ldx, xact, ldxact, ferr, berr, reslts)
DPOT05
Definition dpot05.f:164
subroutine dsyt01(uplo, n, a, lda, afac, ldafac, ipiv, c, ldc, rwork, resid)
DSYT01
Definition dsyt01.f:124
subroutine dsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
DSYSV computes the solution to system of linear equations A * X = B for SY matrices
Definition dsysv.f:171
subroutine dsysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info)
DSYSVX computes the solution to system of linear equations A * X = B for SY matrices
Definition dsysvx.f:284
subroutine dsysvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, iwork, info)
DSYSVXX
Definition dsysvxx.f:505
subroutine dsytrf(uplo, n, a, lda, ipiv, work, lwork, info)
DSYTRF
Definition dsytrf.f:182
subroutine dsytri2(uplo, n, a, lda, ipiv, work, lwork, info)
DSYTRI2
Definition dsytri2.f:127
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
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