matlabprogrammingbylindacoulson
TRANSCRIPT
-
8/9/2019 MATLABProgrammingbyLindaCoulson
1/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
2/86
First Edition, 2009
ISBN 978 93 80168 38 8
All rights reserved.
Published by:
Global Media
1819, Bhagirath Palace,Chandni Chowk, Delhi-110 006Email: [email protected]
-
8/9/2019 MATLABProgrammingbyLindaCoulson
3/86
Table of Contents
1. Basic MATLAB Concepts
2.Data Storage and Manipulation
3. Graphics
4. M File Programming
5. Mathematical Manipulations
6. More advanced I-O & Examples
7. Object-Oriented Programming
8. Comparing Octave and MATLAB
9. Toolboxes
-
8/9/2019 MATLABProgrammingbyLindaCoulson
4/86
Basic MATLAB Concepts
The Current Directory and Defined Path
It is necessary to declare a current directory before saving a file, loading a file, or runningan M-file. By default, unless you edit the MATLAB shortcut, the current directory will
be .../MATLAB/work. After you start MATLAB, change the current directory by either
using the toolbar at the left-hand side of the screen, or entering the path in the bar at the
top.
The current directory is the directory MATLAB will look in first for a function you try tocall. Therefore if you have multiple folders and each of them has an M-file of the same
name, there will not be a discrepancy if you set the current directory beforehand. The
current directory is also the directory in which MATLAB will first look for a data file.
If you still want to call a function but it is not part of the current directory, you mustdefine it using MATLAB's 'set path' utility. To access this utility, follow the path:
file > set path... > add folder...
You could also go to "add folder with subfolders...", if you're adding an entire group ,as
you would if you were installing a toolbox. Then look for and select the folder you want.
If you forget to do this and attempt to access a file that is not part of your defined path
list, you will get an 'undefined function' error.
Saving Files
There are many ways to save to files in MATLAB.
save - saves data to files, *.mat by default uisave - includes user interface hgsave - saves figures to files, *.fig by default diary [filename] - saves all the text input in the command window to a text file.
All of them use the syntax:
save filename.ext
or similar for the other functions. The files are saved in your current directory, as seen on
the top of the window. By default the current directory is .../MATLAB/work.
Loading Files
-
8/9/2019 MATLABProgrammingbyLindaCoulson
5/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
6/86
run the executable file to obtain a result. Instead, MATLAB simply goes line by line and
performs the calculations without the need for an executable.
Partly because of this, it is possible to do calculations one line at a time at the command
line using the same syntax as would be used in a file. It's even possible to write loops and
branches at the command line if you want to! Of course this would lead to a lot of wastedeffort a lot of the time, so doing anything beyond very simple calculations, testing to see
if a certain function, syntax, etc. works, or calling a function you put into an .m file
should be done within an .m file.
Calculator
MATLAB, among other things, can perform the functions of a simple calculator from the
command line. Let us try to solve a simple problem: Sam's car's odometer reading was
3215 when he last filled the fuel tank. Yesterday he checked his odometer and it read3503. He filled the tank and noticed that it took 10 gallons to do that. If his car's gas tank
holds 15.4 gallons, how long can he drive before he is going to run out of gas, assumingthe gas mileage is the same as before?
First let us compute the distance Sam's car has travelled in between the two gas fillings
>> 3503-3215
ans =
288
Gas mileage of Sam's car is
>> 288/10
ans =
28.8
With this, he can drive
>> 28.8 * 15.4
ans =
443.5200
443.52 miles before he runs out of gas.
Let us do the same example, now by creating named variables
>> distance = 3503-3215
distance =
288
>> mileage = distance/10
mileage =
28.8000
>> projected_distance = mileage * 15.4
projected_distance =
-
8/9/2019 MATLABProgrammingbyLindaCoulson
7/86
443.5200
To prevent the result from printing out in the command window, use a semicolon afterthe statement. The result will be stored in memory. You can then access the variable by
calling its name. Example:
>>projected_distance = mileage * 15.4;
>>
>>projected_distance
projected_distance =
443.5200
Using the command line to call functions
The command line can be used to call any function that's in a defined path. To call a
function, the following general syntax is used:
>> [Output variable 1, output variable 2, ...] = functionname(input 1,input 2, input 3,...)
MATLAB will look for a file calledfunctionname.m and will execute all of the codeinside it until it either encounters an error or finishes the file. If the former is true, you'll
hear an annoying noise and will get an error message in red. In the latter case, MATLABwill relinquish control to you, which you can see when the >> symbol is visible on the
bottom of the workspace and the text next to "start" button on the bottom-left of the
screen says "ready".
Use this in order to call homemade functions as well as those built into MATLAB.
MATLAB has a large array of functions, and the help file as well as this book are goodplaces to look for help on what you need to provide as inputs and what you will get back.
BE CAREFUL because the syntax for functions and for indexing arrays is the same! To
avoid confusion, just make sure you don't name a variable the same as any function. Toensure this, type the name of the variable you want to define in the command prompt. If it
tells you:
Error using ==> (functionname)
Not enough input arguments.
then you'll have a conflict with an existing function. If it tells you:
??? Undefined function or variable '(functionname)'
you'll be OK.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
8/86
Reading and Writing from a file:
Command Line
Reading and Writing data from/to a .mat file
The quickest mean of saving and retrieving data is through the binary .mat file format
MATLAB provides. This is the native format for MATLAB.
Note: This author has had some problems with certain classes not being savedcorrectly when saving data using version 7 for use in version 6. Most data itemswill work just fine. Of particular interest was an issue with State-Space objects
that were saved using version 7 to a version 6 compatible file. When the file was
opend in MATLAB version 6+ the State-Space objects did not load.Spradlig
(talk) 04:52, 31 March 2008 (UTC)
Saving Data
The save command is the used to save workspace data to a file.
Save all workspace data to the file mySave.mat in the current directory.>> save('mySave.mat')
>> save(fullfile(pwd, 'mySave.mat'))
Save just the variables myData1 and myData2 to mySave.mat.>> save('mySave.mat', 'myData1', 'myData2')
Save all myData variables to mySave.mat.>> save('mySave.mat', 'myData*')
Save all myData variables to a mySave.mat file compatible with version 6of MATLAB.
>> save('mySave.mat', 'myData*', '-v6')
Save all myData variables to an ASCII file.>> save('mySave.txt', 'myData*', '-ASCII')
Append new variables to the data file.>> save('mySave.mat', 'newData*', '-append')
-
8/9/2019 MATLABProgrammingbyLindaCoulson
9/86
Loading Data
The load command is used to load data from a file into the current workspace.
Load all variables from the file mySave.mat into the current workspace.>> load('mySave.mat')
>> load(fullfile(pwd, 'mySave.mat'))
Load just the variables myData1 and myData2.>> load('mySave.mat', 'myData1', 'myData2')
Load all myData variables.>> load('mySave.mat', 'myData*')
Get a cell array of variables in saved file.>> whos('-file', 'mySave.mat')
Reading and Writing from an Excel spreadsheet
Since analyzing data is one of the more common motivations for using input output I will
start with reading and writing from a spreadsheet. I cover the command line first since it
is often necessary to import the data while an m-function is being evaluated.
MATLAB makes it easy to read from an Excel spreadsheet. It has the built in command
"xlsread". To use thexlsreadfunction use the syntax:
>>g=xlsread('filename');
This line of code readsfilename.xls (from the current directory) and places it in anidentical array inside MATLAB called g. You can then manipulate the array g any way
you want. Make sure that the file you choose is in the same directory were you save your
M-files (usually the work directory) otherwise you get an error. You can specify the path
to a file but, this can get messy.
To write data to an .xls the procedure is very similar. Thexlswrite command below
creates a spreadsheet calledfilename.xls in the current directory from the variable g:
>> xlswrite('filename',g);
NOTE: if you are using MATLAB 6.5 there is no "xlswrite" command (that I'm aware
of). There are several ways to write to a file. The simplest way I have found is
fid=fopen('newFile.xls', 'w');
-
8/9/2019 MATLABProgrammingbyLindaCoulson
10/86
fprintf(fid,'%6.3f %6.3f %10.3f\n', g);
fclose(fid);
You can substitute newFile.xls with .txt. Also, there might be some issues withformatting in Excel. The formatting issues can usually be handled inside Excel but if they
can't you might have to play around with the fopen command parameters. This is pretty
similar (if not the same) way you would write to a file in C.
Reading and Writing from and to other text files
If a file is not an excel spreadsheet, it can still be read using "load" function:
>> load newfile.txt
This works only if the text is entirely numerical, without special formatting. Otherwise
you get a 'unrecognized character' error.
The easiest way to write to a non-excel file, or using MATLAB 6.5 or less, is to use the
same code as that for writing excel files but change the extension. Usually there are no
formatting difficulties with plain text files.
Reading and Writing from a data file: GUI
MATLAB contains a nice GUI application that will guide you through importing data
from any recognized data file (usually .mat, .txt, or .xls on a Windows system). To use it,
go to file > import data, and select the file you want. Then, choose what column
separators are present (by selecting the appropriate radio button). Finally, click "next".
MATLAB saves the variable under a name similar to that of the file, but with
modifications to make it conform with MATLAB syntax. Spaces are omitted, plusses and
minuses are turned into other characters. To see the name MATLAB generated (and
probably change it) type "who" in the command prompt.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
11/86
Data Storage and Manipulation
Data Types and Operations on Point Values
Introduction
A large number of MATLAB's functions are operations on two types of numbers:
rational numbers and boolean numbers.
Rational numbers are what we usually think of when we think of what a number is. 1, 3,and -4.5 are all rational numbers. MATLAB stores rational numbers as doubles by
default, which is a measure of the number of decimal places that are stored in each
variable and thus of how accurate the values are. Note that MATLAB representsirrational numbers such as pi with rational approximations, except when using the
symbolic math toolbox. See that section for details.
Boolean numbers are either "TRUE" or "FALSE", represented in MATLAB by a 1 and a0 respectively. Boolean variables in MATLAB are actually interchangable with doubles,
in that boolean operators can be performed with arrays of doubles and vice versa. Any
non-zero number in this case is considered "TRUE".
Most of the rational operators also work with complex numbers. Complex numbers,
however, cannot be interchanged with boolean values like the real rationals can. See the
complex numbers section for details on how to use them.
Rational Operators on Single ValuesMATLAB has all the standard rational operators. It is important to note, however, that
Unless told otherwise, all rational operations are done on entire arrays, and use the
matrix definitions. Thus, even though for now we're only talking about operations on a
single value, when we get into arrays, it will be important to distinguish between matrix
and componentwise multiplication, for example.
Add, Subtract, multiply, divide, exponent operators:
%addition
a = 1 + 2
%subtractionb = 2 - 1
%matrix multiplication
c = a * b
%matrix division (pseudoinverse)
d = a / b
%exponentiation
e = a ^ b
-
8/9/2019 MATLABProgrammingbyLindaCoulson
12/86
The modulo function returns the remainder when the arguments are divided together, so a
modulo b means the remainder when a is divided by b.
%modulo
remainder = mod(a,b)
All of these functions except for the modulus work for complex numbers as well.
Boolean Operators on Single Values
The boolean operators are & (boolean AND) | (boolean OR) and ~ (boolean NOT
/negation). A value of zero means false, any non-zero value (usually 1) is considered true.
Here's what they do:
>>%boolean AND
>> y = 1 & 0
y = 0
>> y = 1 & 1
y = 1
>>%boolean OR
>> y = 1 | 0
y = 1
>> y = 1 | 1
y = 1
The negation operation in MATLAB is given by the symbol ~, which turns any FALSE
values into TRUE and vice versa:
>> c = (a == b)c = 1
>> ~c
ans = 0
This is necessary because conditionals (IF/SWITCH/TRY) and loops (FOR/WHILE)
always look for statements that are TRUE, so if you want it to do something only when
the statement is FALSE you need to use the negation to change it into a true statement.
The NOT operator has precedence over the AND and OR operators in MATLAB unless
the AND or OR statements are in parenthesis:
>> y = ~1 & 0y = 0
>> y = ~(1&0)
y = 1
Relational Operators
-
8/9/2019 MATLABProgrammingbyLindaCoulson
13/86
Equality '==' returns the value "TRUE" (1) if both arguments are equal. This must not be
confused with the assignment operator '=' which assigns a value to a variable.
>> %relational
>>a=5;b=5;
>>a==b
ans = 1%Assignment
>>a=5;b=3;
>>a=b
a = 3
Note that in the first case, a value of 1 (true) is returned, however for the second case a
gets assigned the value of b.
Greater than, less than and greater than or equal to, less than or equal to are given by >, =, >a=3;b=5;>>a>b> fstring = 'hello'
fstring =
hello
If you would like to include a single quote this is one way to do it:
>> fstring = ''''
fstring =
'
>> fstring = 'you''re'
fstring =
you're
An important thing to remember about strings is that MATLAB treats them as array ofcharacters. To see this, try executing the following code:
-
8/9/2019 MATLABProgrammingbyLindaCoulson
14/86
>> fstring = 'hello';
>> class(fstring)
ans = char
Therefore, many of the array manipulation functions will work the same with these arraysas any other, such as the 'size' function, transpose, and so on. You can also access specific
parts of it by using standard indexing syntax.
Attempting to perform arithmetic operations on character arrays converts them into
doubles.
>> fstring2 = 'world';
>> fstring + fstring2
ans = 223 212 222 216 211
These numbers come from the standard numbers for each character in the array. These
values are obtained by using the 'double' function to turn the array into an array of
doubles.
>> double(fstring)
ans = 104 101 108 108 111
The 'char' function can turn an array of integer-valued doubles back into characters.Attempting to turn a decimal into a character causes MATLAB to round down:
>> char(104.6)
ans = h
>> char(104)
ans = h
Since the MATLAB strings are treated as character arrays, they have some special
functions if you wish to compare the entire string at once rather than just its components:
findstr(bigstring, smallstring) looks to see if a small string is contained in a bigger
string, and if it is returns the index of where the smaller string starts. Otherwise it
returns [].strrep(string1, replaced, replacement) replaces all instances ofreplacedin string1
with replacement
Displaying values of string variables
If all you want to do is display the value of a string, you can omit the semicolon as is
standard in MATLAB.
If you want to display a string in the command window in combination with other text
you must use array notation combined with either the 'display' or the 'disp' function:
>> fstring = 'hello';
-
8/9/2019 MATLABProgrammingbyLindaCoulson
15/86
>> display( [ fstring 'world'] )
helloworld
MATLAB doesn't put the space in between the two strings. If you want one there youmust put it in yourself.
This syntax is also used to concatenate two or more strings into one variable, which
allows insertion of unusual characters into strings:
>> fstring = ['you' char(39) 're']
fstring = you're
Any other function that returns a string can also be used in the array.
Comparing strings
Unlike with rational arrays, strings will not be compared correctly with the relational
operator, because this will treat the string as an array of characters. To get the comparison
you probably intended, use the strcmp function as follows:
>> string1 = 'a';
>> strcmp(string1, 'a')
ans = 1
>> strcmp(string1, 'A')
ans = 0
Note that MATLAB strings are case sensitive so that 'a' and 'A' are not the same. In
addition the strcmp function does notdiscard whitespace:
>> strcmp(string1, ' a')
ans = 0
The strings must be exactly the same in every respect.
If the inputs are numeric arrays then the strcmp function will return 0 even if the values
are the same. Thus it's only useful for strings. Use the == operator for numeric values.
>> strcmp(1,1)
ans = 0.
This section discusses inline functions, anonymous functions, and function handles. Each
of these isportable in that rather than having to write an equation multiple times in aprogram, you can just define it once and then call it whenever you want to use it. In
addition, function handles in particular allow you to pass an equation to another function
for direct evaluation as needed. Inline and anonymous functions are useful for command-
line evaluation or for multiple evaluations in the same m-file.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
16/86
Inline functions
An inline function is one way that a function can be created at the command or in a
script:
>>f = inline('2*x^2-3*x+4','x');>>f(3)
ans = 13
To create a multi-variable inline function, send more inputs to the 'inline' function:
>> f = inline('2*x*y', 'x', 'y');
>> f(2,2)
ans = 8
You cannot make an array of inline functions, MATLAB will tell you that you have toomany inputs or do something weird like that.
Anonymous functions
A function can also be created at the command or in a script:
>>f = @(x) 2*x^2-3*x+4;
>>f(3)
ans = 13
To make an anonymous function of multiple variables, use a comma-separated list todeclare the variables:
>>f = @(x,y) 2*x*y;
>>f(2,2)
ans = 8
It is possible to make an array of anonymous functions in MATLAB 7.1 but this willbecome outdated soon so using this construct in a distributed program is not
recommended.
To pass anonymous functions to other functions, just use the name of the anonymous
function in your call:
>> f = @(t,x) x;
>> ode45(f, [0:15],1)
Function Handles
-
8/9/2019 MATLABProgrammingbyLindaCoulson
17/86
A function handle passes an m-file function into another function. This of course lets you
have more control over what's passed there, and makes your program more general as itlets you pass any m-file (as long as it meets other requirements like having the right
number of input arguments and so on).
To pass an m-file to a function, you must first write the m-file, say something like this:
function xprime = f(t,x)
xprime = x;
Save it as myfunc.m. To pass this to another function, say an ODE integrator, use the @
symbol as follows:
>> ode45(@myfunc, [0:15], 1)
One advantage of using function handles over anonymous functions is that you canevaluate more than one equation in the m-file, thus allowing you to do things like solve
systems of ODEs rather than only one. Anonymous functions limit you to one equation.
Declaring a complex number in MATLAB
Complex numbers in MATLAB are doubles with a real part and an imaginary part. The
imaginary part is declared by using the 'i' or 'j' character. For example, to declare a
variable as '1 + i' just type:
>> compnum = 1 + i
compnum = 1.000 + 1.000i
>> compnum = 1 + j
compnum = 1.000 + 1.000i
Note that if you use j MATLAB still displays i on the screen.
Since i is used as the complex number indicator it is not recommended to use it as a
variable, since it will assume it's a variable if given a choice.
>> i = 3; %bad idea
>> a = 1 + i
a = 4
However, since implicit multiplication is not normally allowed in MATLAB, it is stillpossible to declare a complex number like this:
>> i = 3;
>> a = 1i + 1
a = 1.000 + 1.000i
-
8/9/2019 MATLABProgrammingbyLindaCoulson
18/86
It's best still not to declare i as a variable, but if you already have a long program with i as
a variable and need to use complex numbers this is probably the best way to get around it.
If you want to do arithmetic operations with complex numbers make sure you put the
whole number in parenthesis, or else it likely will not give the intended results.
Arithmetic operations that create complex numbers
There are several operations that create complex numbers in MATLAB. One of them is
taking an even root of a negative number, by definition.
>> (-1)^0.5
ans = 0.000 + 1.000i
>> (-3)^0.25
ans = 0.9306 + 0.9306i
As a consequence of the Euler formula, taking the logarithm of a negative number also
results in imaginary answers.
>> log(-1)
ans = 0 + 3.1416i
In addition, the roots of functions found with the 'roots' function (for polynomials) orsome other rootfinding function will often return complex answers.
MATLAB functions to manipulate complex values
First of all, it is helpful to tell whether a given matrix is real or complex whenprogramming, since certain operations can only be done on real numbers. Since complex
numbers don't have their own class, MATLAB comes with another function called 'isreal'
to determine if a given matrix is real or not. It returns 0 if any of the inputs are complex.
>> A = [1 + i, 3];
>> isreal(A)
ans = 0
>> isreal(A(2))
ans = 1
Notice that it is possible to have real and complex numbers in the same array, since both
are of class double. The function is set up this way so that you can use this as part of aconditional, so that a block only is executed if all elements of array A are real.
To extract just the real part of a complex variable use the 'real' function. To extract just
the complex part use the 'imag' function.
>> real(A)
ans = 1 3
>> imag(A)
-
8/9/2019 MATLABProgrammingbyLindaCoulson
19/86
ans = 1 0
One thing you may need to do is perform an operation on the real values of an array butnot the complex values. MATLAB does not have a function to directly do this, but the
following pair of commands lets you put only the real values into another array:
>> RealIndex = (imag(A) == 0); %if imaginary part is zero then the
number is real)
>> RealOnly = A(RealIndex)
RealOnly = 3
Arrays and Matrices
Introduction to Arrays
Arrays are the fundamental data type of MATLAB. Indeed, the former data typespresented here, strings and number, are particular cases of arrays. As in many traditional
languages, arrays in MATLAB are a collection of several values of the same type (bydefault, the type is equivalent to the C type double on the same architecture. On x86 andpowerpc, it is a floating point value of 64 bits). They are indexed through the use of a
single integer or, to get more than one value, an array of integers..
Declaring Arrays
Row and Column Arrays
A simple way to create a row array is to give a comma separated list of values inside
brackets:
>> array = [0, 1, 4, 5]
array =
0 1 4 5
The commas can be omitted for a row array because MATLAB will assume you want arow array if you don't give it any separators. However, the commas make it easier to read
and can help with larger arrays. The commas indicate that the array will be a horizontal
array.
To make a column array you can use semicolons to separate the values.
>> column = [1; 2; 3]
column =
1
2
3
-
8/9/2019 MATLABProgrammingbyLindaCoulson
20/86
All elements of an array must be the same data type, so for example you cannot put a
function handle and a double in the same array.
Declaring multi-dimensional arrays
Arrays can be multi-dimensional. To create a 2 dimensional array (a matrix in LinearAlgebra terms), we have to give a list of comma separated values, and each row should
be separated by a semi colon:
>> matrix = [1, 2, 3; 4, 5, 6]
matrix =
1 2 3
4 5 6
In MATLAB the term array is synonymous with matrix and will more often than not bereferred to as a matrix. It should be noted that a matrix, as its mathematical equivalent,
requires all its rows and all its columns to be the same size:
>> matrix = [1, 2, 3; 4, 5]
??? Error using ==> vertcat
All rows in the bracketed expression must have the same
number of columns.
Properties of MATLAB arrays and matrices
Contrary to low level languages such as C, an array in MATLAB is a more high level
type of data: it contains various information about its size, its data type, and so on.
>> array = [0,1,4,5];>> length(array)
ans = 4
>> class(array)
ans = double
The number of rows and columns of the matrix can be known through the built-in sizefunction. Following the standard mathematical convention, the first number is the number
of rows and the second is the number of columns:
>> matrix = [1, 2, 3; 4, 5, 6];
>> size(matrix)
ans =
2 3
The goal of MATLAB arrays is to have a type similar to mathematical vectors and
matrices. As such, row and column arrays are not equivalent. Mono-dimensional arraysare actually a special case of multi-dimensional arrays, and the 'size' function can be used
for them as well.
>> size(array)
-
8/9/2019 MATLABProgrammingbyLindaCoulson
21/86
ans =
1 4
Row and column do not have the same size, so they are not equivalent:
>> size(column)
ans =3 1
>> size(row)
ans =
1 3
Why Use Arrays?
A major advantage of using arrays and matrices is that it lets you avoid using loops to
perform the same operation on multiple elements of the array. For example, suppose youwanted to add 3 to each element of the array [1,2,3]. If MATLAB didn't use arrays you
would have to do this using a FOR loop:
>> array = [1,2,3];
>> for ii = 1:3
array(ii) = array(ii) + 3;
>> end
>> array
array = [4,5,6]
Doing this is not efficientin MATLAB, and it will make your programs run very slowly.Instead, you can create another array of 3s and add the two arrays directly. MATLAB
automatically separates the elements:
>> array = [1,2,3];
>> arrayofthrees = [3,3,3];
>> array = array + arrayofthrees
array = [4,5,6];
If all you are doing is adding a constant, you can also omit the declaration of'arrayofthrees', as MATLAB will assume that the constant will be added to all elements
of the array. This is very useful, for example if you use an array with variable size:
>> array = [1,2,3];
>> array + 3
ans = [4,5,6]
The same rule applies to scalar multiplication.
See Introduction to array operations for more information on the operations MATLAB
can perform on arrays.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
22/86
Arrays are a fundamental principle of MATLAB, and almost everything in MATLAB is
done through a massive use of arrays. To have a deeper explanation of arrays and their
operations, see Arrays and matrices.
Introduction to array operations
As arrays are the basic data structure in MATLAB, it is important to understand how to
use them effectively. See the previous section for that.
Arrays in MATLAB obey the same rule as their mathematical counterpart: by default, thematrix definitions of operations are used, unless a special operator called the dot operator
is applied.
Because arrays operations are so similar to the equivalent mathematical operations, abasic knowledge of linear algebra is mandatory to use matlab effectively. However, we
won't be as precise as in mathematics when using the terms vector and matrix. In
MATLAB, both are arrays of doubles (thus being a matrix in the real mathematicalmeaning), and MATLAB considers vectors as a matrics with only one row or only one
column. However, there are special functions just for vectors; see the vector module for
an explanation of how to use these.
Basics
How to input an array
The common way to input an array from the matlab command line is to put the input
figures into list into square brackets:
>> [1, 2, 3]
ans =
1 2 3
Comma is used to separate columns elements, and semicolon is used to separate rows. So
[1, 2, 3] is a row vector, and [1; 2; 3] is a column vector
>> [1; 2; 3]
ans =
1
2
3
If a blankspace is used to seperate elements, the default separator is comma, thus making
the vector a row vector.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
23/86
Logically, inputing a matrix is done by using a comma separated list of column vectors,
or a semicolon seperated list of row vectors:
>> [1, 2, 3; 4, 5, 6]
ans =
1 2 3
4 5 6
Variable assignment
To reuse an array in subsequent operations, one should assign the array to a variable.
Variable assignement is done through the equal symbol:
>> a = [1, 2, 3]
a =
1 2 3
Notice that instead of ans =, the name of the variable is displayed by matlab. If you forgetto assign the last statement to a variable, the variable ans always point to the last non
assigned:
>> [1, 2, 3]
ans =
1 2 3
>> a = ans
a =
1 2 3
But:
>> [1, 2, 3]
ans =
1 2 3
>> b = [4, 5, 6]
b =
4 5 6
>> a = ans
a =
-
8/9/2019 MATLABProgrammingbyLindaCoulson
24/86
1 2 3
Ie ans is really the last non assigned result, and not the result of the last statement.
As it is the case for most interpreted languages, you do not need to declare a variable
before using it, and reusing a variable name in an assignement will overwrite the previous
content.
To avoid cluttering the command line of matlab, you can postfix any command with a
semicolon:
>> a = [1, 2, 3];
Accessing elements of a matrix
Now that you know how to define a simple array, you should know how to access its
elements. Accessing the content of an array is done through the operator (), with theindex inside the parenthesis; the indexing of the first element is 1:
>> a = [1, 2, 3];
>> a(1)
ans =
1
>> a(3)
ans =
3
Accessing an element outside the bounds will result in an error:
>> a(5)
??? Index exceeds matrix dimensions.
To access a single matrix element, you can use the (i,j) subscript, where i is the index in
the row, and j in the column:
>> a= [1, 2; 3, 4];
>> a(1, 2)
ans =
2
>> a(2, 1)
ans =
-
8/9/2019 MATLABProgrammingbyLindaCoulson
25/86
3
You can also access a matrix element through a unique index; in this case, the order iscolumn major, meaning you first go through all elements of the first column, then the 2d
column, etc... The column major mode is the same than in Fortran, and the contrary of theorder in the C language.
>> a = [1, 2, 3; 4, 5, 6];
>> a(3)
ans =
2
It is also possible to access blocks of matrices using the colon (:) operator. This operator
is like a wildcard; it tells MATLAB that you want all elements of a given dimension orwith indices between two given values. For example, say you want to access the entire
first row of matrix a above, but not the second row. Then you can write:
>> a = [1, 2, 3; 4, 5, 6];
>> a(1,:) %row 1, every column
ans =
1 2 3
Now say you only want the first two elements in the first row. To do this, use thefollowing syntax:
>> a = [1, 2, 3; 4, 5, 6];>> a(1, 1:2)
ans =
1 2
The syntax a(:) changes a into a column vector (column major):
>> a = [1, 2, 3; 4, 5, 6]
>> a(:)
ans =
1
4
2
5
3
6
Finally, if you do not know the size of an array but wish to access all elements from a
certain index until the end of the array, use the end operator, as in
>> a = [1, 2, 3; 4, 5, 6]
-
8/9/2019 MATLABProgrammingbyLindaCoulson
26/86
>> a(1, 2:end) %row 1, columns from 2 until end of the array
ans =
2 3
Logical Addressing
In addition to index addressing, you can also access only elements of an array that satisfysome logical criterion. For example, suppose a = [1.1, 2.1, 3.2, 4.5] and you only want
the values between 2 and 4. Then you can achieve this in two ways. The first is to use thefindfunction to find the indices of all numbers between 2 and 4 in the array, and then
address the array with those indices:
>> a = [1.1, 2.1, 3.2, 4.5];
>> INDICES = find(a >= 2 & a > a(INDICES)
ans =
2.1 3.2
This does not work in Matlab 2006b
The second method is to use logical addressing, which first changes a into a logical array,
with value 1 if the logical expression is true and 0 if it is false. It then finds and returns all
values in the a which are true. The syntax for this is as follows:
>> a = [1.1, 2.1, 3.2, 4.5];
>> a(a >= 2 & a > [1, 2, 3] - [1, 2, 1]
ans =
0 0 2
The multiplication by a scalar also works as expected:
>> 2 * [1, 2, 3]
ans =
-
8/9/2019 MATLABProgrammingbyLindaCoulson
27/86
[2, 4, 6]
Multiplication and division are more problematic: multiplying two vectors in does notmake sense. It makes sense only in the matrix context. Using the symbol * in matlab
computes the matrix product, which is only defined when the number of columns of the
left operand matches the number of rows of the right operand:
>> a = [1, 2; 3, 4];
>> a * a
ans =
7 10
15 22
>> a = [1, 2, 3]; b = [1; 2; 3];
>> a * a
??? Error using ==> *
Inner matrix dimensions must agree.
>> a * b
ans =
14
Using the division symbol / has even more constraints, as it imposes the right operand to
be invertible. For square matrices, a / b is equivalent to a * b 1
. For example :
>> a = [1, 2; 3, 4]; b = [1, 2; 1, 2]
>> b / a
ans =
1 0
1 0
>> a / b
Warning: Matrix is singular to working precision.
ans =
Inf Inf
Inf Inf
If you desire to multiply or divide two matrices or vectors componentwise, or to raise all
components of one matrix to the same power, rather than using matrix definitions ofthese operators, you can use the dot (.) operator. The two matrices must have the same
dimensions. For example, for multiplication,
>> a = [1, 2, 3];
>> b = [0, 1, 2];
>> a .* b
ans =
-
8/9/2019 MATLABProgrammingbyLindaCoulson
28/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
29/86
2
3
A vector in MATLAB is defined as an array which has only one dimension with a size
greater than one. For example, the array [1,2,3] counts as a vector. There are several
operations you can perform with vectors which don't make a lot of sense with otherarrays such as matrices. However, since a vector is a special case of a matrix, any matrix
functions can also be performed on vectors as well provided that the operation makessense mathematically (for instance, you can matrix-multiply a vertical and a horizontal
vector). This section focuses on the operations that can only be performed with vectors.
Declaring a vector
Declare vectors as if they were normal arrays, except all dimensions except for one must
have length 1. It does not matter if the array is vertical or horizontal. For instance, both of
the following are vectors:
>> Horiz = [1,2,3];
>> Vert = [4;5;6];
You can use the isvectorfunction to determine in the midst of a program if a variable is a
vector or not before attempting to use it for a vector operation. This is useful for error
checking.
>> isvector(Horiz)
ans = 1
>> isvector(Vert)
ans = 1
Another way to create a vector is to assign a single row or column of a matrix to another
variable:
>> A = [1,2,3;4,5,6];
>> Vec = A(1,:)
Vec = 1 2 3
This is a useful way to store multiple vectors and then extract them when you need to usethem. For example, gradients can be stored in the form of the Jacobian (which is how the
symbolic math toolbox will return the derivative of a multiple variable function) and
extracted as needed to find the magnitude of the derivative of a specific function in asystem.
Declaring a vector with linear or logarithmic spacing
Suppose you wish to declare a vector which varies linearly between two endpoints. Forexample, the vector [1,2,3] varies linearly between 1 and 3, and the vector
[1,1.1,1.2,1.3,...,2.9,3] also varies linearly between 1 and 3. To avoid having to type out
-
8/9/2019 MATLABProgrammingbyLindaCoulson
30/86
all those terms, MATLAB comes with a convenient function called linspace to declare
such vectors automatically:
>> LinVector = linspace(1,3,21)
Lin Vector = Columns 1 through 9
1.0000 1.1000 1.2000 1.3000 1.4000 1.5000 1.6000
1.7000 1.8000Columns 10 through 18
1.9000 2.0000 2.1000 2.2000 2.3000 2.4000 2.5000
2.6000 2.7000
Columns 19 through 21
2.8000 2.9000 3.0000
Note that linspace produces a row vector, not a column vector. To get a column vectoruse the transpose operator (') on LinVector.
The third argument to the function is the total size of the vector you want, which willinclude the first two arguments as endpoints and n - 2 other points in between. If you
omit the third argument, MATLAB assumes you want the array to have 100 elements.
If, instead, you want the spacing to be logarithmic, use the logspace function. Thisfunction, unlike the linspace function, does not find n - 2 points between the first two
arguments a and b. Instead it finds n-2 points between 10^a and 10^b as follows:
>> LinVector = logspace(1,3,21)
logvector = 1.0e+003 *
Columns 1 through 9
0.0100 0.0126 0.0158 0.0200 0.0251 0.0316 0.0398
0.0501 0.0631
Columns 10 through 18
0.0794 0.1000 0.1259 0.1585 0.1995 0.2512 0.31620.3981 0.5012
Columns 19 through 21
0.6310 0.7943 1.0000
Both of these functions are useful for generating points that you wish to evaluate another
function at, for plotting purposes on rectangular and logarithmic axes respectively.
Vector Magnitude
The magnitude of a vector can be found using the norm function:
>> Magnitude = norm(inputvector,2);
For example:
>> magHoriz = norm(Horiz)
magHoriz = 3.7417
>> magVert = norm(Vert)
magVert = 8.7750
-
8/9/2019 MATLABProgrammingbyLindaCoulson
31/86
The input vector can be either horizontal or vertical.
Dot product
The dot product of two vectors of the same size (vertical or horizontal, it doesn't matter as
long as the long axis is the same length) is found using the dotfunction as follows:
>> DP = dot(Horiz, Vert)
DP = 32
The dot product produces a scalar value, which can be used to find the angle if used incombination with the magnitudes of the two vectors as follows:
>> theta = acos(DP/(magHoriz*magVert));
>> theta = 0.2257
Note that this angle is in radians, not degrees.
Cross Product
The cross product of two vectors of size 3 is computed using the 'cross' function:
>> CP = cross(Horiz, Vert)
CP = -3 6 -3
Note that the cross product is a vector. Analogous to the dot product, the angle between
two vectors can also be found using the cross product's magnitude:
>> CPMag = norm(CP);
>> theta = asin(CPMag/(magHoriz*magVert))
theta = 0.2257
The cross product itself is always perpendicular to both of the two initial vectors. If the
cross product is zero then the two original vectors were parallel to each other.
Introduction to Structures
MATLAB provides a means for structure data elements. Structures are created and
accessed in a manner familiar for those accustomed to programming in C.
MATLAB has multiple ways of defining and accessing structure fields. See Declaring
Structures for more details.
Follow this link for MATLAB structure help.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
32/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
33/86
ans =
test
ans =
testing
In some cases you may need to access the field dynamically which can be done as
follows.
>> str = 'c';
>> a(1).(str)
ans =
test
>> a(1).c
ans =
test
Accessing Array Elements
Any given element in a structure array can be accessed through an array index like this
>> a(1).c
ans =
test
To access all elements in a structure array use the syntax {structure}.{field}. In order to
get all values in a vector or array use the brackets ([]) as seen below.
>> [a.('c')]
ans =
testtesting>> [a.('b')]
ans =
0 1
-
8/9/2019 MATLABProgrammingbyLindaCoulson
34/86
Graphics
2D Graphics
Plot
Plots a function in Cartesian Coordinates, x and y.
Example:
x=0:0.1:2; % creates a line vector from 0 to 2
fx=(x+2)./x.^2; % creates fx
plot(x,fx,'-ok') % plots 2d graphics of the function fx
To plot 2 or more graphs in one Figure, then simply append the second (x,y) pair to the
first:
>>>x1 = [1,2,3,4]
>>>y1 = [1,2,3,4]
>>>y2 = [4,3,2,1]
>>>plot(x1,y1,x1,y2)
This will plot y1 and y2 on the same x-axis in the output.
Polar Plot
Plots a function using and r()
t = 0:.01:2*pi;polar(t,sin(2*t).^2)
3D Graphics
plot3
The "plot3" command is very helpful and easy to see three dimensional images. Itfollows the the same syntax as the "plot" command. If you search the MATlab help (notat the command prompt. Go to the HELP tab at the top of the main bar then type plot3 in
the search) you will find all the instruction you need.
Example:
l=[-98.0556 ; 1187.074];
f=[ -33.5448 ; -240.402];
d=[ 1298 ; 1305.5]
plot3(l,f,d); grid on;
-
8/9/2019 MATLABProgrammingbyLindaCoulson
35/86
This example plots a line in 3d. I created this code in an M-file. If you do the same you
change the values and hit the run button in the menu bar to see the effect.
Mesh
Creates a 3D plot using vectors x and y, and a matrix z. If x is n elements long, and y is melements long, z must be an m by n matrix.
Example:
x=[0:pi/90:2*pi]';
y=x';
z=sin(x*y);
mesh(x,y,z);
Contour
Creates a 2D plot of a 3D projection, using vectors x and y, and a matrix z. If x is nelements long, and y is m elements long, z must be an m by n matrix.
Example:
x=[0:pi/90:2*pi]';
y=x';
z=sin(x*y);
contour(x,y,z);
Contourf
Same as contour, but fills color between contour lines
Surface
Basically the same as mesh MATLAB offers incomparable control over the way you canadd details to your plot. From inserting text at the right positions to labelling the axes,
MATLAB from the command line offers you an easy way to create publication style
graphics. With support for Encapsulated postscript and Illustrator output. Complex
figures with several axes and conveying large amounts of information can be created.
Concept of a handle
Most operations on figures generate objects with a set of properties. Users familiar with
Object oriented programming would realize that the functions and the data are
encapsulated into the object. A typical figure would contain at least half a dozen objects.These objects are called handles. A very tacky analogy would be like handles to several
different refrigerators with several different contents. To provide an intuitive feel. I have
listed out the properties from a text handle.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
36/86
Finding a handle
Various commands provide required handles, for example:
h = gcf; % Get current figure
h = gca; % Get current axis
Examples
Axis Label
xlabel labels the x-axis of the current plot
>>xlabel('string')
You can display text on two lines or insert the value of variables
>>xlabel({['First Line or line n ',int2str(a)],['Second Line or line
n',int2str(b)]})
ylabel labels the y-axis of the current plot. It works in same way of xlabel but the output
is vertical in 2D plots.
Documenting a Maximum Value
% Previous code set the x value of the peak data point into x_peak
plot(lags(1:1000:end),abs_cs(1:1000:end));
ptitle = 'UUT and Source Correlation Score Magnitude';
xlabel('Lag');
ylabel('Correlation Magnitude');
title(ptitle);
yloc = max(get(gca,'YLim')); % Put at top of plot
text(lags(x_peak),yloc,[' \leftarrow ' num2str(x_peak) 'ns']);
lstr{1} = sprintf(' Test %d', TESTNUM);
lstr{2} = sprintf(' Unit %d%s', UNITNUM, comparestr);
text(lags(1),mean(get(gca,'YLim')),lstr);
-
8/9/2019 MATLABProgrammingbyLindaCoulson
37/86
M File Programming
M-files
There are 2 types of m-file
Scripts Functions
Scripts are a type of m-file that runs in the current workspace. So if you call a script from
the command line (base workspace) the script will use and manipulate the variables of the
base workspace. This can get very messy and lead to all sorts of strange errors whenloops are involved and the coder is lazy about about naming their loop variables (i.e. for i
= 1:10, if every loop uses i, j, or k then it's likely that any script called from a loop will
alter the loop variable).
Functions are wholly contained in themselves. They possess their own workspace
keeping workspaces separate. This means that all variables necessary for a particular
function must be passed or defined in some way. This can get tedious for complexalgorithms requiring lots of variables. However, any manipulations of variables are
discarded when the function is exited. Only those output arguments provided by the
function are available to the calling workspace. This means that loops can use i, j, or k all
they want because the function's workspace and the calling workspace do not mix.
Any command valid at the command line is valid in any m-file so long as the necessary
variables are present in the m-files operating workspace.
Using functions properly any change can be affected to any algorithm or plotting tool.
This allows for automation of repetitive tasks.
It is optional to end the M-file with 'end'; doing so, however, can lead to complications ifyou have conditionals or loops in your code, or if you're planning on using multiple
functions in the same file (see nested functions for details on this).
Requirements for a function
Custom functions follow this syntax in their most basic form:
function [output1, output2, ...]= function_name(input_arg1,input_arg2)
statements
return;
In current versions of MATLAB the return; line is not required. Thefunction_name can
be anything you like but it is best if the m-file name isfunction_name.m. Calling the
-
8/9/2019 MATLABProgrammingbyLindaCoulson
38/86
function from the command line or another m-file is done by invoking the m-file name of
the function with the necessary input and output arguments.
Within the function itself, there must be a statement that defines each of the output
arguments (output1, output2, etc.). Without some declaration the variable for the output
argument doesn't exist in the function's workspace. This will cause an error about "one ormore output arguments". It is good practice to initialize the output arguments at the
beginning of the function.
Typically output arguments are initialized to empty ([]) or 0 or -1 or something
equivalent for other data types. The reason is that if the function encounters an erroryou've anticipated then the function can return (via the return command) with those
default values. If the initialization value is an invalid value then it can easily be checked
by the calling function for any errors which may not throw a MATLAB error.
Path
In order to invoke a function that function's m-file must be in the current path. There is a
default path that can be setup through the File menu or the addpath command. The order
of the path is important as MATLAB searches the path in order and stops searching after
it finds the 1st
instance of that m-file name.
The current path is
the current directory (which can be seen at the top of the MATLABwindow or by typingpwdat the command prompt
the default pathNote that MATLAB will always search the current directory before searching any of the
rest of the path.
nargin & nargout
The nargin and nargoutcommands are only valid inside functions since scripts are not
passed any arguments. The nargin command returns the number of passed input
arguments. This is useful in conjunction with nargchk
nargchk(min, max, nargin)
where min is the minimum number of arguments necesary for the function to operate and
max is the maximum number of valid input arguments.
The nargoutcommand is useful for determining which output arguments to return.Typically, the outputs are the end results of some algorithm and they are easily
calculated. However, in some instances secondary output arguments can be time
consuming to calculate or require more input arguments than the primary output
-
8/9/2019 MATLABProgrammingbyLindaCoulson
39/86
arguments do. So the function can check the number of output arguments being requestedthrough the nargoutcommand. If the caller isn't saving the secondary output arguments
then they do not need to be calculated.
varargin & varargout
When using MATLAB objects and functions they often allow the user to set properties.
The functions and objects come with default values for these properties but the user is
allowed to override these defaults. This is accomplished through the use ofvarargin.varargin is a cell array that is usually parsed where varargin{i} is a property and
varargin{i+1} is the value the user wishes for that property. The parsing is done with a
foror while loop and a switch statement.
function [out] = myFunc(in, varargin)
The varargoutoutput argument option allows for a variable number of output arguments
just as varargin allows for a variable number of input arguments. From the MATLABsite
function [s,varargout] = mysize(x)
nout = max(nargout,1)-1;
s = size(x);
for k=1:nout, varargout(k) = {s(k)}; end
returns the size vector and, optionally, individual sizes. So
[s,rows,cols] = mysize(rand(4,5));
returns s = [4 5], rows = 4, cols = 5.
Useful syntax guidelines
Placing the semicolon symbol after every line tells the compiler not to place that line ofcode in the command prompt and then execute. This can make your programs run a lot
faster. Also, placing a semicolon after every line helps with the debugging process.
syms x y z;
w=[x y z];
e=[1 2 3];
t=jacobian(e,w);
Placing comments in your code can help other people (and yourself) understand yourcode as it gets more complex.
syms x y z; %syms command makes x y and z symbolic
w=[x y z];
e=[1 2 3];
t=jacobian(e,w);
Comments can also Identify who wrote the code and when they wrote it.
%Some code writer
-
8/9/2019 MATLABProgrammingbyLindaCoulson
40/86
%mm/dd/yyyy
Nested functions
Placing comments
Comment lines begin with the character '%', and anything after a '%' character is ignoredby the interpreter. The % character itself only tells the interpreter to ignore the remainder
of the same line.
In the Matlab editor, commented areas are printed in green by default, so they should be
easy to identify. There are two useful keyboard shortcuts for adding and removing chunksof comments. Select the code you wish to comment or uncomment, and then press Ctrl-R
to place one '%' symbol at the beginning of each line and Ctrl-T to do the opposite.
Matlab also supports multi-line comments, akin to /* ... */ in languages like C or
C++, via the %{ and %} delimiters.
Common uses
Comments are useful for explaining what function a certain piece of code performs
especially if the code relies on implicit or subtle assumptions or otherwise perform subtleactions. Doing this is a good idea both for yourself and for others who try to read your
code. For example,
% Calculate average velocity, assuming acceleration is constant
% and a frictionless environment.force = mass * acceleration
It is common and highly recommended to include as the first lines of text a block ofcomments explaining what an M file does and how to use it. Matlab will output the
comments leading up to the function definition or the first block of comments inside a
function definition when you type:
>> help functionname
All of Matlab's own functions written in Matlab are documented this way as well.
The input() function lets your scripts process data entered at the command line. All inputis converted into a numerical value or array. The argument for the input() function is the
message or prompt you want it to display. Inputting strings require an additional 's'
argument. Example:
%test.m
%let's ask a user for x
-
8/9/2019 MATLABProgrammingbyLindaCoulson
41/86
x = input('Please enter a value for x:')
Then running the script would produce the output:
Please enter a value for x:3
x = 3
>>
Control Flow
IF statement
An IF statement can be used to execute code once when the logical test (expression)
returns a true value (anything but 0). An "else" statement following an if statement isexecuted if the same expression is false (0).
Syntax:
if expression
statements
elseif expression2
statements
end
SWITCH statement
Switch statements are used to perform one of several possible sets of operations,
depending on the value of a single variable. They are intended to replace nested "if"statements depending on the same variable, which can become very cumbersome. The
syntax is as follows:
switch variable
case value1
statements
case value2
statements
...
otherwisestatements
end
The end is only necessary after the entire switch block, not after each case. If youterminate the switch statement and follow it with a "case" statement you will get an error
saying the use of the "case" keyword is invalid. If this happens it is probably because youdeleted a loop or an "if" statement but forgot to delete the "end" that went with it, thus
-
8/9/2019 MATLABProgrammingbyLindaCoulson
42/86
leaving you with surplus "end"s. Thus MATLAB thinks you ended the switch statement
before you intended to.
The otherwise keyword executes a certain block of code (often an error message) for any
value ofvariable other than those specified by the "case" statements.
TRY/CATCH statement
The TRY/CATCH statement executes a certain block of code in the "try" block. If it fails
with an error or a warning, the execution of this code is terminated and the code in the
"catch" block is executed rather than simply reporting an error to the screen and
terminating the entire program. This is useful for debugging and also for filtering outerroneous calculations, like if you accidentally try to find the inverse of a singular matrix,
when you don't wish to end the program entirely.
Syntax:
try
statements
catch
statements
end
Note that unlike the other control flow statements, the TRY/CATCH block does not rely
on any conditions. Therefore the code in the TRY block will always be at least partiallyexecuted. Not all of the TRY block code will always be executed, since execution of the
TRY ends when an error occurs.
FOR statement
The FOR statement executes code a specified number of times using an iterator. Syntax:
for iterator = startvalue:increment:endvalue
statements
end
The iterator variable is initialized to startvalue and is increased by the amount in
incrementevery time it goes through the loop, until it reaches the value endvalue. If
incrementis omitted, it is assumed to be 1, as in the following code:
for ii = 1:3
statements
end
This would execute statements three times.
WHILE statement
-
8/9/2019 MATLABProgrammingbyLindaCoulson
43/86
The while statement executes code until a certain condition evaluates to false or zero.
Example:
while condition
statements
end
Forgetting to change the condition within a while loop is a common cause of infinite
loops.
BREAK and CONTINUE
MATLAB includes the "break" and "continue" keywords to allow tighter loop control.The "break" keyword will cause the program to leave the loop it is currently in and
continue from the next line after the loop ends, regardless of the loop's controlling
conditions. If the code is in a nested loop it only breaks from the loop it's in, not all ofthem. The syntax is simply to write the word "break" within the loop where you desire it
to break.
In contrast to "break", "continue" causes the program to return back to the beginning of
the loop it is presently in, and to recheck the condition to see if it should continue
executing loop code or not. The code in the loop after the "continue" statement is not
executed in the same pass.
Program Flow
The idea of program flow is simple. However, implementing and using flow techniques
effectivly takes practice. MATLAB flow control is almost identical to flow control in C.
There is a tremendous amount of text on the subject of flow in C. If you do a littlehomework in about an hour you can know all you need to from one of numerous C
tutorials. To be good at flow control all you have to do is practice.
Here are a few concepts that you can practice using flow control to implement:
Calculate compounding interest using a while loop (don't cheat by using thealgebraic form).
Create a moving average filter using a for loop Make a counter that keeps track of keystrokes:How many times a typist hits a
certain letter.
As far as I've seen there is little help out there to help people decipher MATLAB's errormessages. Most of the syntax errors are not difficult to fix once you know what is causing
them so this is intended to be a guide to identifying and fixing errors in MATLAB code.
Warnings are also shown here as these often lead to errors later.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
44/86
Arithmetic errors
Usually these are self-explanitory. As a reminder, here are some common functions that
cannot be performed and what MATLAB returns (along with a warning for each one):
a/0 = Inf if a > 0, -Inf if a < 0, and NaN if a = 0.log(0) = -Inf
MATLAB defines 0^0 to be 1.
NaN will very often result in errors or useless results unless measures are taken to avoidpropogating them.
???Error using ==> minus
Matrix dimensions must agree.
So check the dimensions of all the terms in your expression. Often it is an indexing
mistake that causes the terms to be of different size. If you are using power function you
might add a single dot after the parameter. i.e. y=x.^2 instead of y=x^2
Matrix multiplication requires the number ofcolumns in the first matrix to equal the
number ofrows in the second. Otherwise, you get the message:
??? Error using ==> mtimes
Inner matrix dimensions must agree.
Note the difference between this error and the previous one. This error often occurs
because of indexing issues OR because you meant to use componentwise multiplication
but forgot the dot.
Attempting to take the inverse of a singular matrix will result in a warning and a matrix
of Infs. It is wise to calculate the determinant before attempting to take the inverse or,
better, to use a method that does not require you to take the inverse since its not
numerically stable.
Attempting to take a power of a nonsquare matrix results in the error
??? Error using ==> mpower
Matrix must be square.
This is usually because you meant to use componentwise exponentiation and forgot thedot.
Indexing errors
Indexing is a pain in MATLAB, it is probably one of the hardest things to get down,
especially since the syntax for an index is the same as the syntax for a function. One
annoying fact is that the names of variables are case sensitive, but the names of functions
-
8/9/2019 MATLABProgrammingbyLindaCoulson
45/86
are NOT. So if you make an array called Abs and you try to index abs(1), it will return 1no matter what the first value in the array Abs is. Unfortunately, MATLAB will not
return an error for this, so a good rule of thumb is never ever name your variables the
same as a function. This clears up some indexing problems.
Some things are rather obvious but take some practice in avoiding:
You cannot try to access part of an array that does not exist yet.
>> A = [1,3];
>> A(3)
??? Index exceeds matrix dimensions.
Unfortunately, MATLAB doesnt tell you which variable you exceeded the dimensions on
if there's more than one so you'll have to check that. This often occurs if, for example,you are using a loop to change which part of an array is accessed, but the loop doesn't
stop before you reach the end of the array. This also happens if you end up with an empty
matrix as a result of some operation and then try to access an element inside it.
You cannot try to access a negative, complex, noninteger, or zero part of an array; if you
do you get this message:
>> A(-1)
>> A(i)
>> A(1.5)
>> A(0)
??? Subscript indices must either be real positive integers or
logicals.
Note that MATLAB starts counting at 1, not 0 like C++. And again, it doesn't tell youwhich index is not real or logical. Also note that if 0 was a logical 0 (false) then the
statement A(0) would be valid and would return all 0 values in the array.
Attempting to use non-standard MATLAB syntax in your indexing will often result in the
error:
>> A(1::, 2)
??? A(1::, 2)
|
Error: Unexpected MATLAB operator.
The "operator" :: is one of several possible operators that MATLAB does not accept. Thiscould be an example of someone trying to access all rows of A after the first one and the
second column, in which case you should use the "end" syntax, as in:
>> A(1:end, 2)
ans = 3
-
8/9/2019 MATLABProgrammingbyLindaCoulson
46/86
Make sure you are careful when using the colon operator, because it does many differentthings depending on where you put it and misuse often results in these errors. Try putting
in one piece of your code at a time and see what it is doing, it may surpise you.
Assignment errors
Ah, assignment, that is using the = sign to give a variable, or certain elements of an array,
a particular value.
Let's start with a classic mistake:
>> a = 2;
>> if a = 3
??? if a = 3
|
Error: The expression to the left of the equals sign is not a valid
target for an assignment.
This error occurs because you meant to see if "a" equaled 3, but instead you told
MATLAB to assign "a" a value of 3. You cannot do that on the same line that the if/while
statement is on. The correct syntax is
>> if a == 3
>> end
This creates no errors (and you can put anything inside the conditional you want).
You cannot have a normal array with two different classes of data inside it. For example,
>> A = @(T) (1+T)
A =
@(T) (1+T)
>> A(2) = 3
??? Conversion to function_handle from double is not possible.
For such a purpose you should use cell arrays or struct arrays.
Here's the tricky one. Take a look at the following code:
>> A = [1,2,3;4,5,6;7,8,9];
>> A(2,:) = [3,5];
??? Subscripted assignment dimension mismatch.
>> A(2,:) = [1,4,5,6];
??? Subscripted assignment dimension mismatch.
>> A(1:2, 1:2) = [1,2,3,4];
??? Subscripted assignment dimension mismatch.
What is happening here? In all three cases, take a look at the dimensions of the left and
the right hand sides. In the first example, the left hand side is a 1x3 array but the right
-
8/9/2019 MATLABProgrammingbyLindaCoulson
47/86
side is a 1x2 array. In the second, the Left hand side is 1x3 while the right is 1x4. Finally,in the third, the left hand side is 2x2 while the right is 1x4. In all three cases, the
dimensions do not match. They must match if you want to replace a specificportion of an
existing variable. It doesn't matter if they have the same number of data points or not (asthe third example shows); the dimensions must also be the same, with the exception that
if you have a 1xn array on one side and an nx1 on the other MATLAB will automaticallytranspose and replace for you:
>> A(2,:) = [1;2;3]
A = 1 2 3
1 2 3
7 8 9
If you do not want this be aware of it!
Struct array errors
Struct arrays are rather complex, and they have a rigid set of rules of what you can and
can not do with them. Let us first deal with indexing within struct arrays. Suppose youdefine the variable "cube" and want to store the volume and the length of one side of two
different cubes in a struct array. This can be done as follows:
>> cube(1).side = 1;
>> cube(1).volume = 1;
>> cube(2).side = 2;
>> cube(2).volume = 8;
This seems like a good way of storing data and it is for some purposes. However, suppose
you wanted to abstract the volumes from the struct and store them in one array. Youcannotdo it this way:
>> volumes = cube.volume
??? Illegal right hand side in assignment. Too many elements.
You'll notice that if you tell MATLAB to display cube.volume, it will display bothvalues, but reassign the variable ans each time, because it is treated as two separate
variables. In order to avoid the error, you must format 'cube.volume' as an array upon
assignment.
>> volumes = {cube.volume}
You can also write in a separate assignment for each cube but this is more adaptable to
larger numbers of cubes.
Just like extracting data, you must input the data one at a time, even if it is the same for
all instances of the root (cube).
>> cube.volForm = @(S) (S^3)
-
8/9/2019 MATLABProgrammingbyLindaCoulson
48/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
49/86
>> A(1))
??? A(1))
|
Error: Unbalanced or misused parentheses or brackets.
MATLAB tries to tell you where the missing parenthesis should go but it isn't always
right. Thus for a complex expression you have to go through it very carefully to find yourtypo. A useful trick is to try to set a breakpoint a line after the offending line. It won't turn
red until the error is corrected, so keep trying to correct it and saving the file until thatbreakpoint turns red. Of course, after this you have to make sure the parenthesis
placement makes sense, otherwise you'll probably get another error related to invalid
indecies or invalid function calls.
String errors
There are two ways that you can create a string; use the ' string ' syntax, or type two
words separated by only whitespace (not including line breaks), as in
>> save file.txt variable
In this line,file.txtand variable are passed to the save function as strings. It is anoccasional mistake to forget a parenthesis and accidentally try and pass a string to a
function that does not accept strings as input:
>> eye 5
??? Error using ==> eye
Only input must be numeric or a valid numeric class name.
These should not be hard to spot because the string is color-coded purple. Things like this
occur if you uncomment a line of text and forget to change it.
Forgetting the closing ' in the other syntax for a string results in an obvious error:
>> A = 'hi
??? A = 'hi
|
Error: A MATLAB string constant is not terminated properly.
The unterminated string is color-coded red to let you know that it is not terminated, since
it's otherwise easy to forget.
Other miscellaneous errors
You cannot leave trailing functions, and if you do MATLAB gives you an error that is
similar but not exactly the same as that for a missing parenthesis, since it doesn't want to
venture a guess:
>> A = 1+3+
??? A = 1+3+
-
8/9/2019 MATLABProgrammingbyLindaCoulson
50/86
|
Error: Expression or statement is incomplete or incorrect.
These usually are not hard to spot, and often result from forgetting the "..." necessary to
split a line.
The double colon is not the only "unexpected MATLAB operator", there is also "..",
"....", and several other typos that generate this error.
If you accidentally type the ` character you get the error:
>> ??? `
|
Error: The input character is not valid in MATLAB statements or
expressions.
This usually occurs because you intended to put a "1" in the equation but missed the key.
Function Calling errors
It is necessary to know the nature of the input and output arguments of a given function
in order to call it. For MATLAB's built-in functions, this information is found in the
documentation, or by typing
>> help functionname
Most functions (not all however) require at least one input argument, and calling it with
too few will result in an error:
>> A = ode45()
??? Error using ==> ode45
Not enough input arguments. See ODE45.
You cannot call the function with too many input arguments either:
>> A = plus(1,2,3)
??? Error using ==> plus
Too many input arguments.
You can choose how many of the output arguments you want out of those available by
using the bracket notation, but you cannot assign more than the function can output.
>> A = [1,2;3,4]
D = eig(A); %one output argument
[V,D] = eig(A); %two output arguments
[V,D,Mistake] = eig(A);
??? Error using ==> eig
Too many output arguments.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
51/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
52/86
-
8/9/2019 MATLABProgrammingbyLindaCoulson
53/86
Text -> Comment
Or press CRTL+R. This will simply put a '%' in front of every line; if the line is alreadycommented out it will put another '%' there so when you uncomment them the pattern of
comment lines will not change. Commented lines will be ignored by the compiler, so the
effect will be that the program is run without them.
To uncomment a line go to
Text -> Uncomment
Or press CTRL+T.
Another use of commenting is to test the difference between two different possible sets of
code to do something (for example, you may want to test the effect of using ODE113 as
opposed to ODE45 to solve a differential equation, so you'd have one line calling each).
You can test the difference by commenting one out and running the program, then
uncommenting that one and commenting the other one out, and calling the programagain.
How to escape infinite loops
If your program is doing nothing for a long time, it may just be slow (MATLAB creates alot of overhead and if you don't use arrays wisely it will go very, very slow) but if you are
testing a small module, it is more likely that you have an infinite loop. Though MATLAB
can't directly tell you you have an infinite loop, it does attempt to give you some hints.The first comes when you terminate the program. Terminate it by pressing CTRL+C and
MATLAB will give you a message telling you exactly what line you stopped on. If yourprogram is running a long time, it is likely the line you stopped in is in the middle of an
infinite loop (though be warned, if the loop calls a sub-function, it is likely that you willstop in the sub-function and not the parent. Nevertheless, MATLAB also will tell you the
lines of the parents too so you can track down the loop easily enough).
However, sometimes MATLAB won't even let you return to the main window to pressCTRL-C. In this case you probably have to kill the whole MATLAB process. After this,
add a "pause (0.001)" or a similarly small value in the loop you suspect to be the infinite
one. Whenever MATLAB passes this instruction you will be able to interact withMATLAB for a (very) short time, e.g. go to the main window and press STRG-C with
MATLAB being able to respond to your command.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
54/86
Mathematical Manipulations
Linear Algebra
Operations
Squaring a matrix
a=[1 2;3 4];
a^2;
a^2 is the equivalent of a*a. To square each element:
a.^2
The period before the operator tells MATLAB to perform the operation element by
element.
Determinant
Getting the determinant of a matrix, requires that you first define your matrix, then run
the function "det()" on that matrix, as follows:
a = [1 2; 3 4];
det(a)
ans = -2
Symbolic Determinant
You can get the symbolic version of the determinant matrix by declaring the values
within the matrix as symbolic as follows:
m00 = sym('m00'); m01 = sym('m01'); m10 = sym('m10'); m11 = sym('m11');
or
syms m00 m01 m10 m11;
Then construct your matrix out of the symbolic values:
m = [m00 m01; m10 m11];
Now ask for the determinant:
-
8/9/2019 MATLABProgrammingbyLindaCoulson
55/86
det(m)
ans = m00*m11-m01*m10
Transpose
To find the transpose of a matrix all you do is place a apostrophe after the bracket.
Transpose- switch the rows and columns of a matrix.
Example:
a=[1 2 3]
aTranspose=[1 2 3]'
or
b=a' %this will make b the transpose of a
when a is complex, the apostrophe means transpose and conjugate.
Example a=[1 2i;3i 4]; a'=[1 -3i;-2i 4];
For a pure transpose, use .' instead of apostrophe.
Systems of linear equations
Ther are lots of ways to solve these equations.
Homogeneous Solutions
Particular Solutions
State Space Equations
Special Matrices
Often in MATLAB it is necessary to use different types of unique matrices to solve
problems.
Identity matrix
To create an identity matrix (ones along the diagonal and zeroes elsewhere) use the
MATLAB command "eye":
>>a = eye(4,3)
a =
-
8/9/2019 MATLABProgrammingbyLindaCoulson
56/86
1 0 0
0 1 0
0 0 1
0 0 0
Ones Matrix
To create a matrix of all ones use the MATLAB command "ones"
a=ones(4,3)
Produces:
a =
1 1 1
1 1 1
1 1 1
1 1 1
Zero matrix
The "zeros" function produces an array of zeros of a given size. For example,
a=zeros(4,3)
Produces:
a =
0 0 0
0 0 0
0 0 0
0 0 0
This type of matrix, like the ones matrix, is often useful as a "background", on which to
place other values, so that all values in the matrix except for those at certain indecies are
zero.
Row reduced echelon form
To find the Row reduced echelon form of a matrix just use the MATLAB command rref
Example:
a=[1 2 3; 4 5 6];
b=rref(a);
-
8/9/2019 MATLABProgrammingbyLindaCoulson
57/86
It's that simple. (I believe that MATLAB uses the Gauss-Jordan elimination method tomake this computation; don't quote me on that (I'm not even sure if there are other
methods)).
Inverse
To find the inverse of a matrix use the MATLAB command inv. (note the matrix must be
square)
Example:
a=[1 2 3;4 5 6;7 8 9];
b=inv(a);
Coffactor, minor
The Jacobian
t=jacobian(e,w);
e is a scalar vector, w is a vector of functions. Also, this does not solve equationssymbolicaly unless you define the w vector functions as symbolics prior to executing this
statment.
Example:
syms x y z;
w=[x y z];
e=[1 2 3];
t=jacobian(e,w);
Differential Equations
Differential equation solver syntax
All of the differential equations have the same syntax that you must use, and the same
input and output arguments. All of the solvers require three input arguments: afunction
handle to the differential equation you want to solve, a time interval over which tointegrate, and a set of initial conditions. Let us suppose we want to solve the simple
differential equation y' = y, y(0) = 1, which has the true solution y(t) = e^t. Suppose we
want the solution between t = 0 and t = 1.
To use function handles, you must first create an M-file with the function in it like so:
function Yprime = func(t, y)
-
8/9/2019 MATLABProgrammingbyLindaCoulson
58/86
Yprime = 0;
Yprime = y;
Note that you must include the time argument even if it is not used in the differentialequation. The initialization of Yprime to an array of zeros will save you grief if you try to
solve more than one function; Yprime must be returned as a VERTICAL array but, if you
don't initialize it as a verical array (or transpose at the end), it will return a
HORIZONTAL array by default.
Also note that, with the exception of ode15i, the function mustbe solved explicitly for y'.
Once this file is created, call the ODE function with the arguments in the order (function,
timeinterval, initialcond):
>> ode45(@func, [0,1], 1)
The other method is to use anonymous functions, which is only useful if you have one
function (otherwise you must use function handles). You again must declare theanonymous function in terms of both the dependent variable(s) and time:
>> func = @(t,y) y;
>> ode45(func, [0,1], 1)
Calling the ODE function without input arguments gives a graph of the solution. Calling
it with one output argument returns a struct array:
>> Struct = ode45(func, [0,1], 1)
Struct = solver: 'ode45'
extdata: [1x1 struct]
x: [1x11 double]y: [1x11 double]
stats: [1x1 struct]
idata: [1x1 struct]
This data is mostly used to, in the future, call the 'deval' function to get the answer at any
time you want:
>> Solution = deval(Struct, 0.5)
Solution = 1.6487
Deval can also return the derivative at the point of interest by including a second output
argument.
>> [Solution, Derivative] = deval(Struct, 0.5)
Solution = 1.6487
Derivative = 1.6487
Since the derivative of e^x is itself it makes sense that the derivative and solution are the
same here.
-
8/9/2019 MATLABProgrammingbyLindaCoulson
59/86
Calling ode45 with two output arguments returns two lists of data; t first, then the
independent variables in an appropriately-sized matrix.
ODE Options
The are a rather large number of options that MATLAB gives you to modify how itsolves the differential equations. The help file does a pretty good job describing all of
them so they won't be described in detail here. To get a list use the help function:
>>help odeset
To get a list of the different options' names and what you have to pass to it, just type'odeset' into the command prompt. It returns either a data type or a finite list of options. It
also lists, in parenthesis, the default values of all the options.
To set a specific option or list of options, type the name of the option first and then the
value of the option you want. For example, suppose you want to tighten the defaultrelative tolerance from 10^-3 to 10^-4. You would call 'odeset' as follows:
>> option = odeset('RelTol', 10^-4);
Note that the option name must be passed as a string, or else you'll get an 'undefined
variable' error most likely. More than one option can be passed at a time by just putting
them all in a list:
>> option = odeset('RelTol', 10^-4, 'AbsTol', 10^-7, 'MassSingular',
'no');
The options structure can then be passed to the ode function as a forth (optional) inputargument:
>> [T,X] = ode45(@func, [0,1], 1, option);
This will return more accurate values than default because the error tolerances are tighter.It should also compute faster because MATLAB is not checking to see if this is a
differential-algebraic equation (this is what the MassSinglular option does; it is usually
set to 'maybe' so MATLAB checks by itself).
The ODE solvers
MATLAB doesn't just have one ODE solver, it has eight as of the MATLAB 7.1 release.Some are more suited for certain problems than others, which is why all of them are
included. The MATLAB help has a list of what functions each one can do, but here is a
-
8/9/2019 MATLABProgrammingbyLindaCoulson
60/86
quick summary, in roughly the order you should try them unless you already know the
classification of the problem:
Most problems can be solved using ode45, and since this is the best tradeoff of
speed and accuracy it should be the first one you use.
If you need a really tight error tolerance or a lot of data points, use ode113.If you have a relatively loose error tolerance or the problem is slow with ode45,
try ode23.If the problem is truly stiff and ode45 fails, use ode23tb for loose tolerances,
ode23s for slightly tighter tolerances with a constant mass matrix, or ode15s for
tigheter tolerances or nonconstant mass matrices.
If you need a solution without numerical damping on a stiff problem, use ode23t.The s indicates that the algorithm is intended for stiff problems.
There is one other ODE solver, which is special:
Implicit problems can only be solved using ode15i.
Since ode15i has some differences in its syntax, it is discussed next.
Implicit ODEs: ODE15i
Since ode15i is the only ODE solver that solves implicit equations, it must have some
special syntactical rules on how to input the function.
If you are using ode15i declare the function as follows:
function Z = func(t,y,Yprime)