A FORTRAN SUMMARY FOR CGS 3422 STUDENTS
                           Version  7/8/93

  Declaration Statements
   Variable declarations or FUNCTION type or PARAMETER type
     INTEGER identifier_list           REAL identifier_list
     DOUBLE PRECISION identifier_list  COMPLEX identifier_list
     CHARACTER*length identifier_list  CHARACTER identifier*length[,...]
     LOGICAL identifier_list
     {arrays can be declared. REAL X(5), Y(10,20), Z(-10:10,1988:1998)}
   Initializations and sharing
     DATA var_list /value_list/ [,...]  ! Initialize variables
     PARAMETER (identifier = value)     ! Define constants
     EQUIVALENCE (var_list), ...        ! Variables at same address
     COMMON [common_name] var_list      ! Share variables between modules

 Subprogram Statements
   SUBROUTINE name [(argument_list)]    ! Define a subroutine
     statement(s)
   END
   CALL subroutine_name [(argument_list)] ! Call a subroutine
   name ([argument_list]) = expr        ! Define a statement functiom
   type FUNCTION name ([argument_list]) ! Define a function subprogram
     statement(s)
     function_name = expression
     statement(s)
   END

   type function_name                   ! Declaration in calling program
   EXTERNAL function_name               ! Define name to be a function
   RETURN                               ! Do not use

 Executable Statements
   Assignment
     variable_name[(array_index_list)] = expression
     char_variable_name[(index)][([start_pos]:[end_pos])] = char_expr
   Control
     IF (logical_expression) statement
     IF (logical_expression) THEN       ! Requires closing ENDIF
       statement(s)
     [ELSEIF (logical_expression) THEN  ! May have several ELSEIF's
       statement(s)]
     [ELSE                              ! May have 0 or 1 ELSE
       statement(s)]
     ENDIF                              ! Required to end IF - THEN
     DO statement_# variable = initial_expr, limit_expr [,incr_expr]
     CONTINUE
     GO TO statement_#   ! Don't use except in simulated WHILE and REPEAT

     DO variable = initial_expr, limit_expr [,incr_expr]! SFOR
       statement(s)                                     !
     END DO                                             ! SFOR

     DO WHILE (logical_expression)                      ! SFOR
       statement(s)                                     !
     ENDDO                                              ! SFOR

     REPEAT                                             ! SFOR
       statement(s)                                     !
     UNTIL (logical_expression)                         ! SFOR

   Miscellaneous
     STOP		! Do not use
     END   ! Last statement in a module: main pgm, SUBROUTINE or FUNCTION

   I/O Statements
     PRINT fmt, expression_list
     READ fmt, variable_list
     OPEN (UNIT=int_expr,FILE=char_expr,STATUS='OLD'[,IOSTAT=int_var])
     OPEN (UNIT=int_expr,FILE=char_expr,STATUS='NEW'[,IOSTAT=int_var])
     WRITE ([UNIT=]unit,[FMT=]fmt [,IOSTAT=int_variable]) expression_list
     READ ([UNIT=]unit,[FMT=]fmt [,IOSTAT=int_variable]) variable_list
     {unit = *, int_expr, char_expr (for READ) or char_var (for WRITE)}
     {fmt = *, format_statement_#, or char_expression}
     {impiled DO syntax in PRINT, READ & WRITE is:}
     {  (list,variable = initial_expr, limit_expr [, incr_expr])
   n FORMAT (format_list)  ! requires a statement number
     {FORMAT items:
       nX               n blanks
       [n]Iw            integer field w wide
       [n]Fw.d          real field w wide with d decimal digits
       [n]Ew.d          scientific format w wide with d decimal digits
       [n]Gw.d          F format if it fits, else E format
       [n]A[w]          character field w wide
       [n](format_list) repeat items in list n times
       /                skip to new line}
     CLOSE (UNIT=integer_expression)
     BACKSPACE (UNIT=integer_expression)
     REWIND (UNIT=integer_expression)

 Expressions
   Arithmetic Binary Operators + - * / **  {exponentation}
   Relational Binary Ops .EQ. .NE. .GT. .GE. .LT. .LE.
   Logical Binary Ops .OR. .AND. .EQV. .NEQV.
   Character Binary Operator //  {concatenation}
   Arithmetic Unary Operators + -
   Logical unary Operator .NOT.
   Logical constants .TRUE. .FALSE.
   Precedence () ; ** {right to left}; * / ; + - ; // ;
     .EQ. .NE. .GT. .GE. .LT. .LE. ; .NOT. ; .AND. ; .OR. ; .EQV. .NQV.
   An integer binary operated with a real yields a real
   FUNCTION reference: function_name([argument_list])
   Array reference: variable_name[(index_expression_list)]
   Substring reference: variable_name[(index)]([start_pos]:[end_pos])

 Intrinsic Functions
   Trig
     SIN(X), COS(X), TAN(X),
     ASIN(X), ACOS(X), ATAN(X), ATAN2(X,Y),
     SINH(X), COSH(X),TANH(X),
   Math
     SQRT(X), EXP(X) {e to the X}, LOG(X)=ALOG(X), LOG10(X)=ALOG10(X)
     ABS(X), IABS(I)
     MOD(I,J) {remainder of I divided by J}
   Character
     CHAR(I)  {char with ordinal value I. ASCII 65='A', 97='a', 48='0'}
     ICHAR(C) {inverse of CHAR(I)}
     LEN(S)   {length of character string S}
     INDEX(S1,S2) {location of string S2 in S1 or 0 if not found}
     LGT(S1,S2), LGE(S1,S2), LLT(S1,S2), LLE(S1,S2) {compare in ASCII}
   Miscellaneous
     NINT(X)  {nearest integer}
     MIN0(I1,I2,...), MAX0(I1,I2,...)  {integer min and max}
     AMIN1(X1,X2,...), AMAX1(X1,X2,...)  {real min and max}

 Notes:
   Square brackets [] denote optional arguments
   Assume X,Y REAL; I,J INTEGER; C CHARACTER*1; S CHARACTER*n