1 >> Lecture 3 2 >> 3 >> -- Functions 4 >> Zheng-Liang Lu 169 / 221

Transcription

1 1 >> Lecture 3 2 >> 3 >> -- Functions 4 >> Zheng-Liang Lu 169 / 221

2 Functions Recall that an algorithm is a feasible solution to the specific problem. 1 A function is a piece of computer code that accepts an input argument from the caller and returns output for the specific job the caller dealing with. So, the function is a real solution. Functions allow you to modularize a program by separating its tasks into self-contained units. We can program more efficiently and avoid rewriting the computer code for calculations that are performed frequently. Write down the algorithm first, and then program for it. 1 A problem would be solved by couples of methods. Zheng-Liang Lu 170 / 221

3 Built-in Arithmetic Functions Zheng-Liang Lu 171 / 221

4 Built-in Rounding Functions Zheng-Liang Lu 172 / 221

5 Built-in Discrete Math Functions Zheng-Liang Lu 173 / 221

6 Built-in Max Functions Zheng-Liang Lu 174 / 221

7 Built-in Max Functions (Cont d) There are also min functions to find the minimal elements in arrays, similar to max. Zheng-Liang Lu 175 / 221

8 Built-in Average Functions Zheng-Liang Lu 176 / 221

9 Built-in Size Functions Zheng-Liang Lu 177 / 221

10 Variance and Standard Deviation Zheng-Liang Lu 178 / 221

11 Random Number Generators Zheng-Liang Lu 179 / 221

12 Also, you may use randi(n, m, n) to produce an m-by-n random integer matrix ranging from 1 to N. These random number generators are used to produce a set of testing data for your programs Also widely used in Monte Carlo simulation 2 and random number generation algorithms of other distributions 3. 2 See Glasserman (2003). 3 See the acceptance-rejection method and Metropolis-Hastings algorithm. Zheng-Liang Lu 180 / 221

13 User-Defined Functions The syntax of a user-defined function is given by 1 function [output var] = function name(input var) 2 % comment section The output variables, if there exist, are enclosed in square brackets. The input variables, if there exist, must be enclosed with parentheses. function name should start with a letter, and be the same as the file name in which it is saved. Before this function can be used, it must be saved into the current folder 4. 4 If not, change the current folder or add to the path pool. Zheng-Liang Lu 181 / 221

14 Functions without Input and Output 1 function [] = star( ) % [] and () can be dropped. 2 theta = pi / 2 : 0.8 * pi : 4.8 * pi; 3 r = ones(1, 6); 4 polar(theta, r) % plot in polar coordinate Zheng-Liang Lu 182 / 221

15 Example: Addition of Two Numbers 1 function z = myadd(x, y) 2 % input: x,y (two numbers) 3 % output: z (sum of x and y) 4 z = x + y; Zheng-Liang Lu 183 / 221

16 Example: Mean of A Sequence 1 function y = mymean(x) 2 % input: x (array) 3 % output: y (mean) 4 5 sum = 0; 6 for i = 1 : length(x) 7 sum = myadd(sum, x(i)); % call myadd 8 end 9 y = sum / length(x); Zheng-Liang Lu 184 / 221

17 Numbers of Arguments nargin determines the number of input arguments in a function when executed. nargout determines the number of output arguments from a function when executed. varargin is a special word with two roles: varargin declares a function with any number of arguments. 5 The variable varargin itself is a cell array containing the optional arguments to the function. varargout is a special word similar to varargin but for outputs. 5 Note that varargin must be declared as the last input argument and collects all the inputs from that point onwards. Zheng-Liang Lu 185 / 221

18 Example Extend myadd to variable-input-length myadd. 1 function ret = myadd(varargin) 2 switch nargin 3 case 0 4 disp('no input.') 5 case 1 6 x = varargin{1}; 7 ret = x; 8 case 2 9 x = varargin{1}; 10 y = varargin{2}; 11 ret = x + y; 12 case 3 13 x = varargin{1}; 14 y = varargin{2}; 15 z = varargin{3}; Zheng-Liang Lu 186 / 221

19 16 ret = x + y + z; 17 otherwise 18 error('\ntoo many inputs.\n'); 19 end 20 end nargin, nargout, varargin and varargout provide a flexible design for user-defined functions. Note that the key word varargin and varargout should be the last item in the list. This mechanism is so-called function overloading. Zheng-Liang Lu 187 / 221

20 Scope of Variables The variables used in function m files are known as local variables. Any variable defined within the function exists only for the function to use. The only way a function can communicate between other functions is through input arguments and the outputs it returns. Unlike local variables, global variables are available to all parts of a computer program. Use global x to declare x as a global variable. In general, it is a bad idea to define global variables. 6 6 Recall the modularity. Zheng-Liang Lu 188 / 221

21 Example: Local Variables 1 function test 2 x = 0; 3 disp(x); 4 loop(x, 5); 5 disp(x); 6 end 7 8 function loop(x,n) 9 for i = 1 : n 10 x = x + 1; 11 disp(x); 12 end 13 end What are the numbers shown? How to return x in loop to test? Zheng-Liang Lu 189 / 221

