inline VS anonymous functions

I don't see differences between... but - maybe @fun is more wide than inline-function

>> a

a =

     1

>> x=1:10

x =

     1     2     3     4     5     6     7     8     9    10

>> y=@(x) x.^a

y =

    @(x)x.^a

>> y(x)

ans =

     1     2     3     4     5     6     7     8     9    10

>> a=3

a =

     3

>> y(x)

ans =

     1     2     3     4     5     6     7     8     9    10

>> z=inline('x.^a','x')

z =

     Inline function:
     z(x) = x.^a

>> z(x)

??? Error using ==> inlineeval at 15 Error in inline expression ==> x.^a Undefined function or variable 'a'.

Answer 1

Step 1 - define anonymous function in constant a and variable x:

a = 1;
y = @(x) x.^a;

Step 2 - change constant in the workspace, but the anonymous function remains unchanged since a was taken as a parameter in step 1

a = 3;
y(x)

Step 3 - in both cases the constant a is not defined at the moment the anonymous and inline fcns are created, thus the error in both cases

clear all
y = @(x) x.^a;
y(1)

z = inline('x.^a','x')
z(x)

Step 4 alternatives

y = @(x,a) x.^a;
y(1,2)

z = inline('x.^a','x','a')
z(1,2)

inline is an eval wrapper and is much slower than anonymous fcns.

Although my question arises from this concrete problem, I understand steps 1-3 and don't wish use step 4 (to make call of @(x,a) more heavy in case of multiple parameters a,1,a2,a3...). Maybe only one way -- in M-file to construct nested function with using primary function stack.

But the second side of question -- why in MATLAB are introduced inline-functions as already EVAL, @(x) exist?

"much slower"... how many slower? May you give links? or this follows from interpretator VS compilier general discrepance?

Try to eval this snippet:

x = inline('x+1');
y = inline('y^2');
y(2) + x(1)

Eval executes the final expression while evalin remains dynamic in the variables, it's easier to use and definitely more readable.

For the timings look at this example: http://www.mathworks.com/matlabcentral/newsreader/view_thread/295607

The idea of 1st example is not clear for me.
But the 2nd example -- tremendous :)
% Elapsed time is 4.913289 seconds
% Elapsed time is 0.220958 seconds

Thank you.
Also issue --
why in my example message "Undefined function or variable 'a' "?
or parser hasn't seen 2nd parameter in calling, or parser cannot substitutes a for a-value? At last case -- inner difference eval and inline is.

Hi Igor,

for the "why": anonymous functions were "invented" as a replacement for the (somewhat ugly) inline.
Anonymous functions are much more robust then inline, same holds for using function handles in general instead of strings. Your example shows the difference: the function

@(x) x.^a

captures a at this very moment. What ever happens to a does not make a difference. This is in line with general behaviour: if you write

a = 42
x = 2*a;
a = 1;

you won't expect x to be 2. If a is indeed to be variable, use step 4.

I asked another "why" -- concerning inline.
The error is due to "not enough input args" (like this), OR due to parser at calling ">> z(x)" hasn't recognized "a" as a fact variable.

I answered you in step 3