Chapter 11. More Fortran Elements: Functions and Subroutines 11.1 ...

Chapter 11. More Fortran Elements: Functions and Subroutines
11.1 Overview
In many situations, it is useful to write portable Fortran code so that a particular algorithm
may be used in more than one program. It also is helpful when programming a complex problem
to break it up into smaller sections. Fortran functions and subroutines are small subprograms that
allow for portability and division of tasks.
11. 2 Functions
A function in Fortran is a subprogram that takes some arguments, performs some
calculations, and returns a single result. Intrinsic functions such as SIN(), COS(), ABS(), and
EXP() are special built-in cases of Fortran functions; however, an external function subprogram
may be written to perform any desired computation.
11.2.1 Function Subprogram Layout
The layout of an external function subprogram is very similar to any other program layout
in Fortran. A function has four main sections as shown in Figure 11.1: the function type and name
with specified arguments, variable declarations, the main body of the subprogram, and the end of the
subprogram.
type function name(arg1, arg2, …) start of function
implicit none
variable declarations
real arg1, arg2, x, y
integer i, j, k
.
.
.
calculations are carried
out here
.
.
.
return
end
main body of function subprogram
end of function
Figure 11.1. Layout of a typical Fortran function subprogram.
The FUNCTION statement is placed at the beginning of the function subprogram and
identifies the function name. The function must be declared as a specific type, INTEGER or
REAL, prior to the function name. The arguments passed to the function from the main program
are enclosed in parentheses after the function name. Any number of arguments may be passed and
the arguments may correspond to any variable type and also may be arrays.
The Variable Declaration section of the subprogram has the same format as it does in a
regular Fortran program. Note that the arguments passed to the function from a main program
must be declared in the Variable Declaration section.
67

The Main Body of the subprogram has the same format as in a regular Fortran program.
The main computational task of the function is carried out in this section.
The End of the Function is indicated by the statement RETURN, which passes execution
back to the main program, and END, which signifies the end of the function subprogram.
11.2.2 Using an External Function in a Fortran Program
An external function is used in a Fortran program in much the same way as an intrinsic
function. When an intrinsic function is used, it is included as part of an assignment statement. For
example, to evaluate the expression x = 3sin( 24t),
an assignment statement including the intrinsic
function SIN() is used, as illustrated below.
X = 3.0*SIN(24.0*T)
€
An external function may be called in a similar fashion as part of an assignment statement. A
typical assignment statement employing an external function is shown below.
Z = FUNCTION(ARG1, ARG2, …)
The function may be passed one or more arguments by the main program. However, the result of
function evaluation is a single numerical value, just as the result of evaluating sin 1.5
numerical value.
In order to use an external function as part of an assignment statement, the name of the
function must be declared in the Variable Declaration section of the main program. The function
may be declared as real or integer depending on the type of result it
€
returns.
68
( ) yields a single
11.2.3 Function Subprogram Example
The use of an external function in Fortran will be illustrated with the example of numerical
integration. The trapezoidal approximation to the integral of a function is given by the expression
b
∫ f ( x)
dx ≈ h
2 f x [ ( 1)
+ f ( xn ) ] + h∑ f ( xi) . (11.1)
a
In Equation (11.1), the function has been sampled on the interval a ≤ x ≤ b by n points separated
by step size h. An external function written to implement the trapezoidal approximation to the
integral is given
€
below.
€
n−1
i=2

REAL*8 FUNCTION TRAP(NPTS, H, F)
IMPLICIT NONE
INTEGER NPTS, I
REAL*8 H, F(NPTS)
TRAP = 0.5 * H * ( F(1) + F(NPTS) )
DO 100 I = 2, NPTS–1
TRAP = TRAP + H * F(I)
100 CONTINUE
RETURN
END
The arguments that must be passed to the function from the main program include the
number of integration points, the step size h, and the array containing the sampled function. These
variables and any others used within the function subprogram must be defined in the variable
declaration statement. The variable names used in the function argument list are dummy variables.
The same names do not have to be used in the main program but their types must match.
The main body of the function subprogram calculates the value of the integral using the
trapezoidal approximation, Equation (11.1). At the end of the subprogram, the value of the integral
is stored in the variable TRAP. The RETURN statement then sends the program control back to
the main program.
An example of a Fortran program that uses the TRAP function to determine the value of the
integral
e x
1
∫ dx with the trapezoidal approximation is given below. A step size of Δx = 0.01 is
0
employed so that the number of integration points is 101. The main program must define as
REAL*8 the variable TRAP, which corresponds to the value returned by the function subprogram.
€
€
PROGRAM INTEGRATE
IMPLICIT NONE
INTEGER N, I
REAL*8 DELTAX, X, F(101), INTEGRAL, TRAP
DELTAX = 0.01
N = 101
DO 100 I = 1, N
X = DELTAX * (I–1)
F(I) = EXP(X)
100 CONTINUE
INTEGRAL = TRAP(N, DELTAX, F)
WRITE(*,*) 'The value of the integral is ', INTEGRAL
69

