{"id":4233,"date":"2013-01-11T09:00:28","date_gmt":"2013-01-11T14:00:28","guid":{"rendered":"https:\/\/blogs.mathworks.com\/pick\/?p=4233"},"modified":"2013-01-11T16:57:02","modified_gmt":"2013-01-11T21:57:02","slug":"functional-programming-constructs","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/pick\/2013\/01\/11\/functional-programming-constructs\/","title":{"rendered":"Functional Programming Constructs"},"content":{"rendered":"
\r\n

Jiro<\/a>'s pick this week is Functional Programming Constructs<\/a> by Tucker McClure<\/a>.\r\n <\/p>\r\n

Anonymous functions<\/a> are extremely powerful and useful, and I use them all the time whenever I want to create a quick function without writing\r\n a MATLAB file. For me, it's one of those features which the more I use, the more I appreciate. Loren has written this post<\/a> on anonymous functions, and she has discussed the topic in other posts as well.\r\n <\/p>\r\n

For those of you who are not familiar with anonymous functions, let me give you a simple example. Tapping into my mechanical\r\n engineering background, let's simulate a damped harmonic oscillator<\/a> by solving the second-order differential equation numerically with ode45<\/tt><\/a>.\r\n <\/p>\r\n

<\/p>\r\n

We solve the ODE by passing in the system of first order differential equations in the form of<\/p>\r\n

<\/p>\r\n

A second order differential equation becomes a system of two first order differential equations.<\/p>

function<\/span> dY = odeFcn(t, y, m, k, b)\r\n  dY = [y(2); -1\/m * (k * y(1) + b * y(2))];\r\nend<\/span><\/pre>
Then you can solve the system like this (after defining m<\/tt>, k<\/tt>, b<\/tt>, and T<\/tt>):\r\n   <\/p>
[~, Y] = ode45(@(t, y) odeFcn(t, y, m, k, b), T, [0, 1]);<\/pre>
Simple enough. However, instead of creating a separate function file for odeFcn<\/tt>, I can just create an anonymous function. I can do this because this is a simple, one-statement function.\r\n   <\/p>
% Define mass, spring stiffness, and damping<\/span>\r\nm = 5; k = 5; b = 1;\r\n\r\n% Create anonymous function for the damped harmonic oscillator<\/span>\r\nodeFcnAnon = @(t, y) [y(2); -1\/m * (k * y(1) + b * y(2))];<\/pre>
Now, we can just pass the function handle (to the anonymous function) odeFcnAnon<\/tt> to ode45<\/tt>:\r\n   <\/p>
% Define time vector<\/span>\r\nT = 0:0.1:25;\r\n\r\n% Solve<\/span>\r\n[~, Y] = ode45(odeFcnAnon, T, [0, 1]);\r\nplot(T, Y);\r\nlegend('Position'<\/span>, 'Velocity'<\/span>);<\/pre> 
Wasn't that great? I didn't have to write a separate file or a function. I just created the ODE function \"on the fly\". However,\r\n      I can't create any<\/i> function on the fly. An anonymous function can only contain one executable statement, i.e. I cannot have multiple statements\r\n      or flow control commands like if<\/tt> and for<\/tt>.\r\n   <\/p>\r\n   
Well, that's a bummer! I wanted to make my dampled oscillator behave a little differently by adding an external force at a\r\n      certain time. To do that, my ODE function would look something like this:\r\n   <\/p>
function<\/span> dY = odeFcn(t, y, m, k, b, t0, F)\r\n  if<\/span> t > t0  % after time t0, apply force F<\/span>\r\n    dY = [y(2); -1\/m * (k * y(1) + b * y(2) - F)];\r\n  else<\/span>\r\n    dY = [y(2); -1\/m * (k * y(1) + b * y(2))];\r\n  end<\/span>\r\nend<\/span><\/pre>
This certainly has more than one statement. How can I possibly do this with an anonymous function? Is my only choice to write\r\n      a separate function?? ...\r\n   <\/p>\r\n   
Not anymore! My colleague, Tucker, comes to the rescue! He has created a number of functions for flow control commands, as\r\n      well as other functions that aide in use inside anonymous functions. For example, he has a function iif<\/tt>, which is the functional form of if<\/tt>.\r\n   <\/p>
iif(<if this>,      <then that>, ...\r\n    <else if this>, <then that>, ...\r\n    <else>,         <then that>);<\/pre>
Let's see what our ODE anonymous function would look like with this.<\/p>
odeFcnAnon = @(t, y, t0, F) iif( ...<\/span>\r\n   t > t0, @() [y(2); -1\/m*(k*y(1)+b*y(2)-F)], ...<\/span> % if t > t0<\/span>\r\n   true  , @() [y(2); -1\/m*(k*y(1)+b*y(2)  )]);    % else<\/span><\/pre>
And, let's solve. Notice that I'm passing in two extra arguments, t0<\/tt> and F<\/tt>.\r\n   <\/p>
t0 = 15;   % Force applied at 15 seconds<\/span>\r\nF = 5;     % External force<\/span>\r\n[~, Y] = ode45(@(t, y) odeFcnAnon(t, y, t0, F), T, [0, 1]);\r\nplot(T, Y);\r\nlegend('Position'<\/span>, 'Velocity'<\/span>);<\/pre> 
That was cool. I was able to create an anonymous function for my function that contained conditional statements.<\/p>\r\n   
Let me show a couple of more functions, and I'll leave the rest for you to explore. One of the things that are not possible\r\n      with anonymous functions is the ability to deal with outputs of functions. For example, inside an anonymous function, I am\r\n      not able to access the second output of a function, or index into the first column of the output. This is because I can't\r\n      have multiple statements inside an anonymous function, like this:\r\n   <\/p>
@() [var1, var2] = myFunction;var2(:, 1)<\/pre>
For this, Tucker has created output<\/tt> and paren<\/tt>. Let's create an anonymous function that would solve the ODE, extract the position vector, and plot it.\r\n   <\/p>
plotODEFcn = @(t0, F) plot(T, ...<\/span>\r\n   paren(...<\/span>\r\n         output(...<\/span>\r\n                @() ode45(@(t,y) odeFcnAnon(t,y,t0,F), T, [0, 1]), ...<\/span>\r\n                2), ...<\/span>   % Get the 2nd output from ODE45  -  Y<\/span>\r\n         ':'<\/span>, 1));        % Get the 1st column of Y        -  Y(:, 1)<\/span><\/pre>
A little confusing? Don't worry. I was confused as well at first. If you read Tucker's documentation, you'll get a better\r\n      understanding.\r\n   <\/p>\r\n   
Now, we can easily create multiple plots with different forcing conditions.<\/p>
figure; hold all<\/span>;\r\nplotODEFcn(15, 5);   % Force of 5 at 15 seconds<\/span>\r\nplotODEFcn(10, 5);   % Force of 5 at 10 seconds<\/span>\r\nplotODEFcn(20, 10);  % Force of 10 at 20 seconds<\/span>\r\nplotODEFcn(5, 2);    % Force of 2 at 5 seconds<\/span>\r\nplotODEFcn(0, 0);    % No external force<\/span>\r\n\r\nxlabel('Time'<\/span>); ylabel('Position'<\/span>);\r\nlegend('t0=15, F=5'<\/span>, 't0=10, F=5'<\/span>, 't0=20, F=10'<\/span>, 't0=5, F=2'<\/span>, 'No force'<\/span>, ...<\/span>\r\n   'Location'<\/span>, 'NorthWest'<\/span>)<\/pre> 
Comments<\/b><\/p>\r\n   
I found Tucker's entry very educational. I learned quite a few techniques I wasn't aware of. If you would like to have some\r\n      discussion on this topic, feel free to leave comments here<\/a> or you can visit this post<\/a> in Loren's blog where Tucker's functions are also highlighted.\r\n   <\/p>
There are lots more to Tucker's functions, and he has written a detailed document<\/a> deriving some of those functions step by step. It's well-written for such a complex topic. I highly recommend reading through\r\n      it.\r\n   <\/p>\r\n