Thread Subject: Saving an anonymous function handle to a mat-file

Hi,

when I enter

y = 1;
f = @(x)(x+y);
save foobar f;

in the MATLAB command window, the resulting foobar.mat will load and
work when copied to another computer.

When I execute the same code inside a function and copy foobat.mat,
MATLAB on the other computer needs the m-file containing the function
where I defined the function handle "f" to load foobar.mat.

What can I do to change this?

Christian

Christian Zietz <newsgroup@chzsoft.com.ar> wrote in message <6iv5vcFn3i0U1@mid.individual.net>...
> Hi,
>
> when I enter
>
> y = 1;
> f = @(x)(x+y);
> save foobar f;
>
> in the MATLAB command window, the resulting foobar.mat will load and
> work when copied to another computer.
>
> When I execute the same code inside a function and copy foobat.mat,
> MATLAB on the other computer needs the m-file containing the function
> where I defined the function handle "f" to load foobar.mat.
>
> What can I do to change this?
>
> Christian

You could do func2str(f) and save the function as a string. Then reconvert it using eval when loading it back in from the .mat file

y = 1;
f = @(x)(x+y);
fstr=func2str(f)
save foobar fstr;


Then later


load foobar fstr;
f=eval(fstr);

Matt schrieb:

> You could do func2str(f) and save the function as a string. Then
> reconvert it using eval when loading it back in from the .mat file

> y = 1;
> f = @(x)(x+y);
> fstr=func2str(f)
> save foobar fstr;

> Then later

> load foobar fstr;
> f=eval(fstr);

