LAPACK 3.12.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches

## ◆ cdrvpb()

 subroutine cdrvpb ( logical, dimension( * ) dotype, integer nn, integer, dimension( * ) nval, integer nrhs, real thresh, logical tsterr, integer nmax, complex, dimension( * ) a, complex, dimension( * ) afac, complex, dimension( * ) asav, complex, dimension( * ) b, complex, dimension( * ) bsav, complex, dimension( * ) x, complex, dimension( * ) xact, real, dimension( * ) s, complex, dimension( * ) work, real, dimension( * ) rwork, integer nout )

CDRVPB

Purpose:
` CDRVPB tests the driver routines CPBSV and -SVX.`
Parameters
 [in] DOTYPE ``` DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.``` [in] NN ``` NN is INTEGER The number of values of N contained in the vector NVAL.``` [in] NVAL ``` NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.``` [in] NRHS ``` NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.``` [in] THRESH ``` THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.``` [in] TSTERR ``` TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.``` [in] NMAX ``` NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.``` [out] A ` A is COMPLEX array, dimension (NMAX*NMAX)` [out] AFAC ` AFAC is COMPLEX array, dimension (NMAX*NMAX)` [out] ASAV ` ASAV is COMPLEX array, dimension (NMAX*NMAX)` [out] B ` B is COMPLEX array, dimension (NMAX*NRHS)` [out] BSAV ` BSAV is COMPLEX array, dimension (NMAX*NRHS)` [out] X ` X is COMPLEX array, dimension (NMAX*NRHS)` [out] XACT ` XACT is COMPLEX array, dimension (NMAX*NRHS)` [out] S ` S is REAL array, dimension (NMAX)` [out] WORK ``` WORK is COMPLEX array, dimension (NMAX*max(3,NRHS))``` [out] RWORK ` RWORK is REAL array, dimension (NMAX+2*NRHS)` [in] NOUT ``` NOUT is INTEGER The unit number for output.```

Definition at line 156 of file cdrvpb.f.

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*
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 alaerh(path, subnam, info, infoe, opts, m, n, kl, ku, n5, imat, nfail, nerrs, nout)
ALAERH
Definition alaerh.f:147
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 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 cpbt01(uplo, n, kd, a, lda, afac, ldafac, rwork, resid)
CPBT01
Definition cpbt01.f:120
subroutine cpbt02(uplo, n, kd, nrhs, a, lda, x, ldx, b, ldb, rwork, resid)
CPBT02
Definition cpbt02.f:136
subroutine cpbt05(uplo, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, xact, ldxact, ferr, berr, reslts)
CPBT05
Definition cpbt05.f:171
subroutine ccopy(n, cx, incx, cy, incy)
CCOPY
Definition ccopy.f:81
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
real function clange(norm, m, n, a, lda, work)
CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition clange.f:115
real function clanhb(norm, uplo, n, k, ab, ldab, work)
CLANHB returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition clanhb.f:132
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 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
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
subroutine cpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info)
CPBEQU
Definition cpbequ.f:130
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
subroutine cpbtrf(uplo, n, kd, ab, ldab, info)
CPBTRF
Definition cpbtrf.f:142
subroutine cpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
CPBTRS
Definition cpbtrs.f:121
subroutine cswap(n, cx, incx, cy, incy)
CSWAP
Definition cswap.f:81
real function sget06(rcond, rcondc)
SGET06
Definition sget06.f:55
Here is the call graph for this function:
Here is the caller graph for this function: