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.

You'll want to check out the documentation for cellfun and the section about anonymous functions.

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

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

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

It performs

yout=cell(size(y));
for k=1:numel(y)
   yout{k}=sqrt(y{k}/sum(y{k}(:)));
end
y=reshape(yout,size(y));

Explanation: the first call the cellfun will go over each element of y, your original cell, then apply the function @(x) x/sum(x(:)) to each element of your cell (i.e. it will normalize each cell element such that their respective elementwise sum equals to 1). The result is stored in the corresponding element of the output cell. The second call does the same with the sqrt function, so we can unite the two operations in the same command in the loop.

Some proof:

y={[1 2], [3 4]; [5 6], [7 8]; [9 10], [11 12]};

yout1 = cellfun(@(x) x/sum(x(:)), y, 'UniformOutput',0);
yout1 = cellfun(@sqrt, yout1, 'UniformOutput',0);

yout2=cell(size(y));
for k=1:numel(y)
   yout2{k}=sqrt(y{k}/sum(y{k}(:)));
end
yout2=reshape(yout2,size(y));

isequal(yout1,yout2) %returns 1