是否有任何机制可以自动挤压 Matlab / Octave

Question

For an nD array, it would be nice to be able to auto squeeze to remove singleton dimensions. Is there a way to do this that I don't know about? This would be especially useful for aggregate functions (eg sum, mean, etc) where you always expect a result with fewer dimensions.

Here's a simple example:

>> A = ones(3,3,3);
>> B = mean(A);
>> size(B)
ans =  
   1   3   3

>> squeeze(B)
ans =
   1   1   1
   1   1   1
   1   1   1

It would be nice if Matlab/Octave would automatically do the squeezing for me. Or if there was a way to turn that option on (something similar to hold on for plots).

Answer 1

As far as I know, Matlab does not have that. And I don't think it would be a good idea. Consider a modified version of your example:

>> A = ones(3,1,1,3);
>> B = mean(A);
>> size(B)
ans =
     1     1     1     3

What should "auto-squeeze" do here? Reduce B to size [1 1 3] or to [1 3] ?

• You could argue that it should remove the same dimension that mean has turned into a singleton. But then it would have to be done within the mean function, perhaps with an optional input argument. Once you get the function output, there is no information how it was obtained.

• Or you could argue that it should remove all singleton dimensions, like squeeze (more or less) does. But then it would remove dimensions that were already singleton in the function input , which is probably unwanted.

If you ask me, having a second input in squeeze specifiyng which (singleton) dimensions to remove would be a nice addition (in the same vein as you can use mean(A, 1) to force the operation to be applied along the first dimension even if A happens to be a row vector).

Answer 2

I agree with Luis and Cris, but I would add the following.

Both Matlab and Octave do automatically squeeze extra dimensions, in a very particular scenario: any dimensions at the end that have been reduced to singletons, are automatically squeezed out.

Eg

A = ones([1,2,3,4]);
B = mean(A, 4);
size(B)
% ans = 1   2   3

Note, how the answer is [1,2,3] , and not [1,2,3,1] . This is in contrast to languages like python, for instance, where a size of (1,1) is very different to a size of (1,) .

Therefore, with regard to your questions, one way to use this to your advantage could be to ensure that the dimension that is to be reduced is always found at the end, and thus automatically simplified.

This becomes even more useful when you realise that:

size(A(:))       % ans =   24    1     (i.e. 24)
size(A(:,:))     % ans =    1   24
size(A(:,:,:))   % ans =    1    2   12
size(A(:,:,:,:)) % ans =    1    2    3    4

Meaning, if you order your dimensions hierarchically you can ensure that any operations that need to take place over the higher dimensions, can a) be vectorised easily, and b) give a natural result, without the need to waste time squeezing or permuting the resulting dimensions.