P1: PHB

cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

1 Introduction to MATLAB

1.1 Quick Overview

R
This chapter is not intended to be a comprehensive manual of MATLAB . Our sole
aim is to provide sufficient information to give you a good start. If you are familiar
with another computer language, and we assume that you are, it is not difficult to
pick up the rest as you go.
MATLAB is a high-level computer language for scientific computing and
data visualization built around an interactive programming environment. It is
becoming the premier platform for scientific computing at educational institu-
tions and research establishments. The great advantage of an interactive system is
that programs can be tested and debugged quickly, allowing the user to concen-
trate more on the principles behind the program and less on programming itself.
Since there is no need to compile, link, and execute after each correction,
MATLAB programs can be developed in a much shorter time than equivalent
FORTRAN or C programs. On the negative side, MATLAB does not produce stand-
alone applications – the programs can be run only on computers that have MATLAB
installed.
MATLAB has other advantages over mainstream languages that contribute to
rapid program development:

• MATLAB contains a large number of functions that access proven numerical li-
braries, such as LINPACK and EISPACK. This means that many common tasks
(e.g., solution of simultaneous equations) can be accomplished with a single
function call.
• There is extensive graphics support that allows the results of computations to be
plotted with a few statements.
• All numerical objects are treated as double-precision arrays. Thus there is no
need to declare data types and carry out type conversions.
• MATLAB programs are clean and easy to read; they lack the syntactic clutter of
some mainstream languages (e.g., C).

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

2 Introduction to MATLAB

The syntax of MATLAB resembles that of FORTRAN. To get an idea of the simi-
larities, let us compare the codes written in the two languages for solution of simul-
taneous equations Ax = b by Gauss elimination (do not worry about understanding
the inner workings of the programs). Here is the subroutine in FORTRAN 90:

subroutine gauss(A,b,n)
use prec_mod
implicit none
real(DP), dimension(:,:), intent(in out) :: A
real(DP), dimension(:), intent(in out) :: b
integer, intent(in) :: n
real(DP) :: lambda
integer :: i,k
! --------------Elimination phase--------------
do k = 1,n-1
do i = k+1,n
if(A(i,k) /= 0) then
lambda = A(i,k)/A(k,k)
A(i,k+1:n) = A(i,k+1:n) - lambda*A(k,k+1:n)
b(i) = b(i) - lambda*b(k)
end if
end do
end do
! ------------Back substitution phase----------
do k = n,1,-1
b(k) = (b(k) - sum(A(k,k+1:n)*b(k+1:n)))/A(k,k)
end do
return
end subroutine gauss

The statement use prec mod tells the compiler to load the module prec mod
(not shown here), which defines the word length DP for floating-point numbers. Also
note the use of array sections, such as a(k,k+1:n), a very useful feature that was not
available in previous versions of FORTRAN.
The equivalent MATLAB function is (MATLAB does not have subroutines):

function b = gauss(A,b)
n = length(b);
%-----------------Elimination phase-------------
for k = 1:n-1
for i = k+1:n
if A(i,k) ˜= 0
lambda = A(i,k)/A(k,k);

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

3 1.1 Quick Overview

A(i,k+1:n) = A(i,k+1:n) - lambda*A(k,k+1:n);

b(i)= b(i) - lambda*b(k);
end
end
end
%--------------Back substitution phase-----------
for k = n:-1:1
b(k) = (b(k) - A(k,k+1:n)*b(k+1:n))/A(k,k);
end

Simultaneous equations can also be solved in MATLAB with the simple com-
mand A\b (see below).
MATLAB can be operated in the interactive mode through its command window,
where each command is executed immediately upon its entry. In this mode MATLAB
acts like an electronic calculator. Here is an example of an interactive session for the
solution of simultaneous equations:

>> A = [2 1 0; -1 2 2; 0 1 4]; % Input 3 x 3 matrix.

>> b = [1; 2; 3]; % Input column vector
>> soln = A\b % Solve A*x = b by ’left division’
soln =
0.2500
0.5000
0.6250

The symbol >> is MATLAB’s prompt for input. The percent sign (%) marks the
beginning of a comment. A semicolon (;) has two functions: it suppresses printout
of intermediate results and separates the rows of a matrix. Without a terminating
semicolon, the result of a command would be displayed. For example, omission of
the last semicolon in the line defining the matrix A would result in

