An Introduction MATLAB
Rather than re-invent the wheel, we'll use some tried and tested tutorial material. The following notes from the Maths department at the University of Dundee are concise, comprehensive, but also easy to read: http://www.maths.dundee.ac.uk/ftp/na-reports/MatlabNotes.pdf
Once you have read through and understood the above notes, you might like to try your hand at some example exercises:
- easier ones: http://www.facstaff.bucknell.edu/maneval/help211/basicexercises.html
- harder ones: http://www.cl.cam.ac.uk/teaching/2006/UnixTools/matlab-answers.pdf
Hints and Tips on Performance
A common query is, "How can I speed up my MATLAB code?". People often go on to say that it ran fine when they were developing their code, but now that their ambition has grown and they are working on larger problems, they end up waiting for days to get a result. This is sometimes followed up by, "it'll run faster on the HPC system, right?" Well, not necessarily.
Let's try to pick some of this apart.
There are several aspects of some MATLAB code that can really limit it's performance. For loops are a common limiting factor, as is allocation of memory on-the-fly. These limitations can often be addressed by:
- Pre-allocation memory, where appropriate.
- Replacing loops over the elements of a vector or matrix with:
- Scalar and array operations.
- Built-in functions which take vectors or matrices as arguments.
However, before we get into examples of improved code, we need to determine where your code is spending the majority of it's time. It would not be sensible to invest lots of effort in re-writing a section of your program which took only 1% of the overall runtime. Accordingly, the next section focusses on methods for finding hot spots in your code:
Finding where your code is slow
Possibly the simplest way to assess the performance of a sequence of MATLAB operations is to employ the timing functions tic and toc. For example:
tic; n=1500; A=rand(n); B=pinv(A); toc
gives the result:
Elapsed time is 2.163306 seconds.
A more detailed analysis can be elicited from the MATLAB profiler. Let's suppose we have a function which converts cartesian to polar coordinates:
function [r,theta] = cart2plr(x,y) % cart2plr Convert Cartesian coordinates to polar coordinates % % [r,theta] = cart2plr(x,y) computes r and theta with % % r = sqrt(x^2 + y^2); % theta = atan2(y,x); r = sqrt(x^2 + y^2); theta = atan2(y,x);
and we call that function a number of times in the following script:
profile on for i=1:3000 cart2plr(rand(),rand()); end profile off profile viewer
We will be able to see the following analysis in the profile viewer window:
Preallocation of Vectors
Memory allocation is an expensive operation. MATLAB will allow us to assign values to an array inside a loop, where the array keeps growing to accommodate all the iterations of the loop. For example:
for i=1:1000 vec(i) = i^2; end
However, this flexibility will come at the cost of performance, as the frequent resizing of the container vec will incur many requests for additional memory for storage. Therefore, it is wise to pre-allocate storage, if you can predict ahead of time how large the container needs to be. This is probably the simplest way in which you can speed up your MATLAB code.
To demonstrate the benefit of pre-allocation, consider the following two MATLAB scripts.
tic; for i=1:3000, for j=1:3000, x(i,j)=i+j; end end toc
tic; x=zeros(3000); for i=1:3000, for j=1:3000, x(i,j)=i+j; end end toc
When we run these two scripts (on BCp2), we see a significant difference in the runtime:
>> noprealloc Elapsed time is 14.317089 seconds. >> prealloc Elapsed time is 0.279115 seconds.
Scalar and Array Operators
For example, if you would like to perform a scalar operation to a vector, vec, (say, multiply each element by 3) then you do not need to write a loop.
for i = 1:length(vec) vec(i) = vec(i) * 3; end
vec = vec*3
Similarly, if you have two vectors or matrices of the same size, you can perform element-by-element operations using, e.g.
m3 = m1 - m2
Note that array versions of the multiplication, division and exponentiation operators are .*, ./ and .^, respectively.
If you wish to apply the same function to all the elements of an array or vector, then you can pass it as an argument to the function. If you write your own functions, ensure that the operators that you use inside the function can handle vectors or matrices.
MATLAB contains a number of built-in functions which can save you from writing a loop. Examples include:
- sum and prod: which compute the sum or product, respectively, of all the elements of vector.
- cumsum and cumprod: both return a vector and are the cumulative counterparts of 'sum and prod.
- min and max.
- any and all: will return true if any or all of the elements of a vector or matrix are true (>0), respectively.
- find: returns the indices of a vector that satisfy the given expression. For example, find(vec > 7) returns the indices of all elements of vec that are greater than 7.
Another route to higher performance is to outsource an identified bottleneck in you MATLAB code to a piece of compiled code written in C/C++ or Fortran. This is the MEX file approach. A good introduction to creating MEX files is: