ScaLAPACK  2.0.2
ScaLAPACK: Scalable Linear Algebra PACKage
pcptinfo.f
Go to the documentation of this file.
00001       SUBROUTINE PCPTINFO( SUMMRY, NOUT, UPLO, NMAT, NVAL, LDNVAL, NBW,
00002      $                     BWVAL, LDBWVAL, NNB, NBVAL, LDNBVAL, NNR,
00003      $                     NRVAL, LDNRVAL, NNBR, NBRVAL, LDNBRVAL,
00004      $                     NGRIDS, PVAL, LDPVAL, QVAL, LDQVAL, THRESH,
00005      $                     WORK, IAM, NPROCS )
00006 *
00007 *
00008 *
00009 *  -- ScaLAPACK routine (version 1.7) --
00010 *     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
00011 *     and University of California, Berkeley.
00012 *     November 15, 1997
00013 *
00014 *     .. Scalar Arguments ..
00015       CHARACTER          UPLO
00016       CHARACTER*(*)      SUMMRY
00017       INTEGER            IAM,
00018      $                   LDBWVAL, LDNBRVAL, LDNBVAL, LDNRVAL, LDNVAL,
00019      $                   LDPVAL, LDQVAL, NGRIDS, NMAT, NNB, NNBR, NBW,
00020      $                   NPROCS, NNR, NOUT
00021       REAL               THRESH
00022 *     ..
00023 *     .. Array Arguments ..
00024       INTEGER            NBRVAL( LDNBRVAL ), NBVAL( LDNBVAL ),
00025      $                   NRVAL( LDNRVAL ), NVAL( LDNVAL ),
00026      $                   BWVAL( LDBWVAL),
00027      $                   PVAL( LDPVAL ), QVAL(LDQVAL), WORK( * )
00028 *     ..
00029 *
00030 *  Purpose
00031 *  =======
00032 *
00033 *  PCPTINFO get needed startup information for band factorization
00034 *  and transmits it to all processes.
00035 *
00036 *  Arguments
00037 *  =========
00038 *
00039 *  SUMMRY   (global output) CHARACTER*(*)
00040 *           Name of output (summary) file (if any). Only defined for
00041 *           process 0.
00042 *
00043 *  NOUT     (global output) INTEGER
00044 *           The unit number for output file. NOUT = 6, ouput to screen,
00045 *           NOUT = 0, output to stderr.  Only defined for process 0.
00046 *
00047 *  UPLO     (global output) CHARACTER
00048 *           Specifies whether the upper or lower triangular part of the
00049 *           symmetric matrix A is stored.
00050 *           = 'U':  Upper triangular
00051 *           = 'L':  Lower triangular
00052 *
00053 *
00054 *  NMAT     (global output) INTEGER
00055 *           The number of different values that can be used for N.
00056 *
00057 *  NVAL     (global output) INTEGER array, dimension (LDNVAL)
00058 *           The values of N (number of columns in matrix) to run the
00059 *           code with.
00060 *
00061 *  NBW      (global output) INTEGER
00062 *           The number of different values that can be used for @bw@.
00063 *  BWVAL    (global output) INTEGER array, dimension (LDNVAL)
00064 *           The values of BW (number of subdiagonals in matrix) to run
00065 *           the code with.
00066 *
00067 *  LDNVAL   (global input) INTEGER
00068 *           The maximum number of different values that can be used for
00069 *           N, LDNVAL > =  NMAT.
00070 *
00071 *  NNB      (global output) INTEGER
00072 *           The number of different values that can be used for NB.
00073 *
00074 *  NBVAL    (global output) INTEGER array, dimension (LDNBVAL)
00075 *           The values of NB (blocksize) to run the code with.
00076 *
00077 *  LDNBVAL  (global input) INTEGER
00078 *           The maximum number of different values that can be used for
00079 *           NB, LDNBVAL >= NNB.
00080 *
00081 *  NNR      (global output) INTEGER
00082 *           The number of different values that can be used for NRHS.
00083 *
00084 *  NRVAL    (global output) INTEGER array, dimension(LDNRVAL)
00085 *           The values of NRHS (# of Right Hand Sides) to run the code
00086 *           with.
00087 *
00088 *  LDNRVAL  (global input) INTEGER
00089 *           The maximum number of different values that can be used for
00090 *           NRHS, LDNRVAL >= NNR.
00091 *
00092 *  NNBR     (global output) INTEGER
00093 *           The number of different values that can be used for NBRHS.
00094 *
00095 *  NBRVAL   (global output) INTEGER array, dimension (LDNBRVAL)
00096 *           The values of NBRHS (RHS blocksize) to run the code with.
00097 *
00098 *  LDNBRVAL (global input) INTEGER
00099 *           The maximum number of different values that can be used for
00100 *           NBRHS, LDNBRVAL >= NBRVAL.
00101 *
00102 *  NGRIDS   (global output) INTEGER
00103 *           The number of different values that can be used for P & Q.
00104 *
00105 *  PVAL     (global output) INTEGER array, dimension (LDPVAL)
00106 *           Not used (will be returned as all 1s) since proc grid is 1D
00107 *
00108 *  LDPVAL   (global input) INTEGER
00109 *           The maximum number of different values that can be used for
00110 *           P, LDPVAL >= NGRIDS.
00111 *
00112 *  QVAL     (global output) INTEGER array, dimension (LDQVAL)
00113 *           The values of Q (number of process columns) to run the code
00114 *           with.
00115 *
00116 *  LDQVAL   (global input) INTEGER
00117 *           The maximum number of different values that can be used for
00118 *           Q, LDQVAL >= NGRIDS.
00119 *
00120 *  THRESH   (global output) REAL
00121 *           Indicates what error checks shall be run and printed out:
00122 *            = 0 : Perform no error checking
00123 *            > 0 : report all residuals greater than THRESH, perform
00124 *                  factor check only if solve check fails
00125 *
00126 *  WORK     (local workspace) INTEGER array of dimension >=
00127 *           MAX( 8, LDNVAL+2*LDNBVAL+LDNRVAL+LDNBRVAL+LDPVAL+LDQVAL
00128 *    $              +3*LDNVAL)
00129 *           Used to pack input arrays in order to send info in one
00130 *           message.
00131 *
00132 *  IAM      (local input) INTEGER
00133 *           My process number.
00134 *
00135 *  NPROCS   (global input) INTEGER
00136 *           The total number of processes.
00137 *
00138 * ======================================================================
00139 *
00140 * Note: For packing the information we assumed that the length in bytes
00141 * ===== of an integer is equal to the length in bytes of a real single
00142 *       precision.
00143 *
00144 *  =====================================================================
00145 *
00146 *  Code Developer: Andrew J. Cleary, University of Tennessee.
00147 *    Current address: Lawrence Livermore National Labs.
00148 *  This version released: August, 2001.
00149 *
00150 * ======================================================================
00151 *
00152 *     .. Parameters ..
00153       INTEGER            NIN
00154       PARAMETER          ( NIN = 11 )
00155 *     ..
00156 *     .. Local Scalars ..
00157       INTEGER            I, ICTXT
00158       CHARACTER*79       USRINFO
00159       REAL               EPS
00160 *     ..
00161 *     .. External Subroutines ..
00162       EXTERNAL           BLACS_ABORT, BLACS_GET, BLACS_GRIDEXIT,
00163      $                   BLACS_GRIDINIT, BLACS_SETUP, ICOPY, IGEBR2D,
00164      $                   IGEBS2D, SGEBR2D, SGEBS2D
00165 *     ..
00166 *     .. External Functions ..
00167       LOGICAL            LSAME
00168       REAL               PSLAMCH
00169       EXTERNAL           LSAME, PSLAMCH
00170 *     ..
00171 *     .. Intrinsic Functions ..
00172       INTRINSIC          MAX, MIN
00173 *     ..
00174 *     .. Executable Statements ..
00175 *
00176 *     Process 0 reads the input data, broadcasts to other processes and
00177 *     writes needed information to NOUT
00178 *
00179       IF( IAM.EQ.0 ) THEN
00180 *
00181 *        Open file and skip data file header
00182 *
00183          OPEN( NIN, FILE = 'BLLT.dat', STATUS = 'OLD' )
00184          READ( NIN, FMT = * ) SUMMRY
00185          SUMMRY = ' '
00186 *
00187 *        Read in user-supplied info about machine type, compiler, etc.
00188 *
00189          READ( NIN, FMT = 9999 ) USRINFO
00190 *
00191 *        Read name and unit number for summary output file
00192 *
00193          READ( NIN, FMT = * ) SUMMRY
00194          READ( NIN, FMT = * ) NOUT
00195          IF( NOUT.NE.0 .AND. NOUT.NE.6 )
00196      $      OPEN( NOUT, FILE = SUMMRY, STATUS = 'UNKNOWN' )
00197 *
00198 *        Read and check the parameter values for the tests.
00199 *
00200 *        Get UPLO
00201 *
00202          READ( NIN, FMT = * ) UPLO
00203 *
00204 *
00205 *        Get number of matrices and their dimensions
00206 *
00207          READ( NIN, FMT = * ) NMAT
00208          IF( NMAT.LT.1 .OR. NMAT.GT.LDNVAL ) THEN
00209             WRITE( NOUT, FMT = 9994 ) 'N', LDNVAL
00210             GO TO 20
00211          END IF
00212          READ( NIN, FMT = * ) ( NVAL( I ), I = 1, NMAT )
00213 *
00214 *        Get bandwidths
00215 *
00216          READ( NIN, FMT = * ) NBW
00217          NBW = 1
00218          IF( NBW.LT.1 .OR. NBW.GT.LDBWVAL ) THEN
00219             WRITE( NOUT, FMT = 9994 ) 'BW', LDBWVAL
00220             GO TO 20
00221          END IF
00222          READ( NIN, FMT = * ) ( BWVAL( I ), I = 1, NBW )
00223 *
00224 *        Get values of NB
00225 *
00226          READ( NIN, FMT = * ) NNB
00227          IF( NNB.LT.1 .OR. NNB.GT.LDNBVAL ) THEN
00228             WRITE( NOUT, FMT = 9994 ) 'NB', LDNBVAL
00229             GO TO 20
00230          END IF
00231          READ( NIN, FMT = * ) ( NBVAL( I ), I = 1, NNB )
00232 *
00233 *        Get values of NRHS
00234 *
00235          READ( NIN, FMT = * ) NNR
00236          IF( NNR.LT.1 .OR. NNR.GT.LDNRVAL ) THEN
00237             WRITE( NOUT, FMT = 9994 ) 'NRHS', LDNRVAL
00238             GO TO 20
00239          END IF
00240          READ( NIN, FMT = * ) ( NRVAL( I ), I = 1, NNR )
00241 *
00242 *        Get values of NBRHS
00243 *
00244          READ( NIN, FMT = * ) NNBR
00245          IF( NNBR.LT.1 .OR. NNBR.GT.LDNBRVAL ) THEN
00246             WRITE( NOUT, FMT = 9994 ) 'NBRHS', LDNBRVAL
00247             GO TO 20
00248          END IF
00249          READ( NIN, FMT = * ) ( NBRVAL( I ), I = 1, NNBR )
00250 *
00251 *        Get number of grids
00252 *
00253          READ( NIN, FMT = * ) NGRIDS
00254          IF( NGRIDS.LT.1 .OR. NGRIDS.GT.LDPVAL ) THEN
00255             WRITE( NOUT, FMT = 9994 ) 'Grids', LDPVAL
00256             GO TO 20
00257          ELSE IF( NGRIDS.GT.LDQVAL ) THEN
00258             WRITE( NOUT, FMT = 9994 ) 'Grids', LDQVAL
00259             GO TO 20
00260          END IF
00261 *
00262 *        Processor grid must be 1D so set PVAL to 1
00263          DO 8738 I = 1, NGRIDS
00264             PVAL( I ) = 1
00265  8738    CONTINUE
00266 *
00267 *        Get values of Q
00268 *
00269          READ( NIN, FMT = * ) ( QVAL( I ), I = 1, NGRIDS )
00270 *
00271 *        Get level of checking
00272 *
00273          READ( NIN, FMT = * ) THRESH
00274 *
00275 *        Close input file
00276 *
00277          CLOSE( NIN )
00278 *
00279 *        For pvm only: if virtual machine not set up, allocate it and
00280 *        spawn the correct number of processes.
00281 *
00282          IF( NPROCS.LT.1 ) THEN
00283             NPROCS = 0
00284             DO 10 I = 1, NGRIDS
00285                NPROCS = MAX( NPROCS, PVAL( I )*QVAL( I ) )
00286    10       CONTINUE
00287             CALL BLACS_SETUP( IAM, NPROCS )
00288          END IF
00289 *
00290 *        Temporarily define blacs grid to include all processes so
00291 *        information can be broadcast to all processes.
00292 *
00293          CALL BLACS_GET( -1, 0, ICTXT )
00294          CALL BLACS_GRIDINIT( ICTXT, 'Row-major', 1, NPROCS )
00295 *
00296 *        Compute machine epsilon
00297 *
00298          EPS = PSLAMCH( ICTXT, 'eps' )
00299 *
00300 *        Pack information arrays and broadcast
00301 *
00302          CALL SGEBS2D( ICTXT, 'All', ' ', 1, 1, THRESH, 1 )
00303          I = 1
00304          WORK( I ) = NMAT
00305          I = I+1
00306          WORK( I ) = NBW
00307          I = I+1
00308          WORK( I ) = NNB
00309          I = I+1
00310          WORK( I ) = NNR
00311          I = I+1
00312          WORK( I ) = NNBR
00313          I = I+1
00314          WORK( I ) = NGRIDS
00315          I = I+1
00316          IF( LSAME( UPLO, 'L' ) ) THEN
00317             WORK( I ) = 1
00318          ELSE
00319             WORK( I ) = 2
00320          END IF
00321          I = I+1
00322 *        Send number of elements to be sent
00323          CALL IGEBS2D( ICTXT, 'All', ' ', 1, 1, I-1, 1 )
00324 *        Send elements
00325          CALL IGEBS2D( ICTXT, 'All', ' ', I-1, 1, WORK, I-1 )
00326 *
00327          I = 1
00328          CALL ICOPY( NMAT, NVAL, 1, WORK( I ), 1 )
00329          I = I + NMAT
00330          CALL ICOPY( NBW, BWVAL, 1, WORK( I ), 1 )
00331          I = I + NBW
00332          CALL ICOPY( NNB, NBVAL, 1, WORK( I ), 1 )
00333          I = I + NNB
00334          CALL ICOPY( NNR, NRVAL, 1, WORK( I ), 1 )
00335          I = I + NNR
00336          CALL ICOPY( NNBR, NBRVAL, 1, WORK( I ), 1 )
00337          I = I + NNBR
00338          CALL ICOPY( NGRIDS, PVAL, 1, WORK( I ), 1 )
00339          I = I + NGRIDS
00340          CALL ICOPY( NGRIDS, QVAL, 1, WORK( I ), 1 )
00341          I = I + NGRIDS
00342          CALL IGEBS2D( ICTXT, 'All', ' ', I-1, 1, WORK, I-1 )
00343 *
00344 *        regurgitate input
00345 *
00346          WRITE( NOUT, FMT = 9999 )
00347      $                   'SCALAPACK banded linear systems.'
00348          WRITE( NOUT, FMT = 9999 ) USRINFO
00349          WRITE( NOUT, FMT = * )
00350          WRITE( NOUT, FMT = 9999 )
00351      $                   'Tests of the parallel '//
00352      $                   'complex single precision band matrix solve '
00353          WRITE( NOUT, FMT = 9999 )
00354      $                   'The following scaled residual '//
00355      $                   'checks will be computed:'
00356          WRITE( NOUT, FMT = 9999 )
00357      $                   ' Solve residual         = ||Ax - b|| / '//
00358      $                   '(||x|| * ||A|| * eps * N)'
00359          IF( LSAME( UPLO, 'L' ) ) THEN
00360             WRITE( NOUT, FMT = 9999 )
00361      $                   ' Factorization residual = ||A - LL''|| /'//
00362      $                   ' (||A|| * eps * N)'
00363          ELSE
00364             WRITE( NOUT, FMT = 9999 )
00365      $                   ' Factorization residual = ||A - U''U|| /'//
00366      $                   ' (||A|| * eps * N)'
00367          END IF
00368          WRITE( NOUT, FMT = 9999 )
00369      $                   'The matrix A is randomly '//
00370      $                   'generated for each test.'
00371          WRITE( NOUT, FMT = * )
00372          WRITE( NOUT, FMT = 9999 )
00373      $                   'An explanation of the input/output '//
00374      $                   'parameters follows:'
00375          WRITE( NOUT, FMT = 9999 )
00376      $                   'TIME    : Indicates whether WALL or '//
00377      $                   'CPU time was used.'
00378 *
00379          WRITE( NOUT, FMT = 9999 )
00380      $                 'UPLO    : Whether data represents ''Upper'//
00381      $                 ''' or ''Lower'' triangular portion of array A.'
00382          WRITE( NOUT, FMT = 9999 )
00383      $                 'TRANS    : Whether solve is to be done with'//
00384      $                 ' ''Transpose'' of matrix A (T,C) or not (N).'
00385          WRITE( NOUT, FMT = 9999 )
00386      $                   'N       : The number of rows and columns '//
00387      $                   'in the matrix A.'
00388          WRITE( NOUT, FMT = 9999 )
00389      $                   'bw      : The number of diagonals '//
00390      $                   'in the matrix A.'
00391          WRITE( NOUT, FMT = 9999 )
00392      $                   'NB      : The size of the column panels the'//
00393      $                   ' matrix A is split into. [-1 for default]'
00394          WRITE( NOUT, FMT = 9999 )
00395      $                   'NRHS    : The total number of RHS to solve'//
00396      $                   ' for.'
00397          WRITE( NOUT, FMT = 9999 )
00398      $                   'NBRHS   : The number of RHS to be put on '//
00399      $                   'a column of processes before going'
00400          WRITE( NOUT, FMT = 9999 )
00401      $                   '          on to the next column of processes.'
00402          WRITE( NOUT, FMT = 9999 )
00403      $                   'P       : The number of process rows.'
00404          WRITE( NOUT, FMT = 9999 )
00405      $                   'Q       : The number of process columns.'
00406          WRITE( NOUT, FMT = 9999 )
00407      $                   'THRESH  : If a residual value is less than'//
00408      $                   ' THRESH, CHECK is flagged as PASSED'
00409          WRITE( NOUT, FMT = 9999 )
00410      $                   'Fact time: Time in seconds to factor the'//
00411      $                   ' matrix'
00412          WRITE( NOUT, FMT = 9999 )
00413      $                   'Sol Time: Time in seconds to solve the'//
00414      $                   ' system.'
00415          WRITE( NOUT, FMT = 9999 )
00416      $                   'MFLOPS  : Rate of execution for factor '//
00417      $                   'and solve using sequential operation count.'
00418          WRITE( NOUT, FMT = 9999 )
00419      $                   'MFLOP2  : Rough estimate of speed '//
00420      $                   'using actual op count (accurate big P,N).'
00421          WRITE( NOUT, FMT = * )
00422          WRITE( NOUT, FMT = 9999 )
00423      $                   'The following parameter values will be used:'
00424          WRITE( NOUT, FMT = 9999 )
00425      $                   '  UPLO :             '//UPLO
00426          WRITE( NOUT, FMT = 9996 )
00427      $                   'N    ', ( NVAL(I), I = 1, MIN(NMAT, 10) )
00428          IF( NMAT.GT.10 )
00429      $      WRITE( NOUT, FMT = 9997 ) ( NVAL(I), I = 11, NMAT )
00430          WRITE( NOUT, FMT = 9996 )
00431      $                   'bw   ', ( BWVAL(I), I = 1, MIN(NBW, 10) )
00432          IF( NBW.GT.10 )
00433      $      WRITE( NOUT, FMT = 9997 ) ( BWVAL(I), I = 11, NBW )
00434          WRITE( NOUT, FMT = 9996 )
00435      $                   'NB   ', ( NBVAL(I), I = 1, MIN(NNB, 10) )
00436          IF( NNB.GT.10 )
00437      $      WRITE( NOUT, FMT = 9997 ) ( NBVAL(I), I = 11, NNB )
00438          WRITE( NOUT, FMT = 9996 )
00439      $                   'NRHS ', ( NRVAL(I), I = 1, MIN(NNR, 10) )
00440          IF( NNR.GT.10 )
00441      $      WRITE( NOUT, FMT = 9997 ) ( NRVAL(I), I = 11, NNR )
00442          WRITE( NOUT, FMT = 9996 )
00443      $                   'NBRHS', ( NBRVAL(I), I = 1, MIN(NNBR, 10) )
00444          IF( NNBR.GT.10 )
00445      $      WRITE( NOUT, FMT = 9997 ) ( NBRVAL(I), I = 11, NNBR )
00446          WRITE( NOUT, FMT = 9996 )
00447      $                   'P    ', ( PVAL(I), I = 1, MIN(NGRIDS, 10) )
00448          IF( NGRIDS.GT.10 )
00449      $      WRITE( NOUT, FMT = 9997) ( PVAL(I), I = 11, NGRIDS )
00450          WRITE( NOUT, FMT = 9996 )
00451      $                   'Q    ', ( QVAL(I), I = 1, MIN(NGRIDS, 10) )
00452          IF( NGRIDS.GT.10 )
00453      $      WRITE( NOUT, FMT = 9997 ) ( QVAL(I), I = 11, NGRIDS )
00454          WRITE( NOUT, FMT = * )
00455          WRITE( NOUT, FMT = 9995 ) EPS
00456          WRITE( NOUT, FMT = 9998 ) THRESH
00457 *
00458       ELSE
00459 *
00460 *        If in pvm, must participate setting up virtual machine
00461 *
00462          IF( NPROCS.LT.1 )
00463      $      CALL BLACS_SETUP( IAM, NPROCS )
00464 *
00465 *        Temporarily define blacs grid to include all processes so
00466 *        all processes have needed startup information
00467 *
00468          CALL BLACS_GET( -1, 0, ICTXT )
00469          CALL BLACS_GRIDINIT( ICTXT, 'Row-major', 1, NPROCS )
00470 *
00471 *        Compute machine epsilon
00472 *
00473          EPS = PSLAMCH( ICTXT, 'eps' )
00474 *
00475          CALL SGEBR2D( ICTXT, 'All', ' ', 1, 1, THRESH, 1, 0, 0 )
00476          CALL IGEBR2D( ICTXT, 'All', ' ', 1, 1, I, 1, 0, 0 )
00477          CALL IGEBR2D( ICTXT, 'All', ' ', I, 1, WORK, I, 0, 0 )
00478          I = 1
00479          NMAT = WORK( I )
00480          I = I+1
00481          NBW = WORK( I )
00482          I = I+1
00483          NNB = WORK( I )
00484          I = I+1
00485          NNR = WORK( I )
00486          I = I+1
00487          NNBR = WORK( I )
00488          I = I+1
00489          NGRIDS = WORK( I )
00490          I = I+1
00491          IF( WORK( I ) .EQ. 1 ) THEN
00492             UPLO = 'L'
00493          ELSE
00494             UPLO = 'U'
00495          END IF
00496          I = I+1
00497 *
00498          I = NMAT + NBW + NNB + NNR + NNBR + 2*NGRIDS
00499 *
00500          CALL IGEBR2D( ICTXT, 'All', ' ', 1, I, WORK, 1, 0, 0 )
00501          I = 1
00502          CALL ICOPY( NMAT, WORK( I ), 1, NVAL, 1 )
00503          I = I + NMAT
00504          CALL ICOPY( NBW, WORK( I ), 1, BWVAL, 1 )
00505          I = I + NBW
00506          CALL ICOPY( NNB, WORK( I ), 1, NBVAL, 1 )
00507          I = I + NNB
00508          CALL ICOPY( NNR, WORK( I ), 1, NRVAL, 1 )
00509          I = I + NNR
00510          CALL ICOPY( NNBR, WORK( I ), 1, NBRVAL, 1 )
00511          I = I + NNBR
00512          CALL ICOPY( NGRIDS, WORK( I ), 1, PVAL, 1 )
00513          I = I + NGRIDS
00514          CALL ICOPY( NGRIDS, WORK( I ), 1, QVAL, 1 )
00515 *
00516       END IF
00517 *
00518       CALL BLACS_GRIDEXIT( ICTXT )
00519 *
00520       RETURN
00521 *
00522    20 WRITE( NOUT, FMT = 9993 )
00523       CLOSE( NIN )
00524       IF( NOUT.NE.6 .AND. NOUT.NE.0 )
00525      $   CLOSE( NOUT )
00526 *
00527       CALL BLACS_ABORT( ICTXT, 1 )
00528       STOP
00529 *
00530  9999 FORMAT( A )
00531  9998 FORMAT( 'Routines pass computational tests if scaled residual ',
00532      $        'is less than ', G12.5 )
00533  9997 FORMAT( '                ', 10I6 )
00534  9996 FORMAT( 2X, A5, ':        ', 10I6 )
00535  9995 FORMAT( 'Relative machine precision (eps) is taken to be ',
00536      $        E18.6 )
00537  9994 FORMAT( ' Number of values of ',5A, ' is less than 1 or greater ',
00538      $        'than ', I2 )
00539  9993 FORMAT( ' Illegal input in file ',40A,'.  Aborting run.' )
00540 *
00541 *     End of PCPTINFO
00542 *
00543       END