>> A = [2 1 0; -1 2 2; 0 1 4]
A =
2 1 0
-1 2 2
0 1 4

Functions and programs can be created with the MATLAB editor/debugger and
saved with the .m extension (MATLAB calls them M-files). The file name of a saved
function should be identical to the name of the function. For example, if the function
for Gauss elimination listed above is saved as gauss.m, it can be called just like any

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

4 Introduction to MATLAB

MATLAB function:
>> A = [2 1 0; -1 2 2; 0 1 4];
>> b = [1; 2; 3];
>> soln = gauss(A,b)
soln =
0.2500
0.5000
0.6250

1.2 Data Types and Variables

Data Types
The most commonly used MATLAB data types, or classes, are double, char, and log-
ical, all of which are considered by MATLAB as arrays. Numerical objects belong to
the class double, which represent double-precision arrays; a scalar is treated as a
1 × 1 array. The elements of a char type array are strings (sequences of characters),
whereas a logical type array element may contain only 1 (true) or 0 (false).
Another important class is function handle, which is unique to MATLAB. It
contains information required to find and execute a function. The name of a function
handle consists of the character @, followed by the name of the function; for example,
@sin. Function handles are used as input arguments in function calls. For example,
suppose that we have a MATLAB function plot(func,x1,x2) that plots any user-
specified function func from x1 to x2. The function call to plot sin x from 0 to π
would be plot(@sin,0,pi).
There are other data types, such as sparse (sparse matrices), inline (inline ob-
jects), and struct (structured arrays), but we seldom come across them in this text.
Additional classes can be defined by the user. The class of an object can be displayed
with the class command. For example,

>> x = 1 + 3i % Complex number

>> class(x)
ans =
double

Variables
Variable names, which must start with a letter, are case sensitive. Hence xstart and
XStart represent two different variables. The length of the name is unlimited, but
only the first N characters are significant. To find N for your installation of MATLAB,
use the command namelengthmax:
>> namelengthmax
ans =
63

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

5 1.2 Data Types and Variables

Variables that are defined within a MATLAB function are local in their scope.
They are not available to other parts of the program and do not remain in memory
after exiting the function (this applies to most programming languages). However,
variables can be shared between a function and the calling program if they are de-
clared global. For example, by placing the statement global X Y in a function as
well as the calling program, the variables X and Y are shared between the two program
units. The recommended practice is to use capital letters for global variables.
MATLAB contains several built-in constants and special variables, most impor-
tant of which are

ans Default name for results

eps Smallest number for which 1 + eps > 1
inf Infinity
NaN Not a number
√
i or j −1
pi π
realmin Smallest usable positive number
realmax Largest usable positive number

Here are a few examples:

>> warning off % Suppresses print of warning messages

>> 5/0
ans =
Inf

>> 0/0
ans =
NaN

>> 5*NaN % Most operations with NaN result in NaN

ans =
NaN

>> NaN == NaN % Different NaN’s are not equal!

ans =
0

>> eps
ans =
2.2204e-016

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

6 Introduction to MATLAB

Arrays
Arrays can be created in several ways. One of them is to type the elements of the array
between brackets. The elements in each row must be separated by blanks or commas.
Here is an example of generating a 3 × 3 matrix:

>> A = [ 2 -1 0
-1 2 -1
0 -1 1]
A =
2 -1 0
-1 2 -1
0 -1 1

The elements can also be typed on a single line, separating the rows with colons:

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

Unlike most computer languages, MATLAB differentiates between row and col-
umn vectors (this peculiarity is a frequent source of programming and input errors).
For example,

>> b = [1 2 3] % Row vector

b =
1 2 3

>> b = [1; 2; 3] % Column vector

b =
1
2
3

>> b = [1 2 3]’ % Transpose of row vector

b =
1
2
3

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

7 1.2 Data Types and Variables

The single quote (’) is the transpose operator in MATLAB; thus, b’ is the trans-
pose of b.
The elements of a matrix, such as
 
A 11 A 12 A 13
 
A = A 21 A 22 A 23 
A 31 A 32 A 33

can be accessed with the statement A(i,j), where i and j are the row and column
numbers, respectively. A section of an array can be extracted by the use of colon no-
tation. Here is an illustration:

>> A = [8 1 6; 3 5 7; 4 9 2]
A =
8 1 6
3 5 7
4 9 2

>> A(2,3) % Element in row 2, column 3

ans =
7

>> A(:,2) % Second column