22 Example: Global Variable 1 function test1(x) 2 global g 3 g=g+x; 4 disp(g) 5 test2(g) 6 end 7 8 function test2(y) 9 global g 10 g=g+y; 11 disp(g) 12 end Zheng-Liang Lu 190 / 221

23 1 clear all 2 clc 3 % main 4 global g 5 g=0; 6 disp(g) 7 test1(1); 1 >> What if you take global out of the function? Zheng-Liang Lu 191 / 221

24 Types of User-Defined Functions Primary functions and subfunctions Anonymous functions Nested functions Private functions Zheng-Liang Lu 192 / 221

25 Primary Functions and Subfunctions A function m-file may contain more than one user-defined function. The first defined function in the file is called the primary function, whose name is the same as the m-file name. All other functions in the file are called subfunctions. Subfunctions are normally visible only to the primary function and other subfunctions in the same file. Note that the order of the subfunctions does not matter, but function names must be unique within the m-file. Zheng-Liang Lu 193 / 221

26 Example 1 function [a c] = circle(r) % primary function 2 a = area(r); 3 c = circumference(r); 4 end 5 6 function y = area(x) % subfunction 1 7 y = pi*x.ˆ2; 8 end 9 10 function v = circumference(u) % subfunction 2 11 v = 2 * pi * u; 12 end Zheng-Liang Lu 194 / 221

27 1 >> [a c] = circle(2) 2 3 a = c = Note that if only one variable is assigned as output of the function, say, circle, then the area is returned while the circumference is dropped. Zheng-Liang Lu 195 / 221

28 Example 7 One subfunction can be called by other subfunctions in addition to the primary function. 1 function test1 2 fprintf('hi, there. This is test1.\n'); 3 test2; 4 end 5 6 function test2 7 fprintf('hi, there. This is test2.\n'); 8 test1; 9 end Notice that two subfunctions calling each other can lead to a loop, resulting a fatal crash. 7 Thanks to a lively class discussion (MATLAB-238) on June 14, Zheng-Liang Lu 196 / 221

29 Anonymous Functions Anonymous functions enable you to create a simple function without needing to create an m-file for it. Anonymous functions are defined by the function handle, denoted in the command window or in an m-file, and are available only until the workspace is cleared. For example, 1 >> f=@(x) x.ˆ2+x+1 % x.ˆ2 allows vectorization. 2 >> f([1 10]) 3 4 ans = Zheng-Liang Lu 197 / 221

30 You can pass the handle of an anonymous function to other functions. (Try.) You can create anonymous functions having more than one input. One anonymous function can call another to implement function composition. 1 >> f y) sqrt(x.ˆ 2 + y.ˆ 2); % f is a function... handle 2 >> g y) f(x, y).ˆ 2; % g is a composite function 3 >> g(3, 4) 4 5 ans = Zheng-Liang Lu 198 / 221

31 Exercise 89 1 function y = p(a, b, c) 2 y a * x.ˆ 2 + b * x + c; 3 end Note that the function p returns a function handle! 8 Thanks to a lively class discussion (MATLAB-244) on August 22, Contribution by Ms. Queenie Chang (MAT25108) on March 18, Zheng-Liang Lu 199 / 221

32 Nested Functions Functions are said to be nested if the functions are defined within the parent function. A nested function can access the variables of its parent function. 1 function f = parabola(a, b, c) 2 f %f is a function handle of p 3 function y = p(x) % p shares a, b, and c 4 y = a * x.ˆ2 + b * x + c; 5 end 6 end Zheng-Liang Lu 200 / 221

33 1 >> y = parabola(1, 2, 1); % that is y=xˆ2+2*x+1 2 >> y(5) 3 4 ans = Note that the nested functions are defined anywhere within the main function. (Why?) Zheng-Liang Lu 201 / 221

34 Private Functions Private functions are useful when you want to limit the scope of a function. A private functions resides in subfolder with the special name private. The private function is visible only to functions in the parent directory. Note that you cannot call the private function from the command line or from functions outside the parent of the private folder. Zheng-Liang Lu 202 / 221

35 Precedence When Calling Functions We can conduct the following experiment for this: 1 clear; clc; 2 % main 3 n = 10; 4 x = rand(1, n); 5 mu = mean(x); 6 sigma = std(x, mu); Zheng-Liang Lu 203 / 221

36 1 function y = mean(x) 2 fprintf('this is my mean.\n'); 3 y = sum(x) / length(x) 4 std(x,y); % invoking std function 5 function z = std(x,y) 6 fprintf('this is my 1st std (nested function).\n'); 7 z = sqrt(sum(x.ˆ 2) / length(x) - y ˆ 2) 8 end 9 end function z = std(x, y) 12 fprintf('this is my 2nd std (subfunction).\n'); 13 z = sqrt(sum(x.ˆ 2) / length(x) - y ˆ 2) 14 end Zheng-Liang Lu 204 / 221

