16 subroutine
- 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 + 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