Writing Fast MATLAB Code
- 5 files
- 105 downloads
Editor's Note: This file was selected as MATLAB Central Pick of the Week Popular File 2008
Learn how to use the Profiler tool, vectorized functions, and other tricks to writing efficient MATLAB code. This article includes how to convert any array into a column vector, bounding a value without if statements, and repeating/tiling a vector without repmat.
Contents:
* Introduction
* The Profiler
* Array Preallocation
* JIT Acceleration
* Vectorization
* Inlining Simple Functions
* Referencing Operations
* Solving Ax=b
* Numerical Integration
* Signal Processing
* Miscellaneous Tricks
* Further Reading
Cite As
Pascal Getreuer (2020). Writing Fast MATLAB Code (https://www.mathworks.com/matlabcentral/fileexchange/5685-writing-fast-matlab-code), MATLAB Central File Exchange. Retrieved .
Comments and Ratings (93)
Updates
| 1.1.0.0 | Updated for R2008b, new introduction and added Ax=b section |
|
| 1.0.0.0 | Updates for MATLAB 7, including a new section on JIT |
|
Signal Processing section added |
||
Various revisions, integration section added |
||
Inlining Simple Functions section added |
||
Various fixes and revision |
MATLAB Release Compatibility
Platform Compatibility
Windows macOS LinuxCategories
Tags
Acknowledgements
Inspired: Guidelines for writing clean and fast code in MATLAB
Discover Live Editor
Create scripts with code, output, and formatted text in a single executable document.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
Select web siteYou can also select a web site from the following list:
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)
Devin (view profile)
Daniel Peter (view profile)
Eyal Ben-Hur (view profile)
yenlung lin (view profile)
Awesome! Thank you!
wanghu wanghu (view profile)
yes，it's very useful. Thank you very much.
furusuna yume (view profile)
Azalin L (view profile)
Hey Sam Thanks for pointing that out.
Stephen Cobeldick (view profile)
A tidy introduction to writing faster MATLAB code. The PDF covers the main points to consider, the general advice given is sound, and the example code should be able to assist new MATLAB users.
However there are several mistakes, one of which actually slows code down:
* Using |find| when simple logical indexing would be faster: only two out of the nine code examples that use |find(...)| is actually required (both are in "Vectorized Logic"). In all other code examples they could be replaced by logical indexing, which would be faster and simpler code:
http://blogs.mathworks.com/steve/2008/01/28/logical-indexing/
* |ind2sub| is shown with only one output, whereas actually the row and column indices are returned in separate outputs. Thus the subscript indexing example is incorrect.
* Misleading statements like "Using preallocation with a frequently resizing cell array is even more beneficial than with double arrays": MATLAB's own documentation does not make any such statement, and clearly recommends preallocating numeric arrays. Numeric arrays are stored in contiguous memory locations, so preallocation is critical for them: this is reflected in the fact that this is the _very first topic_ on MATLAB's own "Improving Performance" page:
http://www.mathworks.com/help/matlab/matlab_prog/techniques-for-improving-performance.html
The section on preallocation does not mention some other ways to preallocate arrays, in particular:
1. Looping in reverse.
2. Allocating one scalar element at a specific location.
Both of these can be faster than allocating an entire array before commencing calculations.
* Non-standard terminology makes it difficult for readers to transfer this knowledge to MATLAB's own documentation. For example "per-element" operations are actually named "element-wise" or "array" operations by MATLAB, and what are called "indices" in this document are called "linear indices" by MATLAB:
http://www.mathworks.com/help/matlab/matlab_prog/array-vs-matrix-operations.html
http://www.mathworks.com/company/newsletters/articles/matrix-indexing-in-matlab.html
* It would be significantly improved by hyperlinks to the relevant documentation webpages, e.g. for array preallocation, element-wise operations, etc., and for every function used in the code examples.
* No mention of |bsxfun|, one of the most significant and useful functions for fast and efficient vectorized code:
http://www.mathworks.com/help/matlab/ref/bsxfun.html
Aneesh (view profile)
This should be standard issue with every copy of MATLAB. Very useful!
Emre Ozan Alkan (view profile)
Awesome! Thank you!
Manu (view profile)
Michael (view profile)
Olexander Zhytenko (view profile)
very good document
Olexander Zhytenko (view profile)
Good, Thanks!
Sven Koerner (view profile)
David Smith (view profile)
Michael Völker (view profile)
Luis Andres (view profile)
Good work!
Savas (view profile)
Thanks a lot. THis will have a big effect on my code
Javier Lopez-Calderon (view profile)
Great, Thanks!
Nitin (view profile)
Jada (view profile)
Danila (view profile)
Leonardo Glavina (view profile)
Aniket (view profile)
very well written guide..thanks
Nguyen Thang (view profile)
Good, Thanks!
sara (view profile)
Luigi Giaccari (view profile)
Thanks sometimes pdf are better than m-file.
Sunil (view profile)
thank u for such kind information. really helpful tips and please would you suggest me that i have a problem regarding execution time of for loop which i have to execute for 262144 times and its taking too much time about 2 mins so what should i do to reduce the execution time even i have used the preallocation of resultant matrix.
I forgot rating. :)))
Thanks a lot for this. A much for any people speaks MATLAB.
Thank you about this informations
This is so amazing and helpful. I've been struggling with slow executing functions and million element matrices for a long time but now it's all solved. Thanks a lot Mr. and know that you've been a lot of help. A LOT.
Indeed, a very good read ... should talk about things like bsxfun and how mex files compare to past and current matlab speeds. How about a section on I/O and string parsing.
Nice little read with some random tips.
kudos guy. I believe this meet sure meet the yearning fast majority of novice MATLAB users the world over.
good
nice
Kudos, very informative and well written. Thank you for your good efforts!
none
wow its very exciting
Well written article. Quite useful. Thanks.
very usefull
thx
i'm a student interested in this field.
excelente
Very useful tip!! I love it
I love it, Azalin.. way to face off against bad grammar with even worse...
there were some grammar errors...but I guess your a French speaker
apart from that...it was descent
Very good short introduction to optimizing m-files!
fair try
Excellent work.
You may want to correct the submission date. Thought it was old but realised when opened it that it was writen in June 2006.
Very good
Excellent stuff.
Thanks you are really good people
Great Job
It's a great helping tool.
A very good outline of advanced Matlab tips. Well worth reading.
Yes it's a good idea to use the profiler. Using the profiler, I found that Pascal's recommended matrix initial code A = s(ones(m,n)) is four times slower than the simpler A(1:m,1:n) = s or A = s +zeros(m,n)
itis moreuseful
fillfull
Useful
Helpful.
As a beginner, I have found everything clear, fast reading, and useful. Good job!
very good document
Very good description of the indexing features of matlab. Please not that transposing a matrix using ' will complex conjungate the elements aswell. Therefore to create a row-vector by A(:)' should be done with care. Alternatively I think that transpose(A(:)) should be used.
A nice (and brief) collection of useful tips.
Thanks, this is a great basic guide to speeding up Matlab code. I wish I had it a year ago when I started with Matlab.
As a note though, the method shown to avoid repmat is rarely faster (in Matlab 6.5) and usually slower than actually using repmat.
But thanks for the work you put into this, I printed it out and keep it next to Richard Johnson's "Matlab Programming Style Guidelines" on my ML shelf.
It's great
***Response to review***
I'm sorry this article wasn't helpful, perhaps it is too introductory for you. Responding to your points:
(1) ?numel? is not a function as of MATLAB 5.3 (what usually work with). It is a standard function by version 6.1.
(2) It is true that min and max operate over columns rather than entire matrices (the article includes some discussion on this). Thus the suggested methods involving min and max include matrix to vector conversion (using "A(:)" changes A to a vector). It works for matrices and n-D matrices of all sizes.
(3) The advantage of the not repmat method is that there is no function call -- it won't be significantly faster for a single tiling but can make a difference for many separate tiling operations. Furthermore, the standard m-files in MATLAB 4.0 and earlier don't include repmat, so this method is also more compatible.
(4) MEX is not a topic of discussion in this article, only mentioned. I agree it is much more difficult to write and peer and should only be a last resort.
(5) And yes, looping has a fair bit of overhead. Try the profiler on a for loop with many iterations and a one-line inner loop.
You should look into NUMEL rather then prod(size(x)). Also be careful about recommending any or all or even min and max. they operate on vectors and NOT the entire matrix! You suggestions about not repmat are awful. I tried each one of your examples and found that was the same speed or faster. My matrices had around 5 million numbers in them. The last thing I would recommend is the use of MEX files. While it can be faster, it will take that much longer to write, peer, and debug. Did you check the speed of looping in matlab?