CHAPTER 7

Programming and Numerical Analysis

7.1 MATLAB and Programming

MATLAB can be used as a high-level programming language including data structures, functions, instructions for flow control, management of inputs/outputs and even object-oriented programming. MATLAB programs are usually written into files called M-files. An M-file is nothing more than a MATLAB code (script) that executes a series of commands or functions that accept arguments and produces an output. The M-files are created using the text editor.

7.2 The Text Editor

The Editor/Debugger is activated by clicking on the create a new M-file button in the MATLAB desktop or by selecting File New M-file in the MATLAB desktop (Figure 7-1) or Command Window (Figure 7-2). The Editor/Debugger opens a file in which we create the M-file, i.e. a blank file into which we will write MATLAB programming code (Figure 7-3). You can open an existing M-file using File Open on the MATLAB desktop (Figure 7-1) or, alternatively, you can use the command Open in the Command Window (Figure 7-2). You can also open the Editor/Debugger by right-clicking on the Current Directory window and choosing New M-file from the resulting pop-up menu (Figure 7-4). Using the menu option Open, you can open an existing M-file. You can open several M-files simultaneously, each of which will appear in a different window.

Figure 7-5 shows the functions of the icons in the Editor/Debugger.

7.3 Scripts

Scripts are the simplest possible M-files. A script has no input or output arguments. It simply consists of instructions that MATLAB executes sequentially and that could also be submitted in a sequence in the Command Window. Scripts operate with existing data on the workspace or new data created by the script. Any variable that is used by a script will remain in the workspace and can be used in further calculations after the end of the script.

Below is an example of a script that generates several curves in polar form, representing flower petals. Once the syntax of the script has been entered into the editor (Figure 7-6), it is stored in the work library (work) and simultaneously executes by clicking the button or by selecting the option Save and run from the Debug menu (or pressing F5). To move from one chart to the next press ENTER.

7.4 Functions and M-files. Eval and feval

We already know that MATLAB has a wide variety of functions that can be used in everyday work with the program. But, in addition, the program 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.

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. Normally, 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.

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

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 fun1.m. 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 7-11.

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 7-12, 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(3*pi/2)
ans =
95.2214

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)

7.4.1 A Simple Function Definition

A function can also be evaluated at some given arguments (input parameters) via the feval command, the syntax of which is as follows:

As an example we build an M-file named equation2.m which contains the function equation2, whose arguments are the three coefficients of the quadratic equation ax²+bx+c = 0 and whose outputs are the two solutions (Figure 7-13).

Now if we want to solve the equation x² + 2 x + 3 = 0 using feval, we write the following in the Command Window:

>> [x1, x2] = feval('equation2',1,2,3)

x1 =

-1.0000 + 1. 4142i

x2 =

-1.0000 - 1. 4142i

The quadratic equation can also be solved as follows:

>> [x1, x2] = equation2 (1,2,3)

x1 =

  -1.0000 + 1. 4142i

x2 =

-1.0000 - 1. 4142i

If we want to ask for help about the function equation2 we do the following:

>> 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 x 1 and x 2 (output parameters)

Evaluating a function when its arguments (input parameters) are strings is performed via the command eval, whose syntax is as follows:

eval (expression)

This executes the expression when it is a string.

As an example, we evaluate a string that defines a magic square of order 4.

>> n=4;
>> eval(['M' num2str(n) ' = magic(n)'])

M4 =

16 2 3 13
5 11 10 8
9 7  6 12
4 14 15 1

7.5 Local and Global Variables

Typically, each function defined as an M-file contains local variables, i.e., variables that have effect only within the M-file, separate from other M-files and the base workspace. However, it is possible to define variables inside M-files which can take effect simultaneously in other M-files and in the base workspace. For this purpose, it is necessary to define global variables with the GLOBAL command whose syntax is as follows:

Any variables defined as global inside a function are available separately for the rest of the functions and in the base workspace command line. If a global variable does not exist, the first time it is used, it will be initialized as an empty array. If there is already a variable with the same name as a global variable being defined, MATLAB will send a warning message and change the value of that variable to match the global variable. It is convenient to declare a variable as global in every function that will need access to it, and also in the command line, in order to access it from the base workspace. The GLOBAL command is located at the beginning of a function (before any occurrence of the variable).

