Fortran 90 Procedures and Modules , QUB

The Queen's University of Belfast

Parallel Computer Centre

[Next] [Previous] [Top]

Procedures
and
Modules

Procedures
and modules

Topics

Program units
Procedures
INTERFACE blocks
Procedure arguments
RESULT clause for functions
Array-valued functions
Recursive procedures
Generic procedures
Modules
Overloading operators
Defining operators
Assignment overloading
Scope
Program structure

Program units

Main program

Form:

 PROGRAM [name]

  [specification statements]

  [executable statements]

  ...

 END [PROGRAM [name]]

Example:

 PROGRAM test

  ...

  ...

! END

! END PROGRAM

 END PROGRAM test

Procedures

Functions and subroutines

Structurally, procedures may be:
- External - self contained (not necessarily Fortran)
- Internal - inside a program unit
- Module - member of a module
Fortran 77 has only external procedures

External procedures

Form

 SUBROUITNE name ( dummy-argument-list )

  [specification-statements]

  [executable-statements]

  ...

 END [SUBROUTINE [name]]

FUNCTION name ( dummy-argument-list ) [specification-statements] [executable-statements] ... END [FUNCTION [name]]

Internal procedures

Each program unit can contain internal procedures
Internal procedures are collected together at the end of a program unit and preceded by a CONTAINS statement
Same form as external procedures except
that the word SUBROUTINE/FUNCTION
must be present on the END statement
Variables defined in the program unit remain defined in the internal procedures, unless redefined there
Nesting of internal procedures is not permitted

Example

 PROGRAM main



  IMPLICIT NONE 

  REAL :: a, b, c

  REAL :: mainsum

...

  mainsum = add( )

  ...

CONTAINS

  FUNCTION add ( )

   REAL :: add   ! a,b,c defined in `main' 

   add = a + b + c 

  END FUNCTION add

  ...



 END PROGRAM main

INTERFACE blocks

Explicit vs implicit

If an `explicit' interface for a procedure is provided, compiler can check argument inconsistency
Module and internal procedures have an `explicit' interface by default
External procedures have an `implicit' interface by default
INTERFACE block can be used to specify an `explicit' interface for external procedures
Always use INTERFACE block in the calling program unit for external procedures

Form

General form:

 INTERFACE    

   interface_body   

  ...

 END INTERFACE

where interface_body is an exact copy of the subprogram specification, its dummy argument specifications and its END statement

Example

 INTERFACE

  REAL FUNCTION func(x)

   REAL, INTENT(IN) :: x

  END FUNCTION func

 END INTERFACE

Procedure arguments

INTENT

Argument intent - can specify whether an argument is for:
- input (IN),
- output (OUT)
- or both (INOUT)
Examples

INTEGER, INTENT(IN) :: in_only REAL, INTENT(OUT) :: out_only INTEGER, INTENT(INOUT) :: both_in_out

Keyword arguments

Example

 REAL FUNCTION area (start, finish, tol)  

  IMPLICIT NONE

  REAL, INTENT(IN) :: start, finish, tol

  ... 

 END FUNCTION area

Call with:

a = area(0.0, 100.0, 0.01) b = area(start = 0.0, tol = 0.01, finish = 100.0) c = area(0.0, finish = 100.0, tol = 0.01)

Once a keyword is used, all the rest must use keywords

Optional arguments

Example

 REAL FUNCTION area (start, finish, tol)

  IMPLICIT NONE

  REAL, INTENT(IN), OPTIONAL ::        &   

   start, finish, tol   

  ... 

 END FUNCTION area

Call with:

a = area(0.0, 100.0, 0.01) b = area(start=0.0, finish=100.0, tol=0.01) c = area(0.0) d = area(0.0, tol=0.01)

PRESENT

Example

 REAL FUNCTION area (start, finish, tol)

  IMPLICIT NONE

  REAL, INTENT(IN), OPTIONAL ::        &   

   start, finish, tol   

  REAL :: ttol

  ...

  IF ( PRESENT(tol) ) THEN

   ttol = tol

  ELSE

   ttol = 0.01

  END IF

  ... 

 END FUNCTION area

Use intrinsic function PRESENT to check for presence of argument

Derived type

Procedure arguments can be of derived type if:

the procedure is internal to the program unit in which the derived type is defined
or the derived type is defined in a module which is accessible from the procedure

Procedures as arguments

In Fortran 77, a procedure argument is declared as EXTERNAL
In Fortran 90, the procedure that is passed as argument must be an external or a module procedure
Internal procedures are not permitted
For external procedure, you are recommended to supply an INTERFACE block in the calling program unit
A module procedure has an explicit interface by default

Example

The calling program unit:

... INTERFACE REAL FUNCTION func(x, y) REAL, INTENT(IN) :: x, y END FUNCTION func END INTERFACE ... CALL area(func, start, finish, tol)

The external function:

REAL FUNCTION func(x, y) IMPLICIT NONE REAL, INTENT(IN) :: x, y ... END FUNCTION func

RESULT clause
for functions

Functions can have a result clause:

 FUNCTION add (a, b, c) RESULT (sum)

  IMPLICIT NONE

  REAL, INTENT(IN) :: a, b, c

  REAL :: sum

  sum = a + b + c

 END FUNCTION add

Result clause required for recursive functions which call themselves directly

Array-valued functions

In Fortran 90 functions may have an array-valued result:

 FUNCTION add_vec (a, b, n)



  IMPLICIT NONE

  INTEGER, INTENT(IN) :: n

  REAL, DIMENSION (n), INTENT(IN) :: a, b

  REAL, DIMENSION (n) :: add_vec

  INTEGER :: i



  DO i = 1, n

   add_vec(i) = a(i) + b(i)

  END DO



 END FUNCTION add_vec

Recursive procedures

Procedures may be called recursively:
- either A calls B calls A, or
- A calls A directly (RESULT clause required).
Must be defined as recursive procedure:

 RECURSIVE FUNCTION fact(n) RESULT(res)

  IMPLICIT NONE

  INTEGER, INTENT(IN) :: n

  INTEGER :: res

  IF (n == 1) THEN

   res = 1

  ELSE

   res = n * fact(n - 1)

  END IF

 END FUNCTION fact

Generic procedures

Can define your own generic procedures
Need distinct procedures for specific type of arguments and a `generic interface':

 INTERFACE generic_name

  specific_interface_body

  specific_interface_body

  ...

 END INTERFACE

