Alternatives for eval when executing functions in matrix

I'm trying to find a better way to run my code so that I can parallelize it (using parfor).

Here is my setup:

I have a matrix that holds functions for me to run.

A = [myfun(data), myfun1(data, B), myfun2(data,C);
     myfun1(data,B1), myfun2(data,C2), myfun(data) ....]

Each row holds a series of functions that I want to evaluate with each function having different parameters. So in the above matrix I'd like to run myfun(data), myfun1(data,B), myfun2(data,c) compute stats on the data and then move on to row2 and evaluate the next 3 functions, compute stats and repeat for each row in the matrix.

What I am currently doing do to this is iterating through the matrix and running eval(String(A(i,j))). Now my matrix is very large so I would like to parallize the actions and run segments of the matrix concurrently using 'parfor' however parfor will not run with an eval command in the loop.

Is there another way I can do this?

[Stephen23]

@Ashley: Some questions:

1. How many different functions are there?
2. Does each function always take the same number of input arguments?
3. Where are these functions defined: as local functions, or in their own files?
4. In your example matrix

A = [myfun(data), myfun1(data, B), myfun2(data,C);
     myfun1(data,B1), myfun2(data,C2), myfun(data) ....]

you show the functions being called (complete with input arguments), which means that they will be evaluated when you define that matrix. But you state that you use eval to evaluate the functions, which contradicts the matrix that you have shown us. How is the matrix really defined?

I have no idea if it works with parfor, but you could use a structure/cell array to store function handles. Then you can execute each function with the required data (which obviously should be accessible using indexing). Thus a final question:

5. Does the input data get changed within the loop?

[Ashley]

1. I have 4 different possible functions

2. two of the functions take only the data, two take in extra parameters (one has 1 parameter, one has 2)

3. They have their own files

4. I wasn't able to run the functions by calling the matrix. I had originally tried to do for example A(1,1) and the function would not be evaluated so I decided to use eval.

[Ashley]

That was my next plan, the data doesn't get changed but the series of functions build off of each each so the output of the function in cell 1,1 is the input for 1,2.

[Guillaume]

As Stephen says, we have contradicting statements between:

A = [myfun(data), myfun1(data, B), myfun2(data,C);
   myfun1(data,B1), myfun2(data,C2), myfun(data) ....]

which would be a matrix of numbers (all the functions are executed when A is defined), and

eval(string(A(i,j)))

which would imply that A is something like:

A = {'myfun(data)', 'myfun1(data, B)', 'myfun2(data,C)';
     ...}

a completely different thing. It's difficult to give precise answers if we don't know what the starting point really is.

Regardless of what form A takes, what determines what it is? What determines what each element is and whether or not it takes an optional argument. It may be that constructing A completely differently may make the rest much simpler.

[Guillaume]

so the output of the function in cell 1,1 is the input for 1,2

Well, then it's obviously not possible to parallelise that since function 1,1 must be completed before you call function 1,2.

[Ashley]

the columns are dependent on each other but not the rows. The functions in row 1 are not dependent on row2 and the data is different for each row.

[Ashley]

I apologize for the confusion, yes, the cells are filled with strings ie 'myfun(data)'.

The goal of my code is to compare how the resulting data is after applying the functions in different orders with different parameters. Essentially an exhaustive search of these permutations where each row in my matrix is one permutation.

It may be easier to reconstruct my matrix.

Thank you

Answer 1

[Jan]

Use feval instead.

If you post the relevant part of your code, it would be very easy to suggest the modification explicitly. But it would be tedious, to invent some code to show you the difference. But it is something like:

feval('myfun2', data, C)

It is smarter to create a cell array of function handles instead of providing the function names as strings.

But the most efficient solution would be to modify the function such, that they accept a vector or cell array of inputs. With this vectorization the loop is not needed anymore.

You can get more help, if you post the relevant code, including "myfun", "myfun2", etc.

Note: Using eval impedes the JIT acceleration massively. It injects variables and functions dynamically into the current workspace, and this can slow down the processing by up to a factor of 100 - even in code lines, which do not contain the evil eval commands. The rule is simple: Do not use eval, because there is a smarter, nicer and faster solution in general.

[Walter Roberson]

For using parfor you should construct a cell array of function handles. To handle the extra parameters mentioned, parameterize the functions

http://www.mathworks.com/help/matlab/math/parameterizing-functions.html

Answer 2

[Guillaume]

As others have said, using function handles instead of eval would be much better. Here is one approach:

fns = {@(data) myfun1(data), @(data) myfun2(data), @(data) myfun3(data, arg1), @(data) myfun4(data, arg1, arg2)};  %list of functions with their fixed arguments
makechain = @(row) @(data) fns{row(1)}(fns{row(2)}(fns{row(3)}(fns{row(4)}(data))));  %create new function that is chaining a permutation of fns
functionperms = cellfun(@(row) makechain(row), num2cell(perms(1:4), 2), 'UniformOutput', false);  %create all permutations of function chains
results = cell(size(functionperms));
parfor pidx = 1:numel(functionperms)
   results{pidx} = functionperms{pidx}(data);
end

Notes:

• I don't have the parallel toolbox so can test the parfor
• Because there are only 4 functions, I just hardcoded the 4 functions chain as the makechain anonymous function. With more functions, I would have built the chain with a recursive m file.
• In your original eval(string(A(i, j)), the conversion to string looks like a workaround because you don't know how to extract values from a cell array. eval(A{i, j}) would be simpler. {} is used to extract data from cell arrays.