New Fortran 90 Features

Fortran 90 is a major revision of its predecessor many of the inadequacies of FORTRAN 77 have been addressed:

1. Fortran 90 defines a new code format which is much more like every other language;
   • free format -- no reliance on specific positioning of special characters;
   • upto 132 columns per line;
   • more than one statement per line;
   • in-line comments allowed (this makes it easier to annotate code);
   • upper and lower case letters allowed (makes code more readable);
   • it is virtually impossible to misplace a character now;
   • longer and more descriptive object names (upto 31 characters);
   • names can be punctuated by underscores making then more readable.
2. Parallelism can now be expressed using whole array operations which include extensive slicing and sectioning facilities. Arithmetic may now be performed on whole arrays and array sections. Operations in an array valued expression are conceptually performed in parallel.

   To support this feature, many parallel intrinsic functions have been introduced including reduction operations such as SUM (add all elements in an array and return one value -- the sum) and MAXVAL (scan all elements in an array and return one value -- the biggest). This concept comes from APL.

   The masked (parallel) assignment (WHERE) statement is also a new feature.

3. The introduction of dynamic (heap) storage means that pointers and allocatable arrays can be implemented. Temporary arrays can now be created on-the-fly, pointers can be used for aliasing arrays or sections of arrays and implementing dynamic data structures such as linked lists and trees.
4. To combat non-portability, the KIND facility has been introduced. This mechanism allows the user to specify the desired precision of an object in a portable way. Type specifications can be parameterised meaning that the precision of a particular type can be changed by altering the value of one constant. Appropriate intrinsic inquiry functions are defined to query the precision of given objects.
5. User-defined types, which are constructed from existing types, can now be constructed. For example, a type can be defined to represent a 3D coordinate which has three components (x,y,z) or a different type can be used to represent personal details: name, age, sex address, phone number etc. Defining objects in this way is more intuitive and makes programming easier and less error prone.
6. Explicit recursion is now available. For reasons of efficiency the user must declare a procedure to be recursive but it can then be used to call itself.
7. Facility packaging has been introduced -- MODULE s replace many features of FORTRAN 77. They can be used for global definitions (of types, objects, operators and procedures), and can be used to provide functionality whose internal details are hidden from the user (data hiding).

   Reshaping and retyping functions have been added to the language which means that features that relied on storage association (such a EQUIVALENCE) do not have to be used.

• procedure interfaces which declare procedure and argument names and types can now be specified, this means that:
  • programs and procedures can be separately compiled -- more efficient development;
  • array bounds do not have to be passed as arguments;
  • array shape can be inherited from the actual argument;
  • better type checking exists across procedure boundaries;
  • more efficient code can be generated.
• new control constructs have been introduced, for example,
  • DO ... ENDDO (not part of FORTRAN 77) this will reduce use of numeric labels in the program;
  • DO ... WHILE loop;
  • the EXIT command for gracefully exiting a loop;
  • the CYCLE command for abandoning the current iteration of a loop and commencing the next one;
  • named control constructs which are useful for code readability;
  • SELECT CASE control block. which is more succinct, elegant and efficient than an IF .... ELSEIF ... ELSEIF block.

• Internal procedures are now allowed. A procedure is allowed to contain a further procedure with local scope -- it cannot be accessed from outside of the procedure within which it is defined.
• It is now possible to define and overload operators for derived and intrinsic data types which mean that so-called `semantic extension' can be performed, For example, an arbitrary length integer can be implemented using a linked list structure (one digit per cell) and then all the intrinsic operators defined (overloaded) so that this type can be treated in the same way as all other types. The language thus appears to have been extended. All intrinsic operators +, -, *, / and ** and assignment, =, can be overloaded (defined for new types).
• MODULE s also provide object based facilities for Fortran 90, for example, it is possible to use a module to implement the abovementioned long integer data type -- all required facilities (for example, definitions, objects, operators, overloaded intrinsics and manipulation procedures) may be packaged together in a MODULE, the user simple has to USE this module to have all the features instantly available. The module can now be used like a library unit.
• An ancillary standard, `The varying strings module', has been defined and is implemented in a module. When using this module, the user can simply declare an object of the appropriate type (VARYING_STRING) which can be manipulated in exactly the same fashion as the intrinsic character type. All intrinsic operations and procedures are included in the module and are therefore available for all objects of this type. All the implementation details are hidden from the user.
• useful libraries can be written and placed in a module.
• BLOCK DATA subprograms are now redundant since a MODULE can be used for the same purpose.

Return to corresponding overview page