As an example, suppose that we want to study the effect of the interaction coefficients α and β in the Lotka–Volterra predator-prey model:

To do this, we create the function lotka in the M-file lotka.m as depicted in Figure 7-14.

Later, we might type the following in the command line:

>> global ALPHA BETA
ALPHA = 0.01
BETA = 0.02

These global values may then be used for α and β in the M-file lotka.m (without having to specify them). For example, we can generate the graph (Figure 7-15) with the following syntax:

>> [t, y] = ode23 ('lotka', 0.10, [1; 1]); plot(t,y)

7.6 Data Types

MATLAB has 14 different data types, summarized in Figure 7-16 below.

Below are the different types of data:

7.7 Flow Control: FOR, WHILE and IF ELSEIF 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.

7.8 FOR Loops

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:

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 (Figure 7-17):

In this loop we have defined a Hilbert matrix of order (m, n). If we save it as an M-file matriz.m, we can build any Hilbert matrix later by running the M-file and specifying values for the variables m and n (the matrix dimensions) as shown below:

>> M = matriz (4,5)

M =

1.0000 0.5000 0.3333 0.2500 0.2000
0.5000 0.3333 0.2500 0.2000 0.1667
0.3333 0.2500 0.2000 0.1667 0.1429
0.2500 0.2000 0.1667 0.1429 0.1250

7.9 WHILE Loops

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:

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 (Figure 7-18) that is saved as while1.m, which calculates the largest number whose factorial does not exceed 10¹⁰⁰.

Now now run the M-file.

>> while1

n =

    70

7.10 IF ELSEIF ELSE END Loops

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 commands commands1 are executed if the condition is true, and the commands commands2 are executed if the condition is false.

IF statements and FOR statements can be nested. When multiple IF statements are nested using the ELSEIF statement, the general syntax is as follows:

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

In this case, the commands commands1 are executed if condition1 is true, the commands commands2 are executed if condition1 is false and condition2 is true, the commands 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, for example, the M-file else1.m (see Figure 7-19).

When you run the file it returns negative, odd or even according to whether the argument n is negative, non-negative and odd, or non-negative and even, respectively:

>> else1 (8), else1 (5), else1 (-10)

A =

n is even

A =

n is odd

A =

n is negative

7.11 SWITCH and CASE

The switch statement executes certain statements based on the value of a variable or expression. Its basic syntax is as follows:

switch expression (scalar or string)
case value1
statements % runs if expression is value1
case value2
statements % runs if expression is value2
.
.
.
otherwise
statements % runs if neither case is satisfied

end

Below is an example of a function that returns ‘minus one’, ‘zero’, ‘one’, or ‘another value’ according to whether the input is equal to -1,0,1 or something else, respectively (Figure 7-20).

Running the above example we get:

>> case1 (25)
another value

>> case1 (- 1)
minus one

7.12 CONTINUE

The continue statement passes control to the next iteration in a for loop or while loop in which it appears, ignoring the remaining instructions in the body of the loop. Below is an M-file continue.m (Figure 7-21) that counts the lines of code in the file magic.m, ignoring the white lines and comments.

Running the M-file, we get:

>> continue1
25 lines

7.13 BREAK

The break statement terminates the execution of a for loop or while loop, skipping to the first instruction which appears outside of the loop. Below is an M-file break1.m (Figure 7-22) which reads the lines of code in the file fft.m, exiting the loop as soon as it encounters the first empty line.

Running the M-file we get:

>> break1

%FFT Discrete Fourier transform.
%   FFT(X) is the discrete Fourier transform (DFT) of vector X.  For
%   matrices, the FFT operation is applied to each column. For N-D
%   arrays, the FFT operation operates on the first non-singleton
%   dimension.
%
%   FFT(X,N) is the N-point FFT, padded with zeros if X has less
%   than N points and truncated if it has more.
%
%   FFT(X,[],DIM) or FFT(X,N,DIM) applies the FFT operation across the
%   dimension DIM.
%
%   For length N input vector x, the DFT is a length N vector X,
%   with elements
%                    N
%      X(k) =       sum  x(n)*exp(-j*2*pi*(k-1)*(n-1)/N), 1 <= k <= N.
%                   n=1
%   The inverse DFT (computed by IFFT) is given by
%                    N
%      x(n) = (1/N) sum  X(k)*exp( j*2*pi*(k-1)*(n-1)/N), 1 <= n <= N.
%                   k=1
%
%   See also IFFT, FFT2, IFFT2, FFTSHIFT.

