Cell array of anonymous functions to vector anonymous function

I have the following problem: Let's say I have a 1xn cell array called f, that means f{i}(x)=fi(x) gives a function of x for each index i. Is there a way other than using arrayfun to make a vector function out of this, that means to get an anonymous function like f2=@(x) [f{1}(x) f{2}(x) ... f{n}(x)] without having to type it manually? I managed that with arrayfun, but as I use this function a lot, arrayfun takes way too long compared to typing it out manually as I did for f2.

[Jan]

Can you post an explicit example? Currently it sounds like a too complicated approach compared to a simple vectorized function.

[P.C.]

Sure, a simple example for n=3 (with simple functions just for demonstration):

f{1}=@(x) x^1
f{2}=@(x) x^2
f{3}=@(x) x^3

What I want is a function f2 which gives me a vector like this:

f2=@(x) [f{1}(x) f{2}(x) f{3}(x)]

without having to type it manually like this, as n is variable and large. I did try arrayfun, but it is way slower than typing it out manually like I did in the line above, so I cannot use it. There must be an easy way to do this, right?

[David Hill]

function y=f2(f,x)
y=[];
for k=1:length(f)
    y=[y,f{k}(x)];
end

[P.C.]

I did try that too, but this makes the function get called multiple times by itself, which makes it even slower than arrayfun.

[David Hill]

syms x
f=[x,x^2,x^3];
x=5;
y=subs(f);

[P.C.]

The functions I had above were just for demonstration and for n=3, so this does not really work for say n=100. The functions I have are also not analytical, but obtained from an interpolation.

[Dana]

Can you post code doing this with arrayfun? I'm not entirely clear on what the inptus/output here all are.

Answer 1

[Matt J]

The functions I had above were just for demonstration and for n=3, so this does not really work for say n=100.

In situations where you have hundereds of functions, it is normally because you have overlooked vector-valued, vectorized alternatives. For example, instead of

f{1}=@(x) x^1
f{2}=@(x) x^2
f{3}=@(x) x^3
...
f{100}=@(x) x^100

you should really have a single vectorized function,

    f=@(x) x.^(1:100)

[P.C.]

I would do that if I had analytical functions, but I do not. They are obtained from an interpolation of data (using griddedInterpolant), thats why I cannot have a simple vector function in the beginning. The only thing I have are these single anonymous functions in a cell array, and I thought there has to be an easy way of doing what I did manually without sacrificing too much speed. Or is what I am trying to do not possible in Matlab?

[Matt J]

The fact that you have multiple griddedInterpolant operations to do does not explain why you absolutely must have multiple anonymous function instances. griddedInterpolant is a very well-vectorized Matlab tool. You should be able to perform many interpolations in a single function call.

[P.C.]

I tried reading into griddedInterpolant, but I did not see how I could do that. The function I am interpolating has a certain number of lines (for the data points) and n columns. Is it possible to get a 1xn griddedInterpolant "function handle", where each component is an interpolation from the respective column of my data points?

[Bruno Luong]

Please provide us an example of two functions f1 and f2 using griddedInterpolant and show us why they are different (lines+colums whatever, no idea what argument you are talking about), but please show a specific example instead of a verbal description.

[Matt J]

Like Bruno, I encourage you to provide a small example involving the griddedInterpolant operations you are actually doing. But note that if, for example, if you have a 200x100 data matrix

data=rand(200,100);

and you want to interpolate each column data(:,i) at a common set of 50 locations, t

t=sort( rand(50,1)*199+1);

you can do that in a single call using interp1,

dataInterpolated = interp1(data,t)

and you can also wrap this in a single anonymous function, if it is convenient for you for whatever reason,

f=@(t) interp1(data,t)

[P.C.]

I am not sure if what you described is what I want to do, but I can show you what I am doing. Let's assume my data c is given in the form of a 1000xn matrix, and the 1000 data points correspond to the locations t. What I am doing is the following:

for k=1:n
    cInterpolation{k}= griddedInterpolant(t,c(:,k),'linear');
end

From this I get these n function handles I was talking about and which I want in a form of a 1xn vector.

[Bruno Luong]

Indeed there is no shortcut if you change the sample data values at the grid point.

