cellfun is just like looping through the cell matrix and
executing specified function separately on each cell.
It's usually faster than doing the same thing explicitly
in loop, but the basic difference is that its easy to
write and read - its immediately clear what the call is
doing. But you could just as well write the loop yourself.

In your specific case you could use cellfun this way:

mean_a = mean(cellfun(@(x) mean(x(:)), a));

If you have thousands of cells and you want to do something
to each of them you either use a loop or a cellfun
BTW: @(x) means that you want the content of each cell
to be understood as x so that mean(x(:)) gives you what
you want - mean of the whole matrix content of the cell.

Cellfun and arrayfun are generally much slower than simple loop. Their main usecase is to simplify code where performance is not an issue. Better alternative is vectorization which is both fast and concise. (For gpuArrays, arrayfun is faster but that is a special case).

You need to create a new function that only takes one input argument (the cell array element) and then call |datestr| with that argument and the |'local'| option. This can be done all in one go with an anonymous function: C = cellfun(@(x) datestr(x, 'local'), C, 'UniformOutput', false);

cellfun will apply your function to the contents of you cell array. There are 3 ways to specify the function: as a char array (only a handfull of functions, but they are faster when called like this)\ with a function handle, e.g. @mean with an anonymous function That last option is what you see here. %instead of this function output=MyFun(in1,in2) output=in1.*in2; end %you do MyFun=@(in1,in2) in1.*in2;

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

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

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

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

rows is a cell array the same size and shape at a containing vectors of row numbers. a={[1;2;4;5;2;3];[3;2;1;4;5;9;4;1;2];[];[2;3;4];[1;2;4;5;6]} rows = {2:4, 3:6, [], 1:2, 2:4}'; mu = cellfun(@(x,i)mean(x(i)), a, rows); Loop method (suggested by Image Analyst) >2x faster than cellfun. mu = nan(size(a)); for i = 1:numel(a) mu(i) = mean(a{i}(rows{i})); end

sizes = cellfun('size', cellArr, 1); Using the CHAR vector arguments is mentioned in the documentation as "backward compatibility". This calling style is the only one, in which cellfun is faster than a simple loop.

You can use recursion for this.

Firstly, define a function which does one of two things

1. If the input is a numeric matrix, apply some operation.
2. If the input is a cell, call this same function with the cell's contents as inputs.

The function would look something like this (defined locally to another function or in its own m file):

function out = myfunc( in, op )
    if iscell( in )
        out = cellfun( @(x) myfunc(x, op), in, 'UniformOutput', false );
    elseif isnumeric( in )
        out = op( in );
    else
        error( 'Cell contents must be numeric or cell!' )
    end
end

Then you can call myfunc on your cell. Here is an example similar to yours:

a = {[1 2; 3 4], {eye(2), 10}}; % Nested cell arrays with numeric contents
op = @(M) M + 5;                % Some operation to apply to all numeric contents

myfunc( a, op )
% >> ans = 
%     { [6 7; 8 9], {[6 5; 5 6], 15}}

---

Directly using your example, the output of myfunc(f, @(M)M+5) is the same as your {x, y{1}} - i.e. the operation op is applied to every cell and nested cell with the result structured the same as the input.

The answer here is bsxfun. A worked example is below.

% You need a function with the correct number of inputs.
% With your sample, I would do something like this.
myfunc       = @(i,j,k) 0.1 * i + sqrt(j) + k;
myfunc_inner = @(i,j) myfunc(i,j,0);
%    Side not: using separate files for functions is more 
%    efficient, but makes for worse examples on stackoverflow

%Setting up the inputs    
a = 0:0.1:0.3;
b = 100:5:120;

%bsxfun, for two inputs, is called like this.
c = bsxfun(myfunc_inner, a', b)

bsxfun does the following:

• Expands scalar dimensions of the inputs so that they match
• Performs element-wise combinations of the inputs, using the provided function input

In this case, the result is:

c =
           10       10.247       10.488       10.724       10.954
        10.01       10.257       10.498       10.734       10.964
        10.02       10.267       10.508       10.744       10.974
        10.03       10.277       10.518       10.754       10.984

To get the input in the form you requested, simply run c(:).

---

Historical note:

Back in the time-before-time, we had to use bsxfun more often. Now Matlab expands single dimensions without notice when we perform simple operations on numbers. For example, I used to use the following style frequently:

a = [1 2 3];
b = [4 5 6];

c = bsxfun(@plus, a', b)

Whereas now we simply write:

c = a' + b

I don't have the Signal Processing Toolbox, so I can't access the cusum function. However, here is a generic example of using three inputs into cellfun, that you should be able to easily craft into your use case: % The input data A = {[1 2 3],4,5; [6 7 8],9,10}; out = cellfun(@(x,y,z)(x.*y.*z),A(:,1),A(:,2),A(:,3),'UniformOutput',false) I think your equivalent is going to be something like cellfun(@(x,y,z)(cusum(x,constant1,constant2,y,z)),A(:,1),A(:,2),A(:,3),'UniformOutput',false)