ans =
1
5
9

>> A(2:3,2:3) % The 2 x 2 submatrix in lower right corner

ans =
5 7
9 2

Array elements can also be accessed with a single index. Thus A(i) extracts the
ithelement of A, counting the elements down the columns. For example, A(7) and
A(1,3) would extract the same element from a 3 × 3 matrix.

Cells
A cell array is a sequence of arbitrary objects. Cell arrays can be created by enclosing
its contents between braces {}. For example, a cell array c consisting of three cells
can be created by

>> c = {[1 2 3], ’one two three’, 6 + 7i}

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

8 Introduction to MATLAB

c =
[1x3 double] ’one two three’ [6.0000+ 7.0000i]

As seen above, the contents of some cells are not printed in order to save space.
If all contents are to be displayed, use the celldisp command:

>> celldisp(c)
c{1} =
1 2 3
c{2} =
one two three
c{3} =
6.0000 + 7.0000i

Braces are also used to extract the contents of the cells:

>> c{1} % First cell

ans =
1 2 3
>> c{1}(2) % Second element of first cell
ans =
2
>> c{2} % Second cell
ans =
one two three

Strings
A string is a sequence of characters; it is treated by MATLAB as a character array.
Strings are created by enclosing the characters between single quotes. They are con-
catenated with the function strcat, whereas colon operator (:) is used to extract a
portion of the string. For example,

>> s1 = ’Press return to exit’; % Create a string

>> s2 = ’ the program’; % Create another string
>> s3 = strcat(s1,s2) % Concatenate s1 and s2
s3 =
Press return to exit the program
>> s4 = s1(1:12) % Extract chars. 1-12 of s1
s4 =
Press return

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

9 1.3 Operators

1.3 Operators
Arithmetic Operators
MATLAB supports the usual arithmetic operators

+ Addition
− Subtraction
∗ Multiplication
ˆ Exponentiation

When applied to matrices, they perform the familiar matrix operations, as illus-
trated below.

>> A = [1 2 3; 4 5 6]; B = [7 8 9; 0 1 2];

>> A + B % Matrix addition

ans =
8 10 12
4 6 8

>> A*B’ % Matrix multiplication

ans =
50 8
122 17

>> A*B % Matrix multiplication fails

??? Error using ==> * % due to incompatible dimensions
Inner matrix dimensions must agree.

There are two division operators in MATLAB:

/ Right division
\ Left division

If a and b are scalars, the right division a/b results in a divided by b, whereas the left
division is equivalent to b/a. In the case where A and B are matrices, A/B returns the
solution of X*A = B and A\B yields the solution of A*X = B.
Often we need to apply the *, /, and ˆ operations to matrices in an element-
by-element fashion. This can be done by preceding the operator with a period (.) as
follows:

.* Element-wise multiplication
./ Element-wise division
.ˆ Element-wise exponentiation

For example, the computation Cij = A ij Bij can be accomplished with

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

10 Introduction to MATLAB

>> A = [1 2 3; 4 5 6]; B = [7 8 9; 0 1 2];

>> C = A.*B
C =
7 16 27
0 5 12

Comparison Operators
The comparison (relational) operators return 1 for true and 0 for false. These opera-
tors are

< Less than

> Greater than
<= Less than or equal to
>= Greater than or equal to
== Equal to
˜= Not equal to

The comparison operators always act element-wise on matrices; hence, they result
in a matrix of logical type. For example,

>> A = [1 2 3; 4 5 6]; B = [7 8 9; 0 1 2];

>> A > B
ans =
0 0 0
1 1 1

Logical Operators
The logical operators in MATLAB are

& AND
| OR
˜ NOT

They are used to build compound relational expressions, an example of which is

shown below.

>> A = [1 2 3; 4 5 6]; B = [7 8 9; 0 1 2];

>> (A > B) | (B > 5)
ans =
1 1 1
1 1 1

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

11 1.4 Flow Control

1.4 Flow Control

Conditionals
if, else, elseif
The if construct

if condition
block
end

executes the block of statements if the condition is true. If the condition is false,
the block skipped. The if conditional can be followed by any number of elseif
constructs:

if condition
block
elseif condition
block
..
.
end

which work in the same manner. The else clause

..
.
else
block
end

