BIL 104E Introduction to Scientific and Engineering Computing
Lecture 4 Introduction
• Divide and Conquer – Construct a program from smaller pieces or components • These smaller pieces are called modules • Functions – Modules in C – Programs combine user-defined functions with library functions • C standard library has a wide variety of functions
10/4/11 Lecture 4 2 Math Library Functions
• Math library functions – perform common mathematical calculations – #include
10/4/11 Lecture 4 3 Math Library Functions
Function Description Example sqrt( x ) square root of x sqrt( 900.0 ) is 30.0 sqrt( 9.0 ) is 3.0
exp( x ) exponential function ex exp( 1.0 ) is 2.718282 exp( 2.0 ) is 7.389056 log( x ) natural logarithm of x log( 2.718282 ) is 1.0 log( 7.389056 ) is 2.0 (base e) log10( x ) logarithm of x (base 10) log10( 1.0 ) is 0.0 log10( 10.0 ) is 1.0 log10( 100.0 ) is 2.0 fabs( x ) absolute value of x fabs( 5.0 ) is 5.0 fabs( 0.0 ) is 0.0 fabs( -5.0 ) is 5.0 ceil( x ) rounds x to the smallest ceil( 9.2 ) is 10.0 ceil( -9.8 ) is -9.0 integer not less than x floor( x ) rounds x to the largest floor( 9.2 ) is 9.0 floor( -9.8 ) is -10.0 integer not greater than x pow( x, y ) x raised to power y (xy) pow( 2, 7 ) is 128.0 pow( 9, .5 ) is 3.0 fmod( x, y ) remainder of x/y as a fmod( 13.657, 2.333 ) is 1.992 floating point number sin( x ) trigonometric sine of x sin( 0.0 ) is 0.0 (x in radians) cos( x ) trigonometric cosine of x cos( 0.0 ) is 1.0 (x in radians) tan( x ) trigonometric tangent of x tan( 0.0 ) is 0.0 (x in radians) Fig. 5.2 Commonly used math library functions.
10/4/11 Lecture 4 4 User-Defined Functions
• Functions (or modules) are the sets of statements that typically perform an operation or that compute a value.
• To maintain simplicity and readability in longer and more complex problem solutions, instead of using one long main function, we develop programs that use a main function plus additional functions.
• The execution of a program always begins with the main function. Additional functions are called, or invoked, when the program encounters function names. These additional functions must be defined in the file containing the main function or in another file or library of files. After executing the statements in a function, the program execution continues with the statement that called the function.
10/4/11 Lecture 4 5 Advantages of Modular Programming
• A module can be written and tested separately from other parts of the solution; thus, module development can be done in parallel for large projects.
• A module is a small part of the solution; thus, testing it separately is easier.
• Once a module is tested carefully, it does not need to be retested before it can be used in new problem solutions.(reusability)
• The use of modules usually reduces the length of a program, making it more readable.
• The use of modules promotes the concept of abstraction, which allows the programmer to “hide” the details in modules. This allows us to use modules in a functional sense without being concerned about the specific details.
10/4/11 Lecture 4 6 Function Definitions
• Functions can be defined before or after the main function. However, one function must be completely defined before another function begins; function definitions cannot be nested within each other.
• A function consists of a definition statement followed by declarations and statements. If the function does not return a value, the type is void. Thus the general form of a function is:
return_type function_name (parameter declarations) { declarations; statements; }
• The parameter declarations represent the information passed to the function. If there are no input parameters (also called arguments), then the parameter declarations should be void. Additional variables used by a function are defined in the declarations.
10/4/11 Lecture 4 7 Function Definitions
• All functions should include a return statement, which has the following general form:
return expression;
• The expression specifies the value to be returned to the statement that referenced the function. The expression type should match the return type indicated in the function definition to avoid potential errors.
• A void function does not return a value and thus has this general statement:
void function_name (parameter declarations)
• The return statement in a void function does not contain an expression and has the form:
return;
10/4/11 Lecture 4 8 Function Prototype
• Function prototype statements should be included for all functions referenced in a program. The general form of a function prototype is:
return_type function_name (parameter_data_types);
• A function prototype can be included with preprocessor directives, or because a function prototype is defining the type of value being returned by the function, it can also be included with other variable declarations.
• If a programmer-defined function references other programmer- defined functions, it will also need additional prototype statements.
10/4/11 Lecture 4 9 Function Prototype
• Header files, such as stdio.h and math.h, contain the prototype statements for many of the functions in the Standard C library.
• If a program references a large number of programmer-defined functions, it becomes cumbersome to include all the function prototype statements. In these cases, a custom header file can be defined that contains the function prototypes and related symbolic constants.
• A header file must have a filename that ends with a suffix of .h. The file is then referenced with an include statement using double quotes around the file name. Custom header files are often used to accompany routines that are shared by programmers.
10/4/11 Lecture 4 10 Parameter List
• The definition statement of a function defines parameters that are required by the function; these are called formal parameters.
• Any statement that references the function must include values that correspond to the parameters; these are called actual parameters.
• When the function is referenced the value in the ‘actual parameters’ are copied to the ‘formal parameters’ and the steps in the function are executed using the new values in the ‘formal parameters’.
• If a function has more than one parameter, the formal parameters and the actual parameters must match in number, type and order.
• Valid references to the function can also include expressions and can include other function references
10/4/11 Lecture 4 11 Example
• Assume that the definition statement of the function f is double f (double x) { … } • The following references to function f are valid: printf(“%f \n”, f(x+2.5)); printf(“%f \n”, f(y)); z = x*x + f(2*x) ; w = f(fabs(y)) ;
• Here, the formal parameter is still x, but the actual parameter changes depending on the reference selected.
10/4/11 Lecture 4 12 1 /* Fig. 5.3: fig05_03.c 2 Creating and using a programmer-defined function */ 3 #include
1 4 9 16 25 36 49 64 81 100
10/4/11 Lecture 4 13 1 /* Fig. 5.4: fig05_04.c 2 Finding the maximum of three integers */ 3 #include
10/4/11 Lecture 4 14 25 /* Function maximum definition */ 26 /* x, y and z are parameters */ 27 int maximum( int x, int y, int z ) 28 { 29 int max = x; /* assume x is largest */ 30 31 if ( y > max ) { /* if y is larger than max, assign y to max */ 32 max = y; 33 } /* end if */ 34 35 if ( z > max ) { /* if z is larger than max, assign z to max */ 36 max = z; 37 } /* end if */ 38 39 return max; /* max is largest value */ 40 41 } /* end function maximum */
Enter three integers: 22 85 17 Maximum is: 85 Enter three integers: 85 22 17 Maximum is: 85 Enter three integers: 22 17 85 Maximum is: 85
10/4/11 Lecture 4 15 Header Files
• Header files – Contain function prototypes for library functions –
10/4/11 Lecture 4 16 Header Files
Standard library header Explanation
10/4/11 Lecture 4 17 Calling Functions: Call by Value and Call by Reference • Call by value – Copy of argument passed to function – Changes in function do not effect original – Use when function does not need to modify argument • Avoids accidental changes • Call by reference – Passes original argument – Changes in function effect original – Only used with trusted functions • For now, we focus on call by value
10/4/11 Lecture 4 18 Random Number Generation Function • rand function – Load
10/4/11 Lecture 4 19 Random Number Generation Function • srand function –
10/4/11 Lecture 4 20 Random Number Generation Function example
1 /* Fig. 5.7: fig05_07.c 2 Shifted, scaled integers produced by 1 + rand() % 6 */ 3 #include
10/4/11 Lecture 4 21 Random Number Generation Function example
6 6 5 5 6 5 1 1 5 3 6 6 2 4 2 6 2 3 4 1
10/4/11 Lecture 4 22 Local vs Global Variables
• Local variables are defined within a function and include the formal parameters and any other variables declared in function. A local variable can be accessed only in the function that defined it. A local variable has a value when its function is being executed, but its value is not retained when the function is completed.
• Global variables are defined outside the main function and other programmer defined functions so they can be accessed by any function within the program.
• To reference a global or an external variable, a declaration within the function must include the keyword extern before the type designation to tell the computer to look outside the function for the variable. It is optional to use extern designation in the original definition of a global variable.
10/4/11 Lecture 4 23 Local vs Global Variables • The memory assigned to an external variable is retained for the duration of the program. Although an external variable can be referenced from a function, using global variables is generally discouraged. In general, parameters are preferred for transferring information to a function because the parameter is evident in the function prototype, whereas the external variable is not visible in the function prototype.
• The static storage class is used to specify that the memory for a variable should be retained during the entire program execution. Therefore, if a local variable in a function is given a static storage class assignment by using the keyword static before its type specification, the variable will not lose its value when the program exits the function in which it is defined.
Summary – static: local variables defined in functions. • Keep value after function ends • Only known in their own function – extern: default for global variables and functions • Known in any function
10/4/11 Lecture 4 24 Local vs Global Variables Example 1 /* Fig. 5.12: fig05_12.c 2 A scoping example */ 3 #include
10/4/11 Lecture 4 25 Local vs Global Variables Example
26 useLocal(); /* useLocal has automatic local x */ 27 useStaticLocal(); /* useStaticLocal has static local x */ 28 useGlobal(); /* useGlobal uses global x */ 29 useLocal(); /* useLocal reinitializes automatic local x */ 30 useStaticLocal(); /* static local x retains its prior value */ 31 useGlobal(); /* global x also retains its value */ 32 33 printf( "local x in main is %d\n", x ); 34 35 return 0; /* indicates successful termination */ 36 37 } /* end main */ 38 39 /* useLocal reinitializes local variable x during each call */ 40 void useLocal( void ) 41 { 42 int x = 25; /* initialized each time useLocal is called */ 43 44 printf( "\nlocal x in a is %d after entering a\n", x ); 45 x++; 46 printf( "local x in a is %d before exiting a\n", x ); 47 } /* end function useLocal */ 48
10/4/11 Lecture 4 26 Local vs Global Variables Example
49 /* useStaticLocal initializes static local variable x only the first time 50 the function is called; value of x is saved between calls to this 51 function */ 52 void useStaticLocal( void ) 53 { 54 /* initialized only first time useStaticLocal is called */ 55 static int x = 50; 56 57 printf( "\nlocal static x is %d on entering b\n", x ); 58 x++; 59 printf( "local static x is %d on exiting b\n", x ); 60 } /* end function useStaticLocal */ 61 62 /* function useGlobal modifies global variable x during each call */ 63 void useGlobal( void ) 64 { 65 printf( "\nglobal x is %d on entering c\n", x ); 66 x *= 10; 67 printf( "global x is %d on exiting c\n", x ); 68 } /* end function useGlobal */
10/4/11 Lecture 4 27 Local vs Global Variables Example • local x in outer scope of main is 5 • local x in inner scope of main is 7 • local x in outer scope of main is 5
• local x in a is 25 after entering a • local x in a is 26 before exiting a
• local static x is 50 on entering b • local static x is 51 on exiting b
• global x is 1 on entering c • global x is 10 on exiting c
• local x in a is 25 after entering a • local x in a is 26 before exiting a
• local static x is 51 on entering b • local static x is 52 on exiting b
• global x is 10 on entering c • global x is 100 on exiting c
• local x in main is 5
10/4/11 Lecture 4 28