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;

Tell us once you tried it :)

Here's how:

result = cellfun(@(x) [x(:,1) x(:,2)*100], cellArray, 'un', 0);

cellfun and other *funs (except bsxfun) are wrappers for a loop. Think of 'em as a loop and you'd know how to apply.

Option _Uniform_ or _UniformOutput_ set to _0_ (or _false_) means, that output from function will be stored in cell array. It is necessary when function (in your case _plus_) returns non scalar values. If you set the _UniformOutput_ value to _1_ ( or _true_), your function must return scalar values and the output will be concatenated into an array. Look at examples: %% a = {rand(1),rand(2),rand(3),rand(4)} b = {rand(1),rand(2),rand(3),rand(4)} cellfun(@plus,a,b,'UniformOutput', false) %% a = {rand(1),rand(1),rand(1),rand(1)} b = {rand(1),rand(1),rand(1),rand(1)} cellfun(@plus,a,b,'UniformOutput', false) %% a = {rand(1),rand(1),rand(1),rand(1)} b = {rand(1),rand(1),rand(1),rand(1)} cellfun(@plus,a,b,'UniformOutput', true)

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).

The most readable/maintainable approach will probably be to use a list comprehension:

yy = [ np.exp(xxi) for xxi in xx ]

That relies on numpy.exp to implicitly convert each tuple into a numpy.ndarray, which in turn means that you'll get a list of numpy.ndarrays back rather than a list of tuples. That's probably OK for nearly all purposes, but if you absolutely have to have tuples that's also easy enough to arrange:

yy = [ tuple(np.exp(xxi)) for xxi in xx ]

For some purposes (e.g. to avoid memory bottlenecks) you may prefer to use a generator expression rather than a list comprehension (round brackets instead of square).

You cannot use those kinds of conditionals in cellfun, at least not without the use of an auxillary true function that does the equivalent of the C/C++ question-colon operator. The workaround is mask = cellfun(@(y) y>2, Y); X_out = X_in; X_out(mask) = cellfun(@(xin) reshape(xin, ...), X_in(mask), 'uniform', 0);

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

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.

cellfun will work if you have an unnested cell array, i.e. a single level of cells. For example, if you define your array as a 3×3×3×3 cell array of matrices you just need

result = cellfun(@(x) sum(x,1), AB, 'uniformoutput', false);

If you really need to do it a cell array of cell arrays of matrices, you can nest two cellfun. This will be slow:

result = cellfun(@(ab) cellfun(@(x) sum(x,1), ab, 'uniformoutput', false), AB, 'uniformoutput', false);

I'm using sum(x,1) to get the sum of each matrix column. If you want the sum of each row replace 1 by 2.