7.14 TRY ... CATCH

The instructions between try and catch are executed until an error occurs. The instruction lasterr is used to show the cause of the error. The general syntax of the command is as follows:

try,
instruction
...,
instruction
catch,
instruction
...,
instruction
end

7.15 RETURN

The return statement terminates the current script and returns the control to the invoked function or the keyboard. The following is an example (Figure 7-23) that computes the determinant of a non-empty matrix. If the array is empty it returns the value 1.

Running the function for a non-empty array we get:

>> A = [- 1, - 1, 1; 1,0,1; 1,1,1]


A =
-1 -1 -1
 1  0  1
 1 -1 -1

>> det1 (A)

ans =

2

Now we apply the function to an empty array:

>> B =[]

B =

     []

>> det1 (B)

ans =

     1

7.16 Subfunctions

M-file-defined functions can contain code for more than one function. The main function in an M-file is called a primary function, which is precisely the function which invokes the M-file, but subfunctions hanging from the primary function may be added which are only visible for the primary function or another subfunction within the same M-file. Each subfunction begins with its own function definition. An example is shown in Figure 7-24.

The subfunctions mean and median calculate the arithmetic mean and the median of the input list. The primary function newstats determines the length n of the list and calls the subfunctions with the list as the first argument and n as the second argument. When executing the main function, it is enough to provide as input a list of values for which the arithmetic mean and median will be calculated. The subfunctions are executed automatically, as shown below.

>> [mean, median] = newstats ([10,20,3,4,5,6])

mean =

     8

median =

    5.5000

7.17 Commands in M-files

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

7.18 Functions relating to Arrays of Cells

An array is a well-ordered collection of individual items. It is simply a list of elements, each of which is associated with a positive integer called its index, which represents the position of that element in the list. It is essential that each element is associated with a unique index, which can be zero or negative, which identifies it fully, so that to make changes to any elements of the array it suffices to refer to their indices. Arrays can be of one or more dimensions, and correspondingly they have one or more sets of indices that identify their elements. The most important commands and functions that enable MATLAB to work with arrays of cells are the following:

As a first example, we create an array of cells of the same size as the unit square matrix of order two.

>> A = ones(2,2)

A =
1     1
1     1

>> c = cell(size(A))

c =

[]     []
[]     []

We then define and present a 2 × 3 array of cells element by element, and apply various functions to the cells.

>> C{1.1} = [1 2; 4 5];
C{1,2} = 'Name';
C{1,3} = pi;
C{2,1} = 2 + 4i;
C{2,2} = 7;
C{2,3} = magic(3);

>> C

C =

[2x2 double]    'Name'    [    3.1416]
[2.0000+ 4.0000i]    [   7]    [3x3 double]

>> D = cellfun('isreal',C)

D =

1     1     1
0     1     1

>> len = cellfun('length',C)

len =

2     4     1
1     1     3

>> isdbl = cellfun('isclass',C,'double')

isdbl =

1 0 1
1 1 1

The contents of the cells in the array C defined above are revealed using the command celldisp.

>> celldisp(C)

C{1,1} =
1     2
4     5

C{2,1} =

2.0000 + 4.0000i

C{1,2} =

Name

C {2,2} =

7

C {1,3} =

3.1416



C {2,3} =

8 1 6
3 5 7
4 9 2

The following displays a graphical representation of the array C (Figure 7-25).

>> cellplot(C)

7.19 Functions of Multidimensional Arrays

The following group of functions is used by MATLAB to work with multidimensional arrays:

As a first example we concatenate a magic square and Pascal matrix of order 3.

>> A = magic (3); B = pascal (3);
>> C = cat (4, A, B)

C(:,:,1,1) =

8 1 6
3 5 7
4 9 2


C(:,:,1,2) =

1 1 1
1 2 3
1 3 6

The following example flips the Rosser matrix.

>> R=rosser

R =

   611   196  -192   407    -8   -52   -49    29
   196   899   113  -192   -71   -43    -8   -44
  -192   113   899   196    61    49     8    52
   407  -192   196   611     8    44    59   -23
    -8   -71    61     8   411  -599   208   208
   -52   -43    49    44  -599   411   208   208
   -49    -8     8    59   208   208    99  -911
    29   -44    52   -23   208   208  -911    99

