- Fortran 90 contains Fortran 77 as a subset
(except for a few features).
- Consequently,
all Fortran 77 programs can be compiled with F90
and should produce identical results.
- Fortran 77
is an
old programming language
and has
antiquated scoping techniques
- To understand the scoping and lifetime rules of
Fortran 90 you must realize that:
- Variables in subprograms
in Fortran 77 are
created at the beginning
of the program
- Program units (program, subroutine, and function) are independent compilable units (and cannot pass information between each other)
- Variables in subprograms
in Fortran 77 are
created at the beginning
of the program
- There are no general
scopes
in Fortran
- The only place where there is some form of scope is when you use
internal functions :
- An
internal function
may access
all variables defined in the enclosing function
(unless you defind another local variables with the same name)
- However, the enclosing function cannot access any variables define in the internal function
- An
internal function
may access
all variables defined in the enclosing function
- Example:
FUNCTION pythagoras(a, b) ! The enclosing function IMPLICIT NONE REAL :: pythagoras, a, b REAL :: s s = square(a) + square(b) pythagoras = sqrt(s) RETURN CONTAINS ! internal functions follow... REAL FUNCTION square(x) REAL :: x print *, "a = ", a, ", b = ", b !! You can access outer variables square = x*x return END FUNCTION square END FUNCTION pythagoras
- Example Program:
(Demo above code)
- Prog file: click here
- "Local" variables
are only accessible locally
inside a function
Example:
INTEGER FUNCTION myFunction1() IMPLICIT NONE INTEGER :: i ! Local variable myFunction1 = i i = i + 1 RETURN END FUNCTION
- The
scope
of
"local" variables
is the
body of the function
in which the variable is defined
I.e., "local" variables are accessible only inside that function and its internal functions
- Example:
INTEGER FUNCTION myFunction1() IMPLICIT NONE INTEGER :: i !! Different variables myFunction1 = i i = i + 1 RETURN END FUNCTION ! ============================================ INTEGER FUNCTION myFunction2() IMPLICIT NONE INTEGER :: i !! Different variables myFunction2 = i i = i + 1 RETURN END FUNCTION
- The
lifetime
of
"local" variables
is the
beginning of the program
I.e., local variables in Fortran are not created when the program enters its scope (as in C++....
Local variables in Fortran functions are created when the program begins execution.
- Example:
INTEGER FUNCTION myFunction1() IMPLICIT NONE INTEGER :: i myFunction1 = i i = i + 1 RETURN END FUNCTION ! ============================================ INTEGER FUNCTION myFunction2() IMPLICIT NONE INTEGER :: i myFunction2 = i i = i + 1 RETURN END FUNCTION ! ============================================ PROGRAM internal PRINT *, myFunction1() PRINT *, myFunction1() ... PRINT *, myFunction2() PRINT *, myFunction2() ... END
Because the local variables i are created at the start of the program, they will retain the value between function invocations
As a result, you will see the output:
0 (i in myFunction1() 1 ... 0 (i in myFunction2() 1 ...
- Example Program:
(Demo above code)
- Prog file: click here
- To illustrate the
behavior
of
local variable that are
created when program execution enters
its scope, we use this
C++ program:
int myFunction1() { int i, r; r = i; i = i + 1; return(r); } int myFunction2() { int i, r; r = i; i = i + 1; return(r); } int main(int argc, char *argv[]) { cout << myFunction1() << endl; cout << myFunction1() << endl; ... cout << myFunction2() << endl; cout << myFunction2() << endl; ... }Because the local variables i are created each time the function runs, they will NOT retain the value between function invocations
As a result, you will see the output:
??? <------- First time there is "garbage" on the stack... x x <------- Same value each time..... x ... x x x ...
- Example Program:
(Demo above code)
- Prog file: click here
- Fortran is moving
towards a modern programming language
but still has some
historical roots
that it has to get rid off...
- Someday,
local variables
in Fortran will be
created when program execution enters
the scope of the variables
This will result in that behavior of C++:
-
Local variable
will
not retain values
between function invocations
- If this happens ,
existing F77 programs
will
not be able to be re-compile
(some program may make use of the factthat
Local variable
retain values
between function invocations)
- To enable
existing F77 programs
to
re-compile with little effort
Fortran F90 has introduce a special
SAVE variable
statement that save the value of a local variable between invocations
- Example:
SUBROUTINE mySubr(X, Y, Z) IMPLICIT NONE REAL :: X, Y, Z REAL :: A, B, C !! Local variables !! (may lose their value between !! invocation in the future)... SAVE A !! A will retain the value between invocation ... END
- I have
deliberately
avoid discussion the topic
of
recursion
- Because
recursion
is
rarely used
in numerical analysis applications,
I have omitted it in this course and focussed on
other more useful topics.
- In order to have
recusive functions ,
the
local (and parameter) variables
must be
created when execution enters
the recusive function
- Fortran 77
does not support
recusive functions
(Because in Fortran 77, local (and parameter) variables are NOT created when execution enters the recusive function )
However, Fortran 90 does.
Example:
RECURSIVE FUNCTION fac(N) RESULT(facResult) IMPLICIT NONE INTEGER :: facResult !! Return type INTEGER, INTENT(IN) :: N if ( N == 1 ) then facResult = 1 else facResult = N * fac(N-1) end if END FUNCTIONThe RECURSIVE keyword make the Fortran 90 compiler to use a completely different compilation technique for a function.
- Example Program:
(Demo above code)
- Prog file: click here
- Global variables
are accessible globally
from within any function
- Global variables are defined in Fortran using:
- using a common block
(a F77 construct), or
- using a module
- using a common block
(a F77 construct), or
- The common block
is the F77 construct
to
share variables
between different program units
Shared variables can be accessed from within any program or subprogram
Shared variables are effectively "global" variables .
- Syntax of a "common block"
COMMON [/BlockName/] var1, var2, ....
- Example sharing variables:
PROGRAM myProg INTEGER i1, i2 REAL f1, f2 COMMON /John/ i1, f1 ! Must be in same order !!! i1 = 1111 f1 = 2222 i2 = 3333 f2 = 24444 CALL mySubr print *, i1, f1, i2, f2 END
SUBROUTINE mySubr INTEGER i1, i2 REAL f1, f2 COMMON /John/ i1, f1 ! Must be in same order !!! i1 = 5555 f1 = 6666 i2 = 7777 f2 = 8888 RETURN ENDThe subroutine is able to access the shared variables i1 and f1
- Example Program:
(Demo above code)
- Prog file: click here
- Global variables
in F90 are usually defined in
a module
- A module
is used to
group
a set of
related constructs, such as:
- types
- constants
- (global) variables
- declarations and
- (module) procedures
- Syntax to define a Module:
module ModuleName .. .. content of module (discussed later) end moduleIn the module, you can specify zero or more definitions for:
- types
- constants
- variables
- declarations and
- (module) procedures
- Here, we will first look at
using modules
to define global variables
- Syntax to define (global) variable in a module:
MODULE ModuleName [PRIVATE|PUBLIC] !! Default is PUBLIC [PRIVATE::|PUBLIC::] variable definitions... END MODULE [ModuleName]
Meaning:
- The [PRIVATE | PUBLIC]
clause set the
default access mode
for all variables
The default is PUBLIC
- Private
variables can only be accessed by
functions defined inside the module
- The [PRIVATE:: | PUBLIC::] clause selectively set the default access mode for one variable
- The [PRIVATE | PUBLIC]
clause set the
default access mode
for all variables
- Example:
MODULE myModule INTEGER i1 REAL f1 END MODULE
- A module
is a
program unit
and can be
compiled separately
- When compiling a
module
separately, use the
-c option:
f90 -c ModuleFileName.f90
- Also, the compiled module is stored in a file with extension .mod
- The information in a module
must be
processed
using a
USE statement
- Syntax of the USE statement:
USE ModuleName
- NOTE:
-
The USE ModuleName clause
MUST PRECEED
the IMPLICIT NONE clause !!!
- Example:
MODULE myModule INTEGER i1 REAL f1 END MODULE PROGRAM myProg USE myModule IMPLICIT NONE i1 = 1111 f1 = 2222 CALL mySubr --------------------------------+ | print *, i1, f1 | END | | SUBROUTINE mySubr <----------------------------+ USE myModule IMPLICIT NONE i1 = 3333 f1 = 4444 END
The subroutine mySubr will be able to modify the global variables
- Example Program:
(Demo above code)
- Prog file: click here
- Parameter variables
of ordinary functions
are also created from the beginning of the program
(so they exist from the start of the execution - that's
why Fortran is so speedy...)
- Passing parameters in a function call, the caller merely copies the value from its variables into the already existing parameter variables.
- Modules is F90's half-successful attempt to introduce
classes into this ancient programming language
- You can define variables as well as
functions (subroutines) in a module
- Some names can be made PRIVATE to prevent access
from outside the module
- Howvere, Fortran modules are NOT as powerful as
C++ classes:
- There is no inheritance...
- There is no function polymorphism...
- The word is that Fortran 2003
will have inheritance...
Have not look into that yet.... I plan to when the Fortran 2003 compiler is available.