F77 Fortran-77 Informationen

ASSIGN statement-label TO integer-variable
BACKSPACE ( unit [, IOSTAT=..., ERR=label]) ein Record zurueck
BLOCKDATA [name] block-data-subprogram
CALL subroutine-name [([ aktuelle Argumente ])]
CHARACTER[*n] = String aus n (>=1) 8-bit-Characters ('...''...')
CLOSE ( unit [, IOSTAT=v_int*4, STATUS=..., ERR=label])
COMMON [ /name/ ] common-item-list
COMPLEX = COMPLEX*8 (2 real*4)
CONTINUE
DATA variable-list /constant-list/
DIMENSION (up to 7 dimensions)
DO statement-label variable=initial-val.,terminal-val. [,increm.]
DOUBLEPRECISION = REAL*8, auf 16 Stellen genau, Bereich D(+-)308
ELSE
ELSEIF (logical-expression)
END
ENDFILE ( unit [, IOSTAT=..., ERR=label]) schreibt EOF-Marke
ENDIF
ENTRY name [ ( [dummy-Argumente] ) ]
EQUIVALENCE ( equiv-item, equiv-item )
EXTERNAL external-procedure     (zur Spezifikation externer Proz.)
FORMAT ( format-list )
FUNCTION - [type] FUNCTION name ( [dummy-Argumente] )
GOTO statement-number | assigned goto | GOTO (label-list)[,]int.
IF - arithmetic-if | logical-if | block-if
IF (arithm. exp.) label, label, label   (fuer LT, EQ, GT 0)
IF (log. exp.) executable-statement
IF (log. exp.) THEN   (mit ELSEIF, ELSE, ENDIF)
IMPLICIT  INTEGER (I-N) (z.B.; entspricht Default)
INCLUDE 'filename' [not standard]
INQUIRE (  [, IOSTAT=v_int*4, RECL=v_int*4, ... ])
INTEGER = INTEGER*4 (oder integer*2 bei Compiler-Option /I)
INTRINSIC intrinsic-function
LOGICAL = LOGICAL*4, .FALSE. oder .TRUE.  (F oder T in I/O)
OPEN ( unit [, IOSTAT=v_int*4, RECL=int*4, FILE=name, STATUS=...,])
PARAMETER ( constant-name = expression, ...)
PAUSE [ digit-string | character-constant ] (-> DOS)
PRINT format-id. [, iolist]
PROGRAM name
READ (read-write-control) [iolist]  |  READ format-id. [, iolist]
READ (unit [,format, REC=..., IOSTAT=..., END=label, ERR=label])
REAL = REAL*4, auf 7 Stellen genau, Bereich E(+-)38
RETURN [ integer-expression ]
REWIND ( unit [, IOSTAT=..., ERR=label]) zum Anfang des Files
SAVE [ /block-name/ variable-name ]
STOP [ digit-string | character-constant ]
SUBROUTINE name [(dummy-Argumente)]
TO (vgl. ASSIGN)
WRITE (read-write-control) [iolist]
WRITE (unit [,format, REC=..., IOSTAT=..., ERR=label])