Each distinct procedure can be invoked using the generic name, depending on the type of arguments
Generic procedures with derived type of arguments require Modules - see later

Example

Two distinct external subroutines for REAL and INTEGER types:

 SUBROUTINE swapreal (a, b)

  IMPLICIT NONE

  REAL, INTENT(INOUT) :: a, b

  REAL :: temp

  temp = a; a = b; b = temp

 END SUBROUTINE swapreal

 SUBROUTINE swapint (a, b)

  IMPLICIT NONE

  INTEGER, INTENT(INOUT) :: a, b

  INTEGER :: temp

  temp = a; a = b; b = temp

 END SUBROUTINE swapint

Example

Generic interface:

 INTERFACE swap      ! generic name

  SUBROUTINE swapreal (a, b)

   REAL, INTENT(INOUT) :: a, b

  END SUBROUTINE swapreal

  SUBROUTINE swapint (a, b)

   INTEGER, INTENT(INOUT) :: a, b

  END SUBROUTINE swapint

 END INTERFACE

Invoke with:

CALL swap(x, y)

Modules

Very powerful facility with many applications in terms of program structure
Method of sharing data and/or procedures to different program units
Very useful role for definitions of types and associated operators
Form:

 MODULE module-name

  [specification-stmts]

  [executable-stmts]

 [CONTAINS

  module procedures]

 END [MODULE [module-name]]

Accessed via the USE statement

Global data

Global if used in main program or with SAVE attribute (substitute for COMMON)

 MODULE globals

  REAL, SAVE :: a, b, c

  INTEGER, SAVE :: i, j, k

 END MODULE globals

Examples of the USE statements:

 USE globals 

 ! allows all variables in the module to be accessed

 USE globals, ONLY : a, c

 ! allows only variables a and c to be accessed

 USE globals, r => a , s => b 

 ! allows a, b and c to be accessed with local 

 ! variables r, s and c

Module procedures