can be used to define the block of statements which are to be executed if none of the
if–elseif clauses are true. The function signum, which determines the sign of a
variable, illustrates the use of the conditionals:
function sgn = signum(a)
if a > 0
sgn = 1;
elseif a < 0
sgn = -1;
else
sgn = 0;
end

>> signum (-1.5)

ans =
-1

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

12 Introduction to MATLAB

switch
The switch construct is

switch expression
case value1
block
case value2
block
..
.
otherwise
block
end

Here the expression is evaluated and the control is passed to the case that matches
the value. For instance, if the value of expression is equal to value2, the block of state-
ments following case value2 is executed. If the value of expression does not match
any of the case values, the control passes to the optional otherwise block. Here is
an example:

function y = trig(func,x)
switch func
case ’sin’
y = sin(x);
case ’cos’
y = cos(x);
case ’tan’
y = tan(x);
otherwise
error(’No such function defined’)
end

>> trig(’tan’,pi/3)
ans =
1.7321

Loops
while
The while construct
while condition:
block
end

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

13 1.4 Flow Control

executes a block of statements if the condition is true. After execution of the block,
condition is evaluated again. If it is still true, the block is executed again. This process
is continued until the condition becomes false.
The following example computes the number of years it takes for a $1000 princi-
pal to grow to $10,000 at 6% annual interest.

>> p = 1000; years = 0;

>> while p < 10000
years = years + 1;
p = p*(1 + 0.06);
end
>> years
years =
40

for
The for loop requires a target and a sequence over which the target loops. The form
of the construct is

for target = sequence

block
end

For example, to compute cos x from x = 0 to π/2 at increments of π /10, we

could use

>> for n = 0:5 % n loops over the sequence 0 1 2 3 4 5

y(n+1) = cos(n*pi/10);
end
>> y
y =
1.0000 0.9511 0.8090 0.5878 0.3090 0.0000

Loops should be avoided whenever possible in favor of vectorized expressions,

which execute much faster. A vectorized solution to the last computation would be

>> n = 0:5;
>> y = cos(n*pi/10)
y =
1.0000 0.9511 0.8090 0.5878 0.3090 0.0000

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

14 Introduction to MATLAB

break
Any loop can be terminated by the break statement. Upon encountering a break
statement, the control is passed to the first statement outside the loop. In the follow-
ing example, the function buildvec constructs a row vector of arbitrary length by
prompting for its elements. The process is terminated when the input is an empty
element.

function x = buildvec
for i = 1:1000
elem = input(’==> ’); % Prompts for input of element
if isempty(elem) % Check for empty element
break
end
x(i) = elem;
end

>> x = buildvec
==> 3
==> 5
==> 7
==> 2
==>
x =
3 5 7 2

continue
When the continue statement is encountered in a loop, the control is passed to
the next iteration without executing the statements in the current iteration. As an
illustration, consider the following function, which strips all the blanks from the
string s1:

function s2 = strip(s1)
s2 = ’’; % Create an empty string
for i = 1:length(s1)
if s1(i) == ’ ’
continue
else
s2 = strcat(s2,s1(i)); % Concatenation
end
end

>> s2 = strip(’This is too bad’)

s2 =
Thisistoobad

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

15 1.5 Functions

return
A function normally returns to the calling program when it runs out of statements.
However, the function can be forced to exit with the return command. In the exam-
ple below, the function solve uses the Newton–Raphson method to find the zero of
f (x) = sin x − 0.5x. The input x (guess of the solution) is refined in successive iter-
ations using the formula x ← x + x, where x = −f (x)/f  (x), until the change x
becomes sufficiently small. The procedure is then terminated with the return state-
ment. The for loop assures that the number of iterations does not exceed 30, which
should be more than enough for convergence.
function x = solve(x)
for numIter = 1:30
dx = -(sin(x) - 0.5*x)/(cos(x) - 0.5); % -f(x)/f’(x)
x = x + dx;
if abs(dx) < 1.0e-6 % Check for convergence
return
end
end
error(’Too many iterations’)

>> x = solve(2)
x =
1.8955

error
Execution of a program can be terminated and a message displayed with the error
function

error(’message’)

For example, the following program lines determine the dimensions of matrix and
aborts the program if the dimensions are not equal.
[m,n] = size(A); % m = no. of rows; n = no. of cols.
if m ˜= n
error(’Matrix must be square’)
end

1.5 Functions
Function Definition
The body of a function must be preceded by the function definition line

function [output args] = function name(input arguments)

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

16 Introduction to MATLAB

