Input parameters. Function. An ideal black-box representation of a function

Transcription

1 7 Functions 7. Introduction Functions are identifiable pieces of code with a defined interface. They are called from any part of a program and allow large programs to be split into more manageable tasks, each of which can be independently tested. Functions are also useful in building libraries of routines that other programs use. Several standard libraries eist, such as maths and input/output libraries. A function can be thought of as a black bo with a set of inputs and outputs. It processes the inputs in a way dictated by its function and provides some output. In most cases the actual operation of the black bo is invisible to the rest of the program. A modular program consists of a number of black boes working independently of all others, of which each uses variables declared within it (local variables) and any parameters sent to it. Figure 7. illustrates a function represented by an ideal black bo with inputs and outputs, and Figure 7.2 shows a main function calling several sub-functions (or modules). Input parameters Return value Function Function interface Figure 7. An ideal black-bo representation of a function 7.2 Arguments and parameters The data types and names of parameters passed into a function are declared in the function header (its interface) and the actual values sent are referred to as 5 Mastering Pascal

2 arguments. They can be passed either as values (known as passing by value ) or as pointers (known as passing by reference ). Passing by value involves sending a copy of it into the function. It is not possible to change the value of a variable using this method. Variables can only be modified if they are passed by reference (this will be covered in the net chapter). This chapter looks at how parameters pass into a function and how a single value is returned. An argument and a parameter are defined as follows: An argument is the actual value passed to a function. A parameter is the variable defined in the function header. Main program Function Function Function Function Function Function Function Figure 7.2 Hierarchical decomposition of a program 7.3 Pascal functions In Pascal a function returns a single value. It is identified by the function header, which is in the form: FUNCTION function_name(formal_parameter_list) : result_type; where the parameters are passed through the formal_parameter_list and the result type is defined by result_type. Program 7. contains two functions named addition and multiply. In calling the addition function and variables a and b are passed into the parameters c and d, respectively; c and d are local parameters and only eist within addition(). The values of c and d can be changed with no effect Functions 5

3 on the values of a and b. This function returns a value back to the main program by setting a value which is the same name as the function. Program 7. also uses a procedure which, in this case, is similar to a function but does not return any values back to the calling program (procedures will be covered in the net chapter). Program 7. program prog7_(input,output); var a,b,summation,multi:integer; function addition(c,d:integer):integer; addition:=c+d; function multiply(c,d:integer):integer; multiply:=c*d; procedure print_values(c,d,sum,mult:integer); writeln(c,' plus ',d,' is ', sum); writeln(c,' multiplied by ',d, ' is ',mult); a:=5; b:=6; summation:=addition(a,b); multi := multiply(a,b); print_values(a,b,summation,multi); Figure 7.3 shows a simple structure chart of this program. The function addition() is called first; the variables sent are a and b and the return value is put into the variable summation. Net, the multiply() is called; the variables sent are also a and b and the value returned goes into multi. Finally, the function print_values() is called; the values sent are a, b, multi and summation. Program 7. contains functions that return integer data types. It is possible to return any other of Pascal s data types, including real, double and char, by inserting the data type after the function name. A function can have several return points, although it is normally better to have only one return point. This is normally achieved by restructuring the code. An eample of a function with two return values is shown net. In this eample a decision is made as to whether the value passed into the function is positive or negative. If it is greater than or equal to zero it returns the same value, else it returns a negative value (mag=-val). 52 Mastering Pascal

4 main a,b summation a,b multi a,b, summation,multi addition multiply print values Figure 7.3 Basic structure chart for Program 7. program test(input,output); var a:integer; function mag(val:integer):integer; if (val<) then mag:=-val else mag:=val; a:=-5; writeln('mag(a) = ',mag(a)); Program 7.2 contains a function power() which has a return data type of double; the first argument is double and the second is integer. This function uses logarithms to determine the value of raised to the power of n. The formula used is derived net; the ln() function is the natural logarithm and the ep() the eponential function. y = n ln( y) = ln( ) ln( y) = n ln( ) y = ep( n ln( )) n Functions 53

5 Program 7.2 program prog7_2(input,output); var,val:double; n:integer; function power(:double;n:integer):double; power :=ep(n*ln()); writeln('program to determine the result of a value'); writeln('raised to the power of an integer'); writeln('enter to the power of n >>'); readln(,n); val:=power(,n); writeln(,' to power of ',n,' is ',val); 7.4 Local variables Typically variables are required within a function which are not used in the main program. These variables are called local variables and they only eist within the function. A local variable is declared directly after the function header and before the starting keyword. The following eample shows a function called fact which is passed a single integer value (n) and returns a longint data type. It has two local variables, these are val and i. function fact(n:integer):longint; var val,i:longint; (* LOCAL VARIABLES *) val:=; for i:=2 to n do val:=val*i; fact:=val; The outline rules of variable declarations are: Variables that are declared in the main declaration area of the program are known as global variables and they can be accessed by all parts of the program. It is advisable that functions should not use any of the global vari- 54 Mastering Pascal

