2. Subroutines
Subroutines have many features in common
with functions:
They are program units designed to perform a
particular task, under the control of some other
program unit.
They have the same basic form: each consists of a
heading, a specification part, and execution part,
and an END statement.
The scope rules apply to both functions and
subroutines.
3.
Functions and subroutines have the following
differences:
Functions are designed to return a single value to
the program unit that references them.
Subroutines often return more than one value, or
they may return no value at all.
Functions return values via function names,
subroutines return values via arguments
A function is referenced by using its name in an
expression, subroutines are referenced by a call
statement.
4. Subroutine Structure
The subroutine is structured as follows:
Subroutine heading
Specification part.
Execution part
End subroutine statement
Subroutine subroutine_name(formal_argument_list)
We use the heading to name the subroutine and
declare its arguments.
5. Ex:
Polar coordinates to rectangular coordinates:
the subprogram takes two arguments as input and
returns two values.
Subroutine polar_to_rect(R, theta, X,Y)
real, intent(in):: R, theta
read, intent(out):: X,Y
X= R * cos(theta)
Y= R * sin(theta)
End subroutine polar_to_rect
6. Call Statement
A subroutine is referenced by a CALL
statement.
Form
Call Subroutine_name(actual_argument_list)
Each actual argument must agree in
type with the corresponding formal
argument.
7. Call Statement
If there are no actual arguments, the
parentheses in the subroutine reference
may be omitted.
A function is referenced by using its
name in an expression, subroutines are
referenced by a call statement.
8. Argument Association
When the call statement
Call polar_to_rect(RC,TC,XC,YC)
is executed, the values of the actual
arguments RC and TC are passed to the
formal arguments R and Theta Respectively.
RC R
TC Theta
9.
R and Theta are declared to be IN arguments
because the intent is that values are to be
passed and then used within the subroutine.
X and Y are declared to have the Intent(out)
attribute because they are intended only to
pass values back to the calling program.
(XC, YC)
A formal argument may have Intent(inout).
11.
Tell if the following is a valid reference or
not:
rate = calculate(2.45,code,id_num)
call calculate(rate+0.5,0, code 2 id_num)
call calculate(rate, id_num)
call calculate(rate,code,id_num)
call calculate
call calculate(rate,rate,rate)
call calculate(code,code,code)
12. Optional Arguments of Subprograms
In all of our examples of subprograms, the number
and type of actual arguments in a subprogram
reference have matched the number of the formal
arguments in the subprogram heading.
In some cases, however, it is possible to design a
subprogram in which there may be fewer actual
arguments in a reference to a subprogram than there
are formal arguments.
This is accomplished by specifying that some
arguments are optional.
13. Optional Arguments
Ex: A + BX + CX2 + DX3 + EX4
coefficients A,B,C,D, and E are real constants.
function polynomial(x,a,b,c,d,e)
real:: polynomial
real,intent(in):: x,a,b,c,d,e
polynomial = a+b*x+c*x**2+d*x **3 + e*x**4
End function polynomial
14.
Polynomial(2.5,1.5,2.0,3.0,-1,7.2)
is used to calculate
1.5 +2.0 X +3.0 X2 –X3 +7.2 X4 at X=2.5
What about 1 + 2X at X = 3.3
Polynomial(3.3,1.0,2.0,0.0,0.0,0.0)
note that it is necessary to supply zero
coefficients for any term that does not appear
in the polynomial
15.
An alternative is to specify that the argument
specifying the coefficients b,c,d, and e are
optional by using the OPTIONAL specifier:
function polynomial(x,a,b,c,d,e)
real:: polynomial
real,intent(in)::x,a
real,intent(in),optional :: b,c,d,e
polynomial = a+b*x+c*x**2+d*x **3 + e*x**4
End function polynomial
16. Keyword Argument
The association of actual arguments
with formal arguments can also be
given explicitly by using Keyword
Arguments.
Formal_argument= actual_argument
Ex: polynomial(x=2.5, a = 2.0, e = 1.0)
polynomial(e=1.0, a = 2.0, x = 2.5)
17.
The subprogram can use the predefined
function Present() to determine which
arguments have been supplied.
Present( formal_argument)
The return value is true if a value was
supplied for the formal_argument and false
otherwise.
18.
Subroutine polynomial(result,x,a,b,c,d,e)
real,intent(out):: result
real, intent(in):: x,a
real, intent(in):: b,c,d,e
result = a
if(present(b)) result = result + b*x
if(present(c)) result = result + c*x **2
if(present(d)) result = result + d*x**3
if(present(e)) result = result + e*x**4
end subroutine polynomial
