LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
subroutine cchksy ( logical, dimension( * )  DOTYPE,
integer  NN,
integer, dimension( * )  NVAL,
integer  NNB,
integer, dimension( * )  NBVAL,
integer  NNS,
integer, dimension( * )  NSVAL,
real  THRESH,
logical  TSTERR,
integer  NMAX,
complex, dimension( * )  A,
complex, dimension( * )  AFAC,
complex, dimension( * )  AINV,
complex, dimension( * )  B,
complex, dimension( * )  X,
complex, dimension( * )  XACT,
complex, dimension( * )  WORK,
real, dimension( * )  RWORK,
integer, dimension( * )  IWORK,
integer  NOUT 
)

CCHKSY

Purpose: 
 CCHKSY tests CSYTRF, -TRI2, -TRS, -TRS2, -RFS, and -CON.
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]NNB
          NNB is INTEGER
          The number of values of NB contained in the vector NBVAL.
[in]NBVAL
          NBVAL is INTEGER array, dimension (NBVAL)
          The values of the blocksize NB.
[in]NNS
          NNS is INTEGER
          The number of values of NRHS contained in the vector NSVAL.
[in]NSVAL
          NSVAL is INTEGER array, dimension (NNS)
          The values of the number of right hand sides NRHS.
[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]AINV
          AINV is COMPLEX array, dimension (NMAX*NMAX)
[out]B
          B is COMPLEX array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.
[out]X
          X is COMPLEX array, dimension (NMAX*NSMAX)
[out]XACT
          XACT is COMPLEX array, dimension (NMAX*NSMAX)
[out]WORK
          WORK is COMPLEX array, dimension (NMAX*max(2,NSMAX))
[out]RWORK
          RWORK is REAL array, dimension (NMAX+2*NSMAX)
[out]IWORK
          IWORK is INTEGER array, dimension (NMAX)
[in]NOUT
          NOUT is INTEGER
          The unit number for output.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2013

Definition at line 173 of file cchksy.f.

