Math 60 -- Notes Fortran 7

Notes Fortran 7

Math 61 -- D. C. Smolarski, S.J.
Santa Clara University, Department of Mathematics and Computer Science

[Return to Math 60 Homepage | Return to Notes Listing Page]

Obsolescent Features
New Fortran-95 Features
HPF
Fortran 2003 Features
Miscellaneous

Obsolescent Features [EF 19.1]

The Fortran-90 standard (i.e., language definition) introduced the concept of obsolescence and some authors also speak about deprecation. These terms apply to those features that may, in fact, be removed from future revisions of Fortran (i.e., no longer included in future "standards") or have been rendered unnecessary. Most of these statements are no longer needed because of the introduction of newer, more versatile statements and structures, and therefore should be avoided as much as possible to conform to good programming practices. Fortran-95 and Fortran-2003 continue to list certain statements as obsolescent.

Note that compilers will continue to support obsolescent statements and features, and some new compilers may even continue to support features that have been recently removed. Future compilers, however, will not be required to support features once designated as obsolescent and then subsequently removed from the official definition of Fortran.

Fortran-90 "obsolescent" statements and features include the following:

the arithmetic IF statement;
the PAUSE statment (which can be simulated by a READ awaiting input);
real variables as DO loop control variables;
ending several DO loops with the same statement;
ending a DO loop with a statement other than a CONTINUE or END DO;
statements that require statement number variables, such as ASSIGN or assigned GO TO;
the use of an assigned integer as a FORMAT specification;
H (Hollerith) character string field descriptors in FORMAT statements;
branching to an END IF;
alternative RETURN in subprograms.

Of these features, the following have been removed from Fortran-95 and, thus, may not be supported by Fortran-95 compilers:

H (Hollerith) character string field descriptors in FORMAT statements;
real variables as DO loop control variables;
branching to an END IF from outside the IF block;
the PAUSE statment;
statements that require statement number variables, such as ASSIGN or assigned GO TO;
the use of an assigned integer as a FORMAT specification;

Newly declared "obsolescent" statements and features for Fortran-95 include the following:

Computed GO TO;
statement functions;
DATA statements after the first executable statement;
Fixed-form source code;
assumed-size arrays (arrays declared in subprograms with the upper bound in the last dimension an *).
CHARACTER*n style declarations
Assumed-length character functions.

The following has been removed from Fortran-2003 and, thus, may not be supported by Fortran-2003 compilers:

carriage control in output Format statements.

The following are mentioned as "deprecated" (or "redundant") features by certain authors. This designation has no offical status in Fortran standards but are suggestive of features that may, in fact, be eventually listed as "obsolescent." They should also be avoided in new Fortran code, since they can be replicated by newer features which can lead to code that is more easily understandable. Since many of these features are very common in older code that is still widely used, the features will probably continue to be supported in the near future.

COMMON blocks;
BLOCK DATA subprograms;
EQUIVALENCE statements;
Alternative ENTRY into subroutines;
Implicit data typing of identifiers;
The DO WHILE form of the DO loop;
DOUBLE PRECISION real declarations;
Independent DIMENSION and PARAMETER statements;

New Fortran-95 Features [EF 19.2]

The major new features of Fortran-95 (not present in Fortran-90) include the following:

the FORALL statement (cf. section 6.11.3);
a FORALL statement can include a WHERE statement;
the ELSEWHERE clause can include a mask and may be repeated (cf. section 8.12);
designation of user-defined subprograms as PURE -- A function with no side effects can be designated as PURE and a subroutine that only affect the values of arguments with INTENT IN OUT or OUT can also be so designated. The advantage of knowing that a subprogram is "pure" is that this simplifies parallel execution.
designation of user-defined subprograms as ELEMENTAL -- A function with only scalar dummy arguments (not pointers or subprograms) and (if a function) with scalar result (not pointer) can be designated as ELEMENTAL and similarly for a subroutine. Such a function is applied independently to elements of an arrays, e.g., as in SQRT(A) where A is an array. Once again, the advantage of knowing that a subprogram is "elemental" is that this simplifies parallel execution.
A function NULL to nullify a pointer which may also be done at initialization (cf. section 17.4);
Initialization of components of a derived type (cf. section 15.2);
Revised definitions and extensions to functions MINLOC, MAXLOC, CEILING, and FLOOR;
A new intrinsic subroutine CPU_TIME(TIME) which takes a scalar real variable TIME and returns the present processor time in seconds;
A new intrinsic function SIGN to distinguish between positive and negative zero if the processor supports this distinctions;
Automatic deallocation of allocatable arrays when exiting the program segment in which it was declared.

HPF [EF 19.4]

High Performance Fortran or "HPF" is a superset of Fortran-90/95. The main extension are compiler directives that begin with !HPF$. Such statements are seen as comments by other compilers, but are interpreted by HPF compilers to optimize the performance of the code on parallel machines.

HPF also includes a few additional intrinsic functions pertinent to executing code on parallel machines.

Further information about HPF should be obtained from detailed manuals for the machine being used.

Fortran 2003 Features [EF 19.3]

Link to notesfor2003.html page

Miscellaneous

There are numerous other features of Fortran 90/95/2003, many of which would not be used by the casual programmer. This listing merely tries to show you the power of the current version of this language.

