FUNCTION

 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.

Additional information available:

RESULT_Keyword  Function_Reference