Begins a function subprogram.  Identifies the data type of the
  function and names the dummy arguments.  Format:

     [prefx] FUNCTION nam [([p[,p]...])] [RESULT (r-nam)]

     prefx Is either:

           typ [kywd]
           kywd [typ]

     typ   Is a data type.  If you do not specify a data type,
           the data type of the function is implied from its
           name.

           If the data type is CHARACTER, you can specify
           CHARACTER*(*) to indicate an assumed-length function
           type -- the function type assumes the length of its
           definition in the program unit invoking it. Assumed-
           length character functions are obsolescent in
           Fortran 95.  VSI Fortran flags obsolescent features,
           but fully supports them.

     kywd  Is one of the following:

           RECURSIVE    Permits direct recursion to occur.  If
                        a function is directly recursive and
                        array valued, RESULT must also be
                        specified.

           PURE         Restricts the procedure from having
                        side effects.

           ELEMENTAL    Specifies PURE with certain constraints:

                        o A dummy argument:
                          - Must be scalar and cannot have the POINTER
                            attribute
                          - Cannot appear in a specification expression,
                            except as an argument to the BIT_SIZE, KIND,
                            or LEN intrinsic functions or the numeric
                            inquiry intrinsic functions
                          - Must not be *
                          - Must not be a dummy procedure

                        o The function result must be scalar and cannot
                          have the POINTER attribute.

                        An explicit interface must be visible to the
                        caller of an ELEMENTAL procedure.

                        If ELEMENTAL is specified, RECURSIVE must not
                        be specified.

     nam   Is a symbolic name for the function.  The name must be
           unique among all global names in the program.  The name
           is used as a variable within the function.  The value of
           the variable is returned to the caller of the function
           as the value of the function.

           The name can be followed by * and the length of the data
           type. It must be one of the valid length specifiers for
           "typ".  This length overrides the length specified or
           implied by the type.  This length specification is not
           permitted if the length has already been specified
           following CHARACTER.

     p     Is an unsubscripted variable name specifying a dummy
           argument.  The arguments must agree in order, number, and
           type with the actual arguments of the statement invoking
           the function.  A dummy argument must not be defined as an
           array with more elements than the actual argument holds.

     r-nam Is the name of the function result.  This name must not
           be the same as the function name.

  The array declarator for a dummy argument can itself contain
  integer values that are dummy arguments or are references to a
  common block, providing for adjustable size arrays in functions.
  The upper bound of the array declarator for a dummy argument can be
  specified as an asterisk, in which case the upper bound of the
  dummy argument assumes the size of the upper bound of the actual
  argument.  The size in a character string declarator for a dummy
  argument can be specified as an asterisk in parentheses (*) -- in
  which case the size of the actual argument is passed to the dummy
  argument.

  The values of the actual arguments in the invoking program unit
  become the values of the dummy arguments in the function.  If you
  modify a dummy argument, the corresponding actual argument in the
  invoking program unit is also modified; the actual argument must be
  a variable if it is to be modified.

  If the actual argument is a character constant, the dummy argument
  can be either character or numeric in type, unless the name of the
  subprogram being invoked is a dummy argument in the invoking
  program unit.  If the actual argument is a Hollerith constant, the
  dummy argument must be numeric.

  The FUNCTION statement must be the first statement of a function
  subprogram, unless an OPTIONS statement is specified.  A function
  subprogram cannot contain a SUBROUTINE statement, a BLOCK DATA
  statement, a PROGRAM statement, or another FUNCTION statement.
  ENTRY statements can be included to provide multiple entry points
  to the subprogram.

                                 NOTE

          In a function, the function name identifier  refers
          to  the  return  value,  not  the  function itself,
          unless an argument list is present.  Therefore,  it
          is  not  possible to pass a function as an argument
          to another routine from inside the  function.   For
          example, consider the following:

             INTEGER FUNCTION RECURSIVE_FUNCTION
                .
                .
                .
             CALL OTHERSUB (RECURSIVE_FUNCTION)

          The reference to  RECURSIVE_FUNCTION  in  the  CALL
          statement passes the function return value, not the
          function itself.