6 ables directly, but should depend on their values to be passed to them through the function header. Local variables only eist within the function they are declared in, whereas global variables eist throughout the program. A function cannot access another function s local variables. A local variable can have the same name as a global variable. A global variable which has the same name as a local variable will be treated as a different variable. For eample, the global variables i, j and k are declared in the following outline program. Within the function test the local variable i is declared. This will be a different variable to the i global variable. program prog(input,output); var i,j,k: integer; (* GLOBAL VARIABLES *) function test(val:integer):integer; var i:integer; (* LOCAL VARIABLE which is different to *) (* the global variable i *) i:=; k:=5; j:=test(k); 7.5 Eamples This section contains a few sample Pascal programs which use functions Tan function There is no tan function in Pascal; thus to overcome this Pascal Program 7.3 contains a tan function and Test run 7. shows a sample run. Program 7.3 Program prog7_3(input,output); (* Program that uses a function to calculate the *) (* tan of a number *) var answer,number: real; function tan(a:real):real; tan:= sin(a)/cos(a); (* tan is sin over cos *) Functions 55

7 write('enter number >> '); readln(number); answer:=tan(number); writeln('the tan of ',number:8:3,' is ',answer:8:3); Test run 7. Enter number >>.23 The tan of.23 is Centigrade to Fahrenheit conversion Pascal Program 7.4 uses two functions to convert from Fahrenheit to centigrade, and vice versa. Test run 7.2 shows a sample test run. Program 7.4 Program prog7_4(input,output); (* Program that uses a function to convert Fahrenheit to centigrade*) var fahrenheit,centigrade:real; function convert_to_centigrade(f:real ):real; convert_to_centigrade:=5/9* (f-32); function convert_to_fahrenheit(c:real ) :real; convert_to_fahrenheit:=9/5*c+32; write('enter value in Fahrenheit >> '); readln(fahrenheit); centigrade:=convert_to_centigrade(fahrenheit); writeln(fahrenheit:6:3, deg F is ', centigrade:6:3,' deg C'); write('enter value in centigrade'); readln(centigrade); Fahrenheit:=convert_to_fahrenheit(centigrade); writeln(centigrade:6:3,' deg C is ',Fahrenheit:6:3,' deg F'); Test run 7.2 Enter value in Fahrenheit >> 2 2. deg F is -. deg C Enter value in centigrade >> 6 6. deg C is 4. deg F 56 Mastering Pascal

8 Pascal Program 7.5 uses the two functions developed in the previous programs to display a table of values from C to C in steps of C. Test run 7.3 shows a sample run. Program 7.5 Program prog7_5(input,output); (* Program that uses a function to convert centigrade to *) (* Fahrenheit. Centigrade goes from to in steps of. *) var fahrenheit,centigrade:real; i: integer; function convert_to_fahrenheit(c:real ):real; convert_to_fahrenheit:=9/5*c+32; writeln('centigrade Fahrenheit'); for i:= to do centigrade:=*i; fahrenheit:=convert_to_fahrenheit(centigrade); writeln(centigrade:8:3,fahrenheit:8:3); Test run 7.3 Centigrade Fahrenheit Combinational logic In this eample, the following Boolean equation is processed to determine its truth table. Z = ( A + B + ( A. C)). C Figure 7.4 gives a schematic representation of this Boolean function. The four nodes numbered on this schematic are: Functions 57

9 () A + B (2) A. C (3) A + B + ( A. C) (4) ( A + B + ( A. C)). C A B () (3) C (2) (4) Z Figure 7.4 Schematic representation of the function Z = ( A + B + ( A. C)). C Table 7. gives a truth table showing the logical level at each point in the schematic. This table is necessary to check the program results against epected results. Table 7.2 gives the resulting truth table. Table 7. Truth table A B C A + B () A. C (2) A B A C + + (. ) (3) ( A + B + ( A. C)). C (4) Table 7.2 Truth table A B C Z 58 Mastering Pascal

10 Pascal Program 7.6 shows how this Boolean equation is simulated. The permutations of the truth table input variables (that is,,,,,..., ) are generated using 3 nested for loops. The inner loop toggles C from a to a, the net loop toggles B and the outer loop toggles A. The Boolean functions use the logical operators and and or. As Pascal has reserved keywords for AND, OR and NOT the function names have been changed to reflect the number of inputs they have, such as OR3 for a 3-input OR gate and AND2 for a 2-input AND gate. Test run 7.4 shows a sample run of the program. Notice that the results are identical to the truth table generated by analyzing the schematic (apart from / indicated with a FALSE/TRUE). Test run 7.4 A B C Result *************************** FALSE FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE TRUE FALSE TRUE TRUE TRUE TRUE FALSE FALSE TRUE TRUE FALSE TRUE FALSE TRUE TRUE FALSE TRUE TRUE TRUE TRUE FALSE Program 7.6 program prog7_6(input,output); var a,b,c,z:boolean; function NOR2(, y:boolean):boolean; if ( or y ) then nor2:=false else nor2:=true; function OR2(, y:boolean):boolean; if ( or y) then or2:=true else or2:=false; function AND2(, y:boolean):boolean; if ( and y) then and2:=true else and2:=false; function NAND2(, y:boolean):boolean; if ( and y ) then nand2:=false else nand2:=true; Functions 59

11 writeln(' A B C Result'); writeln(' *****************************'); for a:=false to TRUE do for b:=false to TRUE do for c:=false to TRUE do z:=nand2(or2(nor2(a,b),and2(a,c)),c); writeln(a:6,b:6,c:6,z:6); Sine of a value The sine of a value can be determined, from first principles, using the formula: 3 sin( ) = 3! + 5 5! 7 7! + 9 9! K where n! = n ( n ) ( n 2) K 2 and the value of is in radians. Pascal Program 7.7 gives a Pascal program which has a function called sine(). This function calculates the sine of a value using the formula given above. It uses a repeat until loop which calculates each term of the equation and adds it to a running total for the loop. The loop continues until the calculated term is less than 6. The program also includes the following functions: fact(n) which is used to determine the factorial of an integer value, the result is a longint as it may be a large value. pow(,n) which is used to determine the value of to the power of n. to_radians() which is used to convert the value of into radians (by multiplying by π and dividing by 8). Test run 7.5 gives a sample run of this program. It can be seen that the function sine() returns the same value as the Pascal sin() function. Test run 7.5 Enter value (in degrees) >> 23 Sine is.39 Sin is.39 6 Mastering Pascal

12 Program 7.7 program prog7_7(input,output); (* Program to determine the sine of a value from first principles *) var invalue:real; function pow(:real;n:real):real; pow:=ep(n*ln()); function fact(n:integer):longint; var val,i:longint; val:=; for i:=2 to n do val:=val*i; fact:=val; function sine(:real):real; var n,sign:integer; val,term:real; sign:=; val:=; n:=3; repeat term:=pow(,n)/fact(n); n:=n+2; sign:=-sign; val:=val+sign*term; until (term<e-6); (* repeat until term is less than e-6 *) sine:=val; function to_radians(val:real):real; to_radians:=pi*val/8; writeln('enter value (in degrees) >>'); readln(invalue); invalue:=to_radians(invalue); writeln('sine is ',sine(invalue):8:3); writeln('sin is ',sin(invalue):8:3); Functions 6

13 7.6 Eercises 7.6. Write a program which determines the magnitude of an entered value. The program should use a function to determine this Write a program with a function which is passed an arithmetic operator character and two real values. The function will then return the result of the operator on the two values. Program 7.8 shows an outline of the program. Program 7.8 program prog7_8(input,output); var operator:char; value,value2,result:real; function math_function(ch:char;val,val2:real):real; var result:real; case ch of '+': result:=val+val2; '-': result:=val-val2; (* *** Add etra code here *** *) math_function:=result; writeln('enter operator >>'); readln(operator); writeln('enter two values >>'); readln(value,value2); result:=math_function(operator,value,value2); writeln('result is ',result); Write a program with separate functions which determine the gradient of a straight line (m) and the point at which a straight line cuts the y-ais (c). The entered parameters are two points on the line, that is, (, y ) and ( 2, y 2 ). From this program complete Table 7.3 (the first row has already been completed). Table 7.3 Straight line calculations y 2 y 2 m c Mastering Pascal

14 Formulas to calculate these values are: m y y 2 = c = y m Write a program which determines the magnitude and angle of a comple number (in the form +iy, or +jy). The program should use functions to determine each of the values. Complete Table 7.4 using the program (the first row has already been completed), where: 2 2 = y angle = tan mag + y Table 7.4 Comple number calculation y Mag. Angle( ) Referring to Program 7.7, write a function for a cosine function. It can be calculated, from first principles, with: cos( ) = 2 2! + 4 4! 6 6! + 8 8! K The error in the function should be less than Using the functions developed in Eercise and Program 7.7 and the standard sine and cosine library functions, write a program which determines the error between the standard library functions and the developed functions. From this, complete Table 7.5. Table 7.5 Sine and cosine results Value Standard cosine function Developed cosine function Standard sine function Developed sine function Write a mathematical function which determines the eponential of a value using the first principles formula: Functions 63

15 e = + +! 2 2! + 3 3! + 4 4! +K Compare the result with the standard ep() library function Write Boolean logic functions for the following four digital gates: AND3(A,B,C) OR3(A,B,C) NAND3(A,B,C) NOR3(A,B,C) Write a program which has a function which will only return a real value when the entered value is within a specified range. An eample call to this function (which, in this case, is named get_real) is:. inval:=get_real(,); This will only return a value from the function when the entered value is between and. A sample run follows. Test run 7.6 Enter a value > - INVALID INPUT PLEASE RE-ENTER Enter a value > 6 Success. Bye. 64 Mastering Pascal