Published on March 9, 2014
Basic Scientific Programming Subprograms
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.
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.
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.
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
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.
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.
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
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).
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
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)
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.
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
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
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
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)
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.
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
Denn die Subroutine soll die Aufgabe haben, ... 16 Uhr geändert. Unterstützt durch. Die Inhalte des SELFHTML-Wikis unterliegen der CC-BY-SA 3.0 (de).
15 FUNCTIONS AND SUBROUTINES. ... Subroutines specified in subroutine subprograms ... This document was translated by troff2html v0.21 on August 16, ...
What is it ?¶ The preprocess subroutine allows you to enhance XiVO features through the Asterisk dialplan. Features that can be enhanced are : User
16.05.2005, aktualisiert 27.05.2005, 40372 Aufrufe, 3 ... wann welche Subroutine aufgerufen wird. Will ich wissen, was in der Subroutine steht, ...
perlsub - Perl subroutines. SYNOPSIS. To declare subroutines: ... which allows for recursive calls without knowing your subroutine's name. use 5.16.0;
You use subroutines and functions in a Bascom program when you have identical pieces of code at different places in the program. Suppose you have this ...
Using function vs include as “subroutine” in PHP [closed] up vote 1 down vote favorite. 1. ... Jason McCreary Nov 16 '12 at 21:21. As it currently ...
TIP: Although you can refer from a subroutine to any global variable directly, this method normally is considered to be bad programming practice.