In Octave you can't use if/else statements in an inline or anonymous function in the normal way. You can define your function in it's own file or as a subfunction like this:

function a = testIf(x)
     if x>=2
        a = 1;
     else 
        a = 0;
     end
 end

and call arrayfun like this:

arrayfun(@testIf,a)
ans =

   0   1
   1   1

Or you can use this work around with an inline function:

iif = @(varargin) varargin{2 * find([varargin{1:2:end}], 1, ...
                                     'first')}();

arrayfun(iif, a >= 2, 1, true, 0)
ans =

   0   1
   1   1

There's more information here.

The purpose of arrayfun is: "Apply function to each element of array". This is not what you do in the nested for loops. This is a combination of different elements of different arrays. This means, that arrayfun is not a suitable apporach. Even if you get it to work, arrayfun is not necessarily faster than the clean and neat loops.

Many built-in operations like sum and prod are already able to operate across rows or columns, so you may be able to refactor the function you are applying to take advantage of this.

If that's not a viable option, one way to do it is to collect the rows or columns into cells using mat2cell or num2cell, then use cellfun to operate on the resulting cell array.

As an example, let's say you want to sum the columns of a matrix M. You can do this simply using sum:

M = magic(10);           %# A 10-by-10 matrix
columnSums = sum(M, 1);  %# A 1-by-10 vector of sums for each column

And here is how you would do this using the more complicated num2cell/cellfun option:

M = magic(10);                  %# A 10-by-10 matrix
C = num2cell(M, 1);             %# Collect the columns into cells
columnSums = cellfun(@sum, C);  %# A 1-by-10 vector of sums for each cell

Here's your original code: X = [1, 12; 1, 13; 1, 12; 2, 4; 2, 4; 2, 4; 3, 9; 3, 9; 3, 9]; L = X(:,1); U = unique(L); % Define this once, use it in multiple places M = arrayfun(@(x) mean(X(L == x, 2)), U) Another way to write this arrayfun call using a for loop would be: M2 = zeros(numel(U), 1); % Preallocate the result for k = 1:numel(U) % Choose the rows where the first column of X is equal to a specific % value from U, then extract the data in the second column of X for % those rows column2OfSelectedRows = X(L == U(k), 2); % Take the mean of that data and store it in the appropriate row of M2 M2(k, 1) = mean(column2OfSelectedRows); end We can check that M and M2 are equal. isequal(M, M2) But there's another way to do this. What you want to do is use L as a grouping variable and summarize the rows in X that have the same value for that grouping variable. The groupsummary function will let you do this. Note that we're not using U or the unique function here; groupsummary will make one group for each unique value in the grouping variable. groupingVariable = L; dataVariable = X(:, 2); % Apply the mean function to each subset of values in dataVariable whose % corresponding elements in groupingVariable have the same value M3 = groupsummary(dataVariable, groupingVariable, @mean) Check: isequal(M, M3)

Just use a |for|-loop! |cell2mat/mat2cell/arrayfun| are all slow and confusing.

The reason that you don't get any speed increase by calling matlabpool before calling arrayfun is that just the act of creating multiple workers doesn't make all code utilize these workers to perform calculations. If you want to exploit the pool of workers, you need to explicitly parallelize your code with parfor (related info here).

parfor k = 1:10
    result{k} = sum(sum(a*b));
end 

In general, arrayfun does not do any parallelization or acceleration. In fact, it's often slower than simply writing out the for loop because the explicit for loop allows for better JIT acceleration.

for k = 1:10
    result(k) = sum(sum(a * b));
end

If you want to perform the operation you've shown using the GPU, if the input data to arrayfun is a gpuarray, then it will excecute on the GPU (using the distributed version of arrayfun). The issue though is that anything performed on the GPU using arrayfun has to be element-wise operations only so that the operation on each element is independent of the operations on all other elements (making it parallelizable). In your case, it is not element-wise operations and therefore the GPU-version of arrayfun cannot be used.

As a side-note, you'll want to use parpool rather than matlabpool since the latter has been deprecated.

In this case, you don't need arrayfun to perform your calculation, you can simply do this:

imgStack = rand( 10, 10, 4 ); % 4 10x10 images
r = sum( sum( imgStack, 1 ), 2 ); % sum along both dimensions 1 and 2

In general, lots of MATLAB operations will operate on a whole array at once, that's the usual way of avoiding loops.

