I don’t know of a simpler solution.

–Loren

For example: passing the function handle @(x,y,z)displayAll(gcf,x,y,z) to a display manager that (by convention) supplies x,y and z, makes sure that x,y and z are plotted in figure gcf in the manner defined by the function displayAll.

Previously I did this by putting function pointers and default arguments in a cell array and somehow gluing these together in a customized version of feval, say feval_cell.

After applying the new mechanism in our existing code I discovered that calling “nargout” on the anonymous function above returns -1, rather than “nargout(displayAll)”.

One way around this would be to encapsulate the anonymous function in a class, say “myfunction”, and let this class support methods like “nargout” and “feval”. The constructor of such a class would then have to be invoked as:

fp=myfunction(@(x,y,z)displayAll(gcf,x,y,z),…
nargout(displayAll))

But maybe a simpler solution is already available in Matlab somewhere?

This is not a bug. You can get access to the local scope using eval to construct your function handle, but evalin will not let you bypass the local scope to the caller here.

You could create dummy pre and post functions for ones that don’t need it so you can use the same techniques for all your functions, but I don’t know that that will get rid of your problem.

You could perhaps write out your function to a file and then reference that instead. If you do this, you may need to update the path cache and/or use clear to make the new files visible to MATLAB.

–Loren

For instance, following your example, whilst called in a function this way:

function temp
anon = myfun('x,y','mdisp');
x=1:3;
y=10:14;
z=anon(x,y);
end

function anon = myfun(X,fun)
anon = str2func(['@(',X,')',fun,'(',X,')']);
end

function mdisp(varargin)
disp(numel(varargin))
disp(17)
end

Matlab will declare an error as it can not find the function mdisp. It will only run functions available to the base Matlab and not the ones “inside” another function thus presenting this error:

??? Undefined function or method 'mdisp' for input arguments of type 'double'.

Error in ==> @(x,y)mdisp(x,y)

Error in ==> temp at 5
z=anon(x,y);

Now, I am trying to create a wrapper function to process data by chunks, and for such I require 4 arguments;
function S=Wrapper(X,F,R,T)
X being the data
F is the actual function to call
R are the pre-requisites
T are the post-requisites
S is the output

Now, the interesting part is that not all functions require pre and/or post requisites, so I can not simply write an:

A=@(n){R,X(n),T);
...
S(y)=F(A(y));
...

So, A needs to be “variable”, and the way to do it is with a str2func, however, it does not work for calling functions or variables which are not of general “base” scope.
Even using:

{evalin('caller','R'),evalin('caller','X(y)'),evalin('caller','T')}

generates an error:

Warning: The input to STR2FUNC "{evalin('caller','R'),evalin('caller','X(y)'),evalin('caller','T')}" is not a valid function name. This will generate an error in a future release.

Any suggestions? Or is this just a “bug” in Matlab?

Sorry for the oversight – definitely not intentional. Please use the link on the right to make an enhancement request via technical support. I don’t think it is entirely compatible since in a regular function, the function has its return args listed in the program. And now return would depend on position. But would it obey nargout? And what if the results returned were different for different values of nargout? Clearly, I haven’t thought about this enough to evaluate if it’s even realistic.

In your example with anonymous function, you can get the same result now with

myfunc = @(x) (x==1)*2 +(x==2)*3

>>
myfunc = @(x) (x==1)*2 +(x==2)*3
myfunc =
    @(x)(x==1)*2+(x==2)*3
>> myfunc([1 3 2])
ans =
     2     0     3

–Loren

Suggestion: perhaps enable return to accept arguments:

myfunc = @(x) (if (x==1) return(2); else return(3); end);

This would seem to be entirely backward compatible with existing code and may be useful for Matlab functions in general (not just anonymous):

function [a,b] = myfunc(data)
% do some useful computation
return (result1,result2);
end

Thanks,
Yair

I second Loren’s suggestion on giving anonymous and nested functions a try. It took me a little while to get used to the new syntax for anonymous function, but just like any other MATLAB syntax, I am completely used to it now. I had VERY little programming experience when I started using MATLAB (I may have programmed a little in BASIC), so the learning curve was steep, but after that, MATLAB code was MATLAB code, including anonymous functions.

Another relevant example is the new Object Oriented Programming capability that was introduced in R2008a. It’s a completely new programming construct, which may seem extremely foreign to a traditional MATLAB user. I was one of those people. I had no experience in object oriented programming, so I was very confused. I think it took me about a year to get my head around it. Now, it feels very natural, and I love it. It changed how I code in MATLAB, and I can create more sophisticated applications with it.

I think we should not dismiss a particular feature just because it is a foreign concept or syntax. Although, I do agree that there should be added benefits for any new programming constructs. I hope that some of the discussions in this post, as well as the other posts by Loren, will convince you of the benefits of anonymous functions. I do recommend giving them a try.

p.s. BTW, I find Steve’s example with the anonymous function so much easier to understand, because I know how to interpret that syntax. This is how you would read it:

“Do the following for each element of the structure array ‘data’: compare field ‘test’ of the structure with string ‘inverse_real’. Store the results to an array ‘select’.”

Yes, I’ll put some effort into this. Sounds like a fun way to spend the Thanksgiving weekend.

More thoughts from me…

* Another reason I like nested and anonymous functions. This particular discourse will concentrate on anonymous functions mostly, but nested and anonymous functions are so closely related that they points work for both.

Nested/anonymous functions allow for more natural APIs/interfaces. Here’s a quick example. If I want to work with a bunch of lines, ones for which I don’t know the slope and intercept, I have to write a function that takes 3 inputs (x,m,b). But if what I am doing with these lines is integrating, for example, I really need to have the function be a function of x alone, and not include slope/intercept.

No programming languages that I am familiar with allow you to separate parameters (slope/intercept) from unknowns (or variables). They are all just variables. But, if I have a line defined as a function of x, I can ask all kinds of questions about it without having to myself know slope and intercept. For that matter, I can substitute something that’s not strictly a line. Suppose I want to next see what happens with a quadratic. If I use the paradigm of having to write a function, I have to write it now to include, 3 terms, and I have to change my integrator to accept 3 optional arguments, etc.

More elegantly, I can supply a function handle that has only x as an input, and who cares what the underlying function is. That anonymous function carries with it all the information it needs, and the function I send it to doesn’t need to know anything other than it is a function of x. Gets all the parameter messiness out of the way.

* Finally, I recommend you “put some skin in the game” – i.e., read (or reread) posts from this blog under the category Function Handles, download the code or copy/paste it into an editor and try it. There are examples in the documentation. Copy/paste them into files, run them, go through them with a debugger, etc. I don’t think you can replicate my 3 weeks of learning by reading a doc alone. Take the plunge.

–Loren