The input and output arguments must be separated by commas. The number of ar-
guments may be zero. If there is only one output argument, the enclosing brackets
may be omitted.
To make the function accessible to other program units, it must be saved under
the file name function name.m.

Subfunctions
A function M-file may contain other functions in addition to the primary function.
These so-called subfunctions can be called only by the primary function or other
subfunctions in the file; they are not accessible to other program units. Otherwise,
subfunctions behave as regular functions. In particular, the scope of variables de-
fined within a subfunction is local; that is, these variables are not visible to the calling
function. The primary function must be the first function in the M-file.

Nested Functions
A nested function is a function that is defined within another function. A nested func-
tion can be called only by the function in which it is embedded. Nested functions
differ from subfunctions in the scope of the variables: a nested subfunction has ac-
cess to all the variables in the calling function and vice versa.
Normally, a function does not require a terminating end statement. This is not
true for nested functions, where the end statement is mandatory for all functions
residing in the M-file.

Calling Functions
A function may be called with fewer arguments than appear in the function defini-
tion. The number of input and output arguments used in the function call can be
determined by the functions nargin and nargout, respectively. The following ex-
ample shows a modified version of the function solve that involves two input and
two output arguments. The error tolerance epsilon is an optional input that may
be used to override the default value 1.0e-6. The output argument numIter, which
contains the number of iterations, may also be omitted from the function call.

function [x,numIter] = solve(x,epsilon)

if nargin == 1 % Specify default value if
epsilon = 1.0e-6; % second input argument is
end % omitted in function call
for numIter = 1:100
dx = -(sin(x) - 0.5*x)/(cos(x) - 0.5);
x = x + dx;
if abs(dx) < epsilon % Converged; return to
return % calling program
end
end

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

17 1.5 Functions

error(’Too many iterations’)

>> x = solve(2) % numIter not printed

x =
1.8955

>> [x,numIter] = solve(2) % numIter is printed

x =
1.8955
numIter =
4

>> format long

>> x = solve(2,1.0e-12) % Solving with extra precision
x =
1.89549426703398
>>

Evaluating Functions
Let us consider a slightly different version of the function solve shown below. The
expression for dx, namely, x = −f (x)/f  (x), is now coded in the function myfunc,
so that solve contains a call to myfunc. This will work fine, provided that myfunc is
stored under the file name myfunc.m so that MATLAB can find it.

function [x,numIter] = solve(x,epsilon)

if nargin == 1; epsilon = 1.0e-6; end
for numIter = 1:30
dx = myfunc(x);
x = x + dx;
if abs(dx) < epsilon; return; end
end
error(’Too many iterations’)

function y = myfunc(x)
y = -(sin(x) - 0.5*x)/(cos(x) - 0.5);

>> x = solve(2)
x =
1.8955

In the above version of solve the function returning dx is stuck with the name
myfunc. If myfunc is replaced with another function name, solve will not work

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

18 Introduction to MATLAB

unless the corresponding change is made in its code. In general, it is not a good
idea to alter computer code that has been tested and debugged; all data should be
communicated to a function through its arguments. MATLAB makes this possible by
passing the function handle of myfunc to solve as an argument, as illustrated below.

function [x,numIter] = solve(func,x,epsilon)

if nargin == 2; epsilon = 1.0e-6; end
for numIter = 1:30
dx = feval(func,x); % feval is a MATLAB function for
x = x + dx; % evaluating a passed function
if abs(dx) < epsilon; return; end
end
error(’Too many iterations’)

>> x = solve(@myfunc,2) % @myfunc is the function handle

x =
1.8955

The call solve(@myfunc,2)creates a function handle to myfunc and passes it

to solve as an argument. Hence the variable func in solve contains the handle
to myfunc. A function passed to another function by its handle is evaluated by the
MATLAB function

feval(function handle, arguments)

It is now possible to use solve to find a zero of any f (x) by coding the function
x = −f (x)/f  (x) and passing its handle to solve.

Anonymous Functions
If a function is not overly complicated, it can be represented as an anonymous func-
tion. The advantage of an anonymous function is that it is embedded in the program
code rather than residing in a separate M-file. An anonymous function is created with
the command

function handle = @(arguments)expression

which returns the function handle of the function defined by expression. The input
arguments must be separated by commas. Being a function handle, an anonymous
function can be passed to another function as an input argument. The following
shows how the last example could be handled by creating the anonymous function
myfunc and passing it to solve.

