LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ zchkhe()

subroutine zchkhe ( 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 
)

ZCHKHE

Purpose:
 ZCHKHE tests ZHETRF, -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(3,NSMAX))
[out]RWORK
          RWORK is DOUBLE PRECISION array, dimension (max(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 zchkhe.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 = 10 )
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, zlanhe
220  EXTERNAL dget06, zlanhe
221 * ..
222 * .. External Subroutines ..
223  EXTERNAL alaerh, alahd, alasum, xlaenv, zerrhe, zget04,
226  $ zpot02, zpot03, zpot05
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 ) = 'HE'
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 zerrhe( 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  DO 170 imat = 1, nimat
280 *
281 * Do the tests only if DOTYPE( IMAT ) is true.
282 *
283  IF( .NOT.dotype( imat ) )
284  $ GO TO 170
285 *
286 * Skip types 3, 4, 5, or 6 if the matrix size is too small.
287 *
288  zerot = imat.GE.3 .AND. imat.LE.6
289  IF( zerot .AND. n.LT.imat-2 )
290  $ GO TO 170
291 *
292 * Do first for UPLO = 'U', then for UPLO = 'L'
293 *
294  DO 160 iuplo = 1, 2
295  uplo = uplos( iuplo )
296 *
297 * Set up parameters with ZLATB4 for the matrix generator
298 * based on the type of matrix to be generated.
299 *
300  CALL zlatb4( path, imat, n, n, TYPE, kl, ku, anorm, mode,
301  $ cndnum, dist )
302 *
303 * Generate a matrix with ZLATMS.
304 *
305  srnamt = 'ZLATMS'
306  CALL zlatms( n, n, dist, iseed, TYPE, rwork, mode,
307  $ cndnum, anorm, kl, ku, uplo, a, lda, work,
308  $ info )
309 *
310 * Check error code from ZLATMS and handle error.
311 *
312  IF( info.NE.0 ) THEN
313  CALL alaerh( path, 'ZLATMS', info, 0, uplo, n, n, -1,
314  $ -1, -1, imat, nfail, nerrs, nout )
315 *
316 * Skip all tests for this generated matrix
317 *
318  GO TO 160
319  END IF
320 *
321 * For types 3-6, zero one or more rows and columns of
322 * the matrix to test that INFO is returned correctly.
323 *
324  IF( zerot ) THEN
325  IF( imat.EQ.3 ) THEN
326  izero = 1
327  ELSE IF( imat.EQ.4 ) THEN
328  izero = n
329  ELSE
330  izero = n / 2 + 1
331  END IF
332 *
333  IF( imat.LT.6 ) THEN
334 *
335 * Set row and column IZERO to zero.
336 *
337  IF( iuplo.EQ.1 ) THEN
338  ioff = ( izero-1 )*lda
339  DO 20 i = 1, izero - 1
340  a( ioff+i ) = czero
341  20 CONTINUE
342  ioff = ioff + izero
343  DO 30 i = izero, n
344  a( ioff ) = czero
345  ioff = ioff + lda
346  30 CONTINUE
347  ELSE
348  ioff = izero
349  DO 40 i = 1, izero - 1
350  a( ioff ) = czero
351  ioff = ioff + lda
352  40 CONTINUE
353  ioff = ioff - izero
354  DO 50 i = izero, n
355  a( ioff+i ) = czero
356  50 CONTINUE
357  END IF
358  ELSE
359  IF( iuplo.EQ.1 ) THEN
360 *
361 * Set the first IZERO rows and columns to zero.
362 *
363  ioff = 0
364  DO 70 j = 1, n
365  i2 = min( j, izero )
366  DO 60 i = 1, i2
367  a( ioff+i ) = czero
368  60 CONTINUE
369  ioff = ioff + lda
370  70 CONTINUE
371  ELSE
372 *
373 * Set the last IZERO rows and columns to zero.
374 *
375  ioff = 0
376  DO 90 j = 1, n
377  i1 = max( j, izero )
378  DO 80 i = i1, n
379  a( ioff+i ) = czero
380  80 CONTINUE
381  ioff = ioff + lda
382  90 CONTINUE
383  END IF
384  END IF
385  ELSE
386  izero = 0
387  END IF
388 *
389 * End generate test matrix A.
390 *
391 *
392 * Set the imaginary part of the diagonals.
393 *
394  CALL zlaipd( n, a, lda+1, 0 )
395 *
396 * Do for each value of NB in NBVAL
397 *
398  DO 150 inb = 1, nnb
399 *
400 * Set the optimal blocksize, which will be later
401 * returned by ILAENV.
402 *
403  nb = nbval( inb )
404  CALL xlaenv( 1, nb )
405 *
406 * Copy the test matrix A into matrix AFAC which
407 * will be factorized in place. This is needed to
408 * preserve the test matrix A for subsequent tests.
409 *
410  CALL zlacpy( uplo, n, n, a, lda, afac, lda )
411 *
412 * Compute the L*D*L**T or U*D*U**T factorization of the
413 * matrix. IWORK stores details of the interchanges and
414 * the block structure of D. AINV is a work array for
415 * block factorization, LWORK is the length of AINV.
416 *
417  lwork = max( 2, nb )*lda
418  srnamt = 'ZHETRF'
419  CALL zhetrf( uplo, n, afac, lda, iwork, ainv, lwork,
420  $ info )
421 *
422 * Adjust the expected value of INFO to account for
423 * pivoting.
424 *
425  k = izero
426  IF( k.GT.0 ) THEN
427  100 CONTINUE
428  IF( iwork( k ).LT.0 ) THEN
429  IF( iwork( k ).NE.-k ) THEN
430  k = -iwork( k )
431  GO TO 100
432  END IF
433  ELSE IF( iwork( k ).NE.k ) THEN
434  k = iwork( k )
435  GO TO 100
436  END IF
437  END IF
438 *
439 * Check error code from ZHETRF and handle error.
440 *
441  IF( info.NE.k )
442  $ CALL alaerh( path, 'ZHETRF', info, k, uplo, n, n,
443  $ -1, -1, nb, imat, nfail, nerrs, nout )
444 *
445 * Set the condition estimate flag if the INFO is not 0.
446 *
447  IF( info.NE.0 ) THEN
448  trfcon = .true.
449  ELSE
450  trfcon = .false.
451  END IF
452 *
453 *+ TEST 1
454 * Reconstruct matrix from factors and compute residual.
455 *
456  CALL zhet01( uplo, n, a, lda, afac, lda, iwork, ainv,
457  $ lda, rwork, result( 1 ) )
458  nt = 1
459 *
460 *+ TEST 2
461 * Form the inverse and compute the residual.
462 *
463  IF( inb.EQ.1 .AND. .NOT.trfcon ) THEN
464  CALL zlacpy( uplo, n, n, afac, lda, ainv, lda )
465  srnamt = 'ZHETRI2'
466  lwork = (n+nb+1)*(nb+3)
467  CALL zhetri2( uplo, n, ainv, lda, iwork, work,
468  $ lwork, info )
469 *
470 * Check error code from ZHETRI and handle error.
471 *
472  IF( info.NE.0 )
473  $ CALL alaerh( path, 'ZHETRI', info, -1, uplo, n,
474  $ n, -1, -1, -1, imat, nfail, nerrs,
475  $ nout )
476 *
477 * Compute the residual for a symmetric matrix times
478 * its inverse.
479 *
480  CALL zpot03( uplo, n, a, lda, ainv, lda, work, lda,
481  $ rwork, rcondc, result( 2 ) )
482  nt = 2
483  END IF
484 *
485 * Print information about the tests that did not pass
486 * the threshold.
487 *
488  DO 110 k = 1, nt
489  IF( result( k ).GE.thresh ) THEN
490  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
491  $ CALL alahd( nout, path )
492  WRITE( nout, fmt = 9999 )uplo, n, nb, imat, k,
493  $ result( k )
494  nfail = nfail + 1
495  END IF
496  110 CONTINUE
497  nrun = nrun + nt
498 *
499 * Skip the other tests if this is not the first block
500 * size.
501 *
502  IF( inb.GT.1 )
503  $ GO TO 150
504 *
505 * Do only the condition estimate if INFO is not 0.
506 *
507  IF( trfcon ) THEN
508  rcondc = zero
509  GO TO 140
510  END IF
511 *
512 * Do for each value of NRHS in NSVAL.
513 *
514  DO 130 irhs = 1, nns
515  nrhs = nsval( irhs )
516 *
517 *+ TEST 3 (Using TRS)
518 * Solve and compute residual for A * X = B.
519 *
520 * Choose a set of NRHS random solution vectors
521 * stored in XACT and set up the right hand side B
522 *
523  srnamt = 'ZLARHS'
524  CALL zlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
525  $ nrhs, a, lda, xact, lda, b, lda,
526  $ iseed, info )
527  CALL zlacpy( 'Full', n, nrhs, b, lda, x, lda )
528 *
529  srnamt = 'ZHETRS'
530  CALL zhetrs( uplo, n, nrhs, afac, lda, iwork, x,
531  $ lda, info )
532 *
533 * Check error code from ZHETRS and handle error.
534 *
535  IF( info.NE.0 )
536  $ CALL alaerh( path, 'ZHETRS', info, 0, uplo, n,
537  $ n, -1, -1, nrhs, imat, nfail,
538  $ nerrs, nout )
539 *
540  CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
541 *
542 * Compute the residual for the solution
543 *
544  CALL zpot02( uplo, n, nrhs, a, lda, x, lda, work,
545  $ lda, rwork, result( 3 ) )
546 *
547 *+ TEST 4 (Using TRS2)
548 * Solve and compute residual for A * X = B.
549 *
550 * Choose a set of NRHS random solution vectors
551 * stored in XACT and set up the right hand side B
552 *
553  srnamt = 'ZLARHS'
554  CALL zlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
555  $ nrhs, a, lda, xact, lda, b, lda,
556  $ iseed, info )
557  CALL zlacpy( 'Full', n, nrhs, b, lda, x, lda )
558 *
559  srnamt = 'ZHETRS2'
560  CALL zhetrs2( uplo, n, nrhs, afac, lda, iwork, x,
561  $ lda, work, info )
562 *
563 * Check error code from ZHETRS2 and handle error.
564 *
565  IF( info.NE.0 )
566  $ CALL alaerh( path, 'ZHETRS2', info, 0, uplo, n,
567  $ n, -1, -1, nrhs, imat, nfail,
568  $ nerrs, nout )
569 *
570  CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
571 *
572 * Compute the residual for the solution
573 *
574  CALL zpot02( uplo, n, nrhs, a, lda, x, lda, work,
575  $ lda, rwork, result( 4 ) )
576 *
577 *+ TEST 5
578 * Check solution from generated exact solution.
579 *
580  CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
581  $ result( 5 ) )
582 *
583 *+ TESTS 6, 7, and 8
584 * Use iterative refinement to improve the solution.
585 *
586  srnamt = 'ZHERFS'
587  CALL zherfs( uplo, n, nrhs, a, lda, afac, lda,
588  $ iwork, b, lda, x, lda, rwork,
589  $ rwork( nrhs+1 ), work,
590  $ rwork( 2*nrhs+1 ), info )
591 *
592 * Check error code from ZHERFS.
593 *
594  IF( info.NE.0 )
595  $ CALL alaerh( path, 'ZHERFS', info, 0, uplo, n,
596  $ n, -1, -1, nrhs, imat, nfail,
597  $ nerrs, nout )
598 *
599  CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
600  $ result( 6 ) )
601  CALL zpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
602  $ xact, lda, rwork, rwork( nrhs+1 ),
603  $ result( 7 ) )
604 *
605 * Print information about the tests that did not pass
606 * the threshold.
607 *
608  DO 120 k = 3, 8
609  IF( result( k ).GE.thresh ) THEN
610  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
611  $ CALL alahd( nout, path )
612  WRITE( nout, fmt = 9998 )uplo, n, nrhs,
613  $ imat, k, result( k )
614  nfail = nfail + 1
615  END IF
616  120 CONTINUE
617  nrun = nrun + 6
618 *
619 * End do for each value of NRHS in NSVAL.
620 *
621  130 CONTINUE
622 *
623 *+ TEST 9
624 * Get an estimate of RCOND = 1/CNDNUM.
625 *
626  140 CONTINUE
627  anorm = zlanhe( '1', uplo, n, a, lda, rwork )
628  srnamt = 'ZHECON'
629  CALL zhecon( uplo, n, afac, lda, iwork, anorm, rcond,
630  $ work, info )
631 *
632 * Check error code from ZHECON and handle error.
633 *
634  IF( info.NE.0 )
635  $ CALL alaerh( path, 'ZHECON', info, 0, uplo, n, n,
636  $ -1, -1, -1, imat, nfail, nerrs, nout )
637 *
638  result( 9 ) = dget06( rcond, rcondc )
639 *
640 * Print information about the tests that did not pass
641 * the threshold.
642 *
643  IF( result( 9 ).GE.thresh ) THEN
644  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
645  $ CALL alahd( nout, path )
646  WRITE( nout, fmt = 9997 )uplo, n, imat, 9,
647  $ result( 9 )
648  nfail = nfail + 1
649  END IF
650  nrun = nrun + 1
651  150 CONTINUE
652  160 CONTINUE
653  170 CONTINUE
654  180 CONTINUE
655 *
656 * Print a summary of the results.
657 *
658  CALL alasum( path, nout, nfail, nrun, nerrs )
659 *
660  9999 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ', NB =', i4, ', type ',
661  $ i2, ', test ', i2, ', ratio =', g12.5 )
662  9998 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ', NRHS=', i3, ', type ',
663  $ i2, ', test(', i2, ') =', g12.5 )
664  9997 FORMAT( ' UPLO = ''', a1, ''', N =', i5, ',', 10x, ' type ', i2,
665  $ ', test(', i2, ') =', g12.5 )
666  RETURN
667 *
668 * End of ZCHKHE
669 *
subroutine zhetri2(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
ZHETRI2
Definition: zhetri2.f:129
subroutine alahd(IOUNIT, PATH)
ALAHD
Definition: alahd.f:107
subroutine zpot03(UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZPOT03
Definition: zpot03.f:128
double precision function zlanhe(NORM, UPLO, N, A, LDA, WORK)
ZLANHE 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 Hermitian matrix.
Definition: zlanhe.f:126
subroutine zget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
ZGET04
Definition: zget04.f:104
subroutine zerrhe(PATH, NUNIT)
ZERRHE
Definition: zerrhe.f:57
subroutine zhetrs(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZHETRS
Definition: zhetrs.f:122
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:149
subroutine zhet01(UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZHET01
Definition: zhet01.f:128
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
subroutine zhecon(UPLO, N, A, LDA, IPIV, ANORM, RCOND, WORK, INFO)
ZHECON
Definition: zhecon.f:127
subroutine zlatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB4
Definition: zlatb4.f:123
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:83
subroutine zpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
ZPOT05
Definition: zpot05.f:167
subroutine zlaipd(N, A, INDA, VINDA)
ZLAIPD
Definition: zlaipd.f:85
subroutine zlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
ZLATMS
Definition: zlatms.f:334
subroutine zhetrf(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
ZHETRF
Definition: zhetrf.f:179
double precision function dget06(RCOND, RCONDC)
DGET06
Definition: dget06.f:57
subroutine zlarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
ZLARHS
Definition: zlarhs.f:211
subroutine zpot02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPOT02
Definition: zpot02.f:129
subroutine zhetrs2(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, INFO)
ZHETRS2
Definition: zhetrs2.f:129
subroutine zherfs(UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
ZHERFS
Definition: zherfs.f:194
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: