LAPACK  3.10.1
LAPACK: Linear Algebra PACKage
zdrvhex.f
Go to the documentation of this file.
1 *> \brief \b ZDRVHEX
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 ZDRVHE( 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 RWORK( * )
24 * COMPLEX*16 A( * ), AFAC( * ), AINV( * ), B( * ),
25 * $ WORK( * ), X( * ), XACT( * )
26 * ..
27 *
28 *
29 *> \par Purpose:
30 * =============
31 *>
32 *> \verbatim
33 *>
34 *> ZDRVHE tests the driver routines ZHESV, -SVX, and -SVXX.
35 *>
36 *> Note that this file is used only when the XBLAS are available,
37 *> otherwise zdrvhe.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 DOUBLE PRECISION
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*16 array, dimension (NMAX*NMAX)
94 *> \endverbatim
95 *>
96 *> \param[out] AFAC
97 *> \verbatim
98 *> AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
99 *> \endverbatim
100 *>
101 *> \param[out] AINV
102 *> \verbatim
103 *> AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
104 *> \endverbatim
105 *>
106 *> \param[out] B
107 *> \verbatim
108 *> B is COMPLEX*16 array, dimension (NMAX*NRHS)
109 *> \endverbatim
110 *>
111 *> \param[out] X
112 *> \verbatim
113 *> X is COMPLEX*16 array, dimension (NMAX*NRHS)
114 *> \endverbatim
115 *>
116 *> \param[out] XACT
117 *> \verbatim
118 *> XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
119 *> \endverbatim
120 *>
121 *> \param[out] WORK
122 *> \verbatim
123 *> WORK is COMPLEX*16 array, dimension
124 *> (NMAX*max(2,NRHS))
125 *> \endverbatim
126 *>
127 *> \param[out] RWORK
128 *> \verbatim
129 *> RWORK is DOUBLE PRECISION 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 complex16_lin
152 *
153 * =====================================================================
154  SUBROUTINE zdrvhe( 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  DOUBLE PRECISION THRESH
166 * ..
167 * .. Array Arguments ..
168  LOGICAL DOTYPE( * )
169  INTEGER IWORK( * ), NVAL( * )
170  DOUBLE PRECISION RWORK( * )
171  COMPLEX*16 A( * ), AFAC( * ), AINV( * ), B( * ),
172  $ work( * ), x( * ), xact( * )
173 * ..
174 *
175 * =====================================================================
176 *
177 * .. Parameters ..
178  DOUBLE PRECISION ONE, ZERO
179  PARAMETER ( ONE = 1.0d+0, zero = 0.0d+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  DOUBLE PRECISION 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  DOUBLE PRECISION RESULT( NTESTS ), BERR( NRHS ),
200  $ errbnds_n( nrhs, 3 ), errbnds_c( nrhs, 3 )
201 * ..
202 * .. External Functions ..
203  DOUBLE PRECISION DGET06, ZLANHE
204  EXTERNAL DGET06, ZLANHE
205 * ..
206 * .. External Subroutines ..
207  EXTERNAL aladhd, alaerh, alasvm, xlaenv, zerrvx, zget04,
210  $ zpot05, zhesvxx
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 dcmplx, 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 ) = 'Z'
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 zerrvx( 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 ZLATB4 and generate a test matrix
284 * with ZLATMS.
285 *
286  CALL zlatb4( path, imat, n, n, TYPE, KL, KU, ANORM, MODE,
287  $ CNDNUM, DIST )
288 *
289  srnamt = 'ZLATMS'
290  CALL zlatms( n, n, dist, iseed, TYPE, RWORK, MODE,
291  $ cndnum, anorm, kl, ku, uplo, a, lda, work,
292  $ info )
293 *
294 * Check error code from ZLATMS.
295 *
296  IF( info.NE.0 ) THEN
297  CALL alaerh( path, 'ZLATMS', 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 zlaipd( 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 ZHESVX.
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 = zlanhe( '1', uplo, n, a, lda, rwork )
392 *
393 * Factor the matrix A.
394 *
395  CALL zlacpy( uplo, n, n, a, lda, afac, lda )
396  CALL zhetrf( uplo, n, afac, lda, iwork, work,
397  $ lwork, info )
398 *
399 * Compute inv(A) and take its norm.
400 *
401  CALL zlacpy( uplo, n, n, afac, lda, ainv, lda )
402  lwork = (n+nb+1)*(nb+3)
403  CALL zhetri2( uplo, n, ainv, lda, iwork, work,
404  $ lwork, info )
405  ainvnm = zlanhe( '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 = 'ZLARHS'
419  CALL zlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
420  $ nrhs, a, lda, xact, lda, b, lda, iseed,
421  $ info )
422  xtype = 'C'
423 *
424 * --- Test ZHESV ---
425 *
426  IF( ifact.EQ.2 ) THEN
427  CALL zlacpy( uplo, n, n, a, lda, afac, lda )
428  CALL zlacpy( 'Full', n, nrhs, b, lda, x, lda )
429 *
430 * Factor the matrix and solve the system using ZHESV.
431 *
432  srnamt = 'ZHESV '
433  CALL zhesv( 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 ZHESV .
454 *
455  IF( info.NE.k ) THEN
456  CALL alaerh( path, 'ZHESV ', 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 zhet01( uplo, n, a, lda, afac, lda, iwork,
468  $ ainv, lda, rwork, result( 1 ) )
469 *
470 * Compute residual of the computed solution.
471 *
472  CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
473  CALL zpot02( uplo, n, nrhs, a, lda, x, lda, work,
474  $ lda, rwork, result( 2 ) )
475 *
476 * Check solution from generated exact solution.
477 *
478  CALL zget04( 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 )'ZHESV ', 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 ZHESVX ---
499 *
500  IF( ifact.EQ.2 )
501  $ CALL zlaset( uplo, n, n, dcmplx( zero ),
502  $ dcmplx( zero ), afac, lda )
503  CALL zlaset( 'Full', n, nrhs, dcmplx( zero ),
504  $ dcmplx( zero ), x, lda )
505 *
506 * Solve the system and compute the condition number and
507 * error bounds using ZHESVX.
508 *
509  srnamt = 'ZHESVX'
510  CALL zhesvx( 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 ZHESVX.
533 *
534  IF( info.NE.k ) THEN
535  CALL alaerh( path, 'ZHESVX', 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 zhet01( 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 zlacpy( 'Full', n, nrhs, b, lda, work, lda )
558  CALL zpot02( 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 zget04( n, nrhs, x, lda, xact, lda, rcondc,
564  $ result( 3 ) )
565 *
566 * Check the error bounds from iterative refinement.
567 *
568  CALL zpot05( 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 ZHESVX with the computed value
576 * in RCONDC.
577 *
578  result( 6 ) = dget06( 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 )'ZHESVX', 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 ZHESVXX ---
595 *
596 * Restore the matrices A and B.
597 *
598  IF( ifact.EQ.2 )
599  $ CALL zlaset( uplo, n, n, dcmplx( zero ),
600  $ dcmplx( zero ), afac, lda )
601  CALL zlaset( 'Full', n, nrhs, dcmplx( zero ),
602  $ dcmplx( zero ), x, lda )
603 *
604 * Solve the system and compute the condition number
605 * and error bounds using ZHESVXX.
606 *
607  srnamt = 'ZHESVXX'
608  n_err_bnds = 3
609  equed = 'N'
610  CALL zhesvxx( 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 ZHESVXX.
634 *
635  IF( info.NE.k .AND. info.LE.n) THEN
636  CALL alaerh( path, 'ZHESVXX', 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 zhet01( 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 zlacpy( 'Full', n, nrhs, b, lda, work, lda )
659  CALL zpot02( 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 zget04( n, nrhs, x, lda, xact, lda, rcondc,
666  $ result( 3 ) )
667 *
668 * Check the error bounds from iterative refinement.
669 *
670  CALL zpot05( 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 ZHESVXX with the computed value
678 * in RCONDC.
679 *
680  result( 6 ) = dget06( 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 )'ZHESVXX',
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 ZHESVXX
709 
710  CALL zebchvxx(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 ZDRVHEX
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 zlarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
ZLARHS
Definition: zlarhs.f:208
subroutine zebchvxx(THRESH, PATH)
ZEBCHVXX
Definition: zebchvxx.f:96
subroutine zhet01(UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZHET01
Definition: zhet01.f:126
subroutine zerrvx(PATH, NUNIT)
ZERRVX
Definition: zerrvx.f:55
subroutine zget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
ZGET04
Definition: zget04.f:102
subroutine zdrvhe(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZDRVHE
Definition: zdrvhe.f:153
subroutine zlaipd(N, A, INDA, VINDA)
ZLAIPD
Definition: zlaipd.f:83
subroutine zpot02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPOT02
Definition: zpot02.f:127
subroutine zlatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB4
Definition: zlatb4.f:121
subroutine zpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
ZPOT05
Definition: zpot05.f:165
subroutine zlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
ZLATMS
Definition: zlatms.f:332
subroutine zhetri2(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
ZHETRI2
Definition: zhetri2.f:127
subroutine zhetrf(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
ZHETRF
Definition: zhetrf.f:177
subroutine zhesvx(FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, LWORK, RWORK, INFO)
ZHESVX computes the solution to system of linear equations A * X = B for HE matrices
Definition: zhesvx.f:285
subroutine zhesv(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, INFO)
ZHESV computes the solution to system of linear equations A * X = B for HE matrices
Definition: zhesv.f:171
subroutine zhesvxx(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)
ZHESVXX computes the solution to system of linear equations A * X = B for HE matrices
Definition: zhesvxx.f:506
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:103
subroutine zlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
ZLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: zlaset.f:106