CHAPTER 6

Functions

6.1 Custom Defined Functions

We already know that MATLAB has a wide variety of functions that can be used in everyday work with the program. But, in addition, MATLAB also offers the possibility of custom defined functions. The most common way to define a function is to write its definition to a text file, called an M-file, which will be permanent and will therefore enable the function to be used whenever required.

The second way to define a function is to use the relation between MATLAB and Maple, provided you have the symbolic math Toolbox installed. In this case, functions of a variable can also be directly defined.

6.2 Functions and M-files

MATLAB is usually used in command mode (or interactive mode), in which case a command is written in a single line in the Command Window and is immediately processed. But MATLAB also allows the implementation of sets of commands in batch mode, in which case a sequence of commands can be submitted which were previously written in a file. This file (M-file) must be stored on disk with the extension ".m" in the MATLAB subdirectory, using any ASCII editor or by selecting M-file New from the File menu in the top menu bar, which opens a text editor that will allow you to write command lines and save the file with a given name. Selecting M-File Open from the File menu in the top menu bar allows you to edit any pre-existing M-file.

To run an M-file simply type its name (without extension) in interactive mode into the Command Window and press Enter. MATLAB sequentially interprets all commands and statements of the M-file line by line and executes them. Normally the literal commands that MATLAB is performing do not appear on screen, except when the command echo on is active and only the results of successive executions of the interpreted commands are displayed. Work in batch mode is useful when automating large scale tedious processes which, if done manually, would be prone to mistakes. You can enter explanatory text and comments into M-files by starting each line of the comment with the symbol %. The help command can be used to display comments made in a particular M-file.

MATLAB provides certain commands which are frequently used in M-file scripts. Among them are the following:

echo on: View on-screen commands of an M-file script while it is running.

echo off: Hides on-screen commands of an M-file script (this is the default setting).

pause: Interrupts the execution of an M-file until the user presses a key to continue.

keyboard: Interrupts the execution of an M-file and passes the control to the keyboard so that the user can perform other tasks.  The execution of the M-file can be resumed by typing the return command into the Command Window and pressing Enter.

return: Resumes execution of an M-file after an outage.

break: Prematurely exits a loop.

clc: Clears the Command Window.

home: Hides the cursor.

more on: Enables paging of the MATLAB Command Window output.

more off: Disables paging of the MATLAB Command Window output.

more(N): Sets page size to N lines.

menu: Offers a choice between various types of menu for user input.

When you define a function using an M-file, the above commands can be used if necessary.

The command function allows you to define functions in MATLAB, making it one of the most useful applications of M-files. The syntax of this command is as follows:

function output_parameters = function_name (input_parameters)

the function body

Once the function has been defined, it is stored in an M-file for later use. It is also useful to enter some explanatory text in the syntax of the function (using %), which can be accessed later by using the help command.

When there is more than one output parameter, they are placed between square brackets and separated by commas. If there is more than one input parameter, they are separated by commas. The body of the function is the syntax that defines it, and should include commands or instructions that assign values to output parameters. Each command or instruction of the body often appears in a line that ends either with a comma or, when variables are being defined, by a semicolon (in order to avoid duplication of outputs when executing the function). The function is stored in the M-file named function_name.m.

Let us define the function fun1(x) = x ^ 3 - 2 x + cos(x), creating the corresponding M-file named fun1.m by using the syntax:

function p = fun1(x)
% Definition of a simple function
p = x ^ 3 - 2 * x + cos(x);

To define this function in MATLAB select M-file New from the File menu in the top menu bar (or click the button in the MATLAB tool bar). This opens the MATLAB Editor/Debugger text editor that will allow us to insert command lines defining the function, as shown in Figure 6-1.

To permanently save this code in MATLAB select the Save option from the File menu at the top of the MATLAB Editor/Debugger. This opens the Save dialog of Figure 6-2, which we use to save our function with the desired name and in the subdirectory indicated as a path in the file name field. Alternatively you can click on the button or select Save and run from the Debug menu. Functions should be saved using a file name equal to the name of the function and in MATLAB’s default work subdirectory C: MATLAB6p1work.

Once a function has been defined and saved in an M-file, it can be used from the Command Window. For example, to find the value of the function at 3π-2 we write in the Command Window:

>> fun1(pi)