173 *
174 * -- LAPACK test routine (version 3.5.0) --
175 * -- LAPACK is a software package provided by Univ. of Tennessee, --
176 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
177 * November 2013
178 *
179 * .. Scalar Arguments ..
180  LOGICAL tsterr
181  INTEGER nmax, nn, nnb, nns, nout
182  REAL thresh
183 * ..
184 * .. Array Arguments ..
185  LOGICAL dotype( * )
186  INTEGER iwork( * ), nbval( * ), nsval( * ), nval( * )
187  REAL rwork( * )
188  COMPLEX a( * ), afac( * ), ainv( * ), b( * ),
189  $ work( * ), x( * ), xact( * )
190 * ..
191 *
192 * =====================================================================
193 *
194 * .. Parameters ..
195  REAL zero
196  parameter ( zero = 0.0e+0 )
197  COMPLEX czero
198  parameter ( czero = ( 0.0e+0, 0.0e+0 ) )
199  INTEGER ntypes
200  parameter ( ntypes = 11 )
201  INTEGER ntests
202  parameter ( ntests = 9 )
203 * ..
204 * .. Local Scalars ..
205  LOGICAL trfcon, zerot
206  CHARACTER dist, TYPE, uplo, xtype
207  CHARACTER*3 path
208  INTEGER i, i1, i2, imat, in, inb, info, ioff, irhs,
209  $ iuplo, izero, j, k, kl, ku, lda, lwork, mode,
210  $ n, nb, nerrs, nfail, nimat, nrhs, nrun, nt
211  REAL anorm, cndnum, rcond, rcondc
212 * ..
213 * .. Local Arrays ..
214  CHARACTER uplos( 2 )
215  INTEGER iseed( 4 ), iseedy( 4 )
216  REAL result( ntests )
217 * ..
218 * .. External Functions ..
219  REAL sget06, clansy
220  EXTERNAL sget06, clansy
221 * ..
222 * .. External Subroutines ..
223  EXTERNAL alaerh, alahd, alasum, cerrsy, cget04, clacpy,
224  $ clarhs, clatb4, clatms, clatsy, cpot05, csycon,
225  $ csyrfs, csyt01, csyt02, csyt03, csytrf,
226  $ csytri2, csytrs, xlaenv
227 * ..
228 * .. Intrinsic Functions ..
229  INTRINSIC max, min
230 * ..
231 * .. Scalars in Common ..
232  LOGICAL lerr, ok
233  CHARACTER*32 srnamt
234  INTEGER infot, nunit
235 * ..
236 * .. Common blocks ..
237  COMMON / infoc / infot, nunit, ok, lerr
238  COMMON / srnamc / srnamt
239 * ..
240 * .. Data statements ..
241  DATA iseedy / 1988, 1989, 1990, 1991 /
242  DATA uplos / 'U', 'L' /
243 * ..
244 * .. Executable Statements ..
245 *
246 * Initialize constants and the random number seed.
247 *
248  path( 1: 1 ) = 'Complex precision'
249  path( 2: 3 ) = 'SY'
250  nrun = 0
251  nfail = 0
252  nerrs = 0
253  DO 10 i = 1, 4
254  iseed( i ) = iseedy( i )
255  10 CONTINUE
256 *
257 * Test the error exits
258 *
259  IF( tsterr )
260  $ CALL cerrsy( path, nout )
261  infot = 0
262 *
263 * Set the minimum block size for which the block routine should
264 * be used, which will be later returned by ILAENV
265 *
266  CALL xlaenv( 2, 2 )
267 *
268 * Do for each value of N in NVAL
269 *
270  DO 180 in = 1, nn
271  n = nval( in )
272  lda = max( n, 1 )
273  xtype = 'N'
274  nimat = ntypes
275  IF( n.LE.0 )
276  $ nimat = 1
277 *
278  izero = 0
279 *
280 * Do for each value of matrix type IMAT
281 *
282  DO 170 imat = 1, nimat
283 *
284 * Do the tests only if DOTYPE( IMAT ) is true.
285 *
286  IF( .NOT.dotype( imat ) )
287  $ GO TO 170
288 *
289 * Skip types 3, 4, 5, or 6 if the matrix size is too small.
290 *
291  zerot = imat.GE.3 .AND. imat.LE.6
292  IF( zerot .AND. n.LT.imat-2 )
293  $ GO TO 170
294 *
295 * Do first for UPLO = 'U', then for UPLO = 'L'
296 *
297  DO 160 iuplo = 1, 2
298  uplo = uplos( iuplo )
299 *
300 * Begin generate test matrix A.
301 *
302  IF( imat.NE.ntypes ) THEN
303 *
304 * Set up parameters with CLATB4 for the matrix generator
305 * based on the type of matrix to be generated.
306 *
307  CALL clatb4( path, imat, n, n, TYPE, kl, ku, anorm,
308  $ mode, cndnum, dist )
309 *
310 * Generate a matrix with CLATMS.
311 *
312  srnamt = 'CLATMS'
313  CALL clatms( n, n, dist, iseed, TYPE, rwork, mode,
314  $ cndnum, anorm, kl, ku, 'N', a, lda, work,
315  $ info )
316 *
317 * Check error code from CLATMS and handle error.
318 *
319  IF( info.NE.0 ) THEN
320  CALL alaerh( path, 'CLATMS', info, 0, uplo, n, n,
321  $ -1, -1, -1, imat, nfail, nerrs, nout )
322 *
323 * Skip all tests for this generated matrix
324 *
325  GO TO 160
326  END IF
327 *
328 * For matrix types 3-6, zero one or more rows and
329 * columns of the matrix to test that INFO is returned
330 * correctly.
331 *
332  IF( zerot ) THEN
333  IF( imat.EQ.3 ) THEN
334  izero = 1
335  ELSE IF( imat.EQ.4 ) THEN
336  izero = n
337  ELSE
338  izero = n / 2 + 1
339  END IF
340 *
341  IF( imat.LT.6 ) THEN
342 *
343 * Set row and column IZERO to zero.
344 *
345  IF( iuplo.EQ.1 ) THEN
346  ioff = ( izero-1 )*lda
347  DO 20 i = 1, izero - 1
348  a( ioff+i ) = czero
349  20 CONTINUE
350  ioff = ioff + izero
351  DO 30 i = izero, n
352  a( ioff ) = czero
353  ioff = ioff + lda
354  30 CONTINUE
355  ELSE
356  ioff = izero
357  DO 40 i = 1, izero - 1
358  a( ioff ) = czero
359  ioff = ioff + lda
360  40 CONTINUE
361  ioff = ioff - izero
362  DO 50 i = izero, n
363  a( ioff+i ) = czero
364  50 CONTINUE
365  END IF
366  ELSE
367  IF( iuplo.EQ.1 ) THEN
368 *
369 * Set the first IZERO rows to zero.
370 *
371  ioff = 0
372  DO 70 j = 1, n
373  i2 = min( j, izero )
374  DO 60 i = 1, i2
375  a( ioff+i ) = czero
376  60 CONTINUE
377  ioff = ioff + lda
378  70 CONTINUE
379  ELSE
380 *
381 * Set the last IZERO rows to zero.
382 *
383  ioff = 0
384  DO 90 j = 1, n
385  i1 = max( j, izero )
386  DO 80 i = i1, n
387  a( ioff+i ) = czero
388  80 CONTINUE
389  ioff = ioff + lda
390  90 CONTINUE
391  END IF
392  END IF
393  ELSE
394  izero = 0
395  END IF
396 *
397  ELSE
398 *
399 * For matrix kind IMAT = 11, generate special block
400 * diagonal matrix to test alternate code
401 * for the 2 x 2 blocks.
402 *
403  CALL clatsy( uplo, n, a, lda, iseed )
404 *
405  END IF
406 *
407 * End generate test matrix A.
408 *
409 *
410 * Do for each value of NB in NBVAL
411 *
412  DO 150 inb = 1, nnb
413 *
414 * Set the optimal blocksize, which will be later
415 * returned by ILAENV.
416 *
417  nb = nbval( inb )
418  CALL xlaenv( 1, nb )
419 *
420 * Copy the test matrix A into matrix AFAC which
421 * will be factorized in place. This is needed to
422 * preserve the test matrix A for subsequent tests.
423 *
424  CALL clacpy( uplo, n, n, a, lda, afac, lda )
425 *
426 * Compute the L*D*L**T or U*D*U**T factorization of the
427 * matrix. IWORK stores details of the interchanges and
428 * the block structure of D. AINV is a work array for
429 * block factorization, LWORK is the length of AINV.
430 *
431  lwork = max( 2, nb )*lda
432  srnamt = 'CSYTRF'
433  CALL csytrf( uplo, n, afac, lda, iwork, ainv, lwork,
434  $ 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 CSYTRF and handle error.
454 *
455  IF( info.NE.k )
456  $ CALL alaerh( path, 'CSYTRF', info, k, uplo, n, n,
457  $ -1, -1, nb, imat, nfail, nerrs, nout )
458 *
459 * Set the condition estimate flag if the INFO is not 0.
460 *
461  IF( info.NE.0 ) THEN
462  trfcon = .true.
463  ELSE
464  trfcon = .false.
465  END IF
466 *
467 *+ TEST 1
468 * Reconstruct matrix from factors and compute residual.
469 *
470  CALL csyt01( uplo, n, a, lda, afac, lda, iwork, ainv,
471  $ lda, rwork, result( 1 ) )
472  nt = 1
473 *
474 *+ TEST 2
475 * Form the inverse and compute the residual,
476 * if the factorization was competed without INFO > 0
477 * (i.e. there is no zero rows and columns).
478 * Do it only for the first block size.
479 *
480  IF( inb.EQ.1 .AND. .NOT.trfcon ) THEN
481  CALL clacpy( uplo, n, n, afac, lda, ainv, lda )
482  srnamt = 'CSYTRI2'
483  lwork = (n+nb+1)*(nb+3)
484  CALL csytri2( uplo, n, ainv, lda, iwork, work,
485  $ lwork, info )
486 *
487 * Check error code from CSYTRI2 and handle error.
488 *
489  IF( info.NE.0 )
490  $ CALL alaerh( path, 'CSYTRI2', info, 0, uplo, n,
491  $ n, -1, -1, -1, imat, nfail, nerrs,
492  $ nout )
493 *
494 * Compute the residual for a symmetric matrix times
495 * its inverse.
496 *
497  CALL csyt03( uplo, n, a, lda, ainv, lda, work, lda,
498  $ rwork, rcondc, result( 2 ) )
499  nt = 2
500  END IF
501 *
502 * Print information about the tests that did not pass
503 * the threshold.
504 *
505  DO 110 k = 1, nt
506  IF( result( k ).GE.thresh ) THEN
507  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
508  $ CALL alahd( nout, path )
509  WRITE( nout, fmt = 9999 )uplo, n, nb, imat, k,
510  $ result( k )
511  nfail = nfail + 1
512  END IF
513  110 CONTINUE
514  nrun = nrun + nt
515 *
516 * Skip the other tests if this is not the first block
517 * size.
518 *
519  IF( inb.GT.1 )
520  $ GO TO 150
521 *
522 * Do only the condition estimate if INFO is not 0.
523 *
524  IF( trfcon ) THEN
525  rcondc = zero
526  GO TO 140
527  END IF
528 *
529 * Do for each value of NRHS in NSVAL.
530 *
531  DO 130 irhs = 1, nns
532  nrhs = nsval( irhs )
533 *
534 *+ TEST 3 (Using TRS)
535 * Solve and compute residual for A * X = B.
536 *
537 * Choose a set of NRHS random solution vectors
538 * stored in XACT and set up the right hand side B
539 *
540  srnamt = 'CLARHS'
541  CALL clarhs( path, xtype, uplo, ' ', n, n, kl, ku,
542  $ nrhs, a, lda, xact, lda, b, lda,
543  $ iseed, info )
544  CALL clacpy( 'Full', n, nrhs, b, lda, x, lda )
545 *
546  srnamt = 'CSYTRS'
547  CALL csytrs( uplo, n, nrhs, afac, lda, iwork, x,
548  $ lda, info )
549 *
550 * Check error code from CSYTRS and handle error.
551 *
552  IF( info.NE.0 )
553  $ CALL alaerh( path, 'CSYTRS', info, 0, uplo, n,
554  $ n, -1, -1, nrhs, imat, nfail,
555  $ nerrs, nout )
556 *
557  CALL clacpy( 'Full', n, nrhs, b, lda, work, lda )
558 *
559 * Compute the residual for the solution
560 *
561  CALL csyt02( uplo, n, nrhs, a, lda, x, lda, work,
562  $ lda, rwork, result( 3 ) )
563 *
564 *+ TEST 4 (Using TRS2)
565 * Solve and compute residual for A * X = B.
566 *
567 * Choose a set of NRHS random solution vectors
568 * stored in XACT and set up the right hand side B
569 *
570  srnamt = 'CLARHS'
571  CALL clarhs( path, xtype, uplo, ' ', n, n, kl, ku,
572  $ nrhs, a, lda, xact, lda, b, lda,
573  $ iseed, info )
574  CALL clacpy( 'Full', n, nrhs, b, lda, x, lda )
575 *
576  srnamt = 'CSYTRS2'
577  CALL csytrs2( uplo, n, nrhs, afac, lda, iwork, x,
578  $ lda, work, info )
579 *
580 * Check error code from CSYTRS2 and handle error.
581 *
582  IF( info.NE.0 )
583  $ CALL alaerh( path, 'CSYTRS2', info, 0, uplo, n,
584  $ n, -1, -1, nrhs, imat, nfail,
585  $ nerrs, nout )
586 *
587  CALL clacpy( 'Full', n, nrhs, b, lda, work, lda )
588 *
589 * Compute the residual for the solution
590 *
591  CALL csyt02( uplo, n, nrhs, a, lda, x, lda, work,
592  $ lda, rwork, result( 4 ) )
593 *
594 *+ TEST 5
595 * Check solution from generated exact solution.
596 *
597  CALL cget04( n, nrhs, x, lda, xact, lda, rcondc,
598  $ result( 5 ) )
599 *
600 *+ TESTS 6, 7, and 8
601 * Use iterative refinement to improve the solution.
602 *
603  srnamt = 'CSYRFS'
604  CALL csyrfs( uplo, n, nrhs, a, lda, afac, lda,
605  $ iwork, b, lda, x, lda, rwork,
606  $ rwork( nrhs+1 ), work,
607  $ rwork( 2*nrhs+1 ), info )
608 *
609 * Check error code from CSYRFS and handle error.
610 *
611  IF( info.NE.0 )
612  $ CALL alaerh( path, 'CSYRFS', info, 0, uplo, n,
613  $ n, -1, -1, nrhs, imat, nfail,
614  $ nerrs, nout )
615 *
616  CALL cget04( n, nrhs, x, lda, xact, lda, rcondc,
617  $ result( 6 ) )
618  CALL cpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
619  $ xact, lda, rwork, rwork( nrhs+1 ),
620  $ result( 7 ) )
621 *
622 * Print information about the tests that did not pass
623 * the threshold.
624 *
625  DO 120 k = 3, 8
626  IF( result( k ).GE.thresh ) THEN
627  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
628  $ CALL alahd( nout, path )
629  WRITE( nout, fmt = 9998 )uplo, n, nrhs,
630  $ imat, k, result( k )
631  nfail = nfail + 1
632  END IF
633  120 CONTINUE
634  nrun = nrun + 6
635 *
636 * End do for each value of NRHS in NSVAL.
637 *
638  130 CONTINUE
639 *
640 *+ TEST 9
641 * Get an estimate of RCOND = 1/CNDNUM.
642 *
643  140 CONTINUE
644  anorm = clansy( '1', uplo, n, a, lda, rwork )
645  srnamt = 'CSYCON'
646  CALL csycon( uplo, n, afac, lda, iwork, anorm, rcond,
647  $ work, info )
648 *
649 * Check error code from CSYCON and handle error.
650 *
651  IF( info.NE.0 )
652  $ CALL alaerh( path, 'CSYCON', info, 0, uplo, n, n,
653  $ -1, -1, -1, imat, nfail, nerrs, nout )
654 *
655 * Compute the test ratio to compare values of RCOND
656 *
657  result( 9 ) = sget06( rcond, rcondc )
658 *
659 * Print information about the tests that did not pass
660 * the threshold.
661 *
662  IF( result( 9 ).GE.thresh ) THEN
663  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
664  $ CALL alahd( nout, path )
665  WRITE( nout, fmt = 9997 )uplo, n, imat, 9,
666  $ result( 9 )
667  nfail = nfail + 1
668  END IF
669  nrun = nrun + 1
670  150 CONTINUE
671  160 CONTINUE
672  170 CONTINUE
673  180 CONTINUE
674 *
675 * Print a summary of the results.
676 *
677  CALL alasum( path, nout, nfail, nrun, nerrs )
678 *
679  9999 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ', NB =', i4, ', type ',
680  $ i2, ', test ', i2, ', ratio =', g12.5 )
681  9998 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ', NRHS=', i3, ', type ',
682  $ i2, ', test(', i2, ') =', g12.5 )
683  9997 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ',', 10x, ' type ', i2,
684  $ ', test(', i2, ') =', g12.5 )
685  RETURN
686 *
687 * End of CCHKSY
688 *
alahd
subroutine alahd(IOUNIT, PATH)
ALAHD
Definition: alahd.f:95
csyrfs
subroutine csyrfs(UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
CSYRFS
Definition: csyrfs.f:194
alaerh
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:149
clatsy
subroutine clatsy(UPLO, N, X, LDX, ISEED)
CLATSY
Definition: clatsy.f:91
clarhs
subroutine clarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
CLARHS
Definition: clarhs.f:211
csyt02
subroutine csyt02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
CSYT02
Definition: csyt02.f:129
cerrsy
subroutine cerrsy(PATH, NUNIT)
CERRSY
Definition: cerrsy.f:57
csytrs
subroutine csytrs(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
CSYTRS
Definition: csytrs.f:122
csytrs2
subroutine csytrs2(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, INFO)
CSYTRS2
Definition: csytrs2.f:134
sget06
real function sget06(RCOND, RCONDC)
SGET06
Definition: sget06.f:57
xlaenv
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:83
csyt03
subroutine csyt03(UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
CSYT03
Definition: csyt03.f:128
clatms
subroutine clatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
CLATMS
Definition: clatms.f:334
csytrf
subroutine csytrf(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
CSYTRF
Definition: csytrf.f:184
csycon
subroutine csycon(UPLO, N, A, LDA, IPIV, ANORM, RCOND, WORK, INFO)
CSYCON
Definition: csycon.f:127
clansy
real function clansy(NORM, UPLO, N, A, LDA, WORK)
CLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix.
Definition: clansy.f:125
clacpy
subroutine clacpy(UPLO, M, N, A, LDA, B, LDB)
CLACPY copies all or part of one two-dimensional array to another.
Definition: clacpy.f:105
csyt01
subroutine csyt01(UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
CSYT01
Definition: csyt01.f:127
cpot05
subroutine cpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
CPOT05
Definition: cpot05.f:167
clatb4
subroutine clatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
CLATB4
Definition: clatb4.f:123
cget04
subroutine cget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
CGET04
Definition: cget04.f:104
alasum
subroutine alasum(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASUM
Definition: alasum.f:75
csytri2
subroutine csytri2(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
CSYTRI2
Definition: csytri2.f:129

Here is the call graph for this function:

Here is the caller graph for this function: