636 lines
22 KiB
FortranFixed
636 lines
22 KiB
FortranFixed
PROGRAM STIMEE
|
|
*
|
|
* -- LAPACK timing routine (version 3.1) --
|
|
* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
|
|
* October 2006
|
|
*
|
|
* Purpose
|
|
* =======
|
|
*
|
|
* STIMEE is the main timing program for the REAL matrix
|
|
* eigenvalue routines in LAPACK.
|
|
*
|
|
* There are four sets of routines that can be timed:
|
|
*
|
|
* NEP (Nonsymmetric Eigenvalue Problem):
|
|
* Includes SGEHRD, SHSEQR, STREVC, and SHSEIN
|
|
*
|
|
* SEP (Symmetric Eigenvalue Problem):
|
|
* Includes SSYTRD, SORGTR, SORMTR, SSTEQR, SSTERF, SPTEQR, SSTEBZ,
|
|
* SSTEIN, and SSTEDC
|
|
*
|
|
* SVD (Singular Value Decomposition):
|
|
* Includes SGEBRD, SBDSQR, SORGBR, SBDSDC and SGESDD
|
|
*
|
|
* GEP (Generalized nonsymmetric Eigenvalue Problem):
|
|
* Includes SGGHRD, SHGEQZ, and STGEVC
|
|
*
|
|
* Each test path has a different input file. The first line of the
|
|
* input file should contain the characters NEP, SEP, SVD, or GEP in
|
|
* columns 1-3. The number of remaining lines depends on what is found
|
|
* on the first line.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*
|
|
* NEP input file:
|
|
*
|
|
* line 2: NN, INTEGER
|
|
* Number of values of N.
|
|
*
|
|
* line 3: NVAL, INTEGER array, dimension (NN)
|
|
* The values for the matrix dimension N.
|
|
*
|
|
* line 4: NPARM, INTEGER
|
|
* Number of values of the parameters NB, NS, MAXB, and LDA.
|
|
*
|
|
* line 5: NBVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the blocksize NB.
|
|
*
|
|
* line 6: NSVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the number of shifts.
|
|
*
|
|
* line 7: MXBVAL, INTEGER array, dimension (NPARM)
|
|
* The values for MAXB, used in determining whether multishift
|
|
* will be used.
|
|
*
|
|
* line 8: LDAVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the leading dimension LDA.
|
|
*
|
|
* line 9: TIMMIN, REAL
|
|
* The minimum time (in seconds) that a subroutine will be
|
|
* timed. If TIMMIN is zero, each routine should be timed only
|
|
* once.
|
|
*
|
|
* line 10: NTYPES, INTEGER
|
|
* The number of matrix types to be used in the timing run.
|
|
* If NTYPES >= MAXTYP, all the types are used.
|
|
*
|
|
* If 0 < NTYPES < MAXTYP, then line 11 specifies NTYPES integer
|
|
* values, which are the numbers of the matrix types to be used.
|
|
*
|
|
* The remaining lines specify a path name and the specific routines to
|
|
* be timed. For the nonsymmetric eigenvalue problem, the path name is
|
|
* 'SHS'. A line to request all the routines in this path has the form
|
|
* SHS T T T T T T T T T T T T
|
|
* where the first 3 characters specify the path name, and up to MAXTYP
|
|
* nonblank characters may appear in columns 4-80. If the k-th such
|
|
* character is 'T' or 't', the k-th routine will be timed. If at least
|
|
* one but fewer than 12 nonblank characters are specified, the
|
|
* remaining routines will not be timed. If columns 4-80 are blank, all
|
|
* the routines will be timed, so the input line
|
|
* SHS
|
|
* is equivalent to the line above.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*
|
|
* SEP input file:
|
|
*
|
|
* line 2: NN, INTEGER
|
|
* Number of values of N.
|
|
*
|
|
* line 3: NVAL, INTEGER array, dimension (NN)
|
|
* The values for the matrix dimension N.
|
|
*
|
|
* line 4: NPARM, INTEGER
|
|
* Number of values of the parameters NB and LDA.
|
|
*
|
|
* line 5: NBVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the blocksize NB.
|
|
*
|
|
* line 6: LDAVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the leading dimension LDA.
|
|
*
|
|
* line 7: TIMMIN, REAL
|
|
* The minimum time (in seconds) that a subroutine will be
|
|
* timed. If TIMMIN is zero, each routine should be timed only
|
|
* once.
|
|
*
|
|
* line 8: NTYPES, INTEGER
|
|
* The number of matrix types to be used in the timing run.
|
|
* If NTYPES >= MAXTYP, all the types are used.
|
|
*
|
|
* If 0 < NTYPES < MAXTYP, then line 9 specifies NTYPES integer
|
|
* values, which are the numbers of the matrix types to be used.
|
|
*
|
|
* The remaining lines specify a path name and the specific routines to
|
|
* be timed as for the NEP input file. For the symmetric eigenvalue
|
|
* problem, the path name is 'SST' and up to 8 routines may be timed.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*
|
|
* SVD input file:
|
|
*
|
|
* line 2: NN, INTEGER
|
|
* Number of values of M and N.
|
|
*
|
|
* line 3: MVAL, INTEGER array, dimension (NN)
|
|
* The values for the matrix dimension M.
|
|
*
|
|
* line 4: NVAL, INTEGER array, dimension (NN)
|
|
* The values for the matrix dimension N.
|
|
*
|
|
* line 5: NPARM, INTEGER
|
|
* Number of values of the parameters NB and LDA.
|
|
*
|
|
* line 6: NBVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the blocksize NB.
|
|
*
|
|
* line 7: LDAVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the leading dimension LDA.
|
|
*
|
|
* line 8: TIMMIN, REAL
|
|
* The minimum time (in seconds) that a subroutine will be
|
|
* timed. If TIMMIN is zero, each routine should be timed only
|
|
* once.
|
|
*
|
|
* line 9: NTYPES, INTEGER
|
|
* The number of matrix types to be used in the timing run.
|
|
* If NTYPES >= MAXTYP, all the types are used.
|
|
*
|
|
* If 0 < NTYPES < MAXTYP, then line 10 specifies NTYPES integer
|
|
* values, which are the numbers of the matrix types to be used.
|
|
*
|
|
* The remaining lines specify a path name and the specific routines to
|
|
* be timed as for the NEP input file. For the singular value
|
|
* decomposition the path name is 'SBD' and up to 16 routines may be
|
|
* timed.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*
|
|
* GEP input file:
|
|
*
|
|
* line 2: NN, INTEGER
|
|
* Number of values of N.
|
|
*
|
|
* line 3: NVAL, INTEGER array, dimension (NN)
|
|
* The values for the matrix dimension N.
|
|
*
|
|
* line 4: NPARM, INTEGER
|
|
* Number of values of the parameters NB, NS, MAXB, and LDA.
|
|
*
|
|
* line 5: NBVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the blocksize NB.
|
|
*
|
|
* line 6: NSVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the number of shifts.
|
|
*
|
|
* line 7: NEIVAL, INTEGER array, dimension (NPARM)
|
|
* The values for NEISP, used in determining whether multishift
|
|
* will be used.
|
|
*
|
|
* line 8: NBMVAL, INTEGER array, dimension (NPARM)
|
|
* The values for MINNB, used in determining minimum blocksize.
|
|
*
|
|
* line 9: NBKVAL, INTEGER array, dimension (NPARM)
|
|
* The values for MINBLK, also used in determining minimum
|
|
* blocksize.
|
|
*
|
|
* line 10: LDAVAL, INTEGER array, dimension (NPARM)
|
|
* The values for the leading dimension LDA.
|
|
*
|
|
* line 11: TIMMIN, REAL
|
|
* The minimum time (in seconds) that a subroutine will be
|
|
* timed. If TIMMIN is zero, each routine should be timed only
|
|
* once.
|
|
*
|
|
* line 12: NTYPES, INTEGER
|
|
* The number of matrix types to be used in the timing run.
|
|
* If NTYPES >= MAXTYP, all the types are used.
|
|
*
|
|
* If 0 < NTYPES < MAXTYP, then line 13 specifies NTYPES integer
|
|
* values, which are the numbers of the matrix types to be used.
|
|
*
|
|
* The remaining lines specify a path name and the specific routines to
|
|
* be timed. For the nonsymmetric eigenvalue problem, the path name is
|
|
* 'SHG'. A line to request all the routines in this path has the form
|
|
* SHG T T T T T T T T T T T T T T T T T T
|
|
* where the first 3 characters specify the path name, and up to MAXTYP
|
|
* nonblank characters may appear in columns 4-80. If the k-th such
|
|
* character is 'T' or 't', the k-th routine will be timed. If at least
|
|
* one but fewer than 18 nonblank characters are specified, the
|
|
* remaining routines will not be timed. If columns 4-80 are blank, all
|
|
* the routines will be timed, so the input line
|
|
* SHG
|
|
* is equivalent to the line above.
|
|
*
|
|
*=======================================================================
|
|
*
|
|
* The workspace requirements in terms of square matrices for the
|
|
* different test paths are as follows:
|
|
*
|
|
* NEP: 3 N**2 + N*(3*NB+2)
|
|
* SEP: 2 N**2 + N*(2*N) + N
|
|
* SVD: 4 N**2 + MAX( 6*N, MAXIN*MAXPRM*MAXT )
|
|
* GEP: 6 N**2 + 3*N
|
|
*
|
|
* MAXN is currently set to 400,
|
|
* LG2MXN = ceiling of log-base-2 of MAXN = 9, and LDAMAX = 420.
|
|
* The real work space needed is LWORK = MAX( MAXN*(4*MAXN+2),
|
|
* 2*LDAMAX+1+3*MAXN+2*MAXN*LG2MXN+3*MAXN**2 ), and the integer
|
|
* workspace needed is LIWRK2 = 6 + 6*MAXN + 5*MAXN*LG2MXN.
|
|
* For SVD, we assume NRHS may be as big
|
|
* as N. The parameter NEED is set to 4 to allow for 4 NxN matrices
|
|
* for SVD.
|
|
*
|
|
* .. Parameters ..
|
|
INTEGER MAXN, LDAMAX, LG2MXN
|
|
PARAMETER ( MAXN = 400, LDAMAX = 420, LG2MXN = 9 )
|
|
INTEGER NEED
|
|
PARAMETER ( NEED = 6 )
|
|
INTEGER LIWRK2
|
|
PARAMETER ( LIWRK2 = 6+6*MAXN+5*MAXN*LG2MXN )
|
|
INTEGER LWORK
|
|
PARAMETER ( LWORK = 2*LDAMAX+1+3*MAXN+2*MAXN*LG2MXN+
|
|
$ 4*MAXN**2 )
|
|
INTEGER MAXIN, MAXPRM, MAXT, MAXSUB
|
|
PARAMETER ( MAXIN = 12, MAXPRM = 10, MAXT = 10,
|
|
$ MAXSUB = 25 )
|
|
INTEGER NIN, NOUT
|
|
PARAMETER ( NIN = 5, NOUT = 6 )
|
|
* ..
|
|
* .. Local Scalars ..
|
|
LOGICAL FATAL, GEP, NEP, SEP, SVD
|
|
CHARACTER*3 C3, PATH
|
|
CHARACTER*3 VNAME
|
|
CHARACTER*80 LINE
|
|
INTEGER I, INFO, MAXTYP, NN, NPARMS, NTYPES
|
|
REAL S1, S2, TIMMIN
|
|
* ..
|
|
* .. Local Arrays ..
|
|
LOGICAL DOTYPE( MAXT ), LOGWRK( MAXN )
|
|
INTEGER ISEED( 4 ), IWORK( MAXT ), IWORK2( LIWRK2 ),
|
|
$ LDAVAL( MAXPRM ), MVAL( MAXIN ),
|
|
$ MXBVAL( MAXPRM ), MXTYPE( 4 ),
|
|
$ NBKVAL( MAXPRM ), NBMVAL( MAXPRM ),
|
|
$ NBVAL( MAXPRM ), NSVAL( MAXPRM ), NVAL( MAXIN )
|
|
REAL A( LDAMAX*MAXN, NEED ), D( MAXN, 4 ),
|
|
$ OPCNTS( MAXPRM, MAXT, MAXIN, MAXSUB ),
|
|
$ RESULT( MAXPRM, MAXT, MAXIN, MAXSUB ),
|
|
$ WORK( LWORK )
|
|
* ..
|
|
* .. External Functions ..
|
|
LOGICAL LSAMEN
|
|
REAL SECOND
|
|
EXTERNAL LSAMEN, SECOND
|
|
* ..
|
|
* .. External Subroutines ..
|
|
EXTERNAL STIM21, STIM22, STIM26, STIM51
|
|
* ..
|
|
* .. Scalars in Common ..
|
|
REAL ITCNT, OPS
|
|
* ..
|
|
* .. Arrays in Common ..
|
|
INTEGER IPARMS( 100 )
|
|
* ..
|
|
* .. Common blocks ..
|
|
COMMON / CLAENV / IPARMS
|
|
COMMON / LATIME / OPS, ITCNT
|
|
* ..
|
|
* .. Save statement ..
|
|
SAVE / CLAENV /
|
|
* ..
|
|
* .. Intrinsic Functions ..
|
|
INTRINSIC MAX
|
|
* ..
|
|
* .. Data statements ..
|
|
DATA ISEED / 0, 0, 0, 1 /
|
|
DATA MXTYPE / 8, 4, 5, 4 /
|
|
* ..
|
|
* .. Executable Statements ..
|
|
*
|
|
S1 = SECOND( )
|
|
FATAL = .FALSE.
|
|
NEP = .FALSE.
|
|
SEP = .FALSE.
|
|
SVD = .FALSE.
|
|
GEP = .FALSE.
|
|
*
|
|
* Read the 3-character test path
|
|
*
|
|
READ( NIN, FMT = '(A3)', END = 160 )PATH
|
|
NEP = LSAMEN( 3, PATH, 'NEP' ) .OR. LSAMEN( 3, PATH, 'SHS' )
|
|
SEP = LSAMEN( 3, PATH, 'SEP' ) .OR. LSAMEN( 3, PATH, 'SST' )
|
|
SVD = LSAMEN( 3, PATH, 'SVD' ) .OR. LSAMEN( 3, PATH, 'SBD' )
|
|
GEP = LSAMEN( 3, PATH, 'GEP' ) .OR. LSAMEN( 3, PATH, 'SHG' )
|
|
*
|
|
* Report values of parameters as they are read.
|
|
*
|
|
IF( NEP ) THEN
|
|
WRITE( NOUT, FMT = 9993 )
|
|
ELSE IF( SEP ) THEN
|
|
WRITE( NOUT, FMT = 9992 )
|
|
ELSE IF( SVD ) THEN
|
|
WRITE( NOUT, FMT = 9991 )
|
|
ELSE IF( GEP ) THEN
|
|
WRITE( NOUT, FMT = 9990 )
|
|
ELSE
|
|
WRITE( NOUT, FMT = 9996 )PATH
|
|
STOP
|
|
END IF
|
|
WRITE( NOUT, FMT = 9985 )
|
|
WRITE( NOUT, FMT = 9989 )
|
|
*
|
|
* Read the number of values of M and N.
|
|
*
|
|
READ( NIN, FMT = * )NN
|
|
IF( NN.LT.1 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'NN ', NN, 1
|
|
NN = 0
|
|
FATAL = .TRUE.
|
|
ELSE IF( NN.GT.MAXIN ) THEN
|
|
WRITE( NOUT, FMT = 9994 )'NN ', NN, MAXIN
|
|
NN = 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
*
|
|
* Read the values of M
|
|
*
|
|
READ( NIN, FMT = * )( MVAL( I ), I = 1, NN )
|
|
IF( SVD ) THEN
|
|
VNAME = ' M'
|
|
ELSE
|
|
VNAME = ' N'
|
|
END IF
|
|
DO 10 I = 1, NN
|
|
IF( MVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )VNAME, MVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
ELSE IF( MVAL( I ).GT.MAXN ) THEN
|
|
WRITE( NOUT, FMT = 9994 )VNAME, MVAL( I ), MAXN
|
|
FATAL = .TRUE.
|
|
END IF
|
|
10 CONTINUE
|
|
*
|
|
* Read the values of N
|
|
*
|
|
IF( SVD ) THEN
|
|
WRITE( NOUT, FMT = 9988 )'M ', ( MVAL( I ), I = 1, NN )
|
|
READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
|
|
DO 20 I = 1, NN
|
|
IF( NVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'N ', NVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
ELSE IF( NVAL( I ).GT.MAXN ) THEN
|
|
WRITE( NOUT, FMT = 9994 )'N ', NVAL( I ), MAXN
|
|
FATAL = .TRUE.
|
|
END IF
|
|
20 CONTINUE
|
|
ELSE
|
|
DO 30 I = 1, NN
|
|
NVAL( I ) = MVAL( I )
|
|
30 CONTINUE
|
|
END IF
|
|
WRITE( NOUT, FMT = 9988 )'N ', ( NVAL( I ), I = 1, NN )
|
|
*
|
|
* Read the number of parameter values.
|
|
*
|
|
READ( NIN, FMT = * )NPARMS
|
|
IF( NPARMS.LT.1 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'NPARMS', NPARMS, 1
|
|
NPARMS = 0
|
|
FATAL = .TRUE.
|
|
ELSE IF( NPARMS.GT.MAXIN ) THEN
|
|
WRITE( NOUT, FMT = 9994 )'NPARMS', NPARMS, MAXIN
|
|
NPARMS = 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
*
|
|
* Read the values of NB
|
|
*
|
|
READ( NIN, FMT = * )( NBVAL( I ), I = 1, NPARMS )
|
|
DO 40 I = 1, NPARMS
|
|
IF( NBVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'NB ', NBVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
40 CONTINUE
|
|
WRITE( NOUT, FMT = 9988 )'NB ', ( NBVAL( I ), I = 1, NPARMS )
|
|
*
|
|
IF( NEP .OR. GEP ) THEN
|
|
*
|
|
* Read the values of NSHIFT
|
|
*
|
|
READ( NIN, FMT = * )( NSVAL( I ), I = 1, NPARMS )
|
|
DO 50 I = 1, NPARMS
|
|
IF( NSVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'NS ', NSVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
50 CONTINUE
|
|
WRITE( NOUT, FMT = 9988 )'NS ', ( NSVAL( I ), I = 1, NPARMS )
|
|
*
|
|
* Read the values of MAXB
|
|
*
|
|
READ( NIN, FMT = * )( MXBVAL( I ), I = 1, NPARMS )
|
|
DO 60 I = 1, NPARMS
|
|
IF( MXBVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'MAXB', MXBVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
60 CONTINUE
|
|
WRITE( NOUT, FMT = 9988 )'MAXB',
|
|
$ ( MXBVAL( I ), I = 1, NPARMS )
|
|
ELSE
|
|
DO 70 I = 1, NPARMS
|
|
NSVAL( I ) = 1
|
|
MXBVAL( I ) = 1
|
|
70 CONTINUE
|
|
END IF
|
|
*
|
|
IF( GEP ) THEN
|
|
*
|
|
* Read the values of NBMIN
|
|
*
|
|
READ( NIN, FMT = * )( NBMVAL( I ), I = 1, NPARMS )
|
|
DO 80 I = 1, NPARMS
|
|
IF( NBMVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'NBMIN', NBMVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
80 CONTINUE
|
|
WRITE( NOUT, FMT = 9988 )'NBMIN',
|
|
$ ( NBMVAL( I ), I = 1, NPARMS )
|
|
*
|
|
* Read the values of MINBLK
|
|
*
|
|
READ( NIN, FMT = * )( NBKVAL( I ), I = 1, NPARMS )
|
|
DO 90 I = 1, NPARMS
|
|
IF( NBKVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'MINBLK', NBKVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
END IF
|
|
90 CONTINUE
|
|
WRITE( NOUT, FMT = 9988 )'MINBLK',
|
|
$ ( NBKVAL( I ), I = 1, NPARMS )
|
|
ELSE
|
|
DO 100 I = 1, NPARMS
|
|
NBMVAL( I ) = MAXN + 1
|
|
NBKVAL( I ) = MAXN + 1
|
|
100 CONTINUE
|
|
END IF
|
|
*
|
|
* Read the values of LDA
|
|
*
|
|
READ( NIN, FMT = * )( LDAVAL( I ), I = 1, NPARMS )
|
|
DO 110 I = 1, NPARMS
|
|
IF( LDAVAL( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'LDA ', LDAVAL( I ), 0
|
|
FATAL = .TRUE.
|
|
ELSE IF( LDAVAL( I ).GT.LDAMAX ) THEN
|
|
WRITE( NOUT, FMT = 9994 )'LDA ', LDAVAL( I ), LDAMAX
|
|
FATAL = .TRUE.
|
|
END IF
|
|
110 CONTINUE
|
|
WRITE( NOUT, FMT = 9988 )'LDA ', ( LDAVAL( I ), I = 1, NPARMS )
|
|
*
|
|
* Read the minimum time a subroutine will be timed.
|
|
*
|
|
READ( NIN, FMT = * )TIMMIN
|
|
WRITE( NOUT, FMT = 9987 )TIMMIN
|
|
*
|
|
* Read the number of matrix types to use in timing.
|
|
*
|
|
READ( NIN, FMT = * )NTYPES
|
|
IF( NTYPES.LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'NTYPES', NTYPES, 0
|
|
FATAL = .TRUE.
|
|
NTYPES = 0
|
|
END IF
|
|
*
|
|
* Read the matrix types.
|
|
*
|
|
IF( NEP ) THEN
|
|
MAXTYP = MXTYPE( 1 )
|
|
ELSE IF( SEP ) THEN
|
|
MAXTYP = MXTYPE( 2 )
|
|
ELSE IF( SVD ) THEN
|
|
MAXTYP = MXTYPE( 3 )
|
|
ELSE
|
|
MAXTYP = MXTYPE( 4 )
|
|
END IF
|
|
IF( NTYPES.LT.MAXTYP ) THEN
|
|
READ( NIN, FMT = * )( IWORK( I ), I = 1, NTYPES )
|
|
DO 120 I = 1, MAXTYP
|
|
DOTYPE( I ) = .FALSE.
|
|
120 CONTINUE
|
|
DO 130 I = 1, NTYPES
|
|
IF( IWORK( I ).LT.0 ) THEN
|
|
WRITE( NOUT, FMT = 9995 )'TYPE', IWORK( I ), 0
|
|
FATAL = .TRUE.
|
|
ELSE IF( IWORK( I ).GT.MAXTYP ) THEN
|
|
WRITE( NOUT, FMT = 9994 )'TYPE', IWORK( I ), MAXTYP
|
|
FATAL = .TRUE.
|
|
ELSE
|
|
DOTYPE( IWORK( I ) ) = .TRUE.
|
|
END IF
|
|
130 CONTINUE
|
|
ELSE
|
|
NTYPES = MAXTYP
|
|
DO 140 I = 1, MAXT
|
|
DOTYPE( I ) = .TRUE.
|
|
140 CONTINUE
|
|
END IF
|
|
*
|
|
IF( FATAL ) THEN
|
|
WRITE( NOUT, FMT = 9999 )
|
|
9999 FORMAT( / ' Execution not attempted due to input errors' )
|
|
STOP
|
|
END IF
|
|
*
|
|
* Read the input lines indicating the test path and the routines
|
|
* to be timed. The first three characters indicate the test path.
|
|
*
|
|
150 CONTINUE
|
|
READ( NIN, FMT = '(A80)', END = 160 )LINE
|
|
C3 = LINE( 1: 3 )
|
|
*
|
|
* -------------------------------------
|
|
* NEP: Nonsymmetric Eigenvalue Problem
|
|
* -------------------------------------
|
|
*
|
|
IF( LSAMEN( 3, C3, 'SHS' ) .OR. LSAMEN( 3, C3, 'NEP' ) ) THEN
|
|
CALL STIM21( LINE, NN, NVAL, MAXTYP, DOTYPE, NPARMS, NBVAL,
|
|
$ NSVAL, MXBVAL, LDAVAL, TIMMIN, NOUT, ISEED,
|
|
$ A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), D( 1, 1 ), WORK,
|
|
$ LWORK, LOGWRK, IWORK2, RESULT, MAXPRM, MAXT,
|
|
$ MAXIN, OPCNTS, MAXPRM, MAXT, MAXIN, INFO )
|
|
IF( INFO.NE.0 )
|
|
$ WRITE( NOUT, FMT = 9986 )'STIM21', INFO
|
|
*
|
|
* ----------------------------------
|
|
* SEP: Symmetric Eigenvalue Problem
|
|
* ----------------------------------
|
|
*
|
|
ELSE IF( LSAMEN( 3, C3, 'SST' ) .OR. LSAMEN( 3, C3, 'SEP' ) ) THEN
|
|
CALL STIM22( LINE, NN, NVAL, MAXTYP, DOTYPE, NPARMS, NBVAL,
|
|
$ LDAVAL, TIMMIN, NOUT, ISEED, A( 1, 1 ), D( 1, 1 ),
|
|
$ D( 1, 2 ), D( 1, 3 ), A( 1, 2 ), A( 1, 3 ), WORK,
|
|
$ LWORK, LOGWRK, IWORK2, RESULT, MAXPRM, MAXT,
|
|
$ MAXIN, OPCNTS, MAXPRM, MAXT, MAXIN, INFO )
|
|
IF( INFO.NE.0 )
|
|
$ WRITE( NOUT, FMT = 9986 )'STIM22', INFO
|
|
*
|
|
* ----------------------------------
|
|
* SVD: Singular Value Decomposition
|
|
* ----------------------------------
|
|
*
|
|
ELSE IF( LSAMEN( 3, C3, 'SBD' ) .OR. LSAMEN( 3, C3, 'SVD' ) ) THEN
|
|
CALL STIM26( LINE, NN, NVAL, MVAL, MAXTYP, DOTYPE, NPARMS,
|
|
$ NBVAL, LDAVAL, TIMMIN, NOUT, ISEED, A( 1, 1 ),
|
|
$ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), D( 1, 1 ),
|
|
$ D( 1, 2 ), D( 1, 3 ), D( 1, 4 ), WORK, LWORK,
|
|
$ IWORK2, LOGWRK, RESULT, MAXPRM, MAXT, MAXIN,
|
|
$ OPCNTS, MAXPRM, MAXT, MAXIN, INFO )
|
|
IF( INFO.NE.0 )
|
|
$ WRITE( NOUT, FMT = 9986 )'STIM26', INFO
|
|
*
|
|
* -------------------------------------------------
|
|
* GEP: Generalized Nonsymmetric Eigenvalue Problem
|
|
* -------------------------------------------------
|
|
*
|
|
ELSE IF( LSAMEN( 3, C3, 'SHG' ) .OR. LSAMEN( 3, C3, 'GEP' ) ) THEN
|
|
CALL STIM51( LINE, NN, NVAL, MAXTYP, DOTYPE, NPARMS, NBVAL,
|
|
$ NSVAL, MXBVAL, NBMVAL, NBKVAL, LDAVAL, TIMMIN,
|
|
$ NOUT, ISEED, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
|
|
$ A( 1, 4 ), A( 1, 5 ), A( 1, 6 ), D( 1, 1 ), WORK,
|
|
$ LWORK, LOGWRK, RESULT, MAXPRM, MAXT, MAXIN,
|
|
$ OPCNTS, MAXPRM, MAXT, MAXIN, INFO )
|
|
IF( INFO.NE.0 )
|
|
$ WRITE( NOUT, FMT = 9986 )'STIM51', INFO
|
|
ELSE
|
|
WRITE( NOUT, FMT = * )
|
|
WRITE( NOUT, FMT = * )
|
|
WRITE( NOUT, FMT = 9996 )C3
|
|
END IF
|
|
GO TO 150
|
|
160 CONTINUE
|
|
WRITE( NOUT, FMT = 9998 )
|
|
9998 FORMAT( / / ' End of timing run' )
|
|
S2 = SECOND( )
|
|
WRITE( NOUT, FMT = 9997 )S2 - S1
|
|
*
|
|
9997 FORMAT( ' Total time used = ', F12.2, ' seconds', / )
|
|
9996 FORMAT( 1X, A3, ': Unrecognized path name' )
|
|
9995 FORMAT( ' *** Invalid input value: ', A, '=', I6, '; must be >=',
|
|
$ I6 )
|
|
9994 FORMAT( ' *** Invalid input value: ', A, '=', I6, '; must be <=',
|
|
$ I6 )
|
|
9993 FORMAT( ' Timing the Nonsymmetric Eigenvalue Problem routines',
|
|
$ / ' SGEHRD, SHSEQR, STREVC, and SHSEIN' )
|
|
9992 FORMAT( ' Timing the Symmetric Eigenvalue Problem routines',
|
|
$ / ' SSYTRD, SSTEQR, and SSTERF' )
|
|
9991 FORMAT( ' Timing the Singular Value Decomposition routines',
|
|
$ / ' SGEBRD, SBDSQR, SORGBR, SBDSDC and SGESDD' )
|
|
9990 FORMAT( ' Timing the Generalized Eigenvalue Problem routines',
|
|
$ / ' SGGHRD, SHGEQZ, and STGEVC ' )
|
|
9989 FORMAT( / ' The following parameter values will be used:' )
|
|
9988 FORMAT( ' Values of ', A5, ': ', 10I6, / 19X, 10I6 )
|
|
9987 FORMAT( / ' Minimum time a subroutine will be timed = ', F8.2,
|
|
$ ' seconds', / )
|
|
9986 FORMAT( ' *** Error code from ', A, ' = ', I4 )
|
|
9985 FORMAT( / ' LAPACK VERSION 3.0, released June 30, 1999 ' )
|
|
*
|
|
* End of STIMEE
|
|
*
|
|
END
|