ans =

   23.7231

For help on the previous function (assuming that comments were added to the M-file that defines it) you use the command help, as follows:

>> help fun1(x)

 A simple function definition

The definition of a function with more than one input parameter and more than one output parameter is illustrated in the following example (Figure 6-3):

function [x1,x2]=equation2(a,b,c)
% This function solves the quadratic equation ax ^ 2 + bx + c = 0
% whose coefficients are a, b and c (input parameters)
% and whose solutions are x 1 and x 2 (output parameters)
d=b^2-4*a*c;
x1=(-b+sqrt(d))/(2*a);
x 2 = (-b-sqrt (d)) /(2*a);

The saved M-file with the name equation2.m will solve the equation x ^ 2-6 x + 2 = 0 in the following way:

>> [p,q]=equation2(1,-6,2)

p =

    5.6458

q =

    0.3542

We can also ask for help about the function equation2.

>> help equation2

  This function solves the quadratic equation ax ^ 2 + bx + c = 0
  whose coefficients are a, b and c (input parameters)
  and whose solutions are x1 and x2 (output parameters)

We can also evaluate a function defined in an M-file using the command feval, whose syntax is as follows:

feval('F', arg1, arg1,..., argn) evaluates the function F (M-file F.m) with the specified arguments  arg1  arg2,..., argn

For example, we can evaluate previously defined functions using the command feval:

>> [r1,r2]=feval('equation2',1,-6,2)

r1 =

    5.6458

R2 =

    0.3542

>> feval('fun1',pi)

ans =

   23.7231

6.3 Functions and Flow Control. Loops

The use of recursive functions, conditional operations and piecewise defined functions is very common in mathematics. The handling of loops is necessary for the definition of these types of functions. Naturally, the definition of the functions will be made via M-files or through the relationship with Maple, via the symbolic math Toolbox.

6.4 The FOR loop

MATLAB has its own version of the DO statement (defined in the syntax of most programming languages). This statement allows you to run a command or group of commands repeatedly. For example:

>> for i=1:3, x(i)=0, end

x =

     0

x =

     0     0

x =

     0 0 0

The general form of a FOR loop is as follows:

for variable = expression
       commands
end

The loop always starts with the clause for and ends with the clause end, and includes in its interior a whole set of commands that are separated by commas. If any command defines a variable, it must end with a semicolon in order to avoid repetition in the output. Typically, loops are used in the syntax of M-files. Here is an example:

for i=1:m,
    for j=1:n,
        A(i,j)=1/(i+j-1);
    end
end

In this loop (Figure 6-4) we have defined the Hilbert matrix of order (m, n). If we save the M-file (Figure 6-5) as for1.m, we can build any Hilbert matrix by running the M-file and specifying values for the variables m and n as shown below:

>> m = 3, n = 4; for1; A

A =

    1.0000    0.5000    0.3333    0.2500
    0.5000    0.3333    0.2500    0.2000
    0.3333    0.2500    0.2000    0.1667

6.5 The WHILE loop

MATLAB has its own version of the WHILE structure defined in the syntax of most programming languages. This statement allows you to repeat a command or group of commands a number of times while a specified logical condition is met. The general syntax of this loop is as follows:

While condition

commands

end

The loop always starts with the clause while, followed by a condition, and ends with the clause end, and includes in its interior a whole set of commands that are separated by commas which continually loop while the condition is met. If any command defines a variable, it must end with a semicolon in order to avoid repetition in the output. As an example, we write an M-file that is saved as while1.m, which calculates the largest number whose factorial does not exceed 10¹⁰⁰.

n=1;
while prod(1:n) < 1.e100,
      n = n + 1;
end,
n

Now, we run the M-file:

>> while1

n =

    70

6.6 IF ELSEIF ELSE END LOOP

MATLAB, like most structured programming languages, also includes the IF-ELSEIF-ELSE-END structure. Using this structure, scripts can be run if certain conditions are met. The loop syntax is as follows:

If condition
   commands
end

In this case the commands are executed if the condition is true. But the syntax of this loop may be more general.

If condition
   commands1
else
   commands2
end

In this case, the commands1 are executed if the condition is true, and the commands2 are executed if the condition is false.

The IF statements, as well as FOR statements, can be nested. When multiple IF statements are nested, use the ELSEIF statement, whose general syntax is as follows:

if condition1
   commands1
ElseIf condition2
   commands2
ElseIf condition3
   commands3
.
.
else
end

In this case, the commands1 are executed if condition1 is true, the commands2 are executed if condition1 is false and condition2 is true, the commands3 are executed if condition1 and condition2 are false and condition3 is true, and so on.

The previous nested syntax is equivalent to the following unnested syntax, but executes much faster:

if condition1
   commands1
else
      If condition2
         commands2
     else
           if condition3
              commands3
          else
.
.
         end
     end
end

Consider as an example the following M-file named else1.m:

If n < 0,
   A = 'n is negative'
elseif rem(n,2) ==0
   A = 'n is even'
else
   A = 'n is odd'
end

Running it, we obtain the number type (negative, odd or even) for a specified value of n:

>> n = 8; else1

A =

n is even

>> n = 7; else1

A =

n is odd

>> n =-2; else1

A =

n is negative

6.7 Recursive Functions

One of the applications of loops is the creation of recursive functions via M-files. For example, although the factorial function can be defined in MATLAB as n! = prod(1:n), it can be also defined as a recursive function in the following way:

function y=factori(x)
       if x==0
        y=1;
       end
       if x==1
        y=1;
       end
       if x>1
        y=x*feval('factori',x-1);
      end

If we now want to calculate 40!, we do the following:

>> factori(40)

ans =

  8. 1592e + 047

6.8 Conditional Functions

Functions defined differently on different intervals of variation in the independent variable have always played an important role in mathematics. MATLAB enables you to work with these types of functions, which are usually defined using M-files, in the majority of cases relying on FOR loops, WHILE loops, IF-ELSEIF-IF-END, etc.

6.9 Defining Functions Directly. Evaluating Functions

We already know that we can define and evaluate functions by making use of the relation between MATLAB and Maple, provided the symbolic mathematics Toolbox is available. Using this tool, you can define functions of one or severable variables using the command maple.

The advantage of defining functions in this way is that it is not necessary to write files to disk.

6.10 Functions of One Variable

Functions of one variable are defined in the form f =  'function'  (or   f = function whenever its variables have previously been defined as symbolic with syms).

To find the value of the function f at a point, you use the command subs, whose syntax is as follows:

subs(f,a) applies the function f at the point a

subs(f,a,b) substitutes in f the value b by the value a

Let's see how to define the function f (x) = x ^ 2 :

>> f='x^2'  (or: syms x, f = x ^ 2)

f =

x ^ 2

Now we calculate the values f (4), f (a+1) and f(3x+x^2):

>> A=subs(f,4),B=subs(f,'a+1'),C=subs(f,'(3*x+x^2)')

A =

16

B =

(a+1) ^ 2

C =

(3 * x + x ^ 2) ^ 2

6.11 Functions of Several Variables

Functions of one or several variables are defined using the maple command as follows:

maple('f: = x - > f (x)') defines the function f(x)

maple('f:=(x,y,z,...)- > f(x,y,z,...)') defines the function f(x,y,z,...)

maple('f:=(x,y,z,...)- > (f1(x,y,...), f2(x,y,...),...)') defines the vector function (f1(x,y,...), f2(x,y,...),...)

To find the value of the function (x, y, z) - > f(x,y,z...) at the point (a, b, c,...) the expression maple ('f(a,b,c,...)')  is used.

The value of the vector function f:=(x,y,...)-> (f1(x,y,...), f2(x,y,...),...) at the point (a, b,...) is found using the expression maple ('f(a,b,...)').

The function f(x,y) = 2x  + y is defined in the following way:

>> maple('f:=(x,y) - > 2 * x + y');

f (2,3) and f(a,b) are calculated as follows:

>> maple('f(2,3)')

ans =

7

>> maple('f(a,b)')

ans =

2 * a + b

6.12 Piecewise Functions

MATLAB provides a direct command that enables you to define conditional functions that take different values depending on different intervals of definition of the variables (piecewise functions). The command in question is piecewise, and its syntax is presented below:

maple ('piecewise(expr1, value1, expr2, value2,..., exprn, valuen)')

• Defines the piecewise function that takes value1 if the variable satisfies expr1, takes value2 if the variable satisfies expr2, and so on. For all values of the function not covered by the expressions the function takes the value zero.