37 1 function z = std(x, y) 2 fprintf('this is my 3rd std (local file).\n'); 3 z = sqrt(sum(x.ˆ 2) / length(x) - y ˆ 2) 4 end 1 function z = std(x,y) 2 fprintf('this is my 4th std (private).\n'); 3 z = sqrt(sum(x.ˆ 2) / length(x) - y ˆ 2) 4 end Zheng-Liang Lu 205 / 221

38 Precedence When Calling Functions (Concluded) 1 Nested functions 2 Subfunctions within the same file 3 Private functions 4 Local functions in the same directory 5 Built-in functions 6 Standard m files in PATH Zheng-Liang Lu 206 / 221

39 Calling Functions There are four common ways to invoke a function. As a character string identifying the appropriate function m-file. 1 function y = fun1(x) 2 y = x.ˆ2-4; % vectorized function 3 end 1 >> fun1([1 2 3]) 2 3 ans = As a function handle to an existing function M-file. Zheng-Liang Lu 207 / 221

40 1 >> 3) % returns the function value at ans = As a string expression. 1 >> fun2 = 'x.ˆ 2-4'; 2 >> x = fzero(fun2, [0, 3]); % find the root of fun1 in... [0,3] 3 4 x = Zheng-Liang Lu 208 / 221

41 As an inline function object. 1 >> fun inline = inline(fun2); 2 >> x = fzero(fun inline, [0, 3]) 3 4 x = The function handle method (method 2) is the fastest method, followed by method 1. In addition to speed improvement, another advantage of using a function handle is that it provides access to subfunctions, which are normally not visible outside of their m-file. Zheng-Liang Lu 209 / 221

42 Example: Bisection Method The bisection method in mathematics is a root-finding method that repeatedly bisects an interval and then selects a subinterval in which a root must lie for further processing. (Why?) It is often used to obtain an approximate solution. Zheng-Liang Lu 210 / 221

43 Zheng-Liang Lu 211 / 221

44 Idea of Bisection Method 1. At each step, the algorithm divides the interval in two by computing the midpoint c = (a + b)/2 of the interval and the value of the function f (c) at that point. 2. Unless c is itself a root (which is very unlikely, but possible), there are now two possibilities: either f (a) and f (c) have opposite signs and bracket a root, or f (c) and f (b) have opposite signs and bracket a root. Zheng-Liang Lu 212 / 221

45 3. The method selects the subinterval that is a bracket as a new interval to be used in the next step. 4. In this way the interval that contains a zero of f is reduced in width by 1 2 at each step. 5. The process is continued until the interval is sufficiently small How small? A certain number you give is to be the stop criteria. Zheng-Liang Lu 213 / 221

46 Problem Formulation Input - Target function f (x) - Endpoints of the interval [a, b] for any real numbers a < b - Minimal interval length ɛ int = b a Output - the approximate root ˆr Note that a and b will be updated iteratively. Zheng-Liang Lu 214 / 221

47 Solution 1 clear; clc; format long; 2 3 a = input('a =?\n'); 4 b = input('b =?\n'); 5 f x.ˆ 3 - x - 2; % target function 6 eps int = 1e-5; 7 iter = 0; % the number of iterations 8 9 if f(a) == 0 10 r = a; % lucky a 11 elseif f(b) == 0 12 r = b; % lucky b 13 else 14 while b - a > eps int 15 iter = iter + 1; 16 c = (a + b) / 2; % middle point 17 if f(c) == 0 Zheng-Liang Lu 215 / 221

48 18 r = c; % lucky c 19 break; 20 elseif (f(a)*f(c) < 0) 21 b = c; 22 elseif (f(b)*f(c) < 0) 23 a = c; 24 else 25 error('failure: f(a) * f(c) > 0 and f(c) *... f(b) > 0.'); 26 end 27 fprintf('%d: %f', iter, c); 28 end 29 r = c % approximate solution 30 end Zheng-Liang Lu 216 / 221

49 c = Zheng-Liang Lu 217 / 221

50 Remarks Time complexity: O(log 2 (n)) What is n? In this case, n = b a. (Why?) ɛ int So, it is an algorithm which runs in log time. This means that you need to make a trade-off between the numerical precision, that is, the number of digits, and the computation time. Be aware that this algorithm works well only with the premise that the behavior in [a, b] is mild. Approximate solutions may be significantly influenced by the initial interval [a, b]. 11 f (c) 0 but not equal to exactly 0. (Why?) 11 You may try another algorithm for the root finding problem, say, the Newton-Raphson method. Zheng-Liang Lu 218 / 221

51 Exercise Make your bisection method algorithm into a user-defined function, say, bisec. So, you can call bisec to find a root for a specific function in the command window or other programs. Besides, you should extend the function with more input arguments for parameters used in bisec. Zheng-Liang Lu 219 / 221

52 Problem Formulation Input - Target function f (x) - Endpoints of the interval [a, b] for any real numbers a < b - Minimal interval length ɛ int = b a Output - The approximate root ˆr Zheng-Liang Lu 220 / 221

53 1 function r=bisec(f,a,b,eps int,eps abs) >> bisec(@(x) x.ˆ 3 - x - 2, 0, 3, 1e-9, 1e-9) 2 3 ans = Zheng-Liang Lu 221 / 221