>> myfunc = @(x) -(sin(x) - 0.5*x)/(cos(x) - 0.5);

>> x = solve(myfunc,2) % myfunc is already a function handle; it
% should not be input as @myfunc

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

19 1.6 Input/Output

x =
1.8955

We could also accomplish the task with a single line:

>> x = solve(@(x) -(sin(x) - 0.5*x)/(cos(x) - 0.5),2)

x =
1.8955

Inline Functions
Another means of avoiding a function M-file is by creating an inline object from a
string expression of the function. This can be done by the command

function name = inline( expression ,  arg1 ,  arg2  , . . .)

Here expression describes the function and arg1, arg2, . . . are the input arguments. If
there is only one argument, it can be omitted. An inline object can also be passed to
a function as an input argument, as seen in the following example.

>> myfunc = inline(’-(sin(x) - 0.5*x)/(cos(x) - 0.5)’,’x’);

>> x = solve(myfunc,2)
x =
1.8955

1.6 Input/Output
Reading Input
The MATLAB function for receiving user input is

value = input(’prompt ’)

It displays a prompt and then waits for input. If the input is an expression, it is evalu-
ated and returned in value. The following two samples illustrate the use of input:
>> a = input(’Enter expression: ’)
Enter expression: tan(0.15)
a =
0.1511

>> s = input(’Enter string: ’)

Enter string: ’Black sheep’
s =
Black sheep

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

20 Introduction to MATLAB

Printing Output
As mentioned before, the result of a statement is printed if the statement does not end
with a semicolon. This is the easiest way of displaying results in MATLAB. Normally
MATLAB displays numerical results with about five digits, but this can be changed
with the format command:

format long switches to 16-digit display

format short switches to 5-digit display

To print formatted output, use the fprintf function:

fprintf(’format ’, list )

where format contains formatting specifications and list is the list of items to be
printed, separated by commas. Typically used formatting specifications are

%w.d f Floating point notation

%w .d e Exponential notation
\n Newline character

where w is the width of the field and d is the number of digits after the decimal point.
Line break is forced by the newline character. The following example prints a format-
ted table of sin x versus x at intervals of 0.2:

>> x = 0:0.2:1;
>> for i = 1:length(x)
fprintf(’%4.1f %11.6f\n’,x(i),sin(x(i)))
end
0.0 0.000000
0.2 0.198669
0.4 0.389418
0.6 0.564642
0.8 0.717356
1.0 0.841471

1.7 Array Manipulation

Creating Arrays
We learned before that an array can be created by typing its elements between
brackets:

>> x = [0 0.25 0.5 0.75 1]

x =
0 0.2500 0.5000 0.7500 1.0000

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

21 1.7 Array Manipulation

Colon Operator
Arrays with equally spaced elements can also be constructed with the colon operator.

x = first elem:increment:last elem

For example,

>> x = 0:0.25:1
x =
0 0.2500 0.5000 0.7500 1.0000

linspace
Another means of creating an array with equally spaced elements is the linspace
function. The statement

x = linspace(xfirst ,xlast ,n)

creates an array of n elements starting with xfirst and ending with xlast. Here is an
illustration:

>> x = linspace(0,1,5)
x =
0 0.2500 0.5000 0.7500 1.0000

logspace
The function logspace is the logarithmic counterpart of linspace. The call

x = logspace(zfirst ,zlast ,n)

creates n logarithmically spaced elements starting with x = 10zfir st and ending with
x = 10zlast . Here is an example:

>> x = logspace(0,1,5)
x =
1.0000 1.7783 3.1623 5.6234 10.0000

zeros
The function call

X = zeros(m,n)

returns a matrix of m rows and n columns that is filled with zeros. When the function
is called with a single argument, for example, zeros(n), an n × n matrix is created.

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

22 Introduction to MATLAB

ones

X = ones(m,n)

The function ones works in the manner as zeros, but fills the matrix with ones.

rand

X = rand(m,n)

This function returns a matrix filled with random numbers between 0 and 1.

eye
The function eye

X = eye(n)

creates an n × n identity matrix.

Array Functions
There are numerous array functions in MATLAB that perform matrix operations and
other useful tasks. Here are a few basic functions:

length
The length n (number of elements) of a vector x can be determined with the function
length:

n = length(x)

size
If the function size is called with a single input argument:

[m,n] = size(X )

