Basic math operations on contents of a cell array

Is there any reason why basic math operations don't work with cell arrays? Seems to me it would extremely useful and efficient if you could do the following:

C = [0.7152  1.0000];
A = [0.6807  0; 0  1.0000];
Apows = {A,A^2,A^3};
C*Apows

Result:

Undefined operator '*' for input arguments of type 'cell'.

Expected:

{C*Apows{1},C*Apows{2},C*Apows{3}} =

1×3 cell array

{1×2 double} {1×2 double} {1×2 double}

Is this the only/best way to do this (which I got from this answer):

cellfun(@(x) C*x,Apows,'UniformOutput',false);

ans =

1×3 cell array

{1×2 double} {1×2 double} {1×2 double}

Answer 1

[Matt J]

Is there any reason why basic math operations don't work with cell arrays? Seems to me it would extremely useful and efficient if you could do the following:

Cell arrays are designed for containing objects of different types and sizes. They are a fundamentally inefficient way to hold objects that are all the same size, partly because their contents are not guaranteed to be held contiguously in RAM. Because a better data type is usually available for the situations you describe, TMW hasn't bothered to define such operations for cells. You could write cell-like class with overloaded arithmetic operations if you wished, but it would be syntactic sugar, and nothing more.

For the scenario in your example, moreover, the best method is in any case a simple for loop. This accomplishes the whole operation with just 3 multiplications with A, unlike the approach you presented which first forms Apow.

out=cell(1,4);
out{1}=C;
for i=2:4
    
    out{i}=out{i-1}*A;
    
end

out=out(2:end);

[Bill Tubbs]

Yes, a for loop might be a good solution in the case I presented. (That is exactly how I actually create Apows in my original code, I just presented it this way for brevity). The reason I asked for an alternative to for loops is because I want to subsequently use Apows for multiple computations. E.g. for C*Apows(1:n-1), and for C*Apows(2:n)*B, ... etc. I thought it would be nice to not have to loop over it each time I use it.

[Matt J]

No, there is no way to avoid loops when iterating over cell arays and in fact cellfun is not truly an alternative to looping either. You will find that cellfun has the same performance as a for-loop. It's just a way of doing the same things as a loop, but with shorter syntax.

[Bill Tubbs]

Thanks, that answers the question!

[Bill Tubbs]

It could be argued that the applicability of cellfun is so great that it could be replaced with a dedicated language feature. E.g. something similar to list comprehensions in Python. Maybe something like this:

{C*x for x=Apows}

(would produce a cell array)

Answer 2

[James Tursa]

I suppose only TMW could give you their reasons for not implementing numeric operations on cell arrays. Maybe they simply didn't want to expend the effort when cellfun( ) would suffice.

One other option for you is to stack your matrices in a single array:

Apows = cat(3,A,A^2,A^3);

Then you can use a variety of options for doing the page matrix multiplies:

pagemtimes (R2020b)

https://www.mathworks.com/help/matlab/ref/pagemtimes.html?s_tid=srchtitle

Some options from the FEX:

MULTIPROD:

https://www.mathworks.com/matlabcentral/fileexchange/8773-multiple-matrix-multiplications--with-array-expansion-enabled

MTIMESX: (C-mex code requiring C compiler) needs updated build routine for later MATLAB versions

https://www.mathworks.com/matlabcentral/fileexchange/25977-mtimesx-fast-matrix-multiply-with-multi-dimensional-support

MMX: (C-mex code requiring C compiler)

https://www.mathworks.com/matlabcentral/fileexchange/37515-mmx-multithreaded-matrix-operations-on-n-d-matrices

[Bill Tubbs]

Thanks, these alternatives to using cellarrays seem to be exactly what I am actually looking for in this case where the computations are matrix operations. I will look into these...