maple ('piecewise(expr1, value1, expr2, value2,..., exprn, valuen, valuem)')

• Defines the piecewise function that takes value1 if the variable satisfies expr1, takes value2 if the variable satisfies expr2, and so on. For all values of the function not covered by the expressions the function takes the value valuem.

maple ('convert (expression,piecewise)')

• Converts the expression containing Heavside, abs, signum, etc. functions to a piecewise function. The command can be applied to a list or set of expressions which is converted to a list or set.

maple ('convert (expression, piecewise variable)')

• Converts the expression containing Heavside, abs, signum, etc. functions to a piecewise function according to the specified variable.

maple ('convert (expression,pwlist)')

• Converts the expression containing functions to its representation in the form of a piecewise list.

maple ('convert (expression, pwlist,variable)')

• Converts the expression containing functions to its representation in the form of a piecewise list based on the specified variable.

A great advantage of this command is that it can be used together with commands like discont, diff, int, dsolve. This allows you to directly analyze the continuity, differentiability and integrability of piecewise-defined functions. At the same time, it allows this type of function to be used in the analysis of differential equations. Here are some examples:

>> pretty(sym(maple('piecewise(x>0,x)')))

                         |x           0 < x
                         
                         | 0        otherwise

>> pretty(sym(maple('piecewise(x*x>4 and x<8,f(x))')))

                                           2
                | f (x)             4 - x < 0 and x - 8 < 0
                
                |  0                 otherwise

>> pretty(sym(maple('simplify(piecewise(x*x>4 and x<8,f(x)))')))

                         | f (x)       x < - 2
                         |
                         |  0          x < = 2
                         
                         | f(x)        x < 8
                         |
                         |  0          8 <= x

>> pretty(sym(maple('piecewise(x<0,-1,x<1,0,1)')))

                        | -1      x < 0
                        |
                        0      x < 1
                        |
                        | 1      otherwise

It is possible to define piecewise functions using the arrow operator, and to evaluate previously defined functions at different points.

>> pretty(sym(maple('f:=x->piecewise(x<0,-1,x<1,0,1) : f(1/2)')))

                                  0

>> pretty(sym(maple('f(5),f(-5),f(-infinity),f(infinity)')))

                             1, - 1, - 1, 1

You can also directly simplify functions defined in terms of predefined piecewise functions