Modules may contain procedures that can be accessed by other program units
Same form as external procedure except:
- Procedures must follow a CONTAINS statement
- The END statement must have SUBROUTINE or FUNCTION specified.
Particularly useful for a collection of derived types and associated operations

Example to `add' variables with derived type:

MODULE point_module TYPE point REAL :: x, y END TYPE point CONTAINS FUNCTION addpoints (p, q) TYPE (point), INTENT(IN) :: p, q TYPE (point) :: addpoints addpoints%x = p%x + q%x addpoints%y = p%y + q%y END FUNCTION addpoints END MODULE point_module

A program unit would contain:

USE point_module TYPE (point) :: px, py, pz ... pz = addpoints(px, py)

Generic procedures

Using modules allows arguments of derived type and hence generic procedures with derived types

Example with derived type:

 MODULE genswap

  IMPLICIT NONE

  TYPE point

   REAL :: x, y

  END TYPE point

  INTERFACE swap     ! generic interface

   MODULE PROCEDURE swapreal, &

    swapint,  swaplog, swappoint   

  END INTERFACE

 CONTAINS

  SUBROUTINE swappoint (a, b)

   TYPE (point), INTENT(INOUT) :: a, b 

   TYPE (point) :: temp

   temp = a; a = b;    b = temp

  END SUBROUTINE swappoint 

  ...   ! swapint, swapreal, swaplog  

     ! procedures are defined here

 END MODULE genswap

Public and private objects

By default all objects in a module are available to a program unit which includes the USE statement
Can restrict the use of certain objects to the guest program
May wish to update module subroutines at any time, keeping the purpose and interface the same, but changing the meaning of specific variables
Achieved via PRIVATE attribute or PRIVATE statement:

INTEGER, PRIVATE :: keep, out

Overloading operators

Can extend the meaning of an intrinsic operator to apply to additional data types - operator overloading
Need an INTERFACE block with the form

 INTERFACE OPERATOR (intrinsic_operator)

  interface_body

 END INTERFACE

Example - define `+' for character variables to concatenate two strings ignoring any trailing blanks

Example

MODULE operator_overloading

 IMPLICIT NONE

 ...

 INTERFACE OPERATOR (+) 

  MODULE PROCEDURE concat

 END INTERFACE

 ...

CONTAINS

 FUNCTION concat(cha, chb)

  CHARACTER (LEN=*), INTENT(IN) :: &

   cha, chb 

  CHARACTER (LEN=LEN_TRIM(cha) + &

   LEN_TRIM(chb)) :: concat

  concat = TRIM(cha) // TRIM(chb)

 END FUNCTION concat

 ...

END MODULE operator_overloading

