The FORTRAN language includes three types of functions: intrinsic functions, function statements, and function subprograms. Each of these types of functions calculates a single value. Intrinsic functions are built into the compiler and are directly accessible in a program. Statement functions and function subprograms allow the programmer to write needed functions that are not in the compiler's library. If the computation can be written in a single assignment statement the statement function should be used. A function subprogram is a complete, separate program from the main program that computes a single value that is returned to the main program in the function name. A function subprogram may contain any FORTRAN statement. It is composed of the function name, its argument list, a RETURN statement and an END statement. The general form is

type FUNCTION name (formal argument list)
FUNCTION name = value

Example - Average of Three Numbers


c This program uses a function to find the average of three numbers.
        PROGRAM func_ave

c Type variables in main program (a, b, and c are local variables).
        REAL a,b,c,average

c Prompt for and get numbers to be averaged.
        PRINT *,'Enter the three numbers to be averaged.'
        READ *, a,b,c

c Invoke function average  
        PRINT *,'The three numbers to be averaged are ',a,b,c
        PRINT *,'The average of the three numbers is', average(a,b,c)

c Function average
        REAL FUNCTION average(x,y,z)

c Type variables in function (x, y, and z are local variables).
        REAL x,y,z

c Function name contains the value the function calculates and returns.
        average = (x + y + z)/3.0

FORTRAN variables are local to their respective programs/subprograms. That is, they are accessible only by the program or subprogram in which they are defined. In the statement

