Well Structured

FORTRAN is very well structured. All routines should have a clear beginning statement, and a corresponding ending one. For example (since case-in-sensitiveness, usually written in either all lower or all upper case)

PROGRAM MY_VERY_USEFUL_CODE
    ...
    CALL PROBLEM_SOLVING (...)
    ...
    STOP
END PROGRAM MY_VERY_USEFUL_CODE

SUBROUTINE PROBLEM_SOLVING (...)
    ...
    RESULT = AVERAGE_SCORE (...)
    RETURN
END SUBROUTINE PROBLEM_SOLVING

FUNCTION  AVERAGE_SCORE (...)
    ...
    RETURN
END FUNCTION AVERAGE_SCORE

Even the DO loop and IF structure are also finished with an END statement.

DO I = ISTART, IEND
    ...
END DO

IF (CONDITION)
    ...
ELSE
    ...
END IF

Modules

Similar to classes in C++, modules are very important and widely-used in FORTRAN. Modules, in the form of a separate code structure, may contain various definitions/declarations and can use other predefined modules. Theoretically modules are not classes, but usually used to provide some data structures (objects) for sharing, since in most scientific computations objects are known beforehand and the task is to manipulate them. Modules can also contain specific routines accessing the objects inside and accessible only when the module is used, similar to the encapsulation concept of classes. By using modules, the code can be written very concisely. Here is an example and its usage.

MODULE MY_PARAMETERS
    DOUBLE PRECISION, PARAMETER :: THE_EARTH_RADIUS = 6371.0D0
END MODULE  MY_PARAMETERS

SUBROUTINE EARTH_STORY (...)
    USE MY_PARAMETERS
    DOUBLE PRECISION:: THE_EARTH_DIAMETER 
    ...
    THE_EARTH_DIAMETER = 2 * THE_EARTH_RADIUS 
    ...
    RETURN
END SUBROUTINE EARTH_STORY 

Overloading

As a modern language, FORTRAN also supports routine overloading: the ability to pick up the correct one from a group of routines with different unique interfaces by calling a fixed routine name. The routines are usually of the same functionality.

MODULE MY_KINETICS
     INTERFACE  GENERIC_KINETIC
           SUBROUTINE KINETIC_ROUTINE_A(...)
                   ...
           END SUBROUTINE KINETIC_ROUTINE_A

           SUBROUTINE KINETIC_ROUTINE_B(...)
                   ...
           END SUBROUTINE KINETIC_ROUTINE_B

           SUBROUTINE KINETIC_ROUTINE_C(...)
                   ...
           END SUBROUTINE KINETIC_ROUTINE_C
                   ...
     END INTERFACE GENERIC_KINETIC
END MODULE  MY_KINETICS

After this module is cited

USE MY_KINETICS

with each of the specific routines available, the call

CALL GENERIC_KINETIC(...)

will invoke the specific routine with the matching unique interface. In C++, overloading is a type of class polymorphism.

High Precision

Most FORTRAN compilers have built-in data types of very high precision, like quadruple precision

REAL*16    ::  VELOCITY(3,1000)
COMPLEX*32 ::  HAMILTONIAN(1000, 1000)

Collective Operations

FORTRAN supports collective operations on a whole array or a section of it.

REAL*16 ::  V1(3,100), V2(3,100), V3(3,100)
...
V1 = 0.0Q0
V1(2:3, 20:50) = 0.9Q0
V2 = 0.8Q0 * V3 

which assign all the "mentioned" elements with the corresponding values, without a need of loop(s). A pure array name means all elements.

Dynamic Memory Allocation

Early versions of FORTRAN had a big drawback: they did not allow for dynamic memory allocation, forcing re-compilation for array sizes changed. Newer versions of FORTRAN (since F90) support such operations even for many-dimensional arrays.

REAL*16, ALLOCATABLE :: COMPLICATED_DATA(:, :, :, :, :, :) 
INTEGER              :: I1=3, I2=90, I3=80, I4, I5, I6=28
I4 = 24; I5 = 500
ALLOCATE(COMPLICATED_DATA(I1, I2, I3, I4, I5, I6)) 

in contrast to C/C++ where all arrays are allocated as one-dimensional.

User Defined Data Types

FORTRAN also supports user defined data types:

TYPE PERSON
     CHARACTER(LEN=10) ::  NAME
     REAL              ::  AGE
     INTEGER           ::  ID
END TYPE PERSON
TYPE(PERSON) :: YOU, ME
REAL :: DIFF
YOU%ID = 12345
DIFF = YOU%AGE - ME%AGE

Some Other Features

• FORTRAN also supports recursive routines calls and optional arguments for routines.
• OpenMP and OpenAcc can easier understand and parallelize FORTRAN code.
• Compilers check FORTRAN code strictly based on grammars and point out any problems they find.

Links and Further Reading

• Fortran Standard Technical Committee
• Fortran Wikipedia Entry with information about History, features, and variants of Fortran.
• List of Fortran Compilers. We are operating the GNU and Intel compilers on our systems, see our compiler help file.
• FORTRAN 90/95 explained, by Michael Metcalf and John Reid. A good introduction focussing on the 90 version that introduced many of the "modern" features.

Help

Send email to cac.help@queensu.ca. We have scientific programmers on staff who will probably be able to help you out. Of course, we can't do the coding for you but we do our best to get your code ready for parallel machines and clusters.