MATLAB's normal "arrayfun" is not parallel. However, for GPUArrays (with Parallel Computing Toolbox), there is a parallel version of arrayfun.

I wish it were a cleverer answer, but I'm afraid that it's simply that MATLAB has been heavily optimized for |for| loops over the years but the same optimizations have not been applied to |arrayfun|. In this case by far the most important optimization will be multithreading, so perhaps you have 32 virtual cores to work with. It's tempting to just convert the arrayfun implementation to a for loop internally but as other have implied, the devil is in the detail since it would take some effort to get identical, backwards compatible behaviour. Best just to think of |arrayfun| as syntactic sugar only to be used for performance non-critical situations. Or for the GPU, where it has a special implementation.

This is interesting. Your examples are performing two different operations, which happen to lead to the same result. It's kind of fun to explore.

TL;DR. You should generally use arrayfun when your input is an array, and cellfun when your input is a cell, although you can often force arrayfun to do the job, with varyig levels of syntax hell.

Fundamentally, arrayfun is meant to operate on arrays and cellfun is meant to operate on cells. But, the Matlab-wise will note that a cell is nothing more than an array of "cells", so arrayfun works anyway.

---

As you point out, the following two lines perform the same operation:

cellfun(@(c) c, {'one' 'two' 'three'}, 'uniformoutput', 0)   %returns  {'one' 'two' 'three'}
arrayfun(@(c) c(1), {'one' 'two' 'three'});                  %returns  {'one' 'two' 'three'}

However, if we want to do something during our manipulations, it's a little different. For example, we may want to extract the first character of each string. Compare the results of cellfun and arrayfun here:

cellfun( @(c) c(1), {'one' 'two' 'three'}, 'uniformoutput', 0);  %returns {'o' 't' 't'}
arrayfun(@(c) c(1), {'one' 'two' 'three'});                      %Returns {'one' 'two' 'three'}

Do get the same result with arrayfun, we need to dereference the cell within the anonymous function, and then extract the character, and then put the results into a cell array rather than a character array. Like this:

arrayfun(@(c) c{1}(1), {'one' 'two' 'three'},'uniformoutput',false)  %Returns {'o' 't' 't'}

---

So the difference is that cellfun takes care of the dereference operation which is required to do detailed operations on individual elements of a cell when looping (that is, the {}), whereas arrayfun just performs the standard indexing (that is, the ()). In addition, the 'uniformoutput',false notation determines if the output is written to a regular arral or a cell array.

To show what this means in code, see the following functions which are equivalent to cellfun and arrayfun, both with and without the 'uniformoutput',false notation. These four functions are equivalent except for the use of the () vs. {} within the loop:

function out = cellFunEquivalent(fn, x)
    for ix = numel(x):-1:1
        out(ix) = fn(x{ix});
    end
    out = reshape(out,size(x));
end

function out = arrayFunEquivalent(fn, x)
    for ix = numel(x):-1:1
        out(ix) = fn(x(ix));
    end
    out = reshape(out,size(x));
end

function out = cellFunEquivalent_nonuniform(fn, x)
    for ix = numel(x):-1:1
        out{ix} = fn(x{ix});
    end
    out = reshape(out,size(x));
end

function out = arrayFunEquivalent_nonuniform(fn, x)
    for ix = numel(x):-1:1
        out{ix} = fn(x(ix));
    end
    out = reshape(out,size(x));
end

For the example you posted, the arrayfun function is actually operating on single element cells, and reconstructing a copy of those cells into another array of the same (cell) class (see arrayFunEquivalent). The cellfun operation is dereferencing each element of the input cell array and then reconstructing a copy of those strings into a cell array (see cellFunEquivalent_nonuniform). When the input x is a cell, these operations are equivalent.

I think the main use of it is abstraction and the advantages that come with it:

• Applying a function to each element of an array comes up in many situations. Wrapping this pattern into a function raises the level of abstraction: you do not need to think in loops, your intent is probably clearer. If you are familiar with Python, comprehensions do this, as well as the built-in map function. NumPy also applies a function on each element of an array.
• It allows MathWorks to implement this pattern efficiently. Although arrayfun is currently implemented with a for loop, this might change in the future. If MathWorks later decides to change the implementation, as soon as the function signature remains the same, no backward compatibility issue arises.
• It allows third-party to reimplement it, as it is already done in the Parallel Computing Toolbox. You would need to rewrite your code with parfor to achieve the same.