LAPACK  3.10.1
LAPACK: Linear Algebra PACKage
zdrvpb.f
Go to the documentation of this file.
1 *> \brief \b ZDRVPB
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 ZDRVPB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
12 * A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK,
13 * RWORK, 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 NVAL( * )
23 * DOUBLE PRECISION RWORK( * ), S( * )
24 * COMPLEX*16 A( * ), AFAC( * ), ASAV( * ), B( * ),
25 * $ BSAV( * ), WORK( * ), X( * ), XACT( * )
26 * ..
27 *
28 *
29 *> \par Purpose:
30 * =============
31 *>
32 *> \verbatim
33 *>
34 *> ZDRVPB tests the driver routines ZPBSV and -SVX.
35 *> \endverbatim
36 *
37 * Arguments:
38 * ==========
39 *
40 *> \param[in] DOTYPE
41 *> \verbatim
42 *> DOTYPE is LOGICAL array, dimension (NTYPES)
43 *> The matrix types to be used for testing. Matrices of type j
44 *> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
45 *> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
46 *> \endverbatim
47 *>
48 *> \param[in] NN
49 *> \verbatim
50 *> NN is INTEGER
51 *> The number of values of N contained in the vector NVAL.
52 *> \endverbatim
53 *>
54 *> \param[in] NVAL
55 *> \verbatim
56 *> NVAL is INTEGER array, dimension (NN)
57 *> The values of the matrix dimension N.
58 *> \endverbatim
59 *>
60 *> \param[in] NRHS
61 *> \verbatim
62 *> NRHS is INTEGER
63 *> The number of right hand side vectors to be generated for
64 *> each linear system.
65 *> \endverbatim
66 *>
67 *> \param[in] THRESH
68 *> \verbatim
69 *> THRESH is DOUBLE PRECISION
70 *> The threshold value for the test ratios. A result is
71 *> included in the output file if RESULT >= THRESH. To have
72 *> every test ratio printed, use THRESH = 0.
73 *> \endverbatim
74 *>
75 *> \param[in] TSTERR
76 *> \verbatim
77 *> TSTERR is LOGICAL
78 *> Flag that indicates whether error exits are to be tested.
79 *> \endverbatim
80 *>
81 *> \param[in] NMAX
82 *> \verbatim
83 *> NMAX is INTEGER
84 *> The maximum value permitted for N, used in dimensioning the
85 *> work arrays.
86 *> \endverbatim
87 *>
88 *> \param[out] A
89 *> \verbatim
90 *> A is COMPLEX*16 array, dimension (NMAX*NMAX)
91 *> \endverbatim
92 *>
93 *> \param[out] AFAC
94 *> \verbatim
95 *> AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
96 *> \endverbatim
97 *>
98 *> \param[out] ASAV
99 *> \verbatim
100 *> ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
101 *> \endverbatim
102 *>
103 *> \param[out] B
104 *> \verbatim
105 *> B is COMPLEX*16 array, dimension (NMAX*NRHS)
106 *> \endverbatim
107 *>
108 *> \param[out] BSAV
109 *> \verbatim
110 *> BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
111 *> \endverbatim
112 *>
113 *> \param[out] X
114 *> \verbatim
115 *> X is COMPLEX*16 array, dimension (NMAX*NRHS)
116 *> \endverbatim
117 *>
118 *> \param[out] XACT
119 *> \verbatim
120 *> XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
121 *> \endverbatim
122 *>
123 *> \param[out] S
124 *> \verbatim
125 *> S is DOUBLE PRECISION array, dimension (NMAX)
126 *> \endverbatim
127 *>
128 *> \param[out] WORK
129 *> \verbatim
130 *> WORK is COMPLEX*16 array, dimension
131 *> (NMAX*max(3,NRHS))
132 *> \endverbatim
133 *>
134 *> \param[out] RWORK
135 *> \verbatim
136 *> RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
137 *> \endverbatim
138 *>
139 *> \param[in] NOUT
140 *> \verbatim
141 *> NOUT is INTEGER
142 *> The unit number for output.
143 *> \endverbatim
144 *
145 * Authors:
146 * ========
147 *
148 *> \author Univ. of Tennessee
149 *> \author Univ. of California Berkeley
150 *> \author Univ. of Colorado Denver
151 *> \author NAG Ltd.
152 *
153 *> \ingroup complex16_lin
154 *
155 * =====================================================================
156  SUBROUTINE zdrvpb( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
157  $ A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK,
158  $ RWORK, NOUT )
159 *
160 * -- LAPACK test routine --
161 * -- LAPACK is a software package provided by Univ. of Tennessee, --
162 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
163 *
164 * .. Scalar Arguments ..
165  LOGICAL TSTERR
166  INTEGER NMAX, NN, NOUT, NRHS
167  DOUBLE PRECISION THRESH
168 * ..
169 * .. Array Arguments ..
170  LOGICAL DOTYPE( * )
171  INTEGER NVAL( * )
172  DOUBLE PRECISION RWORK( * ), S( * )
173  COMPLEX*16 A( * ), AFAC( * ), ASAV( * ), B( * ),
174  $ bsav( * ), work( * ), x( * ), xact( * )
175 * ..
176 *
177 * =====================================================================
178 *
179 * .. Parameters ..
180  DOUBLE PRECISION ONE, ZERO
181  PARAMETER ( ONE = 1.0d+0, zero = 0.0d+0 )
182  INTEGER NTYPES, NTESTS
183  parameter( ntypes = 8, ntests = 6 )
184  INTEGER NBW
185  parameter( nbw = 4 )
186 * ..
187 * .. Local Scalars ..
188  LOGICAL EQUIL, NOFACT, PREFAC, ZEROT
189  CHARACTER DIST, EQUED, FACT, PACKIT, TYPE, UPLO, XTYPE
190  CHARACTER*3 PATH
191  INTEGER I, I1, I2, IEQUED, IFACT, IKD, IMAT, IN, INFO,
192  $ ioff, iuplo, iw, izero, k, k1, kd, kl, koff,
193  $ ku, lda, ldab, mode, n, nb, nbmin, nerrs,
194  $ nfact, nfail, nimat, nkd, nrun, nt
195  DOUBLE PRECISION AINVNM, AMAX, ANORM, CNDNUM, RCOND, RCONDC,
196  $ ROLDC, SCOND
197 * ..
198 * .. Local Arrays ..
199  CHARACTER EQUEDS( 2 ), FACTS( 3 )
200  INTEGER ISEED( 4 ), ISEEDY( 4 ), KDVAL( NBW )
201  DOUBLE PRECISION RESULT( NTESTS )
202 * ..
203 * .. External Functions ..
204  LOGICAL LSAME
205  DOUBLE PRECISION DGET06, ZLANGE, ZLANHB
206  EXTERNAL lsame, dget06, zlange, zlanhb
207 * ..
208 * .. External Subroutines ..
209  EXTERNAL aladhd, alaerh, alasvm, xlaenv, zcopy, zerrvx,
213 * ..
214 * .. Intrinsic Functions ..
215  INTRINSIC dcmplx, max, min
216 * ..
217 * .. Scalars in Common ..
218  LOGICAL LERR, OK
219  CHARACTER*32 SRNAMT
220  INTEGER INFOT, NUNIT
221 * ..
222 * .. Common blocks ..
223  COMMON / infoc / infot, nunit, ok, lerr
224  COMMON / srnamc / srnamt
225 * ..
226 * .. Data statements ..
227  DATA iseedy / 1988, 1989, 1990, 1991 /
228  DATA facts / 'F', 'N', 'E' / , equeds / 'N', 'Y' /
229 * ..
230 * .. Executable Statements ..
231 *
232 * Initialize constants and the random number seed.
233 *
234  path( 1: 1 ) = 'Zomplex precision'
235  path( 2: 3 ) = 'PB'
236  nrun = 0
237  nfail = 0
238  nerrs = 0
239  DO 10 i = 1, 4
240  iseed( i ) = iseedy( i )
241  10 CONTINUE
242 *
243 * Test the error exits
244 *
245  IF( tsterr )
246  $ CALL zerrvx( path, nout )
247  infot = 0
248  kdval( 1 ) = 0
249 *
250 * Set the block size and minimum block size for testing.
251 *
252  nb = 1
253  nbmin = 2
254  CALL xlaenv( 1, nb )
255  CALL xlaenv( 2, nbmin )
256 *
257 * Do for each value of N in NVAL
258 *
259  DO 110 in = 1, nn
260  n = nval( in )
261  lda = max( n, 1 )
262  xtype = 'N'
263 *
264 * Set limits on the number of loop iterations.
265 *
266  nkd = max( 1, min( n, 4 ) )
267  nimat = ntypes
268  IF( n.EQ.0 )
269  $ nimat = 1
270 *
271  kdval( 2 ) = n + ( n+1 ) / 4
272  kdval( 3 ) = ( 3*n-1 ) / 4
273  kdval( 4 ) = ( n+1 ) / 4
274 *
275  DO 100 ikd = 1, nkd
276 *
277 * Do for KD = 0, (5*N+1)/4, (3N-1)/4, and (N+1)/4. This order
278 * makes it easier to skip redundant values for small values
279 * of N.
280 *
281  kd = kdval( ikd )
282  ldab = kd + 1
283 *
284 * Do first for UPLO = 'U', then for UPLO = 'L'
285 *
286  DO 90 iuplo = 1, 2
287  koff = 1
288  IF( iuplo.EQ.1 ) THEN
289  uplo = 'U'
290  packit = 'Q'
291  koff = max( 1, kd+2-n )
292  ELSE
293  uplo = 'L'
294  packit = 'B'
295  END IF
296 *
297  DO 80 imat = 1, nimat
298 *
299 * Do the tests only if DOTYPE( IMAT ) is true.
300 *
301  IF( .NOT.dotype( imat ) )
302  $ GO TO 80
303 *
304 * Skip types 2, 3, or 4 if the matrix size is too small.
305 *
306  zerot = imat.GE.2 .AND. imat.LE.4
307  IF( zerot .AND. n.LT.imat-1 )
308  $ GO TO 80
309 *
310  IF( .NOT.zerot .OR. .NOT.dotype( 1 ) ) THEN
311 *
312 * Set up parameters with ZLATB4 and generate a test
313 * matrix with ZLATMS.
314 *
315  CALL zlatb4( path, imat, n, n, TYPE, kl, ku, anorm,
316  $ mode, cndnum, dist )
317 *
318  srnamt = 'ZLATMS'
319  CALL zlatms( n, n, dist, iseed, TYPE, rwork, mode,
320  $ cndnum, anorm, kd, kd, packit,
321  $ a( koff ), ldab, work, info )
322 *
323 * Check error code from ZLATMS.
324 *
325  IF( info.NE.0 ) THEN
326  CALL alaerh( path, 'ZLATMS', info, 0, uplo, n,
327  $ n, -1, -1, -1, imat, nfail, nerrs,
328  $ nout )
329  GO TO 80
330  END IF
331  ELSE IF( izero.GT.0 ) THEN
332 *
333 * Use the same matrix for types 3 and 4 as for type
334 * 2 by copying back the zeroed out column,
335 *
336  iw = 2*lda + 1
337  IF( iuplo.EQ.1 ) THEN
338  ioff = ( izero-1 )*ldab + kd + 1
339  CALL zcopy( izero-i1, work( iw ), 1,
340  $ a( ioff-izero+i1 ), 1 )
341  iw = iw + izero - i1
342  CALL zcopy( i2-izero+1, work( iw ), 1,
343  $ a( ioff ), max( ldab-1, 1 ) )
344  ELSE
345  ioff = ( i1-1 )*ldab + 1
346  CALL zcopy( izero-i1, work( iw ), 1,
347  $ a( ioff+izero-i1 ),
348  $ max( ldab-1, 1 ) )
349  ioff = ( izero-1 )*ldab + 1
350  iw = iw + izero - i1
351  CALL zcopy( i2-izero+1, work( iw ), 1,
352  $ a( ioff ), 1 )
353  END IF
354  END IF
355 *
356 * For types 2-4, zero one row and column of the matrix
357 * to test that INFO is returned correctly.
358 *
359  izero = 0
360  IF( zerot ) THEN
361  IF( imat.EQ.2 ) THEN
362  izero = 1
363  ELSE IF( imat.EQ.3 ) THEN
364  izero = n
365  ELSE
366  izero = n / 2 + 1
367  END IF
368 *
369 * Save the zeroed out row and column in WORK(*,3)
370 *
371  iw = 2*lda
372  DO 20 i = 1, min( 2*kd+1, n )
373  work( iw+i ) = zero
374  20 CONTINUE
375  iw = iw + 1
376  i1 = max( izero-kd, 1 )
377  i2 = min( izero+kd, n )
378 *
379  IF( iuplo.EQ.1 ) THEN
380  ioff = ( izero-1 )*ldab + kd + 1
381  CALL zswap( izero-i1, a( ioff-izero+i1 ), 1,
382  $ work( iw ), 1 )
383  iw = iw + izero - i1
384  CALL zswap( i2-izero+1, a( ioff ),
385  $ max( ldab-1, 1 ), work( iw ), 1 )
386  ELSE
387  ioff = ( i1-1 )*ldab + 1
388  CALL zswap( izero-i1, a( ioff+izero-i1 ),
389  $ max( ldab-1, 1 ), work( iw ), 1 )
390  ioff = ( izero-1 )*ldab + 1
391  iw = iw + izero - i1
392  CALL zswap( i2-izero+1, a( ioff ), 1,
393  $ work( iw ), 1 )
394  END IF
395  END IF
396 *
397 * Set the imaginary part of the diagonals.
398 *
399  IF( iuplo.EQ.1 ) THEN
400  CALL zlaipd( n, a( kd+1 ), ldab, 0 )
401  ELSE
402  CALL zlaipd( n, a( 1 ), ldab, 0 )
403  END IF
404 *
405 * Save a copy of the matrix A in ASAV.
406 *
407  CALL zlacpy( 'Full', kd+1, n, a, ldab, asav, ldab )
408 *
409  DO 70 iequed = 1, 2
410  equed = equeds( iequed )
411  IF( iequed.EQ.1 ) THEN
412  nfact = 3
413  ELSE
414  nfact = 1
415  END IF
416 *
417  DO 60 ifact = 1, nfact
418  fact = facts( ifact )
419  prefac = lsame( fact, 'F' )
420  nofact = lsame( fact, 'N' )
421  equil = lsame( fact, 'E' )
422 *
423  IF( zerot ) THEN
424  IF( prefac )
425  $ GO TO 60
426  rcondc = zero
427 *
428  ELSE IF( .NOT.lsame( fact, 'N' ) ) THEN
429 *
430 * Compute the condition number for comparison
431 * with the value returned by ZPBSVX (FACT =
432 * 'N' reuses the condition number from the
433 * previous iteration with FACT = 'F').
434 *
435  CALL zlacpy( 'Full', kd+1, n, asav, ldab,
436  $ afac, ldab )
437  IF( equil .OR. iequed.GT.1 ) THEN
438 *
439 * Compute row and column scale factors to
440 * equilibrate the matrix A.
441 *
442  CALL zpbequ( uplo, n, kd, afac, ldab, s,
443  $ scond, amax, info )
444  IF( info.EQ.0 .AND. n.GT.0 ) THEN
445  IF( iequed.GT.1 )
446  $ scond = zero
447 *
448 * Equilibrate the matrix.
449 *
450  CALL zlaqhb( uplo, n, kd, afac, ldab,
451  $ s, scond, amax, equed )
452  END IF
453  END IF
454 *
455 * Save the condition number of the
456 * non-equilibrated system for use in ZGET04.
457 *
458  IF( equil )
459  $ roldc = rcondc
460 *
461 * Compute the 1-norm of A.
462 *
463  anorm = zlanhb( '1', uplo, n, kd, afac, ldab,
464  $ rwork )
465 *
466 * Factor the matrix A.
467 *
468  CALL zpbtrf( uplo, n, kd, afac, ldab, info )
469 *
470 * Form the inverse of A.
471 *
472  CALL zlaset( 'Full', n, n, dcmplx( zero ),
473  $ dcmplx( one ), a, lda )
474  srnamt = 'ZPBTRS'
475  CALL zpbtrs( uplo, n, kd, n, afac, ldab, a,
476  $ lda, info )
477 *
478 * Compute the 1-norm condition number of A.
479 *
480  ainvnm = zlange( '1', n, n, a, lda, rwork )
481  IF( anorm.LE.zero .OR. ainvnm.LE.zero ) THEN
482  rcondc = one
483  ELSE
484  rcondc = ( one / anorm ) / ainvnm
485  END IF
486  END IF
487 *
488 * Restore the matrix A.
489 *
490  CALL zlacpy( 'Full', kd+1, n, asav, ldab, a,
491  $ ldab )
492 *
493 * Form an exact solution and set the right hand
494 * side.
495 *
496  srnamt = 'ZLARHS'
497  CALL zlarhs( path, xtype, uplo, ' ', n, n, kd,
498  $ kd, nrhs, a, ldab, xact, lda, b,
499  $ lda, iseed, info )
500  xtype = 'C'
501  CALL zlacpy( 'Full', n, nrhs, b, lda, bsav,
502  $ lda )
503 *
504  IF( nofact ) THEN
505 *
506 * --- Test ZPBSV ---
507 *
508 * Compute the L*L' or U'*U factorization of the
509 * matrix and solve the system.
510 *
511  CALL zlacpy( 'Full', kd+1, n, a, ldab, afac,
512  $ ldab )
513  CALL zlacpy( 'Full', n, nrhs, b, lda, x,
514  $ lda )
515 *
516  srnamt = 'ZPBSV '
517  CALL zpbsv( uplo, n, kd, nrhs, afac, ldab, x,
518  $ lda, info )
519 *
520 * Check error code from ZPBSV .
521 *
522  IF( info.NE.izero ) THEN
523  CALL alaerh( path, 'ZPBSV ', info, izero,
524  $ uplo, n, n, kd, kd, nrhs,
525  $ imat, nfail, nerrs, nout )
526  GO TO 40
527  ELSE IF( info.NE.0 ) THEN
528  GO TO 40
529  END IF
530 *
531 * Reconstruct matrix from factors and compute
532 * residual.
533 *
534  CALL zpbt01( uplo, n, kd, a, ldab, afac,
535  $ ldab, rwork, result( 1 ) )
536 *
537 * Compute residual of the computed solution.
538 *
539  CALL zlacpy( 'Full', n, nrhs, b, lda, work,
540  $ lda )
541  CALL zpbt02( uplo, n, kd, nrhs, a, ldab, x,
542  $ lda, work, lda, rwork,
543  $ result( 2 ) )
544 *
545 * Check solution from generated exact solution.
546 *
547  CALL zget04( n, nrhs, x, lda, xact, lda,
548  $ rcondc, result( 3 ) )
549  nt = 3
550 *
551 * Print information about the tests that did
552 * not pass the threshold.
553 *
554  DO 30 k = 1, nt
555  IF( result( k ).GE.thresh ) THEN
556  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
557  $ CALL aladhd( nout, path )
558  WRITE( nout, fmt = 9999 )'ZPBSV ',
559  $ uplo, n, kd, imat, k, result( k )
560  nfail = nfail + 1
561  END IF
562  30 CONTINUE
563  nrun = nrun + nt
564  40 CONTINUE
565  END IF
566 *
567 * --- Test ZPBSVX ---
568 *
569  IF( .NOT.prefac )
570  $ CALL zlaset( 'Full', kd+1, n, dcmplx( zero ),
571  $ dcmplx( zero ), afac, ldab )
572  CALL zlaset( 'Full', n, nrhs, dcmplx( zero ),
573  $ dcmplx( zero ), x, lda )
574  IF( iequed.GT.1 .AND. n.GT.0 ) THEN
575 *
576 * Equilibrate the matrix if FACT='F' and
577 * EQUED='Y'
578 *
579  CALL zlaqhb( uplo, n, kd, a, ldab, s, scond,
580  $ amax, equed )
581  END IF
582 *
583 * Solve the system and compute the condition
584 * number and error bounds using ZPBSVX.
585 *
586  srnamt = 'ZPBSVX'
587  CALL zpbsvx( fact, uplo, n, kd, nrhs, a, ldab,
588  $ afac, ldab, equed, s, b, lda, x,
589  $ lda, rcond, rwork, rwork( nrhs+1 ),
590  $ work, rwork( 2*nrhs+1 ), info )
591 *
592 * Check the error code from ZPBSVX.
593 *
594  IF( info.NE.izero ) THEN
595  CALL alaerh( path, 'ZPBSVX', info, izero,
596  $ fact // uplo, n, n, kd, kd,
597  $ nrhs, imat, nfail, nerrs, nout )
598  GO TO 60
599  END IF
600 *
601  IF( info.EQ.0 ) THEN
602  IF( .NOT.prefac ) THEN
603 *
604 * Reconstruct matrix from factors and
605 * compute residual.
606 *
607  CALL zpbt01( uplo, n, kd, a, ldab, afac,
608  $ ldab, rwork( 2*nrhs+1 ),
609  $ result( 1 ) )
610  k1 = 1
611  ELSE
612  k1 = 2
613  END IF
614 *
615 * Compute residual of the computed solution.
616 *
617  CALL zlacpy( 'Full', n, nrhs, bsav, lda,
618  $ work, lda )
619  CALL zpbt02( uplo, n, kd, nrhs, asav, ldab,
620  $ x, lda, work, lda,
621  $ rwork( 2*nrhs+1 ), result( 2 ) )
622 *
623 * Check solution from generated exact solution.
624 *
625  IF( nofact .OR. ( prefac .AND. lsame( equed,
626  $ 'N' ) ) ) THEN
627  CALL zget04( n, nrhs, x, lda, xact, lda,
628  $ rcondc, result( 3 ) )
629  ELSE
630  CALL zget04( n, nrhs, x, lda, xact, lda,
631  $ roldc, result( 3 ) )
632  END IF
633 *
634 * Check the error bounds from iterative
635 * refinement.
636 *
637  CALL zpbt05( uplo, n, kd, nrhs, asav, ldab,
638  $ b, lda, x, lda, xact, lda,
639  $ rwork, rwork( nrhs+1 ),
640  $ result( 4 ) )
641  ELSE
642  k1 = 6
643  END IF
644 *
645 * Compare RCOND from ZPBSVX with the computed
646 * value in RCONDC.
647 *
648  result( 6 ) = dget06( rcond, rcondc )
649 *
650 * Print information about the tests that did not
651 * pass the threshold.
652 *
653  DO 50 k = k1, 6
654  IF( result( k ).GE.thresh ) THEN
655  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
656  $ CALL aladhd( nout, path )
657  IF( prefac ) THEN
658  WRITE( nout, fmt = 9997 )'ZPBSVX',
659  $ fact, uplo, n, kd, equed, imat, k,
660  $ result( k )
661  ELSE
662  WRITE( nout, fmt = 9998 )'ZPBSVX',
663  $ fact, uplo, n, kd, imat, k,
664  $ result( k )
665  END IF
666  nfail = nfail + 1
667  END IF
668  50 CONTINUE
669  nrun = nrun + 7 - k1
670  60 CONTINUE
671  70 CONTINUE
672  80 CONTINUE
673  90 CONTINUE
674  100 CONTINUE
675  110 CONTINUE
676 *
677 * Print a summary of the results.
678 *
679  CALL alasvm( path, nout, nfail, nrun, nerrs )
680 *
681  9999 FORMAT( 1x, a, ', UPLO=''', a1, ''', N =', i5, ', KD =', i5,
682  $ ', type ', i1, ', test(', i1, ')=', g12.5 )
683  9998 FORMAT( 1x, a, '( ''', a1, ''', ''', a1, ''', ', i5, ', ', i5,
684  $ ', ... ), type ', i1, ', test(', i1, ')=', g12.5 )
685  9997 FORMAT( 1x, a, '( ''', a1, ''', ''', a1, ''', ', i5, ', ', i5,
686  $ ', ... ), EQUED=''', a1, ''', type ', i1, ', test(', i1,
687  $ ')=', g12.5 )
688  RETURN
689 *
690 * End of ZDRVPB
691 *
692  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 zswap(N, ZX, INCX, ZY, INCY)
ZSWAP
Definition: zswap.f:81
subroutine zcopy(N, ZX, INCX, ZY, INCY)
ZCOPY
Definition: zcopy.f:81
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 zdrvpb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
ZDRVPB
Definition: zdrvpb.f:159
subroutine zpbt05(UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
ZPBT05
Definition: zpbt05.f:171
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 zpbt02(UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPBT02
Definition: zpbt02.f:136
subroutine zlaipd(N, A, INDA, VINDA)
ZLAIPD
Definition: zlaipd.f:83
subroutine zpbt01(UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID)
ZPBT01
Definition: zpbt01.f:120
subroutine zlatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB4
Definition: zlatb4.f:121
subroutine zlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
ZLATMS
Definition: zlatms.f:332
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 zlaqhb(UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, EQUED)
ZLAQHB scales a Hermitian band matrix, using scaling factors computed by cpbequ.
Definition: zlaqhb.f:141
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
subroutine zpbtrf(UPLO, N, KD, AB, LDAB, INFO)
ZPBTRF
Definition: zpbtrf.f:142
subroutine zpbequ(UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, INFO)
ZPBEQU
Definition: zpbequ.f:130
subroutine zpbtrs(UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
ZPBTRS
Definition: zpbtrs.f:121
subroutine zpbsvx(FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, EQUED, S, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, RWORK, INFO)
ZPBSVX computes the solution to system of linear equations A * X = B for OTHER matrices
Definition: zpbsvx.f:342
subroutine zpbsv(UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
ZPBSV computes the solution to system of linear equations A * X = B for OTHER matrices
Definition: zpbsv.f:164