>> flipdim(R,1)

ans =

ans =

    29   -44    52   -23   208   208  -911    99
   -49    -8     8    59   208   208    99  -911
   -52   -43    49    44  -599   411   208   208
    -8   -71    61     8   411  -599   208   208
   407  -192   196   611     8    44    59   -23
  -192   113   899   196    61    49     8    52
   196   899   113  -192   -71   -43    -8   -44
   611   196  -192   407    -8   -52   -49    29

Now we define an array by concatenation and permute and inverse permute its elements.

>> a = cat(3,eye(2),2*eye(2),3*eye(2))


a(:,:,1) =

1 0
0 1


a(:,:,2) =

2 0
0 2


a(:,:,3) =

3 0
0 3

>> B = permute(a,[3 2 1])

B(:,:,1) =

1 0
2 0
3 0

B(:,:,2) =

0 1
0 2
0 3

>> C = ipermute(B,[3 2 1])

C(:,:,1) =

1 0
0 1

C(:,:,2) =

2 0
0 2

C(:,:,3) =

3 0
0 3

The following example evaluates the function in the square [-2, 2] × [-2, 2] and displays it graphically (Figure 7-26).

>> [X 1, X 2] = ndgrid(-2:.2:2,-2:.2:2);
Z = X 1. * exp(-X1.^2-X2.^2);
mesh (Z)

In the following example we resize a 3 × 4 random matrix to a 2 × 6 matrix.

>> A = rand(3,4)

A =

0.9501    0.4860    0.4565    0.4447
0.2311    0.8913    0.0185    0.6154
0.6068    0.7621    0.8214    0.7919

>> B = reshape(A,2,6)

B =

   0.9501 0.6068 0.8913 0.4565 0.8214 0.6154
   0.2311 0.4860 0.7621 0.0185 0.4447 0.7919

7.20 Numerical Analysis Methods in MATLAB

MATLAB programming techniques allow you to implement a wide range of numerical algorithms. It is possible to design programs which perform numerical integration and differentiation, solve differential equations, optimize non-linear functions, etc. However, MATLAB’s Basic module already has a number of tailor-made functions which implement some of these algorithms. These functions are set out in the following subsections. In the next chapter we will give some examples showing how these functions can be used in practice.

7.21 Zeros of Functions and Optimization

The commands (functions) that enables MATLAB’s Basic module to optimize functions and find the zeros of functions are as follows:

As a first example we find the value of x that minimizes the function cos(x) in the interval (3,4).

>> x = fminbnd(@cos,3,4)

x =
3.1416

We could also have used the following syntax:

>> x = fminbnd(inline('cos(x)'),3,4)

x =
3.1416

In the following example we find the above minimum to 8 decimal places and find the value of x that minimizes the cosine in the given interval, presenting information relating to all iterations of the process.

>> [x,fval,f] = fminbnd(@cos,3,4,optimset('TolX',1e-8,...          'Display','iter'));


Func-count     x          f(x)       Procedure
1        3.38197    -0.971249        initial
2        3.61803    -0.888633        golden
3        3.23607    -0.995541        golden
4        3.13571    -0.999983        parabolic
5         3.1413           -1        parabolic
6        3.14159           -1        parabolic
7        3.14159           -1        parabolic
8        3.14159           -1        parabolic
9        3.14159           -1        parabolic

Optimization terminated successfully:
the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-008

In the following example, taking (- 1, 2; 1) as initial values, we find the minimum and target value of the following function of two variables:

