1. BIL 104E Introduction to Scientific and Engineering Computing Lecture 4

2. 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 22.11.2016Lecture 42

3. Math Library Functions Math library functions – perform common mathematical calculations – #include Format for calling functions – FunctionName( argument ); If multiple arguments, use comma-separated list – printf( "%.2f", sqrt( 900.0 ) ); Calls function sqrt, which returns the square root of its argument All math functions return data type double – Arguments may be constants, variables, or expressions 22.11.2016Lecture 43

4. Math Library Functions 22.11.2016Lecture 44

5. 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. 22.11.2016Lecture 45

6. 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. 22.11.2016Lecture 46

7. 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. 22.11.2016Lecture 47

8. 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; 22.11.2016Lecture 48

9. 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. 22.11.2016Lecture 49

10. 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. 22.11.2016Lecture 410

11. 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 22.11.2016Lecture 411

12. 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. 22.11.2016Lecture 412

13. 22.11.2016Lecture 413 1 4 9 16 25 36 49 64 81 100

14. 22.11.2016Lecture 414

15. 22.11.2016Lecture 415 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

16. Header Files Header files – Contain function prototypes for library functions –,, etc – Load with #include #include Custom header files – Create file with functions – Save as filename.h – Load in other files with # include "filename.h" – Reuse functions 22.11.2016Lecture 416

17. Header Files 22.11.2016Lecture 417

18. 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 22.11.2016Lecture 418

19. Random Number Generation Function rand function – Load – Returns "random" number between 0 and RAND_MAX (at least 32767) – i = rand(); – Pseudorandom Preset sequence of "random" numbers Same sequence for every function call Scaling – To get a random number between 1 and n – 1 + ( rand() % n ) rand() % n returns a number between 0 and n - 1 Add 1 to make random number between 1 and n – 1 + ( rand() % 6) – number between 1 and 6 22.11.2016Lecture 419

20. Random Number Generation Function srand function – – Takes an integer seed and jumps to that location in its "random" sequence srand( seed ); – srand( time( NULL ) );/*load */ time( NULL ) – Returns the time at which the program was compiled in seconds – “Randomizes" the seed 22.11.2016Lecture 420

21. Random Number Generation Function example 22.11.2016Lecture 421

22. 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 22.11.2016Lecture 422

23. 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. 22.11.2016Lecture 423

24. 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 22.11.2016Lecture 424

25. Local vs Global Variables Example 22.11.2016Lecture 425

26. Local vs Global Variables Example 22.11.2016Lecture 426

27. Local vs Global Variables Example 22.11.2016Lecture 427

28. 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 22.11.2016Lecture 428