STOP
END
In the main program, the variable denoting the number of points is N but in the function the
same variable is defined as NPTS. The variable names do not have to match. The first argument in
the argument list of the function will be stored as the integer variable NPTS in the function no
matter what it is called in the main program. Similarly, in the main program, the step size is called
DELTAX, but in the function the same variable is called H. In both the main program and the
function subprogram, the array containing the function to be integrated is called F; however, in
general the two array names do not have to match.
11.2.4 Compiling Source Code Containing External Functions
To compile a Fortran program that uses an external function, the source code may be saved
in a single file or in multiple files. If the source code for the main program and the external
function is stored in a single file, the source code for the function must be listed after the main
program. The compilation with g77 is then no different than that of a single Fortran program:
g77 –o pgm.exe file.f
If the source code of the main program is stored in one file and the source code of the external
function is stored in a second file, then the compilation statement must include both files:
g77 –o pgm.exe file1.f file2.f
Here, file1.f and file2.f are the two files containing the main program and external function source
code, and pgm.exe is the single executable program created by compilation. Note that any number
of external functions may be employed in a main program.
11.3 Subroutines
A subroutine in Fortran also is a subprogram and is similar to an external function. The
difference is that a function may return only one numerical result and a subroutine may return
multiple numerical results.
11.3.1 Subroutine Layout
The layout of a subroutine is very similar to that of a function. A subroutine has four main
sections as shown in Figure 11.2: the subroutine name with specified arguments, variable
declarations, the main body of the subroutine, and the end of the subroutine.
70

subroutine name(arg1, arg2, …) start of subroutine
implicit none
variable declarations
real arg1, arg2, x, y
integer i, j, k
.
.
.
calculations are carried
out here
.
.
.
return
end
main body of subroutine
end of subroutine
Figure 11.2. Layout of a typical Fortran subroutine.
The SUBROUTINE statement is placed at the beginning of the subroutine and identifies
the subroutine name. The arguments passed to and from the subroutine are enclosed in parentheses
after the subroutine name. Any number of arguments may be passed back and forth and the
arguments may correspond to any variable type and also may be arrays.
The Variable Declaration section of the subroutine has the same format as it does in a
regular Fortran program. Note that the arguments passed between the subroutine and the main
program must be declared in the Variable Declaration section.
The Main Body of the subroutine has the same format as in a regular Fortran program.
The main computational tasks of the subroutine are carried out in this section.
The End of the Subroutine is indicated by the statement RETURN, which passes
execution back to the main program, and END, which signifies the end of the subroutine.
11.3.2 Using a Subroutine in a Fortran Program
A subroutine is employed in a Fortran program in a slightly different way than an external
function. Because the subroutine may pass back to the main program multiple numerical results,
the subroutine is not included as part of an assignment statement. Rather, a CALL statement is
employed. The format of a typical CALL statement is shown below.
CALL NAME(ARG1, ARG2, …)
In the CALL statement, NAME refers to the name of the subroutine. Note that the subroutine name
should not be the same as any other variable name and unlike an external function, it should not be
declared as a real or integer variable. This is because a subroutine may pass back to the main
program the values of many variables, both real and integer, while a function only returns a single
value.
71