Now the expression `cha + chb' is meaningful

Defining operators

Can define new operators - especially useful for user defined types
Operator name must have a `.' at the beginning and end
Need to define the operation via a function which has one or two non-optional arguments with INTENT(IN)
Example - find the straight line distance between two derived type `points'

 PROGRAM main

  USE distance_module

  TYPE (point) :: p1, p2

  ...

  distance = p1 .DIST. p2      

  ...

 END PROGRAM main

Example

 MODULE distance_module

  ...

  TYPE point

   REAL :: x, y

  END TYPE point

  ...

  INTERFACE OPERATOR (.DIST.)

   MODULE PROCEDURE calcdist

  END INTERFACE

  ...

 CONTAINS

  ...

  REAL FUNCTION calcdist (px, py)

   TYPE (point), INTENT(IN) :: px, py

   calcdist = SQRT ((px%x-py%x)**2  &

    + (px%y-py%y)**2 )

  END FUNCTION calcdist

  ...

 END MODULE distance_module

Assignment overloading

When using derived data types, may need to extend the meaning of assignment (=) to new data types:

 REAL :: ax

 TYPE (point) :: px

 ...

 ax = px     ! type point assigned to type real

 ...    ! not valid until defined

Need to define the assignment via a subroutine with two non-optional arguments, the first having INTENT(OUT), the second having INTENT(IN) and create an interface assignment block:

 INTERFACE ASSIGNMENT (=)   

  subroutine interface body

 END INTERFACE

Example

 MODULE assignoverload_module

  ...

  TYPE point

   REAL :: x, y

  END TYPE point

  ...

  INTERFACE ASSIGNMENT (=)

   MODULE PROCEDURE assignnew

  END INTERFACE

  ...

 CONTAINS

  SUBROUTINE assignnew (ax, px)

   REAL, INTENT(OUT) :: ax

   TYPE (point), INTENT(IN) :: px

   ax = MAX(px%x, px%y)

  END SUBROUTINE assignnew

  ...

 END MODULE assignoverload_module

The program unit might include:

... USE assignover_mod ... REAL :: ax TYPE (point) :: px ... ax = px ! Type point to type real now defined ...

Scope

Scoping unit

The scope of a named entity or label is the set of non-overlapping scoping units where that name or label may be used unambiguously.

A scoping unit is one of the following:

a derived type definition,
a procedure interface body, excluding any derived-type definitions and interface bodies contained within it, or
a program unit or an internal procedure, excluding derived-type definitions, interface bodies, and subprograms contained within it.

Labels and names

The scope of a label is a main program or a procedure, excluding any internal procedures contained within it
Entities declared in different scoping unit
are always different
Within a scoping unit, each named entity must have a distinct name, with the exception of generic names of procedures
The names of program units are global, so each must distinct from the others and from any of the local entities of the program unit
The scope of a name declared in a module extends to any program units that USE the module

Example

MODULE scope1         ! scope 1

...         ! scope 1

CONTAINS         ! scope 1

 SUBROUTINE scope2        ! scope 2

  TYPE scope3       ! scope 3

   ...      ! scope 3

  END TYPE       ! scope 3

  INTERFACE        ! scope 3

  ...       ! scope 4

  END INTERFACE       ! scope 3

  REAL x, y       ! scope 3

100  ...       ! scope 3

  CONTAINS       ! scope 3

   FUNCTION scope5(...)      ! scope 5

    REAL y     ! scope 5

    y = x + 1.0     ! scope 5

100    ...     ! scope 5

   END FUNCTION    scope5   ! scope 5

 END SUBROUTINE  scope2       ! scope 2

END MODULE   scope1       ! scope 1

Program structure

Order of statements

When to use INTERFACE blocks

When a module/external procedure is called:

Which defines or overloads an operator, or the assignment
Using a generic name

Additionally, when an external procedure:

Is called with keyword/optional argument
Is an array-valued/pointer function or a character function which is neither a constant nor assumed length
Has a dummy argument which is an assumed-shape array, a pointer/target
Is a dummy or actual argument (not mandatory but recommended)

Summary

Fortran 77 style:

Main program with external procedures, possibly in a library.
No interfaces, so argument inconsistencies are not checked by compiler.

Simple Fortran 90:

Main program with internal procedures.
Interfaces are `explicit', so argument inconsistencies are trapped by compiler.

Fortran 90 with modules:

Main program and module(s) containing interfaces and possibly specifications, and external procedures (possibly precompiled libraries).

A Fortran 90 version of the Fortran 77 style - with interfaces to permit compiler checking of argument inconsistencies. (Used by Nag?)
Main program and module(s) containing specifications, interfaces and procedures.

No external procedures.

Expected for sophisticated Fortran 90 programs.

[Next] [Previous] [Top]

All documents are the responsibility of, and copyright, © their authors and do not represent the views of The Parallel Computer Centre, nor of The Queen's University of Belfast.
Maintained by Alan Rea, email A.Rea@qub.ac.uk

Generated with CERN WebMaker

Procedures and Modules

Procedures and modules

Topics

Program units

Main program

Procedures

Functions and subroutines

External procedures

Form

Internal procedures

Example

INTERFACE blocks

Explicit vs implicit

Form

Procedure arguments

INTENT

Keyword arguments

Optional arguments

PRESENT

Derived type

Procedures as arguments

RESULT clause for functions

Array-valued functions

Recursive procedures

Generic procedures

Example

Example

Modules

Global data

Module procedures

Generic procedures

Public and private objects

Overloading operators

Example

Defining operators

Example

Assignment overloading

Example

Scope

Scoping unit

Labels and names

Example

Program structure

Order of statements

When to use INTERFACE blocks

Summary

Procedures
and
Modules

Procedures
and modules

RESULT clause
for functions