it determines the number of rows m and the number of columns n in the matrix X. If
called with two input arguments:

m = size(X ,dim)

it returns the length of X in the specified dimension (dim = 1 yields the number of
rows, and dim = 2 gives the number of columns).

reshape
The reshape function is used to rearrange the elements of a matrix. The call

Y = reshape(X ,m,n)

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

23 1.7 Array Manipulation

returns an m × n matrix the elements of which are taken from matrix X in the
column-wise order. The total number of elements in X must be equal to m × n. Here
is an example:

>> a = 1:2:11
a =
1 3 5 7 9 11
>> A = reshape(a,2,3)
A =
1 5 9
3 7 11

dot

a = dot(x,y )

This function returns the dot product of two vectors x and y which must be of the
same length.

prod

a = prod(x)

For a vector x, prod(x) returns the product of its elements. If x is a matrix, then a is
a row vector containing the products over each column. For example,

>> a = [1 2 3 4 5 6];
>> A = reshape(a,2,3)
A =
1 3 5
2 4 6

>> prod(a)
ans =
720

>> prod(A)
ans =
2 12 30

sum

a = sum(x)

This function is similar to prod, except that it returns the sum of the elements.

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

24 Introduction to MATLAB

cross

c = cross(a,b)

The function cross computes the cross product: c = a × b, where vectors a and b
must be of length 3.

1.8 Writing and Running Programs

MATLAB has two windows available for typing program lines: the command window
and the editor/debugger. The command window is always in the interactive mode, so
that any statement entered into the window is immediately processed. The interac-
tive mode is a good way to experiment with the language and try out programming
ideas.
MATLAB opens the editor window when a new M-file is created, or an existing
file is opened. The editor window is used to type and save programs (called script
files in MATLAB) and functions. One could also use a text editor to enter program
lines, but the MATLAB editor has MATLAB-specific features, such as color coding and
automatic indentation, that make work easier. Before a program or function can be
executed, it must be saved as a MATLAB M-file (recall that these files have the .m
extension). A program can be run by invoking the run command from the editor’s
debug menu.
When a function is called for the first time during a program run, it is compiled
into P-code (pseudo-code) to speed up execution in subsequent calls to the func-
tion. One can also create the P-code of a function and save it on disk by issuing the
command

pcode function name

MATLAB will then load the P-code (which has the .p extension) into the memory
rather than the text file.
The variables created during a MATLAB session are saved in the MATLAB
workspace until they are cleared. Listing of the saved variables can be displayed by
the command who. If greater detail about the variables is required, type whos. Vari-
ables can be cleared from the workspace with the command

clear a b . . .

which clears the variables a, b, . . .. If the list of variables is omitted, all variables are
cleared.
Assistance on any MATLAB function is available by typing

help function name

in the command window.

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

25 1.9 Plotting

1.9 Plotting

MATLAB has extensive plotting capabilities. Here we illustrate some basic commands
for two-dimensional plots. The example below plots sin x and cos x on the same plot.

% Plot example
x = 0:0.05*pi:2*pi; % Create x-array
y = sin(x); % Create y-array
plot(x,y,’k-o’) % Plot x-y points with specified color
% (’k’ = black) and symbol (’o’ = circle)
hold on % Allows overwriting of current plot
z = cos(x); % Create z-array
plot(x,z,’k-x’) % Plot x-z points (’x’ = cross)
grid on % Display coordinate grid
xlabel(’x’) % Display label for x-axis
gtext(’sin x’) % Create mouse-movable text (move cross-
gtext(’cos x’) % hairs to the desired location and
% press ’Enter’)

0.8

0.6

0.4

0.2
sin x
0

−0.2

−0.4
cos x
−0.6

−0.8

−1
0 1 2 3 4 5 6 7
x

A function stored in an M-file can be plotted with a single command, as shown

below.

function y = testfunc(x) % Stored function

y = (x.ˆ3).*sin(x) - 1./x;

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press

P1: PHB
cuus734 CUUS734/Kiusalaas 0 521 19133 3 August 29, 2009 12:17

26 Introduction to MATLAB

>> fplot(@testfunc,[1 20]) % Plot from x = 1 to 20

>> grid on

8000

6000

4000

2000

−2000

−4000

−6000
2 4 6 8 10 12 14 16 18 20

https://doi.org/10.1017/CBO9780511812200.003 Published online by Cambridge University Press