- The Fortran 90
introduced the
module feature
can be used to
replace
the following features:
- INCLUDE
- Common block (see global variables: click here )
- Stand-alone subroutines and functions
- The Fortran 90
module
implements
some new features
that were not available in Fortran 77:
- Shared declaration (especially: user-defined types)
- Privately access (global) variables
- Module functions that are more flexible than stand-alone functions
- Syntax
of a
module
module module_name .... end module - A module
is a
program unit
and can be
stored in a
separate file
and compiled
separately
using the command:
f90 -c ModuleProgFile.f90
The f90 compiler will produces a module file:
module_name.mod
- A program unit
(PROGRAM or SUBROUTINE/FUNCTION) that wants to
use the
constants,
types,
variables,
functions, etc
in a module must
use
the module
as
its first statment:
PROGRAM Main USE ModuleName ! must be the first statement ....
- A module has the following
syntax structure :
MODULE ModuleName Specification Part 1. can USE other module 2. user-defined types 3. (global) constants 4. (global) variables 5. generic function's interfaces CONTAINS Implementaion Part contain subroutines/functions described in the subprogram interfaces END MODULE [ModuleName] - NOTES
- A module can
use other modules :
module this_module USE that_module ... end moduleWe can thus use other modules to define the current module
NOTE: that it not the same as inheritance
- A module defintion for a module
cannot use itself
module this_module USE this_module <--- illegal !!! ... end module
- There is
no need
to
declare subroutines/functions
in the Implementation Part
The USE clause will implicitly declare the functions
- The generic
interface spefication
uses a
symplified syntax :
interface generic_function_name MODULE PROCEDURE subrotine1, subroutine2, ... end interfaceYou do not need to provide spefications for input parameters or return values
F90 will fill it in automatically (when it processes the Implementation Part )
- A function/subroutine specified in as part of a generic function (named interface) must be defined in the Implementation Part of the module
- A module can
use other modules :
- The following module
contains the necessary
type definition
and
functions
to implement
a
linked list
MODULE ListModule ! ====================== Specification part =============== TYPE ListElem REAL :: value; TYPE(ListElem), POINTER :: next; END TYPE ListElem CONTAINS ! ====================== Implementation part =============== ! ----------------------- ! Insert at head ! ----------------------- FUNCTION InsertList(head, elem) IMPLICIT NONE type( ListElem ), pointer :: head, elem type( ListElem ), pointer :: InsertList elem%next => head InsertList => elem END FUNCTION ! ----------------------- ! Delete at head ! ----------------------- FUNCTION DeleteList(head) IMPLICIT NONE type( ListElem ), pointer :: head type( ListElem ), pointer :: DeleteList type( ListElem ), pointer :: h IF ( ASSOCIATED(head) ) THEN h => head head => head%next deallocate(h) END IF DeleteList => head END FUNCTION ! ----------------------- ! Print ! ----------------------- SUBROUTINE PrintList(head) IMPLICIT NONE type( ListElem ), pointer :: head type( ListElem ), pointer :: ptr ptr => head print *, "The list is: " DO WHILE ( associated(ptr) ) print *, ptr%value ptr => ptr%next END DO print * END SUBROUTINE END MODULE
- Example Program that uses the ListModule:
PROGRAM ListProcessing Use ListModule type( ListElem ), pointer :: head type( ListElem ), pointer :: newElem integer, parameter :: N = 4 NULLIFY( head ) ! Empty list ! --------------------------------------------- ! Add the N elements ! --------------------------------------------- DO i = 1, N ALLOCATE( newElem ) CALL random_number( newElem%value ) head => InsertList(head, newElem) CALL PrintList(head) END DO head => DeleteList(head) END PROGRAM
- Example Program:
(Demo above code)
- The Main Prog file: click here
- The List Module file: click here
How to compile and run:
f90 -c list-module.f90 // list-module.o + listmodule.mod f90 -c main-list.f90 // main-list.o f90 main-list.o list-module.o
NOTE: you need to include the "list-module.o" file because the module contains the implementation of the functions/subroutines
- The following module
contains the necessary
type definition ,
functions
and a
"named" interface
to implement
the overloaded
Matrix * Matrix
and
Matrix * Vector
operation
*
MODULE MatrixOps ! ====================== Specification part =============== TYPE MyReal REAL x ! To avoid conflict with REAL END TYPE MyReal INTERFACE operator(*) MODULE PROCEDURE MatVecMult, MatMatMult END INTERFACE ! ====================== Implementation part =============== CONTAINS ! ----------------------- ! Matrix * Vector ! ----------------------- FUNCTION MatVecMult(A, v) result (w) implicit none TYPE(MyReal), dimension(:,:), INTENT(IN) :: A TYPE(MyReal), dimension(:), INTENT(IN) :: v TYPE(MyReal), dimension( SIZE(A,1) ) :: w integer :: j integer :: N N = SIZE(A,2) w(:).x = 0.0 !! clear whole vector DO j = 1, N w(:).x = w(:).x + v(j).x * A( :, j ).x END DO END FUNCTION ! ----------------------- ! Matrix * Matrix ! ----------------------- FUNCTION MatMatMult(A, B) result (C) implicit none TYPE(MyReal), dimension(:,:), INTENT(IN) :: A TYPE(MyReal), dimension(:,:), INTENT(IN) :: B TYPE(MyReal), dimension( size(A,1), size(B, 2) ) :: C integer :: M, N, i, j M = size(A,1) N = size(B,2) C(:,:).x = 0.0 !! clear whole matrix DO i = 1, M DO j = 1, N C(:,i).x = C(:,i).x + B(j,i).x*A(:,j).x END DO END DO END FUNCTION END MODULE
- Example Program that uses the MatrixModule:
PROGRAM Main USE MatrixOps implicit none TYPE(MyReal), dimension( 3, 3 ) :: A, B, C TYPE(MyReal), dimension( 3 ) :: v1, v2 v2 = A * v1 !! Matrix * Vector C = A * B !! Matrix * Matrix END PROGRAM
- Example Program:
(Demo above code)
- The Main Prog file: click here
- The Matrix Module file: click here
How to compile and run:
f90 -c matrix-module.f90 // matrix-module.o + matrixmodule.mod f90 -c main-matrix.f90 // main-list.o f90 main-matrix.o matrix-module.o
NOTE: you need to include the "matrix-module.o" file because the module contains the implementation of the functions/subroutines
- Accessibility
of
variables
and
subprograms
in modules are
controlled
by 2 accessibility modifiers
(similar to C++):
- PUBLIC
-
Public items are
accessible
to program units
outside the current module
- PRIVATE
-
Private items are
accessible
only to subroutine/functions
inside the current module
- PUBLIC
- The initial access mode
PUBLIC
The access mode can be changed using:
PRIVATE ! Permanent change ! - Items that follows will have PRIVATE access PUBLIC ! Permanent change ! - Items that follows will have PUBLIC access PRIVATE :: x, y ! One time change ! - Items x, y will have PRIVATE access PUBLIC :: x, y ! One time change ! - Items x, y will have PUBLIC access
- Example:
MODULE MyModuleName PRIVATE !! Make everything in module private by default PUBLIC :: var1, func1 !! Make these items public PUBLIC :: x, y, z, OPERATOR(.add.) PRIVATE :: u, v, w, ASSIGNMENT(=), OPERATOR(*) integer, PRIVATE :: a, b, c !! Another way to make it private .... END MODULE
- The names of
any object
in a module
canbe
renamed
to
resolve name clashes
- Syntax:
USE module_name, newName1 => Name1, & newName2 => Name2, ...
- NOTE:
- Once a new name newName1 is assigned, the object Name1 cannot be accessed using Name1 any longer !
- The option
ONLY
allows the program unit
to selectively import
objects from a module
- Syntax:
USE module_name, ONLY : name1, name2, ...
- Selectively imported
names can also be
renamed :
USE module_name, ONLY : new1 => name1, & new2 => name2, ...