ABS(x)              |x|            R(R)
ACOS(x)             arccos(x)      R(R)
AIMAG(x)            Im(x)          R(C)
AINT(x)             int(x)         R(R)
ALOG(x)             ln(x)          R(R)
ALOG10(x)           lg(x)          R(R)
AMAX0(x,y,...)      max            R(I)
AMAX1(x,y,...)      max            R(R)
AMIN0(x,y,...)      min            R(I)
AMIN1(x,y,...)      min            R(R)
AMOD(x,y)           mod(x/y)       R(R)
ANINT(x)            int(x+-0.5)    R(R)
ASIN(x)             arcsin(x)      R(R)
ATAN(x)             arctan(x)      R(R)
ATAN2(x,y)          arctan(x/y)    R(R)
BTEST(x,y)          true if bit y in x is 1     L(I)
CABS(x)             abs(x)         R(C)
CCOS(x)             cos(x)         C(C)
CEXP(x)             exp(x)         C(C)
CHAR(x)             character      char(I)
CLOG(x)             ln(x)          C(C)
CMPLX(x[,y])        complex(Re,Im) C(...)
CONJG(x)            cmplx(Re,-Im)  C(C)
COS(x)              cos(x)         R(R)
COSH(x)             cosh(x)        R(R)
CSIN(x)             sin(x)         C(C)
CSQRT(x)            sqrt(x)        C(C)
DABS(x)             |x|            D(D)
DACOS(x)            arccos(x)      D(D)
DASIN(x)            arcsin(x)      D(D)
DATAN(x)            arctan(x)      D(D)
DATAN2(x,y)         arctan(x/y)    D(D)
DBLE(x)             double prec.   D(...)
DCOS(x)             cos(x)         D(D)
DCOSH(x)            cosh(x)        D(D)
DDIM(x,y)           x-y if >0      D(D)
DEXP(x)             exp(x)         D(D)
DIM(x,y)            x-y if >0      R(R)
DINT(x)             int(x)         D(D)
DLOG(x)             ln(x)          D(D)
DLOG10(x)           lg(x)          D(D)
DMAX1(x)            max            D(D)
DMIN1(x)            min            D(D)
DMOD(x,y)           mod(x/y)       D(D)
DNINT(x)            int(x+-0.5)    D(D)
DPROD(x,y)          x*y            D(R)
DSIGN(x,y)          |x|*sign(y)    D(D)
DSIN(x)             sin(x)         D(D)
DSINH(x)            sinh(x)        D(D)
DSQRT(x)            sqrt(x)        D(D)
DTAN(x)             tan(x)         D(D)
DTANH(x)            tanh(x)        D(D)
EXP(x)              exp(x)         R(R)
FLOAT(x)            real           R(I)
HFIX(x)             short integer  H(...)
I(x,y)              logical product     I(I)
IABS(x)             |x|            I(I)
IBCHNG(x,y)         reverse bit y in x  I(I)
IBCLR(x,y)          set bit y in x to 0     I(I)
IBSET(x,y)          set bit y in x to 1     I(I)
ICHAR(char)         ASCII          I(char)
IDIM(x,y)           x-y if >0      I(I)
IDINT(x)            integer        I(D)
IDNINT(x)           int(x+-0.5)    I(D)
IEOR(x,y)           exclusive or   I(I)
IFIX(x)             integer        I(R)
INDEX(a1,a2)        index(a2 in a1)I(char)
INT(x)              integer        I(R)
IOR(x,y)            inclusive or   I(I)
ISHA(x,y)           shift x arithmetically left y bits  I(I)
ISHC(x,y)           rotate x left y bits    I(I)
ISHFT(x,y)          = ISHL
ISHL(x,y)           shift x logically left y bits       I(I)
ISIGN(x,y)          |x|*sign(y)    I(I)
JFIX(x)             long integer   J(...)
LEN(a)              length         I(char)
LGE(a,b)            lex(>=)        L(char)
LGT(a,b)            lex(>)         L(char)
LLE(a,b)            lex(<=)        L(char)
LLT(a,b)            lex(<)         L(char)
LOG(x)              ln(x)          R(R)(?)
LOG10(x)            lg(x)          R(R)(?)
MAX(x,y,...)        max            I(I)(?)
MAX0(x,y,...)       max            I(I)
MAX1(x,y,...)       max            I(R)
MIN(x,y,...)        min            I(I)(?)
MIN0(x,y,...)       min            I(I)
MIN1(x,y,...)       min            I(R)
MOD(x,y)            mod(x/y)       I(I)
NINT(x)             int(x+-0.5)    I(R)
REAL(x)             real           R(I)
SIGN(x,y)           |x|*sign(y)    R(R)
SIN(x)              sin(x)         R(R)
SINH(x)             sinh(x)        R(R)
SNGL(x)             real           R(D,C)
SQRT(x)             sqrt(x)        R(R)
TAN(x)              tan(x)         R(R)
TANH(x)             tanh(x)        R(R)