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

ZCHKSY

Purpose: 
 ZCHKSY tests ZSYTRF, -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 DOUBLE PRECISION
          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*16 array, dimension (NMAX*NMAX)
[out]AFAC
          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]AINV
          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]B
          B is COMPLEX*16 array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.
[out]X
          X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]XACT
          XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]WORK
          WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX))
[out]RWORK
          RWORK is DOUBLE PRECISION 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 zchksy.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  DOUBLE PRECISION thresh
183 * ..
184 * .. Array Arguments ..
185  LOGICAL dotype( * )
186  INTEGER iwork( * ), nbval( * ), nsval( * ), nval( * )
187  DOUBLE PRECISION rwork( * )
188  COMPLEX*16 a( * ), afac( * ), ainv( * ), b( * ),
189  $ work( * ), x( * ), xact( * )
190 * ..
191 *
192 * =====================================================================
193 *
194 * .. Parameters ..
195  DOUBLE PRECISION zero
196  parameter ( zero = 0.0d+0 )
197  COMPLEX*16 czero
198  parameter ( czero = ( 0.0d+0, 0.0d+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  DOUBLE PRECISION anorm, cndnum, rcond, rcondc
212 * ..
213 * .. Local Arrays ..
214  CHARACTER uplos( 2 )
215  INTEGER iseed( 4 ), iseedy( 4 )
216  DOUBLE PRECISION result( ntests )
217 * ..
218 * .. External Functions ..
219  DOUBLE PRECISION dget06, zlansy
220  EXTERNAL dget06, zlansy
221 * ..
222 * .. External Subroutines ..
223  EXTERNAL alaerh, alahd, alasum, xlaenv, zerrsy, zget04,
224  $ zlacpy, zlarhs, zlatb4, zlatms, zlatsy, zpot05,
225  $ zsycon, zsyrfs, zsyt01, zsyt02, zsyt03, zsytrf,
226  $ zsytri2, zsytrs, zsytrs2
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 ) = 'Zomplex 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 zerrsy( 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 ZLATB4 for the matrix generator
305 * based on the type of matrix to be generated.
306 *
307  CALL zlatb4( path, imat, n, n, TYPE, kl, ku, anorm,
308  $ mode, cndnum, dist )
309 *
310 * Generate a matrix with ZLATMS.
311 *
312  srnamt = 'ZLATMS'
313  CALL zlatms( n, n, dist, iseed, TYPE, rwork, mode,
314  $ cndnum, anorm, kl, ku, 'N', a, lda, work,
315  $ info )
316 *
317 * Check error code from ZLATMS and handle error.
318 *
319  IF( info.NE.0 ) THEN
320  CALL alaerh( path, 'ZLATMS', 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 zlatsy( 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 zlacpy( 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 = 'ZSYTRF'
433  CALL zsytrf( 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 ZSYTRF and handle error.
454 *
455  IF( info.NE.k )
456  $ CALL alaerh( path, 'ZSYTRF', 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 zsyt01( 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 zlacpy( uplo, n, n, afac, lda, ainv, lda )
482  srnamt = 'ZSYTRI2'
483  lwork = (n+nb+1)*(nb+3)
484  CALL zsytri2( uplo, n, ainv, lda, iwork, work,
485  $ lwork, info )
486 *
487 * Check error code from ZSYTRI2 and handle error.
488 *
489  IF( info.NE.0 )
490  $ CALL alaerh( path, 'ZSYTRI2', 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 zsyt03( 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 = 'ZLARHS'
541  CALL zlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
542  $ nrhs, a, lda, xact, lda, b, lda,
543  $ iseed, info )
544  CALL zlacpy( 'Full', n, nrhs, b, lda, x, lda )
545 *
546  srnamt = 'ZSYTRS'
547  CALL zsytrs( uplo, n, nrhs, afac, lda, iwork, x,
548  $ lda, info )
549 *
550 * Check error code from ZSYTRS and handle error.
551 *
552  IF( info.NE.0 )
553  $ CALL alaerh( path, 'ZSYTRS', info, 0, uplo, n,
554  $ n, -1, -1, nrhs, imat, nfail,
555  $ nerrs, nout )
556 *
557  CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
558 *
559 * Compute the residual for the solution
560 *
561  CALL zsyt02( 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 = 'ZLARHS'
571  CALL zlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
572  $ nrhs, a, lda, xact, lda, b, lda,
573  $ iseed, info )
574  CALL zlacpy( 'Full', n, nrhs, b, lda, x, lda )
575 *
576  srnamt = 'ZSYTRS2'
577  CALL zsytrs2( uplo, n, nrhs, afac, lda, iwork, x,
578  $ lda, work, info )
579 *
580 * Check error code from ZSYTRS2 and handle error.
581 *
582  IF( info.NE.0 )
583  $ CALL alaerh( path, 'ZSYTRS', info, 0, uplo, n,
584  $ n, -1, -1, nrhs, imat, nfail,
585  $ nerrs, nout )
586 *
587  CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
588 *
589 * Compute the residual for the solution
590 *
591  CALL zsyt02( uplo, n, nrhs, a, lda, x, lda, work,
592  $ lda, rwork, result( 4 ) )
593 *
594 *
595 *+ TEST 5
596 * Check solution from generated exact solution.
597 *
598  CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
599  $ result( 5 ) )
600 *
601 *+ TESTS 6, 7, and 8
602 * Use iterative refinement to improve the solution.
603 *
604  srnamt = 'ZSYRFS'
605  CALL zsyrfs( uplo, n, nrhs, a, lda, afac, lda,
606  $ iwork, b, lda, x, lda, rwork,
607  $ rwork( nrhs+1 ), work,
608  $ rwork( 2*nrhs+1 ), info )
609 *
610 * Check error code from ZSYRFS and handle error.
611 *
612  IF( info.NE.0 )
613  $ CALL alaerh( path, 'ZSYRFS', info, 0, uplo, n,
614  $ n, -1, -1, nrhs, imat, nfail,
615  $ nerrs, nout )
616 *
617  CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
618  $ result( 6 ) )
619  CALL zpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
620  $ xact, lda, rwork, rwork( nrhs+1 ),
621  $ result( 7 ) )
622 *
623 * Print information about the tests that did not pass
624 * the threshold.
625 *
626  DO 120 k = 3, 8
627  IF( result( k ).GE.thresh ) THEN
628  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
629  $ CALL alahd( nout, path )
630  WRITE( nout, fmt = 9998 )uplo, n, nrhs,
631  $ imat, k, result( k )
632  nfail = nfail + 1
633  END IF
634  120 CONTINUE
635  nrun = nrun + 6
636 *
637 * End do for each value of NRHS in NSVAL.
638 *
639  130 CONTINUE
640 *
641 *+ TEST 9
642 * Get an estimate of RCOND = 1/CNDNUM.
643 *
644  140 CONTINUE
645  anorm = zlansy( '1', uplo, n, a, lda, rwork )
646  srnamt = 'ZSYCON'
647  CALL zsycon( uplo, n, afac, lda, iwork, anorm, rcond,
648  $ work, info )
649 *
650 * Check error code from ZSYCON and handle error.
651 *
652  IF( info.NE.0 )
653  $ CALL alaerh( path, 'ZSYCON', info, 0, uplo, n, n,
654  $ -1, -1, -1, imat, nfail, nerrs, nout )
655 *
656 * Compute the test ratio to compare values of RCOND
657 *
658  result( 9 ) = dget06( rcond, rcondc )
659 *
660 * Print information about the tests that did not pass
661 * the threshold.
662 *
663  IF( result( 9 ).GE.thresh ) THEN
664  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
665  $ CALL alahd( nout, path )
666  WRITE( nout, fmt = 9997 )uplo, n, imat, 9,
667  $ result( 9 )
668  nfail = nfail + 1
669  END IF
670  nrun = nrun + 1
671  150 CONTINUE
672  160 CONTINUE
673  170 CONTINUE
674  180 CONTINUE
675 *
676 * Print a summary of the results.
677 *
678  CALL alasum( path, nout, nfail, nrun, nerrs )
679 *
680  9999 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ', NB =', i4, ', type ',
681  $ i2, ', test ', i2, ', ratio =', g12.5 )
682  9998 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ', NRHS=', i3, ', type ',
683  $ i2, ', test(', i2, ') =', g12.5 )
684  9997 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ',', 10x, ' type ', i2,
685  $ ', test(', i2, ') =', g12.5 )
686  RETURN
687 *
688 * End of ZCHKSY
689 *
alahd
subroutine alahd(IOUNIT, PATH)
ALAHD
Definition: alahd.f:95
zsycon
subroutine zsycon(UPLO, N, A, LDA, IPIV, ANORM, RCOND, WORK, INFO)
ZSYCON
Definition: zsycon.f:127
alaerh
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:149
zlacpy
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:105
zerrsy
subroutine zerrsy(PATH, NUNIT)
ZERRSY
Definition: zerrsy.f:57
zget04
subroutine zget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
ZGET04
Definition: zget04.f:104
zlarhs
subroutine zlarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
ZLARHS
Definition: zlarhs.f:211
zsytri2
subroutine zsytri2(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
ZSYTRI2
Definition: zsytri2.f:129
zsyt01
subroutine zsyt01(UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZSYT01
Definition: zsyt01.f:127
xlaenv
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:83
zsytrf
subroutine zsytrf(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
ZSYTRF
Definition: zsytrf.f:184
zsytrs2
subroutine zsytrs2(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, INFO)
ZSYTRS2
Definition: zsytrs2.f:134
zlatsy
subroutine zlatsy(UPLO, N, X, LDX, ISEED)
ZLATSY
Definition: zlatsy.f:91
zlatb4
subroutine zlatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB4
Definition: zlatb4.f:123
zsyt03
subroutine zsyt03(UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZSYT03
Definition: zsyt03.f:128
zlansy
double precision function zlansy(NORM, UPLO, N, A, LDA, WORK)
ZLANSY 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: zlansy.f:125
zsyt02
subroutine zsyt02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZSYT02
Definition: zsyt02.f:129
dget06
double precision function dget06(RCOND, RCONDC)
DGET06
Definition: dget06.f:57
zlatms
subroutine zlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
ZLATMS
Definition: zlatms.f:334
zpot05
subroutine zpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
ZPOT05
Definition: zpot05.f:167
zsyrfs
subroutine zsyrfs(UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
ZSYRFS
Definition: zsyrfs.f:194
zsytrs
subroutine zsytrs(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZSYTRS
Definition: zsytrs.f:122
alasum
subroutine alasum(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASUM
Definition: alasum.f:75

Here is the call graph for this function:

Here is the caller graph for this function: