16 subroutine

1. Basic Scientific Programming
Subprograms

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).

10. Subroutine calculate(alpha,beta,gamma)
real,intent(in):: alpha
integer,intent(out)::beta
integer,intent(inout):: gamma
…
end subroutine calculate
Assume the following declarations in the main
program
integer:: code, id_num
real:: rate

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 + CX
2
+ DX
3
+ EX
4
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 X
2
–X
3
+7.2 X
4
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