However if you intend later to apply cInterpolation{k} on the same known query points; I can offer the method to build a sparse matrix that when multiplied with c(:,:) will return the interpolation values at the query points.

No need for a list of function handles.

[P.C.]

Yes, I do want to apply cInterpolation{k}(t) at the same t for all k later. Is your method faster than using the arrayfun function? Because I tried it and it is way slower than manually typing it out, which is not possible for large n of course.

Edit: I am not changing the sample points, the sample points are inside of t and c(:,k) are the corresponding values I want to interpolate. Thats the order of griddedInterpolant in the matlab documentation.

[Bruno Luong]

You can't do faster than sparse-matrix multiplication. Now it might take time to build the matrix but I think it's faster than loop with griddedInterpolant() construction.

Check this thread where I gives the construction of gridded/scattered interpolation matrices in 2D.

[Matt J]

Yes, I do want to apply cInterpolation{k}(t) at the same t for all k later.

This is equivalent to what I have already given you. It is the same as doing,

cInterpolation  = @(tq) interp1(t,c,tq);

[P.C.]

I did see that, but it does not seem to work if I want to define it as a function. This one looks different though, let me try it.

[Bruno Luong]

Wait a minute, if it's 1D interpolation why don't you just simply do

cInterpolation  = interp1(t,c,ti);

? where

t: is m x 1  % grid sample points
c: is m x n  % data value
ti: is p x 1  % query points

The result cInterpolation will be size (p x n), each column is the interpolation using the correponding column of c..

[Matt J]

I was missing an @ sign. It should work now.

[Matt J]

Here is an example

>> t=(1:6).'; c=t+(0:5)

c =

     1     2     3     4     5     6
     2     3     4     5     6     7
     3     4     5     6     7     8
     4     5     6     7     8     9
     5     6     7     8     9    10
     6     7     8     9    10    11

>> cInterpolation  = @(tq) interp1(t,c,tq);
>> cInterpolation([1.5, 2.7, 3.8])

ans =

    1.5000    2.5000    3.5000    4.5000    5.5000    6.5000
    2.7000    3.7000    4.7000    5.7000    6.7000    7.7000
    3.8000    4.8000    5.8000    6.8000    7.8000    8.8000

[Bruno Luong]

Yes I think Matt and I show you the same solution, much simpler and straighforward.

[P.C.]

Yes this seems to work, but it looks to be quite a bit slower than the griddedInterpolant function I was using. The same must be possible with the griddedInterpolant function, or not?

[Bruno Luong]

No, griddedInterpolant can't deal with array of values in 1D (pitty TMW).

Are you sure it's slower? Do you compare inte INTERP1 solution with or without the step of construct your anonymous functions using griddedInterpolant?

[P.C.]

It does look like it, yes. What I tried is replacing the for-loop you saw above and the function call with arrayfun with the one line you and Matt showed, so there is no griddedInterpolant involved at all. The one with griddedInterpolant finishes in about 420 seconds (from tic and toc), and the interp1 interpolation did not finish within 15 minutes.Should they work as fast as each other, or are these functions working differently? I am just wondering, because even the documentation for interp1 says "This syntax is not recommended. Use griddedInterpolant instead."

[Bruno Luong]

Can you provide the typical sizes of c and that of the query points tq ?

[P.C.]

Yes sure, the sizes are:

t:10000x1

c:10000x100

tq:45000x1

[Bruno Luong]

Something very odd it takes 78 ms on my computer, not 15 minutes.

m = 10000;
n = 100;
p = 45000;

t = sort(rand(m,1));
tq = rand(p,1);
c = rand(m,n);

tic
ci2 = interp1(t,c,tq);
toc % Elapsed time is 0.077927 seconds.

Unless your computer has tiny RAM

[P.C.]

I did use it as an anonymous function though like in Matt's code. Does it make a difference if you call the tq separately one by one instead of all in one call? Maybe I did something wrong, but I pretty much just replaced my loop with the one line.

[Bruno Luong]

The difference is noise

tic
interfun = @(tq) interp1(t,c,tq);
ci2 = interfun(tq);
toc % Elapsed time is 0.063195 seconds.

Why you want to call one by one? Do you prefer to get your result in 70 ms or 15 minutes?