LAPACK  3.10.0
LAPACK: Linear Algebra PACKage
cdrvpb.f
Go to the documentation of this file.
1 *> \brief \b CDRVPB
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 CDRVPB( 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 * REAL THRESH
19 * ..
20 * .. Array Arguments ..
21 * LOGICAL DOTYPE( * )
22 * INTEGER NVAL( * )
23 * REAL RWORK( * ), S( * )
24 * COMPLEX A( * ), AFAC( * ), ASAV( * ), B( * ),
25 * $ BSAV( * ), WORK( * ), X( * ), XACT( * )
26 * ..
27 *
28 *
29 *> \par Purpose:
30 * =============
31 *>
32 *> \verbatim
33 *>
34 *> CDRVPB tests the driver routines CPBSV 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 REAL
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 array, dimension (NMAX*NMAX)
91 *> \endverbatim
92 *>
93 *> \param[out] AFAC
94 *> \verbatim
95 *> AFAC is COMPLEX array, dimension (NMAX*NMAX)
96 *> \endverbatim
97 *>
98 *> \param[out] ASAV
99 *> \verbatim
100 *> ASAV is COMPLEX array, dimension (NMAX*NMAX)
101 *> \endverbatim
102 *>
103 *> \param[out] B
104 *> \verbatim
105 *> B is COMPLEX array, dimension (NMAX*NRHS)
106 *> \endverbatim
107 *>
108 *> \param[out] BSAV
109 *> \verbatim
110 *> BSAV is COMPLEX array, dimension (NMAX*NRHS)
111 *> \endverbatim
112 *>
113 *> \param[out] X
114 *> \verbatim
115 *> X is COMPLEX array, dimension (NMAX*NRHS)
116 *> \endverbatim
117 *>
118 *> \param[out] XACT
119 *> \verbatim
120 *> XACT is COMPLEX array, dimension (NMAX*NRHS)
121 *> \endverbatim
122 *>
123 *> \param[out] S
124 *> \verbatim
125 *> S is REAL array, dimension (NMAX)
126 *> \endverbatim
127 *>
128 *> \param[out] WORK
129 *> \verbatim
130 *> WORK is COMPLEX array, dimension
131 *> (NMAX*max(3,NRHS))
132 *> \endverbatim
133 *>
134 *> \param[out] RWORK
135 *> \verbatim
136 *> RWORK is REAL 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 complex_lin
154 *
155 * =====================================================================
156  SUBROUTINE cdrvpb( 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  REAL THRESH
168 * ..
169 * .. Array Arguments ..
170  LOGICAL DOTYPE( * )
171  INTEGER NVAL( * )
172  REAL RWORK( * ), S( * )
173  COMPLEX A( * ), AFAC( * ), ASAV( * ), B( * ),
174  $ bsav( * ), work( * ), x( * ), xact( * )
175 * ..
176 *
177 * =====================================================================
178 *
179 * .. Parameters ..
180  REAL ONE, ZERO
181  PARAMETER ( ONE = 1.0e+0, zero = 0.0e+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  REAL 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  REAL RESULT( NTESTS )
202 * ..
203 * .. External Functions ..
204  LOGICAL LSAME
205  REAL CLANGE, CLANHB, SGET06
206  EXTERNAL lsame, clange, clanhb, sget06
207 * ..
208 * .. External Subroutines ..
209  EXTERNAL aladhd, alaerh, alasvm, ccopy, cerrvx, cget04,
213 * ..
214 * .. Intrinsic Functions ..
215  INTRINSIC cmplx, 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 ) = 'Complex 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 cerrvx( 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 CLATB4 and generate a test
313 * matrix with CLATMS.
314 *
315  CALL clatb4( path, imat, n, n, TYPE, kl, ku, anorm,
316  $ mode, cndnum, dist )
317 *
318  srnamt = 'CLATMS'
319  CALL clatms( 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 CLATMS.
324 *
325  IF( info.NE.0 ) THEN
326  CALL alaerh( path, 'CLATMS', 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 ccopy( izero-i1, work( iw ), 1,
340  $ a( ioff-izero+i1 ), 1 )
341  iw = iw + izero - i1
342  CALL ccopy( i2-izero+1, work( iw ), 1,
343  $ a( ioff ), max( ldab-1, 1 ) )
344  ELSE
345  ioff = ( i1-1 )*ldab + 1
346  CALL ccopy( 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 ccopy( 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 cswap( izero-i1, a( ioff-izero+i1 ), 1,
382  $ work( iw ), 1 )
383  iw = iw + izero - i1
384  CALL cswap( i2-izero+1, a( ioff ),
385  $ max( ldab-1, 1 ), work( iw ), 1 )
386  ELSE
387  ioff = ( i1-1 )*ldab + 1
388  CALL cswap( 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 cswap( 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 claipd( n, a( kd+1 ), ldab, 0 )
401  ELSE
402  CALL claipd( n, a( 1 ), ldab, 0 )
403  END IF
404 *
405 * Save a copy of the matrix A in ASAV.
406 *
407  CALL clacpy( '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 CPBSVX (FACT =
432 * 'N' reuses the condition number from the
433 * previous iteration with FACT = 'F').
434 *
435  CALL clacpy( '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 cpbequ( 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 claqhb( 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 CGET04.
457 *
458  IF( equil )
459  $ roldc = rcondc
460 *
461 * Compute the 1-norm of A.
462 *
463  anorm = clanhb( '1', uplo, n, kd, afac, ldab,
464  $ rwork )
465 *
466 * Factor the matrix A.
467 *
468  CALL cpbtrf( uplo, n, kd, afac, ldab, info )
469 *
470 * Form the inverse of A.
471 *
472  CALL claset( 'Full', n, n, cmplx( zero ),
473  $ cmplx( one ), a, lda )
474  srnamt = 'CPBTRS'
475  CALL cpbtrs( uplo, n, kd, n, afac, ldab, a,
476  $ lda, info )
477 *
478 * Compute the 1-norm condition number of A.
479 *
480  ainvnm = clange( '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 clacpy( '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 = 'CLARHS'
497  CALL clarhs( path, xtype, uplo, ' ', n, n, kd,
498  $ kd, nrhs, a, ldab, xact, lda, b,
499  $ lda, iseed, info )
500  xtype = 'C'
501  CALL clacpy( 'Full', n, nrhs, b, lda, bsav,
502  $ lda )
503 *
504  IF( nofact ) THEN
505 *
506 * --- Test CPBSV ---
507 *
508 * Compute the L*L' or U'*U factorization of the
509 * matrix and solve the system.
510 *
511  CALL clacpy( 'Full', kd+1, n, a, ldab, afac,
512  $ ldab )
513  CALL clacpy( 'Full', n, nrhs, b, lda, x,
514  $ lda )
515 *
516  srnamt = 'CPBSV '
517  CALL cpbsv( uplo, n, kd, nrhs, afac, ldab, x,
518  $ lda, info )
519 *
520 * Check error code from CPBSV .
521 *
522  IF( info.NE.izero ) THEN
523  CALL alaerh( path, 'CPBSV ', 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 cpbt01( uplo, n, kd, a, ldab, afac,
535  $ ldab, rwork, result( 1 ) )
536 *
537 * Compute residual of the computed solution.
538 *
539  CALL clacpy( 'Full', n, nrhs, b, lda, work,
540  $ lda )
541  CALL cpbt02( 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 cget04( 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 )'CPBSV ',
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 CPBSVX ---
568 *
569  IF( .NOT.prefac )
570  $ CALL claset( 'Full', kd+1, n, cmplx( zero ),
571  $ cmplx( zero ), afac, ldab )
572  CALL claset( 'Full', n, nrhs, cmplx( zero ),
573  $ cmplx( 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 claqhb( 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 CPBSVX.
585 *
586  srnamt = 'CPBSVX'
587  CALL cpbsvx( 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 CPBSVX.
593 *
594  IF( info.NE.izero ) THEN
595  CALL alaerh( path, 'CPBSVX', 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 cpbt01( 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 clacpy( 'Full', n, nrhs, bsav, lda,
618  $ work, lda )
619  CALL cpbt02( 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 cget04( n, nrhs, x, lda, xact, lda,
628  $ rcondc, result( 3 ) )
629  ELSE
630  CALL cget04( 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 cpbt05( 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 CPBSVX with the computed
646 * value in RCONDC.
647 *
648  result( 6 ) = sget06( 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 )'CPBSVX',
659  $ fact, uplo, n, kd, equed, imat, k,
660  $ result( k )
661  ELSE
662  WRITE( nout, fmt = 9998 )'CPBSVX',
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 CDRVPB
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 ccopy(N, CX, INCX, CY, INCY)
CCOPY
Definition: ccopy.f:81
subroutine cswap(N, CX, INCX, CY, INCY)
CSWAP
Definition: cswap.f:81
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 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 cpbt02(UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
CPBT02
Definition: cpbt02.f:136
subroutine cpbt01(UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID)
CPBT01
Definition: cpbt01.f:120
subroutine cdrvpb(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT)
CDRVPB
Definition: cdrvpb.f:159
subroutine claipd(N, A, INDA, VINDA)
CLAIPD
Definition: claipd.f:83
subroutine cpbt05(UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
CPBT05
Definition: cpbt05.f:171
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 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 claqhb(UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, EQUED)
CLAQHB scales a Hermitian band matrix, using scaling factors computed by cpbequ.
Definition: claqhb.f:141
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 cpbequ(UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, INFO)
CPBEQU
Definition: cpbequ.f:130
subroutine cpbtrs(UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
CPBTRS
Definition: cpbtrs.f:121
subroutine cpbtrf(UPLO, N, KD, AB, LDAB, INFO)
CPBTRF
Definition: cpbtrf.f:142
subroutine cpbsv(UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
CPBSV computes the solution to system of linear equations A * X = B for OTHER matrices
Definition: cpbsv.f:164
subroutine cpbsvx(FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, EQUED, S, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, RWORK, INFO)
CPBSVX computes the solution to system of linear equations A * X = B for OTHER matrices
Definition: cpbsvx.f:342