This won't work unless I also save all variables involved in the
anonymous function (in this case it's only "y"), because "y" will be
undefined (or even worse: have another value) when I reload foobar.mat
and evaluate "fstr".

Christian
--
Christian Zietz - CHZ-Soft - czietz (at) gmx.net
WWW: http://www.chzsoft.com.ar/
PGP/GnuPG-Key-ID: 0x6DA025CA

"Matt " <mjacobson.removethis@xorantech.com> wrote in message <gae6t8$7de$1@fred.mathworks.com>...

>
> load foobar fstr;
> f=eval(fstr);
>

But the variable y=1 is lost for ever...

Bruno

> This won't work unless I also save all variables involved in the
> anonymous function (in this case it's only "y"), because "y" will be
> undefined (or even worse: have another value) when I reload foobar.mat
> and evaluate "fstr".

That's right it won't, but you never discussed the role of y in your original post, so I could only assume that it is a parameter that would be made available when the function was loaded back in.

One approach would be to do

strrep(fstr,y,numstr(y));

before saving.

You could also consider setting up f() as an inline function instead of an anonymous one, in a similar way.

"Matt " <mjacobson.removethis@xorantech.com> wrote in message <gae9fm$r7n$1@fred.mathworks.com>...
>
> > This won't work unless I also save all variables involved in the
> > anonymous function (in this case it's only "y"), because "y" will be
> > undefined (or even worse: have another value) when I reload foobar.mat
> > and evaluate "fstr".


I think I misunderstood you earlier.

No, when you execute

>>f=eval(fstr)

the result is

f =

    @(x)(x+y)


In other words, all that happens is that fstr is converted from a string back to an anonymous function, f. It does not matter whether y exists in memory, at that point.

Of course, if you then try to evaluate the anonymous function f(x), you will get an error unless you first provide y, but presumably you have a way of doing that. Otherwise, why would you want to re-use the function on a different machine?

Christian Zietz <newsgroup@chzsoft.com.ar> wrote in message <6iv5vcFn3i0U1@mid.individual.net>...

>
> What can I do to change this?
>

Please try this:

% file savefun.m
function savefun(file, f)

sfun = functions(f);
sfun.file = '';
save(file,'sfun');

% file loadfun.m
function f=loadfun(file)

data=load(file);
sfun = data.sfun;

for n=1:length(sfun.workspace)
    wn = sfun.workspace{n};
    vlist=fieldnames(wn);
    for k=1:length(vlist)
        val = wn.(vlist{k}); %#ok
        eval([vlist{k} '= val;']);
    end
end
f=eval(sfun.function);

% file t.m
function t

y = 1;
f = @(x)(x+y);
savefun('foo.mat', f);

% end t

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Now try this in command line

>> t % save anonymous function inside a function
>> f=loadfun('foo.mat') % load in workspace

f =

    @(x)(x+y)

>> f(0) % evaluate

ans =

     1

% Bruno

Matt schrieb:

> Of course, if you then try to evaluate the anonymous function f(x),
> you will get an error unless you first provide y, but presumably you
> have a way of doing that. Otherwise, why would you want to re-use the
> function on a different machine?

When you declare a function handle, MATLAB "freezes" the current
workspace and saves it together with the function handle. You can go

y = 1;
f = @(x)(x+y)
clear y;

and

f(3)

will still evaluate to 4. Even if you now enter

y = pi;

f(3) will still be 4.

When you save a function handle to a mat-file the workspace at the time
the function was defined is also saved. This obviously doesn't happen if
you just save the string that is func2str(f).

Christian
--
Christian Zietz - CHZ-Soft - czietz (at) gmx.net
WWW: http://www.chzsoft.com.ar/
PGP/GnuPG-Key-ID: 0x6DA025CA

I wrote:

> When you declare a function handle, MATLAB "freezes" the current
> workspace and saves it together with the function handle.

PS:
<http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_prog/f4-70115.html#f4-71621>

Christian
--
Christian Zietz - CHZ-Soft - czietz (at) gmx.net
WWW: http://www.chzsoft.com.ar/
PGP/GnuPG-Key-ID: 0x6DA025CA

This loadfun should be safer:

function fun___=loadfun(file)

data=load(file);
sfun___ = data.sfun;

clear file data;

evalvar(sfun___);

fun___ = sfun___.function;
clear sfun___;
fun___=eval(fun___);

end

% nested function
function evalvar(sfun)

for n=1:length(sfun.workspace)
    wn = sfun.workspace{n};
    vlist=fieldnames(wn);
    for k=1:length(vlist)
        val = wn.(vlist{k});
        assignin('caller',vlist{k}, val);
    end
end

end

% Bruno

Bruno Luong schrieb:

> This loadfun should be safer:

Thank you very much! I'll give it a try as soon as I'm back at the
computer where MATLAB is installed.

Christian
--
Christian Zietz - CHZ-Soft - czietz (at) gmx.net
WWW: http://www.chzsoft.com.ar/
PGP/GnuPG-Key-ID: 0x6DA025CA

> PS:
> <http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_prog/f4-70115.html#f4-71621>
>
> Christian


OK. good to know...

> When I execute the same code inside a function and copy foobat.mat,
> MATLAB on the other computer needs the m-file containing the function
> where I defined the function handle "f" to load foobar.mat.

So why does this happen? If anonymous functions carry their own internal snapshots of the workspace, what would it be trying to recover from the m-file where it was born?

"Matt " <mjacobson.removethis@xorantech.com> wrote in message <gaektb$glf$1@fred.mathworks.com>...
>
> what would it be trying to recover from the m-file where it was born?
>

Something such as anonymous nested functions of the local m-file.

If the mfile is modified/changed/deleted, such information is of course lost together with the m-file that carries the anonymous function.

Bruno

"Bruno Luong" <b.luong@fogale.findmycountry> wrote in message <gaenr2$dc7$1@fred.mathworks.com>...
> "Matt " <mjacobson.removethis@xorantech.com> wrote in message <gaektb$glf$1@fred.mathworks.com>...
> >
> > what would it be trying to recover from the m-file where it was born?
> >
>
> Something such as anonymous nested functions of the local m-file.
>
> If the mfile is modified/changed/deleted, such information is of course lost together with the m-file that carries the anonymous function.
>
> Bruno

That makes sense, but that surely doesn't explain why something as simple as @(x) (x+y) is a problem.