Argument "Intent" [EF 12.1]
With the possibility of running programs on parallel machines, Fortran has included a designation for variables used in specialized types of procedures (i.e., subroutines or functions) (i.e., "pure" or "elemental" procedures -- Cf. EF 19.2) to aid readability and the compilation process. This designation is called the "intent" of the arguments.
The three options for the "intent" of an argument are:
- in -- used for data only coming into a subprogram;
- out -- used for data only going out from a subprogram;
- in out -- used for data flowing in either direction.
For example,
```
      REAL, INTENT(IN) :: X, Y
```
Optional and Keyword Arguments [EF 12.2]
One can designate any procedure argument as "OPTIONAL", e.g.,
```
         SUBROUTINE SOLVE(A, B, C, N)
         REAL, OPTIONAL :: A, C
         REAL           :: B
         INTEGER, OPTIONAL :: N
```
When invoking this subroutine and NOT including an optional argument, one should specify the arguments AFTER the omitted argument in this way:
```
         CALL SOLVE(A,B,N=N2)
```
It is also permitted to specify all the argument or even to rearrange the arguments when using the specification, e.g.,
```
         CALL SOLVE(B=B,N=N2,A=A)
```
One makes use of a LOGICAL function PRESENT to determine which an optional argument has, in fact, been used and this can be used to give a default value, e.g.,
```
         IF (.NOT. (PRESENT(C))) THEN
             C = 1.0
         END IF
```
INTERFACES [EF 9.6]
Interfaces have already been introduced in special cases, when use recursive subprograms, or point variables. They may also be used in other specialized situations, such as when declared a new operator (see EF 16.3 for details) or declaring "generic" functions (for arguments of different data types) (see EF 12.3 for details) or giving new meaning to the assignment symbol (see EF 16.4 for details).
Modules and Data Encapsulation [EF 15.6]
MODULES may also be used to provide data encapsulation for certain specialized data structures, by using the PRIVATE designator for the variables declared within the MODULE for example. The following is an example of the way a stack can be implemented in Fortran-90/95/2003.
The underlying data structure is part of a derived type and this type and associated subprograms are placed in a module called STACK_MOD. The derived type is called STACK and its data, the array STACKELEMENT which will contain the contents of the stack, and the top-of-stack pointer TOP will be PRIVATE, and therefore inaccessible to any program segment which makes use of the derived type.
The module also contains three local routines: PUSH, which adds elements to the stack; POP, which deletes the element on the top of the stack; and INIT, which initializes a new stack by correctly setting the TOP variable to 0. (This last routine is needed in Fortran-90, since initializing a component of a derived type is not allowed in Fortran-90, but this feature has been included in Fortran-95/2003.)
```
        MODULE STACK_MOD
          TYPE STACK
             PRIVATE
              INTEGER :: STACKELEMENT(100)
              INTEGER :: TOP
           END TYPE
        CONTAINS
          SUBROUTINE INIT(S)
          TYPE(STACK) :: S
          S%TOP = 0
          END SUBROUTINE
	  !
          SUBROUTINE PUSH(S,ITEM)
          TYPE(STACK) :: S
	  INTEGER :: ITEM
          IF (S%TOP < 100) THEN
             S%TOP=S%TOP+1
             S%STACKELEMENT(S%TOP) = ITEM
	  ELSE
             WRITE(*,*) "STACK OVERFLOW"
             STOP
	  ENDIF
	  END SUBROUTINE
	  !
          INTEGER FUNCTION POP(S)
          TYPE(STACK) :: S
          IF (S%TOP > 0) THEN
            POP = S%STACKELEMENT(S%TOP)
            S%TOP = S%TOP-1
          ELSE
            WRITE(*,*) "STACK UNDERFLOW"
	    STOP
          ENDIF
          END FUNCTION
        END MODULE
```
The following program makes use of the STACK_MOD module and declares two stacks, S and T. It then pushes a few values onto the two stacks and pops the values off to print them out. (For further information about stacks, see a complete book on Data Structures.)
```
	PROGRAM TESTSTACK
	USE STACK_MOD
	TYPE(STACK) S,T
	INTEGER TEMP
	! Initial both stackpointers
	CALL INIT(S)
	CALL INIT(T)
	! Push several values onto the stacks
	CALL PUSH(S,3)
	CALL PUSH(S,4)
	CALL PUSH(S,5)
	CALL PUSH(T,1)
	CALL PUSH(T,2)
	! Pop a value off and save it in TEMP
	! before printing it out
	TEMP = POP(S)
	WRITE(*,*) TEMP
	! Pop off values and print out directly
	WRITE(*,*) POP(S)
	WRITE(*,*) POP(S)
	WRITE(*,*) POP(T)
	WRITE(*,*) POP(T)
	END
```
"EXTERNAL" and "INTRINSIC" Statements [EF 10.9]
Fortran permits the use of function names are arguments in procedures. In other words, it is permitted to pass a function name as an argument. For example, if one creates a function to perform numerical differentiation or integrations, it would be useful to be able to pass, as an argument, the function one wishes to differentiate or integrate. If such a function is part of the Fortran library (e.g., SIN, COS, then this should be designated as "INTRINSIC", otherwise it is designated as "EXTERNAL".
Order of Specification Statements [EF 18.11]
It has already been noted that declarations of variables must come before the first executable statement, that the USE statement must come before any sort of declarations, that the IMPLICIT NONE must come before any other declarations. Other specification statements usually can come in any order. See EF 18.11 for more specific rules
Other Statements [EF 18]
There are other Fortran statements that had been common prior to the introduction of Fortran-90, which are no longer used (or recommended not to be used). These include the COMMON statement (used for designating variables being shared between routines --- now replaced by a MODULE), variations of the IF statment, the DATA statement (used to initialize variables, now possible when declaring variables), the PARAMETER statement (used to designate an identifier as a constant and assign the unchangeable value --- now included as an "attribute" when declaring variables), the independent DIMENSION statement (now included as an "attribute" to designation the dimensions of arrays), and the EQUIVALENCE statement (formerly used to indicate that two different identifiers should be considered identical for the duration of the program segment, but now replaced by a pointer).
Anyone needing information about these statements (for example, when maintaining older code) should consult a fuller reference on Fortran.