-
MATLAB Programming/Print Version
Chapter 1: A Tutorial Introduction
Chapter 2: 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 running an M-file. By default, unless you
edit the MATLAB shortcut, thecurrent directory will be
.../MATLAB/work. After you start MATLAB, change the current
directory by either using the toolbar at the left-hand side of
thescreen, 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 to call. Therefore if you have multiple
folders and each of them hasan 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 whichMATLAB 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 must define it using MATLAB's 'set path'
utility. To access this utility, followthe 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 andselect 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 interfacehgsave - saves figures to files,
*.fig by defaultdiary [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
Likewise, there are many ways to load files into the workspace.
One way is to use the "file" menu. To open a .m file click "open",
whereas to import datafrom a data file select "import data..." and
follow the wizard's instructions.
An alternative way to load a saved .mat file (within a function,
for example) is to type:
>> load filename.ext
The file must be in a recognized directory (usually your current
directory, but at least one for which the path has been set).
The data in the .mat file is stored with the same name as the
variable originally had when it was saved. To get the name of this
and all other environmentvariables, type "who".
To open an .m file, you can use file -> open, or type
>>open filename.ext
File Naming Constraints
You can name files whatever you want (usually simpler is better
though), with a few exceptions:
-
MATLAB for Windows retains the file naming constraints set by
DOS. The following characters cannot be used in filenames:
" / : * < > | ?
You're not allowed to use the name of a reserved word as the
name of a file. For example, while.m is not a valid file name
because while is one ofMATLAB's reserved words.
When you declare an m-file function, the m-file must be the same
name as the function or MATLAB will not be able to run it. For
example, if youdeclare a function called 'factorial':
function Y = factorial(X)
You must save it as "factorial.m" in order to use it. MATLAB
will name it for you if you save it after typing the function
declaration, but if you
change the name of the function you must change the name of the
file manually, and vice versa.
Introduction
MATLAB is interesting in that it is dynamically compiled. In
other words, when you're using it, you won't run all your code
through a compiler, generatean executable, and then run the
executable file to obtain a result. Instead, MATLAB simply goes
line by line and performs the calculations without theneed 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 evenpossible to write loops and branches at
the command line if you want to. Of course this would often lead to
a lot of wasted efforts, so doing anythingbeyond 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'sodometer reading was 3215 when he last
filled the fuel tank. Yesterday he checked his odometer and it read
3503. He filled the tank and noticed that ittook 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, assuming the gas
mileage isthe 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 =
443.5200
To prevent the result from printing out in the command window,
use a semicolon after the statement. The result will be stored in
memory. You can thenaccess 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:
>> [Output1, Output2, ..] = functionname(input1,
input2,..)
MATLAB will look for a file called functionname.m and will
execute all of the code inside it until it either encounters an
error or finishes the file. In theformer case, it produces a noise
and displays an error message in red. In the latter case, MATLAB
will relinquish control to you, which you can see whenthe >>
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 thiswikibook are good places to look for help
on what you need to provide as inputs and what you will get
back.
Be careful; 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 anyfunction. To ensure 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.
External Resources
ControlTheoryPro.com
(http://wikis.controltheorypro.com/index.php?title=Basic_Tutorial)
Reading and Writing from a file: Command Line
Reading and Writing data from/to a .mat file
The quickest means 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 saved correctly when saving data using version 7 for use in
version 6. Most
data items will 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 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 6 of 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')
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 thecommand 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 the xlsread function use the
syntax:
>>g=xlsread('filename');
This line of code reads filename.xls (from the current
directory) and places it in an identical array inside MATLAB called
g. You can then manipulate thearray 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) otherwiseyou 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. The
xlswrite command below creates a spreadsheet called filename.xls in
the current directoryfrom 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 Ihave found is
fid=fopen('newFile.xls', 'w');
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 with formatting in Excel. The formatting issues can
usually be handled insideExcel 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 afile 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.
For reading more general text files, MATLAB does not have a
function to do it easily (unless you have excel), but you can read
very general text files(with different delimiters for both cells
and text within cells) using the "textread.m" function in the
MATLAB file exchange (do a google search to find it).You can also
try to use fscanf if the formatting is consistent enough (i.e.
consistent numbers of spaces, no mixing of strings and numbers in
columns, and soon).
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 aWindows system). To use it, go to file >
import data, and select the file you want. Then, choose what column
separators are present (by selecting theappropriate 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 areomitted, plusses and minuses are turned into other
characters. To see the name MATLAB generated (and probably change
it) type "who" in the commandprompt.
External Resources
ControlTheoryPro.com
(http://wikis.controltheorypro.com/index.php?title=Category:MATLAB)
MatlabCodes.Webs.com
(http://matlabcodes.webs.com?title=Category:MATLAB)
Chapter 3: 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 rationalnumbers 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 valuesare. Note that MATLAB represents
irrational numbers such as pi with rational approximations, except
when using the symbolic math toolbox. See thatsection for
details.
Boolean numbers are either "TRUE" or "FALSE", represented in
MATLAB by a 1 and a 0 respectively. Boolean variables in MATLAB are
actuallyinterchangable with doubles, in that boolean operators can
be performed with arrays of doubles and vice versa. Any non-zero
number in this case isconsidered "TRUE".
Most of the rational operators also work with complex numbers.
Complex numbers, however, cannot be interchanged with boolean
values like the realrationals can. See the complex numbers section
for details on how to use them.
Rational Operators on Single Values
MATLAB has all the standard rational operators. It is important
to note, however, that Unless told otherwise, all rational
operations are done onentire 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 %subtraction b = 2 - 1 %matrix
multiplication c = a * b %matrix division (pseudoinverse) d = a / b
%exponentiation e = a ^ b
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.
Relational Operators
Equality '==' returns the value "TRUE" (1) if both arguments are
equal. This must not be confused with the assignment operator '='
which assigns a valueto 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
-
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 of characters. To see this, try executing the
following code:
>> fstring = 'hello'; >> class(fstring) ans =
char
Therefore, many of the array manipulation functions will work
the same with these arrays as 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 arrayinto 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 toround down:
>> char(104) ans = h >> char(104.6) 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 thanjust 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 of
replaced in 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, one way is to use array notation
combined with either the 'display'or the 'disp' function:
>> fstring = 'hello'; >> display( [ fstring 'world']
) helloworld
MATLAB doesn't put the space in between the two strings. If you
want one there you must 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.
You can also use the "strcat" function to concatenate strings,
which does the same thing as above when you use two strings, but it
is especially useful if youare using a cell array of strings
because it lets you concatenate the same thing to all of the
strings at once. Unfortunately you can't use it to add white
space(strcat discards what MATLAB considers extraneous whitespace).
Here's the syntax for this use.
>> strCell = {'A', 'B'};
-
>> strcat(strCell, '_'); ans = A_ B_
Finally, although MATLAB doesn't have a printf function you can
do essentially the same thing by using 1 as your file identifier in
the fprintf function. Theformat identifiers are essentially the
same as they are in C.
>> X = 9.2 >> fprintf(1, '%1.3f\n', X); 9.200
The "9.200" is printed to the screen. fprintf is nice compared
to display because you don't have to call num2str on all of the
numbers in a string - just usethe appropriate format identifer in
the place you want it.
>> X = 9.2 >> fprintf(1, 'The value of X is %1.3f
meters per second \n', X); The value of X is 9.200 meters per
second
Cell arrays of strings
In many applications (particularly those where you are parsing
text files, reading excel sheets with text, etc.) you will
encounter cell arrays of strings.
You can use the function "iscellstr" to tell if all of the
elements in a given cell array are strings or not.
>> notStrCell = {'AA', []}; >> iscellstr(notStrCell)
ans = 0
This is useful since functions that work with cell arrays of
strings will fail if provided with something that's not a cell
array of strings. In particular, they allfail if any elements of
the provided cell array are the empty array ( [] ) which is
somewhat frustrating if the provided text file contains empty
cells. Youmust catch this exception before calling cellstr
manipulation functions.
Searching a cell array of strings can be done with the
"strmatch", "strfind", and "regexp" functions. Strmatch looks for a
string within a cell array of stringswhose first characters exactly
match the string you pass to it, and returns the index of all
strings in the array for which it found a match. If you give it
the'exact' option, it will only return the indexes of elements that
are exactly the same as what you passed. For example:
>> strCell = {'Aa', 'AA'}; >> strmatch('A',
strCell); ans = 1, 2 >> strmatch('A', strCell, 'exact'); ans
= [] >> strmatch('Aa', strCell, 'exact'); ans = 1
Strfind looks for a specific string within a cell array of
strings, but it tries to find it in any part of each string. For
each element x of the given cell array ofstrings, it will return an
empty array if there is no match found in x and the starting index
(remember, strings are arrays of characters) of all matches in x if
amatch to the query is found.
>> strCell = {'Aa', 'AA'}; >> strfind(strCell, 'A');
ans = % answer is a cell array with two elements (same size as
strCell): 1 % Index of the beginning of string "A" in the first
cell 1 2 % Index of each instance of the beginning of string "A" in
the second cell >> strfind(strCell, 'a'); ans = 2 [] % 'a' is
not found
The "cellfun" / "isempty" combination is very useful for
identifying cases where the string was or was not found. You can
use the find function incombination with these two functions to
return the index of all the cells in which the query string was
found.
>> strCell = {'Aa', 'AA'}; >> idxCell =
strfind(strCell, 'a'); >> isFound = ~cellfun('isempty',
idxCell); % Returns "0" if idxCell is empty and a "1" otherwise
>> foundIdx = find(isFound) foundIdx = 2
The strfind function also has some other options, such as the
option to only return the index of the first or last match. See the
documentation for details.
The regexp function works the same way as strfind but instead of
looking for strings literally, it tries to find matches within the
cell array of strings usingregular expressions. Regular expressions
are a powerful way to match patterns within strings (not just
specific strings within strings). Entire books havebeen written
about regular expressions, so they cannot be covered in as much
detail here. However, some good resources online include
regular-expresions.info (http://www.regular-expressions.info/) and
the MATLAB documentation for the matlab-specific syntax. Note that
MATLAB implementssome, but not all, of the extended regular
expressions available in other languages such as Perl.
-
Unfortunately, MATLAB does not innately have functions to do
common string operations in some other languages such as string
splitting. However, it isquite possible to find many of these
functions in a google search.
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 not discard
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 == operatorfor numeric values.
>> strcmp(1,1) ans = 0.
This section discusses anonymous functions and function handles.
Both of these are portable in that rather than having to write an
equation multiple timesin a program, 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 anequation to another
function for direct evaluation as needed. Anonymous functions are
useful for command-line evaluation or for multiple evaluations in
thesame m-file.
Anonymous functions
An anonymous function can 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 to declare 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 will become outdated soon so using this construct in a
distributedprogram 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
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 yourprogram more general as it lets you
pass any m-file (as long as it meets other requirements like having
the right number of input arguments and so on). Thefunctionality is
similar to that of function pointers in C++.
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 can evaluate more than one equation in the m-file, thus
allowing you to dothings like solve systems of ODEs rather than
only one. Anonymous functions limit you to one equation.
How to write a function that accepts a function handle
You can also write your own functions that accept function
handles. Simply define them as variables in your header, and then
call them as if they werefunctions:
% myadd adds two variables together
function result = myfunc(func, a, b);
result = func(a, b);
[in a separate m-file]
function sum = myadd(a, b)
sum = a+b;
The command you send to myfunc looks like this:
>> result = myfunc(@myadd, 1, 2);
result = 3
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. Forexample, 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 still possible to declare a complex number like
this:
>> i = 3;
>> a = 1i + 1
a = 1.000 + 1.000i
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 thebest 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 theintended 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) or some 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 when programming, 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. Itreturns 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 youcan use this as part of a conditional, 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)
ans = 1 0
One thing you may need to do is perform an operation on the real
values of an array but not the complex values. MATLAB does not have
a function todirectly 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 types presented here, strings and number, are
particular cases of arrays. Asin many traditional languages, arrays
in MATLAB are a collection of several values of the same type (by
default, the type is equivalent to the C typedouble on the same
architecture. On x86 and powerpc, it is a floating point value of
64 bits). They are indexed through the use of a single integer or,
to getmore 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 a row array if you don't give it any separators.
However, thecommas 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
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 Linear Algebra 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 be referred to as a matrix. It should be noted that
a matrix, as itsmathematical 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 datatype, 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 size function. Following the standard
mathematical convention, the firstnumber 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 arrays are actually a special
case of multi-dimensional arrays, and the 'size' function can be
used for them as well.
>> size(array)
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. Forexample, suppose you wanted 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 efficient in MATLAB, and it will make your
programs run very slowly. Instead, you can create another array of
3s and add the twoarrays 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 toall 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.
Arrays are a fundamental principle of MATLAB, and almost
everything in MATLAB is done through a massive use of arrays. To
have a deeperexplanation 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, the matrix definitions of operations are
used, unless a specialoperator called the dot operator is
applied.
Because arrays operations are so similar to the equivalent
mathematical operations, a basic knowledge of linear algebra is
mandatory to use matlabeffectively. However, we won't be as precise
as in mathematics when using the terms vector and matrix. In
MATLAB, both are arrays of doubles (thusbeing a matrix in the real
mathematical meaning), and MATLAB considers vectors as a matrices
with only one row or only one column. However, thereare 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 separate elements, the default
separator is comma, thus making the vector a row vector.
Logically, inputting a matrix is done by using a comma separated
list of column vectors, or a semicolon separated 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 assignment 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 forget to assign the last statement to
a variable, the variable ans alwayspoint 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 =
1 2 3
I.e. 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 assignment willoverwrite 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 theoperator (), with the index 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 =
3
-
You can also access a matrix element through a unique index; in
this case, the order is column major, meaning you first go through
all elements of the firstcolumn, then the 2d column, etc... The
column major mode is the same as in Fortran, and the contrary of
the order 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 ofa given dimension or with indices
between two given values. For example, say you want to access the
entire first row of matrix a above, but not thesecond 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 the following 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]
>> 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 satisfy some 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 the find function to find the indices of allnumbers
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. Itthen 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
-
The interesting part is of course applying some operations on
those arrays. You can for example use the classic arithmetic
operations + and - on any arrayin matlab: this results in the
vector addition and subtraction as defined in classic vector
vectors spaces , which is simply the addition and
subtractionelements wise:
>> [1, 2, 3] - [1, 2, 1]
ans =
0 0 2
The multiplication by a scalar also works as expected:
>> 2 * [1, 2, 3]
ans =
[2, 4, 6]
Multiplication and division are more problematic: multiplying
two vectors in does not make sense. It makes sense only in the
matrix context. Using thesymbol * in matlab computes the matrix
product, which is only defined when the number of columns of the
left operand matches the number of rows ofthe 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 (see
Wikipedia:Invertible matrix). For squarematrices, is equivalent to
. 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 usingmatrix definitions of these 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 =
0 2 6
The other two componentwise operators are ./ and .^.
-
As matlab is a numerical computing language, you should keep in
mind that a matrix which is theoretically invertible may lead to
precision problems andthus giving imprecise results or even totally
wrong results. The message above "matrix is singular to working
precision" should appear in those cases,meaning the results cannot
be trusted.
Non-square matrices can also be used as the right operand of /;
in this case, it computes the pseudoinverse. This is especially
useful in least squareproblems.
Boolean Operators on Arrays
The same boolean operators that can be used for point values can
also be used to compare arrays. To do this, MATLAB compares the
elementscomponentwise and returns them in a logical array of the
same size as the two arrays being compared. The two arrays must
have the same size. Forexample,
>> A = [2,4], B = [1,5];
>> A < B
ans =
[0 1]
You must be careful when using comparisons between arrays as
loop conditions, since they clearly do not return single values and
therefore can causeambiguous results. The loop condition should be
reducable to a single boolean value, T or F, not an array. Two
common ways of doing this are the "any"and the "all" functions. A
function call any(array) will return true if array contains any
nonzero values and false if all values are zero. It does
thecomparisons in one direction first then the other, so to reduce
a matrix you must call the any function twice. The function all,
similarly, returns true if andonly if all elements in a given row
or column are nonzero.
Solving Linear Systems
To solve a linear system in the form Ax = b use the "\"
operator.
Example:
>>A = [4 5 ; 2 8];
b = [23 28]';
x = A\b
x =
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 avector. There are several operations you can
perform with vectors which don't make a lot of sense with other
arrays such as matrices. However, since avector is a special case
of a matrix, any matrix functions can also be performed on vectors
as well provided that the operation makes sense 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, all dimensions
except for one must have length 1. It does not matter if the array
is vertical or horizontal. Forinstance, both of the following are
vectors:
>> Horiz = [1,2,3];
>> Vert = [4;5;6];
You can use the isvector function 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 use them. For example, gradients can be
stored in the form of theJacobian (which is how the symbolic math
toolbox will return the derivative of a multiple variable function)
and extracted as needed to find the magnitudeof the derivative of a
specific function in a system.
Declaring a vector with linear or logarithmic spacing
Suppose you wish to declare a vector which varies linearly
between two endpoints. For example, the vector [1,2,3] varies
linearly between 1 and 3, andthe vector [1,1.1,1.2,1.3,...,2.9,3]
also varies linearly between 1 and 3. To avoid having to type out
all those terms, MATLAB comes with a convenientfunction called
linspace to declare such vectors automatically:
>> LinVector = linspace(1,3,21)
LinVector = Columns 1 through 9
1.0000 1.1000 1.2000 1.3000 1.4000 1.5000 1.6000 1.7000
1.8000
Columns 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 vector use the transpose operator (') on
LinVector.
The third argument to the function is the total size of the
vector you want, which will include the first two arguments as
endpoints and n - 2 other points inbetween. 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. This function, unlike the linspace function,
does not find n - 2 pointsbetween the first two arguments a and b.
Instead it finds n-2 points between 10^a and 10^b as follows:
>> LogVector = 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.3162 0.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 logarithmicaxes 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
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 in combination 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'smagnitude:
>> 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 toeach 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 programmingin C.
MATLAB has multiple ways of defining and accessing structure
fields. See Declaring Structures for more details.
Note: Structure field names must begin with a letter, and are
case-sensitive. The rest of the name may contain letters, numerals,
and underscorecharacters. Use the namelengthmax function to
determine the maximum length of a field name.
Declaring Structures
Structures can be declared using the struct command.
>> a = struct('b', 0, 'c', 'test')
a =
b: 0
c: 'test'
In MATLAB, variables do not require explicit declaration before
their use. As a result structures can be declared with the '.'
operator.
>> b.c = 'test'
b =
c: 'test'
Structures can be declared as needed and so can the fields.
Arrays of Structures
Structures can also be arrays. Below is an example
>> a = struct('b', 0, 'c', 'test'); % Create structure
>> a(2).b = 1; % Turn it into an array by creating another
element
>> a(2).c = 'testing'
a =
1x2 struct array with fields:
b
c
>> a(1) % Initial structure
ans =
b: 0
c: 'test'
>> a(2) % The second element
ans =
b: 1
c: 'testing'
Accessing Fields
When the field name is known the field value can be accessed
directly.
>> a.c
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 square brackets ([]) as seenbelow.
>> [a.('c')]
ans =
testtesting
>> [a.('b')]
ans =
0 1
Or you can put them all into a cell array (rather than
concatenating them) like this:
>> {a.('c')}
ans = {'test', 'testing'}
External Resources
ControlTheoryPro.com
(http://wikis.controltheorypro.com/index.php?title=Structures)
Introduction
Cell arrays are created just like regular arrays except that
curly brackets are used instead of square brackets.
array = [1, 2, 3; 4, 5, 6];
cell_array = {1, 2, 3; 4, 5, 6};
The array variable is 1 array with 2 rows and 3 columns. Each
element is a scalar. The cell_array variable is essentially an
array of arrays. In this case thecell_array variable is made up of
6 arrays with 1 scalar element in each of the 6 arrays.
Cell arrays have fewer limitations than regular arrays. The
regular array, defined by the square brackets, can hold numbers or
strings but if it holds stringsin each element all the strings must
be the same length. Also, if 1 element of an array is a string all
elements must be a string. Cell arrays have neither ofthese
limitations.
cell_array = {1, 2, 'a', 'abc'; rand(3, 2), magic(3), eye(3),
'junk'}
cell_array =
[ 1] [ 2] 'a' 'abc'
[3x2 double] [3x3 double] [3x3 double] 'junk'
With the lack of limitations/rules for the content of a cell
array comes complications. These cell arrays are very powerful
tools but take a lot of time to getused to because each element can
be almost anything.
Cell arrays can also be dynamically resized--a key feature in
more advanced data structures. For example, one can create a queue
data structure using
thecommands:cell_array{end+1}='a';cell_array{end+1}='b';...
etc.
Once can pop an element from the front of the queue using the
commands:
-
cell_array(1)=[]; % remove first element -
resizecell_array(1)=[]; % remove first element - resize... etc.
External Links
ControlTheoryPro.com
(http://wikis.controltheorypro.com/index.php?title=Cell_Arrays)MATLAB
Programming/Sparce Matrices
Chapter 4: 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 two or more graphs in one figure, 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 makes it easy to see
three-dimensional images. It follows the same syntax as the "plot"
command. If you searchthe MATLAB help (not at the command prompt.
Go to the HELP tab at the top of the main bar and then type plot3
in the search), you will find all theinstruction you need.
Example:
l=[-98.0556 ; 1187.074];
f=[ -33.5448 ; -240.402];
d=[ 1298 ; 1305.5]
plot3(l,f,d); grid on;
This example plots a line in 3D. I created this code in an
M-file. If you do the same, change the values and hit the run
button in the menu bar to see theeffect.
Mesh
Creates a 3D plot using vectors x and y, and a matrix z. If x is
n elements 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);
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 n elements 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 can add details to your plot. From inserting text
at the right positionsto labelling the axes, MATLAB from the
command line offers you an easy way to create publication style
graphics. With support for EncapsulatedPostScript and Adobe
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 andthe data are encapsulated into the
object. A typical figure would contain at least half a dozen
objects. These objects are called handles. A very tackyanalogy
would be like handles to several different refrigerators with
several different contents. To provide an intuitive feel. I have
listed out the propertiesfrom a text handle.
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);
Chapter 5: 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 andmanipulate the variables of the base workspace.
This can get very messy and lead to all sorts of strange errors
when loops are involved and the coder islazy 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 loopvariable).
Functions are wholly contained in themselves. They possess their
own workspace keeping workspaces separate. This means that all
variables necessaryfor a particular function must be passed or
defined in some way. This can get tedious for complex algorithms
requiring lots of variables. However, anymanipulations of variables
are discarded when the function is exited. Only those output
arguments provided by the function are available to the
callingworkspace. 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 if you have conditionals or loops in your
code, or if you're planningon 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.
The function_name can be anything you like but it is best if the
m-file name isfunction_name.m. Calling the function from the
command line or another m-file is done by invoking the m-file name
of the function with the necessaryinput 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 thevariable for the output argument
doesn't exist in the function's workspace. This will cause an error
about "one or more output arguments". It is goodpractice 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 encountersan error you've anticipated then the
function can return (via the return command) with those default
values. If the initialization value is an invalid value thenit 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 thatm-file name.
The current path is
the current directory (which can be seen at the top of the
MATLAB window or by typing pwd at the command prompt
the default path
Note that MATLAB will always search the current directory before
searching any of the rest of the path.
nargin & nargout
The nargin and nargout commands are only valid inside functions
since scripts are not passed any arguments. The nargin command
returns the numberof passed input arguments. This is useful in
conjunction with nargchk
nargchk(min, max, nargin)
where min is the minimum number of arguments necessary for the
function to operate and max is the maximum number of valid input
arguments.
The nargout command is useful for determining which output
arguments to return. Typically, the outputs are the end results of
some algorithm and theyare easily calculated. However, in some
instances secondary output arguments can be time consuming to
calculate or require more input arguments thanthe primary output
arguments do. So the function can check the number of output
arguments being requested through the nargout command. If the
callerisn'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 theseproperties but the user is allowed to override
these defaults. This is accomplished through the use of varargin.
varargin is a cell array that is usuallyparsed 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 for or while loopand a switch
statement.
function [out] = myFunc(in, varargin)
The varargout output argument option allows for a variable
number of output arguments just as varargin allows for a variable
number of inputarguments. From the MATLAB
site(http://www.mathworks.com/access/helpdesk/help/techdoc/index.html?/access/helpdesk/help/techdoc/ref/varargout.html&http://www.google.com/search?sourceid=navclient&ie=UTF-8&rlz=1T4GFRD_enUS257US258&q=varargout+MATLAB)
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 of code in the command prompt and then
execute. This can makeyour 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 your code 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
%mm/dd/yyyy
See the 'comments' section for more details on this.
Nested functions
External Links
Large parts of this page come from the ControlTheoryPro.com page
on M-files
(http://wikis.controltheorypro.com/index.php?title=M-files),
Scripts(http://wikis.controltheorypro.com/index.php?title=MATLAB_Scripts),
and Functions
(http://wikis.controltheorypro.com/index.php?title=MATLAB_Functions).
Placing comments
Comment lines begin with the character '%', and anything after a
'%' character is ignored by the interpreter. The % character itself
only tells the interpreterto 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 foradding and removing chunks of comments.
Select the code you wish to comment or uncomment, and then press
Ctrl-R to (-/ for Mac) place one '%'symbol at the beginning of each
line and Ctrl-T (-T for Mac) to do the opposite.
-
MATLAB also supports multi-line comments, akin to /* ... */ in
languages like C or C++, via the %{ and %} delimiters. But there is
a small and
important difference. In MATLAB it is not allowed that the lines
starting with %{ or %} contains any other text (execpt white
spaces). Otherwise it would
not work. E.g.
%{ for i = 1:10
disp(i)
end %}
gives an error, but
%{
for i = 1:10
disp(i)
end
%}
works just fine.
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 orotherwise perform subtle actions. 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 of comments 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.
Comments can also be used to identify authors, references,
licenses, and so on. Such text is often found at the end of an M
file though also can be foundat the beginning. Finally, comments
can be used to aid in debugging, as explained in Debugging M
Files.
The input() function lets your scripts process data entered at
the command line. All input is converted into a numerical value or
array. The argument for theinput() 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 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 when the logical
test (expression) returns a true value (anything but 0). An "else"
statement following an "if"statement is executed 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 replacenested "if" statements depending on the
same variable, which can become very cumbersome. The syntax is as
follows:
switch variable
case value1
statements(1)
case value2
statements(2)
...
otherwise
statements
end
The end is only necessary after the entire switch block, not
after each case. If you terminate the switch statement and follow
it with a "case" statement youwill get an error saying the use of
the "case" keyword is invalid. If this happens it is probably
because you deleted a loop or an "if" statement but forgot todelete
the "end" that went with it, thus 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 of variable other than those specified
by the "case"statements.
Programmers who are used to C style languages, often put break
statements after each case. In C, C++, and Java, not putting a
break statement allowsthe code to fall through in the code above,
if value1 is true, then statements(1), statements(2), etc., will
execute in C-style languages. However, inMATLAB only statements(1)
will execute.
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 isterminated and the code in the "catch" block is
executed rather than simply reporting an error to the screen and
terminating the entire program. This isuseful for debugging and
also for filtering out erroneous calculations, like if you
accidentally try to find the inverse of a singular matrix, when you
don't wishto 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 willalways be at least partially executed. Not all
of the TRY block code will always be executed, since execution of
the TRY ends when an error occurs. Inaddition, the statements in
the CATCH block will never be executed if the TRY block does not
fail.
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 increment every time it goes through the
loop, until it reaches the valueendvalue. If increment is 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
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, CONTINUE, and RETURN
MATLAB includes the "break" and "continue" keywords to allow
tighter loop control. The "break" keyword will cause the program to
leave the loop it iscurrently 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 breaksfrom the
loop it's in, not all of them. 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 itshould continue executing loop
code or not. The code in the loop after the "continue" statement is
not executed in the same pass.
If you want to exit a function entirely (as opposed to just a
loop) before the last line of code, it is possible to do so using
the "return" keyword. The valueof any output variables is
immediately returned to the calling function. As an example of how
this works, consider the following function:
function output = controlTest(doWhat);
switch doWhat
case 1
output = -1;
return;
case 2
output = 3;
end
output = output + 4;
Calling
>> output = controlTest(1)
would return output = -1, because output is defined to -1 and
the return statement tells MATLAB to immediately take the current
value of output andpass it back to the calling function. However,
calling
>> output = controlTest(2)
would return output = 7, because output is initially defined as
3 and then 4 is added to it. Since the return statement is only
executed in the case thatdoWhat=1, it is not called and the rest of
the function executes.
Beware that if the output variables are not defined before
calling the return statement, you will get an error, so use this
with some degree of caution.
Program Flow
The idea of program flow is simple. However, implementing and
using flow techniques effectivly takes practice. MATLAB flow
control is almost identicalto flow control in C. There is a
tremendous amount of text on the subject of flow in C. If you do a
little homework in about an hour you can know all youneed 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 the algebraic 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 error messages. Most of the syntax errors
are not difficult to fix onceyou 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.
Arithmetic errors
Usually these are self-explanatory. As a reminder, here are some
common functions that cannot be performed and what MATLAB returns
(along with awarning 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 avoid propogating 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 usingpower 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 of columns in the
first matrix to equal the number of rows 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 usecomponentwise 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 totake 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 the dot.
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 afunction. One annoying fact is that the
names of variables are case sensitive, but the names of functions
are NOT. So if you make an array called Abs andyou try to index
abs(1), it will return 1 no matter what the first value in the
array Abs is. Unfortunately, MATLAB will not return an error for
this (althoughMATLAB v2008+ or so will return a warning saying that
this will be changed in a later version), so a good rule of thumb
is never ever name yourvariables 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 oftenoccurs 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 you which index is not real or logical. Also
note that if 0 was a logical0 (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. This could be an example of someone trying
to access all rows of Aafter the first one and the second column,
in which case you should use the "end" syntax, as in:
>> A(1:end, 2)
ans = 3
Make sure you are careful when using the colon operator, because
it does many different things depending on where you put it and
misuse often results inthese 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 sameline 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 1x3array but the right 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
theright is 1x4. In all three cases, the dimensions do not match.
They must match if you want to replace a specific portion of an
existing variable. It doesn'tmatter if they have the same number of
data points or not (as the third example shows); the dimensions
must also be the same, with the exception that ifyou have a 1xn
array on one side and an nx1 on the other MATLAB will automatically
transpose 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 structarrays. Suppose you define 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 bedone 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 storethem in one array. You cannot do 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 both values, but reassign the variable ans each time,
because it is treated astwo 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)
??? Incorrect number of right hand side elements in dot name
assignment. Missing [] around left hand side is a likely cause.
>> cube(:).volForm = @(S) (S^ 3)
??? Insufficient outputs from right hand side to satisfy comma
separated
list expansion on left hand side. Missing [] are the most likely
cause.
Unfortunately missing [] is not the cause, since adding them
causes more errors. The cause is that you cannot assign the same
value to all fields of the samename at once, you must do it one at
a time, as in the following code:
>> for ii = 1:2
>> cube(ii).volForm = @(S) (S^ 3);
>> end
>> cube
ans = 1x2 struct array with fields:
volume
side
volForm
The same volume formula is then found in both cubes. This
problem can be alleviated if you do not split the root, which is
highly recommended. Forexample, you can use a struct like this:
>> shapes.cubeVol = @(S) (S^ 3);
>> shapes.cube(1).vol = 1;
>> shapes.cube(2).vol = 8;
This avoids having to use a loop to put in the formula common to
all cubes.
Syntax errors
Parenthesis errors
Unlike in C++, you are not required to terminate every line with
anything but a line break of some sort. However, there are still
syntax rules you have tofollow. In MATLAB you have to be especially
careful with where you put your parenthesis so that MATLAB will do
what you want it to.
A very common error is illustrated in the following:
>> A(1
??? A(1
|
Error: Expression or statement is incorrect--possibly unbalanced
(, {, or [.
This error is simple enough, it means you're missing a
parenthesis, or you have too many. Another closely related error is
the following:
>> 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 verycarefully to find your typo. 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 keeptrying to
correct it and saving the file until that breakpoint 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), asin
>> save file.txt variable
In this line, file.txt and variable are passed to the save
function as strings. It is an occasional mistake to forget a
parenthesis and accidentally try and passa 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.
A common mistake with strings is to try to compare them using
the '==' operator. This does not work if the strings are not the
same length, becuase stringsare arrays of characters, and to
compare arrays with '==' they must be the same size. To compare two
strings you must use the strcmp function:
>> 'AA' == 'AaA'
??? Error using ==> eq
Matrix dimensions must agree.
>> strcmp('AA', 'AaA')
ans = 0
>> strcmp('A', 'a')
ans = 0
>> strcmp('AA', 'AA')
ans = 1
Note that MATLAB strings are case sensitive, 'A' and 'a' are not
the same string.
Also beware that the ' character for beginning and ending
strings is the same character indicating transposition. So if you
close a string and don't begin it,you will most likely end up with
an error about an undefined variable (if you're trying to transpose
an undefined variable) or just get really weird resultsbecause you
transposed something you didn't intend to.
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+
|
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. Another possibility is that you named
your m-fi