11.3.3 Subroutine Example
The use of a subroutine in Fortran will be illustrated with the example of the Verlet
algorithm. Recall from Chapter 5 and Assignment 1 that the velocity Verlet algorithm for
numerically approximating solutions to Newton’s equations of motion is
€
x n+1 = x n + v n Δt + 1
2 a n Δt
( )2 . (11.2)
vn+1 = vn + 1
2 an + a ( n+1)Δt
. (11.3)
A subroutine written to carry out N steps of the Verlet algorithm for the harmonic oscillator is given
below. The number of points, time step size, harmonic oscillator force constant, mass, and initial
position and initial velocity
€
are the variables passed to the subroutine. The subroutine returns two
arrays, the position and velocity as functions of time.
SUBROUTINE VERLET(N, DT, K, M, X0, V0, X, V)
IMPLICIT NONE
INTEGER N, I
REAL*8 DT, K, M, X0, V0, A1, A2, X(N), V(N)
X(1) = X0
V(1) = V0
DO 100 I = 2, N
A1 = –K*X(I–1)/M
X(I) = X(I–1) + V(I–1)*DT + 0.5*A1*DT**2
A2 = –K*X(I)/M
V(I) = V(I–1) + 0.5*(A1+A2)*DT
100 CONTINUE
RETURN
END
All the variables passed from the main program to the subroutine as well as any others used
within the subroutine must be defined in the variable declaration statement. As was the case for
external function, the variable names used in the subroutine argument list are dummy variables. The
same names do not have to be used in the main program but their types must match.
The main body of the subroutine carries out multiple iterations of the Verlet equations
(11.2) and (11.3). At the end of the subroutine, the array X contains the position as a function of
time and the array V contains the velocity as a function of time. These arrays are passed back to the
main program. The RETURN statement then sends the program control back to the main program.
An example of a main program that calls the VERLET subroutine is given below. The
values of the step size, number of time steps, force constant, mass, and initial position and velocity
are all input from the screen. The main program then calls the VERLET subroutine to advance the
72

position and velocity solutions in time. Once the subroutine has completed its calculations, the
results are written to a file by the main program along with the time.
PROGRAM HARMOSC
IMPLICIT NONE
INTEGER NTIME, I
REAL*8 DELTAT, K, M, T, X0, V0, X(5000), V(5000)
OPEN(UNIT=25, FILE='verlet.out', STATUS='unknown')
WRITE(*,*)'Enter force constant:'
READ(*,*) K
WRITE (*,*)'Enter mass:'
READ(*,*) M
WRITE (*,*)'Enter deltat:'
READ(*,*) DELTAT
WRITE (*,*)'Enter no. of time steps:'
READ(*,*) NTIME
WRITE (*,*)'Enter initial position:'
READ(*,*) X0
WRITE (*,*)'Enter initial velocity:'
READ(*,*) V0
CALL VERLET(NTIME, DELTAT, K, M, X0, V0, X, V)
T = 0.
DO 100 I = 1, NTIME
T = T + DELTAT
WRITE(25,*) T, X(I), V(I)
100 CONTINUE
CLOSE(UNIT=25)
STOP
END
In the main program, the variable denoting the number of time steps is NTIME but in the
subroutine the same variable is defined as N. As was the case for external functions, the variable
names do not have to match in the subroutine and main program. The first argument in the
argument list of the subroutine will be stored as the integer variable N in the function no matter
what it is called in the main program. Similarly, in the main program, the time step size is called
DELTAT, but in the subroutine the same variable is called DT.
11.3.4 Compiling Source Code Containing Subroutines
To compile a Fortran program that uses a subroutine, the source code may be saved in a
single file or in multiple files. If the source code for the main program and the subroutine is stored
in a single file, the source code for the subroutine must be listed after the main program. The
compilation with g77 is then no different than that of a single Fortran program:
73

g77 –o pgm.exe file.f
If the source code of the main program is stored in one file and the source code of the subroutine is
stored in a second file, then the compilation statement must include both files:
g77 –o pgm.exe file1.f file2.f
Here, file1.f and file2.f are the two files containing the main program and subroutine source code,
and pgm.exe is the single executable program created by compilation. Note that any number of
subroutines may be employed in a main program.
74

Chapter 11 Review Problems
1. Construct an external function in Fortran to convert degrees Fahrenheit to Celsius. The
function is passed the temperature in degrees Fahrenheit and returns the temperature in Celsius.
Write a main program to input the temperature in degrees Fahrenheit and use the external
function to convert to Celsius. The main program should then write out the temperature in
degrees Fahrenheit and Celsius to the screen.
2. Write an external function in Fortran to calculate the factorial n!
3. Construct a subroutine to calculate the average and standard deviation of a data set. The
subroutine should be passed the number of data points and a one-dimensional array containing
the data.
75