>> pretty(sym(maple('p:= piecewise(x<0,-x,x>0,x):p'))

                                 | -x        x < 0
                        p:=      
                                 | x         0 < x

>> pretty(sym(maple('p:= piecewise(x<0,-x,x>0,x):simplify(p^2 + 5)')))

                                 2
                                x + 5

However, you cannot directly simplify functions defined in terms of predefined piecewise functions that include parameters.

>> pretty(sym(maple('p:= piecewise(x<a,x,x>b,x*x):p')))

                                | x         x < a
                                |
                        p:=     
                                |   2
                                | x         b < x

>> pretty(sym(maple('p:= piecewise(x<a,x,x>b,x*x):simplify(p^2)')))

                         | x         x < a^ 2
                         |
                         
                         |   2
                         | x         b < x

To simplify the above expression, we need to convert it into a piecewise function in terms of the main variable x.

>>  pretty(sym(maple('convert(p,piecewise,x)')))

                          |   2
                          | x             x < a
                          |
                            0             x = a
                          |
                          |   4
                          | x             a < x

A piecewise function can also be expressed as a list.

>> pretty(sym(maple('f:=piecewise(x<0,-1,x<1,0,1):')));
>> pretty(sym(maple('convert(f,pwlist)')))

                           [- 1, 0, 0, 1, 1]

6.13 Functional Operations

Normally, functions defined in MATLAB operate on their arguments. However, there are also functional operators that operate on other functions (i.e. functional operators have functions as arguments), for example, the inverse function operator. MATLAB also allows the classical operations between functions (sum, product, etc.).

Among the functional operators and classical operations between functions offered by MATLAB, we highlight the following:

syms x y z...

f = f(x,y,z,...), g = g(x,y,z,...), h = h(x,y,z,...)...

symadd(f,g) adds the functions f and g (i.e. f + g)

symop(f,'+',g,'+',h,'+',...) performs the sum f+g+h+...

maple('f+g+h+...') performs the sum  f+g+h +...

symsub(f,g) subtracts g from f (i.e. f-g)

symop(f,'-',g,'-',h,'-',...) forms the successive difference f-g-h-...

maple('f-g-h-...)') forms the successive difference f-g-h-...

symmul(f, g) finds the product of f and g (i.e. f * g)

symop(f,' * ',g,' * ',h,' * ',...) forms the product  f*g*h*...

maple('f*g*h*,...) ') forms the product f * g * h *...

symdiv(f,g) finds the quotient f / g

symop(f,'/',g,'/ ',h,'/ ',...) forms the successive quotient f/(g/(h/...

maple('f/g/h/...) ') forms the successive quotient f/(g/(h/...

sympow(f,k) raises f to the power k (k is a scalar)

symop(f,'^',g) raises a function f to the power of another function g

maple('f^g') raises a function f to the power of another function g

compose(f,g) composes two functions f and g (i.e. f(g(x)))

compose(f,g,u) composes the functions f and g, taking the expression u as the domain of f and g

maple('f @g @h @...') composes the functions f, g, h...

maple('f(g(h(...)'))) composes the functions f, g, h...

g = finverse(f) gives the inverse of the function f

g = finverse(f,v) gives the inverse of the function f using the symbolic variable v as an independent variable

maple('invfunc[f(x)]') gives the inverse of the function f(x)

maple('f(x)@@(-1)') gives the inverse of the function f(x)

maple('map(function,exp)') applies the given function to each operand or element of the expression (according to the first level of operations), where exp is a list or set

maple('map2(f,exp,list)') applies the function f to the elements of the list, in such a way that the function has as its first argument the constant expression expr, and as the second argument, each item in the specified list

maple('unapply(expr,x1,x2,...,xn)') returns an operator from the expression expr in the variables x1, x2,..., xn

maple('applyop(f,n,expr)') applies the function to the nth operand of the expression

maple('applyop(function,{n1, n2,..., nk},expr)') applies the function to the n1, n2,..., nk-th operands of the expression

maple('applyop(function,n,expr,arg2,..., argn)') replaces the nth operand of the expression expr by the result of applying the given function to it, passing arg2,..., argn as additional arguments

Here are some examples:

>> maple('p: = x ^ 2 + sin (x) + 1')

ans =

p := x^2+sin(x)+1

>>  pretty(sym(maple('f:= unapply(p,x):f')))

                                   2
                             x -> x  + sin(x) + 1

>> pretty(sym(maple('f(Pi/6)')))

                                    2
                             1/36 pi + 3/2

>> maple('q:= x^2 + y^3 + 1'):
>> pretty(sym(maple('f:= unapply(q,x) :f')))


                                   2    3
                             x -> x  + y  + 1

>> pretty(sym(maple('f(2)')))

                                     3
                                5 + y

>> pretty(sym(maple('g:= unapply(q,x,y) :g')))


                                       2    3
                            (x, y) -> x  + y  + 1

>> pretty(sym(maple('g(2,3)')))

                                  32
>> clear all
>> maple('p:= y^2-2*y-3');
>> pretty(sym(maple('applyop(f,2,p)')))

                            2
                           y  + f(-2 y) - 3

>> pretty(sym(maple('applyop(f,2,p,x1,x2)')))


                        2
                       y  + f(-2 y, x1, x2) - 3

>> pretty(sym(maple('applyop(f,{2,3},p)')))


                          2
                         y + f(-2 y) + f (- 3)

>> pretty(sym(maple('map(f,x + y*z)')))

                            f (x) + f(y z)

>> pretty(sym(maple('map(f,{a,b,c})')))

                          {f(a), f(b), f(c)}

>> pretty(sym(maple('map(x -> x^2, x + y)')))

                                2    2
                               x  + y

>> pretty(sym(maple('map2(f,g,{a,b,c})')))

                     {f(g, a), f(g, b), f(g, c)}

>> pretty(sym(maple('map(diff,[(x+1)*(x+2),x*(x+2)],x)')))

                          [2 x + 3, 2 x + 2]

>> pretty(sym(maple('map2(diff,x^y/z,[x,y,z])')))

                         y     y            y
                        x y   x  ln(x)     x
                       [----, --------, - ----]
                        x z      z          2
                                           z