0

I am trying to write a function that takes a cell array of functions as an input and that outputs the same functions, but in a somewhat different format.

Specifically, I want a row vector, of say length N, of functions fVec = [f1(x, y, z), f2(x,y,z), ..., fn(x, y, z)] all of which always output a column vector of the same length, say M. Now I want the evaluation of fVec(x, y, z) to output an MXN matrix, where each column represents the output of its corresponding vector.

However, because Matlab doesn't accept regular function handle arrays, it must be done using cell arrays. (, right?)

Moreover, I want a general function that works for several sets of functions, that don't necessarily have three inputs. That is, I want the function fVec(1, ..., x) = [f1(1, ..., x), f2(1, ..., x), fn(1, ..., x)], meaning that each of the funtions f1, f2, fn always have the same number of inputs.

Therefore, I need some function that takes as an input a cell array of function handles {f1(1, ..., x), f2(1, ..., x), fn(1, ..., x)} and outputs some overarching function fVec(1, ..., x).

I already tried writing a function that I thought should do this:

function overArchingFunction = transformFunctionArray(functionArray)
    if length(functionArray) == 1
        if isa(functionArray, 'cell')
            overArchingFunction = functionArray{:};
        else
            overArchingFunction = functionArray;
        end
    else
        disp(cellfun(@(fun) fun(x), functionArray, ...
                'UniformOutput', false))
        overArchingFunction = @(vars) cell2mat(cellfun(@(fun) fun(vars), functionArray, ...
                'UniformOutput', false));
    end
end

This works for "arrays of length 1", obviously. However, there is a problem with this code. Let's make a test function, say testfun = @(a, b, c, d, e) a(:,3) - a(:,2) (where testfun is a function of b, c, d, e to replicate the most general scenario), and make an array of this function, functionArray = {testfun, testfun}.

Now we call our function overArchingFunction = transformFunctionArray(functionArray). However, when calling solution = transfun([[10 1 2]; [3 4 5]], 0, 0, 0, 0), I want the output to be:

solution =

     1     1
     1     1

This is not the case, because with the @(vars) and fun(vars) statements, I'm restricting the number of input variables to this function to only one variable, whereas I am trying to pass five arguments (namely [[10 1 2]; [3 4 5]], 0, 0, 0, 0). I though I'd fix this by replacing vars with varargin, but this gives me the error:

Attempt to execute SCRIPT varargin as a function:
/MATLAB/toolbox/matlab/lang/varargin.m

Summarising, how do I retain the original number of input arguments of f1, f2, ..., fn in the overArchingFunction?

Sam
  • 305
  • 1
  • 8
  • How about just passing a `struct` between functions, with all your arguments as fields? – Adriaan Oct 28 '19 at 12:25
  • Unfortunately, I'm building on top of (inaccessible and thus immutable) existing code where the arguments are strictly passed as "loose" arguments. Therefore, I'd like to stay as close to the existing code as possible and try to accept the arguments in the manner I described above. – Sam Oct 28 '19 at 12:34
  • Not a complete duplicate, but certainly related: https://stackoverflow.com/questions/58143196/summation-of-n-function-handles-in-matlab – Cris Luengo Oct 28 '19 at 12:49
  • My comment here is the same: not everything needs to be an anonymous function. This problem is easy to solve with a regular function using `varargin`. – Cris Luengo Oct 28 '19 at 12:50
  • By the way: did you run the code? `overArchingFunction = functionArray{:};` should give you an error message. – Cris Luengo Oct 28 '19 at 12:54
  • I agree with you on that point; I don't necessarily want `testfun` in my above example to be anonymous. However, in this example, it doesn't matter whether `testfun` is anonymous or not; it is the declaration of the input arguments to `overArchingFunction` that's the bottleneck. I.e., in the function definition of `overArchingFunction`, I'm using a non-anonymous function that still has the `varargin` problem. – Sam Oct 28 '19 at 12:55
  • I did run the code and I didn't run into an error at that point. Running either `mytestfun = @(a, b, c, d, e) a(:,3) - a(:,2); transfun = transformFunctionArray(mytestfun)` or `mytestfun = @(a, b, c, d, e) a(:,3) - a(:,2); transfun = transformFunctionArray({mytestfun})` doesn't result in any errors for me. – Sam Oct 28 '19 at 12:58

1 Answers1

0

I found it. The answer indeed lay in using varargin. However, because varargin passes a cell structure input, you need to access those cells' contents by using varargin{:}. The function should thus be:

function overArchingFunction = transformFunctionArray(functionArray)
    if length(functionArray) == 1
        if isa(functionArray, 'cell')
            overArchingFunction = functionArray{:};
        else
            overArchingFunction = functionArray;
        end
    else
        overArchingFunction = @(varargin) cell2mat(cellfun(@(fun) fun(varargin{:}), 
            functionArray, ...
                'UniformOutput', false));
    end
end

Such that the following commands give the required answer.

>> testfun = @(a, b, c, d, e) a(:,3) - a(:,2)

testfun =

  function_handle with value:

    @(a,b,c,d,e)a(:,3)-a(:,2)

>> transfun = transformFunctionArray({mytestfun, mytestfun})

transfun =

  function_handle with value:

    @(varargin)cell2mat(cellfun(@(fun)fun(varargin{:}),functionArray,'UniformOutput',false))

>> myans = transfun([[10 1 2]; [3 4 5]], 0, 0, 0, 0)

myans =

     1     1
     1     1
Sam
  • 305
  • 1
  • 8