>> [x,fval] = fminsearch(inline('100*(x(2)-x(1)^2)^2+...
(((1-x (1)) ^ 2'), [- 1.2, 1])

x =

1.0000 1.0000


fval =

8. 1777e-010

The following example computes a zero of the sine function with an initial estimate of 3, and a zero of the cosine function between 1 and 2.

>> x = fzero(@sin,3)

x =

3.1416

>> x = fzero(@cos,[1 2])

x =

    1.5708

7.22 Numerical Integration

MATLAB contains functions that allow you to perform numerical integration using Simpson’s method and Lobatto’s method. The syntax of these functions is as follows:

As a first example, we calculate using Simpson’s method.

>> F = inline('1./(x.^3-2*x-5)');
>> Q = quad(F,0,2)

Q =

-0.4605

Then we observe that the integral remains unchanged even if we increase the tolerance to 10^-18.

>> Q = quad(F,0,2,1.0e-18)

Q =

-0.4605

In the following example we evaluate the same integral using Lobatto’s method.

>> Q = quadl(F,0,2)

Q =

-0.4605

We evaluate the double integral .

>> Q = dblquad (inline (' y * sin (x) + x * cos (y)'), pi, 2 * pi, 0, pi)

Q =

   -9.8696

7.23 Numerical Differentiation

The derivative f'(x) of a function f (x) can simply be defined as the rate of change of f (x) with respect to x. The derivative can be expressed as a ratio between the change in f (x), denoted by df (x), and the change in x, denoted by dx. The derivative of a function f at the point x_k can be estimated by using the expression:

provided the values x_k, x_k-1 are close to each other. Similarly the second derivative f''(x) of the function f(x) can be estimated as the first derivative of f'(x), i.e.:

MATLAB includes in its Basic module the function diff, which allows you to approximate derivatives. The syntax is as follows:

As an example we consider the function f(x) = x⁵-3x⁴-11x³+27x²+10x-24, find the difference vector of [-4,-3.9,-3.8,...,4.8,4.9,5] the difference vector of [f(-4),f(-3.9),f(-3.8),...,f(4.8),f(4.9),f(5)] and the elementwise quotient of the latter by the former, and graph the function in the interval [-4,5]. See Figure 7-27.

>> x =-4:0.1: 5;
>> f = x.^5-3*x.^4-11*x.^3 + 27*x.^2 + 10*x-24;
>> df=diff(f)./diff(x)

df =

  1.0e+003 *

  Columns 1 through 7

    1.2390    1.0967    0.9655    0.8446    0.7338    0.6324    0.5400

  Columns 8 through 14

    0.4560    0.3801    0.3118    0.2505    0.1960    0.1477    0.1053

  Columns 15 through 21

    0.0683    0.0364    0.0093   -0.0136   -0.0324   -0.0476   -0.0594

  Columns 22 through 28

   -0.0682   -0.0743   -0.0779   -0.0794   -0.0789   -0.0769   -0.0734

  Columns 29 through 35

   -0.0687   -0.0631   -0.0567   -0.0497   -0.0424   -0.0349   -0.0272

  Columns 36 through 42

   -0.0197   -0.0124   -0.0054    0.0012    0.0072    0.0126    0.0173

  Columns 43 through 49

    0.0212    0.0244    0.0267    0.0281    0.0287    0.0284    0.0273

  Columns 50 through 56

    0.0253    0.0225    0.0189    0.0147    0.0098    0.0044   -0.0014

  Columns 57 through 63

   -0.0076   -0.0140   -0.0205   -0.0269   -0.0330   -0.0388   -0.0441

  Columns 64 through 70

   -0.0485   -0.0521   -0.0544   -0.0553   -0.0546   -0.0520   -0.0472

  Columns 71 through 77

-0.0400   -0.0300   -0.0170   -0.0007    0.0193    0.0432    0.0716

  Columns 78 through 84

    0.1046    0.1427    0.1863    0.2357    0.2914    0.3538    0.4233

  Columns 85 through 90

    0.5004    0.5855    0.67910.7816    0.8936    1.0156

>> plot (x, f)

7.24 Approximate Solutions of Differential Equations

MATLAB provides commands in its Basic module allowing for the numerical solution of ordinary differential equations (ODEs), differential algebraic equations (DAEs) and boundary value problems. It is also possible to solve systems of differential equations with boundary values and parabolic and elliptic partial differential equations.

7.25 Ordinary Differential Equations with Initial Values

An ordinary differential equation contains one or more derivatives of the dependent variable y with respect to the independent variable t. A first order ordinary differential equation with an initial value for the independent variable can be represented as:

The previous problem can be generalized to the case where y is a vector, y = (y1, y2,...,yn).

MATLAB’s Basic module commands relating to ordinary differential equations and differential algebraic equations with initial values are presented in the following table:

The common syntax for the previous seven commands is the following:

[T, y] = solver(odefun,tspan,y0)
[T, y] = solver(odefun,tspan,y0,options)
[T, y] = solver(odefun,tspan,y0,options,p1,p2...)
[T, y, TE, YE, IE] = solver(odefun,tspan,y0,options)

In the above, solver can be any of the commands ode45, ode23, ode113, ode15s, ode23s, ode23t, or ode23tb.

The argument odefun evaluates the right-hand side of the differential equation or system written in the form y' = f (t, y) or M(t, y)y '=f (t, y), where M(t, y) is called a mass matrix. The command ode23s can only solve equations with constant mass matrix. The commands ode15s and ode23t can solve algebraic differential equations and systems of ordinary differential equations with a singular mass matrix. The argument tspan is a vector that specifies the range of integration [t₀, t_f] (tspan= [t₀, t₁,...,t_f], which must be either an increasing or decreasing list, is used to obtain solutions for specific values of t). The argument y₀ specifies a vector of initial conditions. The arguments p1, p2,... are optional parameters that are passed to odefun. The argument options specifies additional integration options using the command options odeset which can be found in the program manual. The vectors T and Y present the numerical values of the independent and dependent variables for the solutions found.

As a first example we find solutions in the interval [0,12] of the following system of ordinary differential equations:

For this, we define a function named system1 in an M-file, which will store the equations of the system. The function begins by defining a column vector with three rows which are subsequently assigned components that make up the syntax of the three equations (Figure 7-28).

We then solve the system by typing the following in the Command Window:

>> [T, Y] = ode45(@system1,[0 12],[0 1 1])

T =

0
0.0001
0.0001
0.0002
0.0002
0.0005
.
.
11.6136
11.7424
11.8712
12.0000

Y =
0 1.0000 1.0000
0.0001 1.0000 1.0000
0.0001 1.0000 1.0000
0.0002 1.0000 1.0000
0.0002 1.0000 1.0000
0.0005 1.0000 1.0000
0.0007 1.0000 1.0000
0.0010 1.0000 1.0000
0.0012 1.0000 1.0000
0.0025 1.0000 1.0000
0.0037 1.0000 1.0000
0.0050 1.0000 1.0000
0.0062 1.0000 1.0000
0.0125 0.9999 1.0000
0.0188 0.9998 0.9999
0.0251 0.9997 0.9998
0.0313 0.9995 0.9997
0.0627 0.9980 0.9990
.
.
0.8594  -0.5105 0.7894
0.7257  -0.6876 0.8552
0.5228  -0.8524 0.9281
0.2695  -0.9631 0.9815
-0.0118 -0.9990 0.9992
-0.2936 -0.9540 0.9763
-0.4098 -0.9102 0.9548
-0.5169 -0.8539 0.9279
-0.6135 -0.7874 0.8974
-0.6987 -0.7128 0.8650

To better interpret the results, the above numerical solution can be graphed (Figure 7-29) by using the following command:

>> plot (T, Y(:,1), '-', T, Y(:,2),'-', T, Y(:,3),'. ')

7.26 Ordinary Differential Equations with Boundary Conditions

MATLAB also allows you to solve ordinary differential equations with boundary conditions. The boundary conditions specify a relationship that must hold between the values of the solution function at the end points of the interval on which it is defined. The simplest problem of this type is the system of equations

where x is the independent variable, y is the dependent variable and y' is the derivative with respect to x  (i.e., y'= dy/dx). In addition, the solution on the interval [a, b] has to meet the following boundary condition:

More generally this type of differential equation can be expressed as follows:

where the vector p consists of parameters which have to be determined simultaneously with the solution via the boundary conditions.

The command that solves these problems is bvp4c, whose syntax is as follows:

Sol = bvp4c (odefun, bcfun, solinit)
Sol = bvp4c (odefun, bcfun, solinit, options)
Sol = bvp4c(odefun,bcfun,solinit,options,p1,p2...)

In the syntax above odefun is a function that evaluates f (x, y). It may take one of the following forms:

dydx = odefun(x,y)
dydx = odefun(x,y,p1,p2,...)
dydx = odefun (x, y, parameters)
dydx = odefun(x,y,parameters,p1,p2,...)

The argument bcfun in Bvp4c is a function that computes the residual in the boundary conditions. Its form is as follows:

Res = bcfun (ya, yb)
Res = bcfun(ya,yb,p1,p2,...)
Res = bcfun (ya, yb, parameters)
Res = bcfun(ya,yb,parameters,p1,p2,...)

The argument solinit is a structure containing an initial guess of the solution. It has the following fields: x (which gives the ordered nodes of the initial mesh so that the boundary conditions are imposed at a = solinit.x(1)and b = solinit.x(end)) and y (the initial guess for the solution, given as a vector, so that the i-th entry is a constant guess for the i-th component of the solution at all the mesh points given by x). The structure solinit is created using the command bvpinit. The syntax is solinit = bvpinit(x,y).

As an example we solve the second order differential equation:

whose solutions must satisfy the boundary conditions:

This is equivalent to the following problem (where y₁=y and y₂=y'):

We consider a mesh of five equally spaced points in the interval [0,4] and our initial guess for the solution is y₁ = 1 and y₂ = 0. These assumptions are included in the following syntax:

>> solinit = bvpinit (linspace (0,4,5), [1 0]);

The M-files depicted in Figures 7-30 and 7-31 show how to enter the equation and its boundary conditions.

The following syntax is used to find the solution of the equation:

>> Sun = bvp4c (@twoode, @twobc, solinit);

The solution can be graphed (Figure 7-32) using the command bvpval as follows:

>> y = bvpval (Sun, linspace (0,4));
>> plot (x, y(1,:));

7.27 Partial Differential Equations

MATLAB’s Basic module has features that enable you to solve partial differential equations and systems of partial differential equations with initial boundary conditions. The basic function used to calculate the solutions is pedepe, and the basic function used to evaluate these solutions is pdeval.

The syntax of the function pedepe is as follows:

Sol = pdepe (m, pdefun, icfun, bcfun, xmesh, tspan)
Sol = pdepe (m, pdefun, icfun, bcfun, xmesh, tspan, options)
Sun = pdepe(m,pdefun,icfun,bcfun,xmesh,tspan,options,p1,p2...)

The parameter m takes the value 0, 1 or 2 according to the nature of the symmetry of the problem (block, cylindrical or spherical, respectively). The argument pdefun defines the components of the differential equation, icfun defines the initial conditions, bcfun defines the boundary conditions, xmesh and tspan are vectors [x₀, x₁,...,x_n] and [t₀, t₁,...,t_f] that specify the points at which a numerical solution is requested (n, f≥3), options specifies some calculation options of the underlying solver (RelTol, AbsTol,NormControl, InitialStep and MaxStep to specify relative tolerance, absolute tolerance, norm tolerance, initial step and max step, respectively) and p1, p2,... are parameters to pass to the functions pdefun, icfun and bcfun.

pdepe solves partial differential equations of the form:

where a≤x≤b and t₀≤t≤t_f. Moreover, for t = t₀ and for all x the solution components meet the initial conditions:

and for all t and each x = a or x = b, the solution components satisfy the boundary conditions of the form:

In addition, we have that a = xmesh (1), b = xmesh (end), tspan (1) =t₀ and tspan (end) = t_f. Moreover pdefun finds the terms c, f and s of the partial differential equation, so that:

[c, f, s] = pdefun (x, t, u, dudx)

Similiarly icfun evaluates the initial conditions

u = icfun (x)

Finally, bcfun evaluates the terms p and q of the boundary conditions:

[pl, ql, pr, qr] = bcfun (xl, ul, xr, ur, t)

As a first example we solve the following partial differential equation (x[0,1] and t≥0):

satisfying the initial condition:

and the boundary conditions:

We begin by defining functions in M-files as shown in Figures 7-33 to 7-35.

Once the support functions have been defined, we define the function that solves the equation (see the M-file in Figure 7-36).

To view the solution (Figures 7-37 and 7-38), we enter the following into the MATLAB Command Window:

>> pdex1

As a second example we solve the following system of partial differential equations (x[0,1] and t≥0):

satisfying the initial conditions:

and the boundary conditions:

To conveniently use the function pdepe, the system can be written as:

The left boundary condition can be written as:

and the right boundary condition can be written as:

We start by defining the functions in M-files as shown in Figures 7-39 to 7-41.

Once the support functions are defined, the function that solves the system of equations is given by the M-file shown in Figure 7-42.

To view the solution (Figures 7-43 and 7-44), we enter the following in the MATLAB Command Window:

>> pdex4