PRINT *,`The average of the three numbers is ' , average(a,b,c)

the variables a, b, and c are local to the main program and are called the actual arguments. The values of a, b, and c are communicated to the function when it is invoked. In the function they are referenced by the local variables x, y, and z and are called the formal (because they give the form of the variable) or dummy arguments. The actual arguments and the formal arguments may have the same or different variable names.

The function name, average, holds the value of the average that is computed in the function.

An assignment statement, average = (x + y + z)/3.0, is used to store the average to be returned to the main program. The function name is part of an expression and may be placed anywhere an expression may be placed.

REAL FUNCTION average (x, y, z)
average = (x+y+z)/3.0

The argument list is the input values a, b, and c that the function needs to compute the average.

The type of the value returned, the average, is explicitly typed in the FUNCTION name

REAL FUNCTION average(x,y,z)

At the RETURN statement, control is returned to the main program where the function was invoked and program execution continues from that point.

The END statement indicates the end of the function.

The sequence of execution of a main program and a function subprogram is given pictorially in Figure 1.

Figure 1

The gestation program in FORTRAN 7.11 provides several opportunities to use functions. The following example computes the median gestation and median life span. It has been rewritten to make use of a function to compute the medians.

Example - Compute Median with Function


c This program determines the median for the set of gestation values and 
c life span values.  If numdat is odd, the location of the median
c in the array is (numdat/2 + 1).  If numdat is even, there are two
c middle values and the locations of these values are (numdat/2) and
c (numdat/2 + 1).  The median is the mean of these two middle values.
c This is accomplished through the use of a function that is invoked twice.

        PROGRAM median_fun

c Specification statements
        INTEGER numdat
        PARAMETER (numdat=22)
        INTEGER gest(numdat), life(numdat)
        REAL median        

c Open the file.
c Read the values from the data file animals.dat into the arrays (gest 
c contains the gestation period in days for each animal), and life 
c (contains the life span in years for each animal).

        DO 100 k = 1, numdat
           READ (20,*)gest(k), life(k)
100     CONTINUE

c Invoke the function median
        PRINT *, 'The median gestation period is', median(gest,numdat)
        PRINT *, 'The median life span is', median(life,numdat)

c Function median
        REAL FUNCTION median(list,num)
        INTEGER list(num),num

c Calculate median
        IF (mod(num,2) .NE. 0) THEN
           median = real(list(num/2 + 1))
           median = real(list(num/2)+list(num/2 + 1))/2.0
        END IF

This example illustrates several precepts of functions.

A function can be thought of as a "box" that computes a value. The input is what is needed to compute the value. The function contains the needed calculations and the output is the result of the calculations.

Functions are usually placed after the main program although they may be placed before it. In programs with more than one function, the order in which the functions appear does not matter.

Example - Smoothing an Ordered Set of Values

Program Description
Both scientific theory and applied science depend on accurate measurements. All real measurements are inaccurate due to such factors as instrumentation error and inaccuracies in recreating physical phenomenon in the laboratory. When the level of inaccuracies in the data adversely affect outcomes, it becomes necessary to "smooth" or average the data. Data smoothing can make the data more useful.

This program takes a maximum of 100 ordered sets of data points and averages each y values with the n preceding and the n following y values starting with yvals(n+1) and ending with yvals(nodata-n) where nodata is the total number of y values.

Input/Output Description
The input file consists of up to 100 values. The first value in the file is the number of values in the array to be averaged. The remaining values are the y values of the set of data points to be smoothed. The user inputs the number of values to be averaged. Table 1 shows the original data for a set of 10 data points.

Table 1: Original Data Points
X axis Y axis
1 2
2 7
3 10
4 6
5 11
6 14
7 18
8 19
9 16
10 17

The output is a listing of the averaged y values.

Mathematical Equations
The set of y values is "smoothed" by averaging each value of y with the n proceeding and the n following y values (running average method). The number of values to be averaged is 2n+ 1. If n = 2 and the array containing the y values is yvals, the smoothed value for yvals(6) is found by (yvals(4) + yvals(5) +yvals(6) + yvals(7) + yvals(8))/5.0

1. Open the file and read the number of values in file (nodata).
2. Prompt for and get the value for n - the number of preceding and following y values used in averaging the y values.
3. Read the y values from the file.
4. Starting with yvals(n + 1) and ending with yvals(nodata - n), repeatedly invoke the function that averages the y values.
5. In the function, average the current y value with the n proceeding and n following y values.
6. Display the new y values.

Smoothing an Ordered Set of Values

Visualization of Data

Why are the values yvals((i-n:i+n),i-n, i+n) passed to the function smooth?

What is the advantage of having a file that indicates the number of items to be read?


1. Rewrite the gestation program to include functions that

2. Program - Escape Velocity

Problem Definition
Interspacial travel will require a spacecraft to reach escape velocity, the velocity that a spacecraft must reach to escape from the gravitational field of a planet and travel off into space. This program calculates the escape velocity.

Input/Output Description
The input will consist of the planetary mass and radius. The following table gives the data for three planets.

Table 2: Planet Data
Planet Mass (kg) Radius (m)
Earth 6.0e24 6.4e6
Moon 7.4e22 1.7e6
Jupiter 1.9e27 7.1e7

The output is the escape velocity.

Mathematical Equation
The escape velocity is given by the expression

where G is the gravitational constant

M is the mass of the planet (in kg) and R is the planet's radius (in meters).

1. Prompt for and get the planetary mass and radius.
2. Write a function that uses the mass and radius to calculate the escape velocity.
3. Display the escape velocity.

Execute the program and enter the mass and radius values for Earth.

Did you get the results you expected for the escape velocity of Earth? Is it a reasonable value for the escape velocity?

Modify the escape velocity program in the following way:

3. Modify the Smoothing an Ordered Set of Values Program in the following way:

Execute the program with different values for n. How does the output differ?

Execute the program with different final values in the loop that causes the data to be smoothed more than once during one execution. How does the output differ?

4. Sinusoidal Curve Data Program

Problem Description
A sinusoidal curve, that is, a continuous curve that oscillates periodically between maximum and minimum values, is found in several real-world situations in which a dependent variable repeats its values at regular intervals as the independent variable changes. Sun spot cycles, tidal waves, sound waves, and electrical current and voltage are examples of sinusoidal curves.

The values for points that form a sinusoidal curve are specified in a table. Using the running average technique, write a program that smooths the Y values. Plot the points for each set of data on the same grid and compare the resulting curves.

Input/Output Description
The input is a data file containing the 50 original y values. The user inputs the number of values to be averaged.

The output is a graph that plots the original points and the points with the smoothed y values.

Mathematical Equations
The y values are smoothed by averaging each y value with the n proceeding and the n following y values.


1. Open the file and read the y values into an array called yvals.
2. Prompt for and get the number of preceding and following y values to be used for averaging (n).
3. Invoke the function that averages the y values.
4. In the function, average n proceeding y values, n following y values, and the current y value to calculate the new y value.
5. Smooth the data more than once.
6. Display the new y values and write them to a file.
7. Graph the original points and the points with the smoothed y values on the same coordinate grid.

Execute the program with different values of n and graph the results of each.

What happens to the amplitude of the curve as n increases?