LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ 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.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

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 *
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
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 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
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
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
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 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
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: