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