Advanced Programming
Advanced Programming
MATLAB
2
MATLAB and Memory
function y = foo(x,a,b)
a(1) = a(1) + 12;
y = a*x+b;
▪ Calling foo
y = foo(1:3,2,4)
– i.e., x = 1:3, a = 2, b = 4
3
In-place Optimizations
x = 2*x + 3;
y = 2*x + 3;
4
In-place Optimizations
function showInPlace
xx = randn(n,1);
xx = myfunc(xx); % vs. yy = myfunc(xx)
xx = myfuncInPlace(xx); % vs. yy = myfuncInPlace(xx)
function x = myfuncInPlace(x)
x = sin(2*x.^2+3*x+4);
function y = myfunc(x)
y = sin(2*x.^2+3*x+4);
d = [1 2] % Double array
dcell = {d} % Cell array containing
dstruct.d = d
whos
6
MATLAB and Memory
n = 10000;
s.A = rand(n,n);
s.B = rand(n,n);
sNew = s;
s.A(1,1) = 17;
7
MATLAB and Memory
% each 1x3
im2(1,1).pixel = [red(1) green(1) blue(1)];
im2(2,1).pixel = [red(2) green(2) blue(2)];
...
im2(m,n).pixel = [red(m*n) green(m*n) …
blue(m*n)];
8
Tables
▪ Built-in functionality
(merge, sort, etc.)
9
Categorical Arrays
▪ Performance improvement
– Up to 50x faster using contains with string than strfind with cellstr
– Up to 2x memory savings using string over cellstr
11
Summary of MATLAB and Memory
12
MATLAB and Memory: Additional Resources
▪ Recorded Webinar:
– Tackling Big Data in MATLAB
– mathworks.com -> Recorded Webinars
13
Functions
14
A comp.soft-sys.matlab Post
Question:
With the new function types introduced in R14, I am curious as to which methods would be preferable from a speed
standpoint. We have:
1. Functions defined in separate files
2. Subfunctions
3. Inline functions
4. Anonymous functions
5. Nested functions
Other than scope, persistence, or program structure, is there some difference that makes MATLAB work better with
the type?
15
comp.soft-sys.matlab Post Answered
Cleve’s Answer
Good question, and a hard one to answer. As MATLAB evolves, the answer will change. The function call
mechanism in the current version of MATLAB is pretty expensive, for any kind of function. One of the most
important tasks facing our Accelerator/JIT team today is to make function calls faster. This is why we have
introduced the @ notation for both function handles and anonymous functions. Future versions of MATLAB
should have improved speed for anything involving the @ sign.
Inline functions were an experiment in the use of the overloading mechanism that turned out to be useful. But we've
always regarded them as a bit of a hack. So our advice now is to phase out their use over time. Other than that,
your choice today among the other kinds of functions should be based on style and convenience.
16
Function Quiz
17
Function Quiz Review
18
Advice
▪ You can use the function functions to explore details of the function
referred to by a particular function handle.
▪ NOTE: Changing the values of the struct output from functions does NOT
alter the function handle details!
19
Nested Function Applications
20
Application 1:
Solving Optimization Problems
▪ We get many posts on comp.soft-sys.matlab about optimization. The
problems fall into several catgories. The one we will address to today is:
21
Optimization Example (unconstrained)
Objective function:
a x1^2 + b x1 x2 + c x2^2 + d abs(x2 – x1)+ e*randn
22
Application 2:
Building a Graphical User Interface for Volume Visualization
23
Why Use Nested and Anonymous Functions?
24
Function Usage Advice
▪ You can now (as of Release 14) call functions without inputs using this notation:
y = foo();
▪ Put all nested functions at the bottom of the enclosing function. You may prefer to have
them defined right where you will use them, but this can become unwieldy.
▪ Place a comment next to a call to a nested function stating what workspace variables are
altered by the call (since the nested function can see the enclosing workspace).
25
More Function Usage Advice
▪ Nested functions are good when there is significant shared information (many pieces or
large arrays).
▪ Nested functions are very good when there is much large data to share for reading and
writing.
▪ Local functions (or private functions) are useful when users don't need these directly.
Those who need them can see.
▪ Data sharing inside local functions is only reading large arrays, not making copies and
changing them.
26
MATLAB Function Types: Additional Resources
27
Summary
28