Well, simply define a new anonymous function as @(x) myFunc(x,4) and use it this way:

F = cellfun(@(x) myFunc(x,4), C)

As per the MATLAB CELLFUN documentation the first argument to CELLFUN has to be a function handle, not just the "raw" name of a function. So, something like this...

B = {[1 2;3 4] , [5 6;7 8]}
cellfun(@mtimes,B,B)

(notice the @ sign in front of mtimes on the second line).

By putting in a "raw" mtimes, MATLAB is trying to evaluate the function MTIMES on no arguments, and use the result of that as the first argument to CELLFUN. But, as the error messages indicate, MTIMES acting on no arguments is an error.

Instead, use @mtimes to mean the function handle that "points to" the MTIMES function.

You can do this using an anonymous function that calls myfun with the two additional arguments:

cellfun(@(x) myfun(x,const1,const2), cellarray)

To do this very fast, do not use either cellfun or str2double. Some possibilities:

strjoin with sscanf

Use strjoin to combine the strings in cell array x into a single long space-delimited string, which can then be parsed very quickly with sscanf:

sscanf(strjoin(reshape(x,1,[])),'%f')

Note the reshape is included to guarantee the cell array is a row, as required by strjoin. A simple permute (.') could be used if you know x is a column, or nothing if x is already a row.

vertcat (or str2mat) with sscanf

Instead of strjoin, form a virtual comma-separated list of strings with x{:} and vertically concatenate them with vertcat (if each string has the same number of characters). Transpose this 2D character array and sscanf can again parse it quickly in a single shot:

sscanf(vertcat(x{:})','%f');

Or if the number of characters varies from string to string, you can use str2mat, which creates a space-padded 2D character array that sscanf also happily reads:

sscanf(str2mat(x)','%f');

test

Create a cell array of string representations of 10,000 random numbers:

>> x = sprintfc('%f',rand(1e4,1));

Note the use of the undocumented sprintfc to print to cells.

Reference methods:

>> tic; d0 = str2double(x); toc
Elapsed time is 0.302148 seconds.
>> tic; d1 = cellfun(@(x) sscanf(x,'%f'),x); toc
Elapsed time is 0.277386 seconds.
>> isequal(d0,d1)
ans =
     1

strjoin and vertcat:

>> tic; d2 = sscanf(strjoin(reshape(x,1,[])),'%f'); toc
Elapsed time is 0.068129 seconds.
>> isequal(d0,d2)
ans =
     1
>> tic; d3 = sscanf(vertcat(x{:}).','%f'); toc
Elapsed time is 0.024312 seconds.
>> isequal(d0,d3)
ans =
     1
>> tic; d4 = sscanf(str2mat(x).','%f'); toc
Elapsed time is 0.011917 seconds.
>> isequal(d0,d4)
ans =
     1

Note: these numbers are ballpark as then should be run over multiple iterations inside of a script or function, but all code is warmed. Try them out.

You could define your own, special function to call anonymous functions with given parameters, e.g.:

% define special function to call function handles
myfuncall = @(fh, v) fh(v{:});

% execute MacVecProd using myfuncall
b = myfuncall(@MacVecProd, v)

Based on your comment that you have array of functions and you want to execute them for your input arguments, you could do as follows:

  % cell array of function handles
  myFunctioins = {@MacVecProd, @MacVecProd2, @MacVecProd3};

  % execute each function with v parameters
  % I assume you want to execute them for the same input v
  resultCell = cellfun(@(fh) fh(v{:}), myFunctioins, 'UniformOutput', 0);

As constructed, the *fun family of functions exists for this purpose (e.g., cellfun is the pertinent one here). They are other questions on the use and performance of these functions.

However, if you construct f as a function that constructs a cell array as

f = @(x) {sin(x), cos(x), x+4};

then you can call the function more naturally: f([1,2,3]) for example. This method also avoids the need for the ('UniformOutput',false) option pair needed by cellfun for non-scalar argument.

You can also use regular double arrays, but then you need to be wary of input shape for concatenation purposes: @(x) [sin(x), cos(x), x+4] vs. @(x) [sin(x); cos(x); x+4].