LAPACK  3.10.1
LAPACK: Linear Algebra PACKage
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,
210  $ cpot05, xlaenv, chesvxx
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 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 clarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
CLARHS
Definition: clarhs.f:208
subroutine cpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
CPOT05
Definition: cpot05.f:165
subroutine clatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
CLATB4
Definition: clatb4.f:121
subroutine cget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
CGET04
Definition: cget04.f:102
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 chet01(UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
CHET01
Definition: chet01.f:126
subroutine cebchvxx(THRESH, PATH)
CEBCHVXX
Definition: cebchvxx.f:96
subroutine claipd(N, A, INDA, VINDA)
CLAIPD
Definition: claipd.f:83
subroutine cpot02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
CPOT02
Definition: cpot02.f:127
subroutine cerrvx(PATH, NUNIT)
CERRVX
Definition: cerrvx.f:55
subroutine clatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
CLATMS
Definition: clatms.f:332
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 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 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 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 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
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