Difference between [] and [1x0] in MATLAB

Question

I have a loop in MATLAB that fills a cell array in my workspace (2011b, Windows 7, 64 bit) with the following entries:

my_array = 
    [1x219 uint16]
    [         138]
    [1x0   uint16] <---- row #3
    [1x2   uint16]
    [1x0   uint16]
    []             <---- row #6
    [         210]
    [1x7   uint16]
    [1x0   uint16]
    [1x4   uint16]
    [1x0   uint16]
    [         280]
    []
    []
    [         293]
    [         295]
    [1x2   uint16]
    [         298]
    [1x0   uint16]
    [1x8   uint16]
    [1x5   uint16]

Note that some entries hold [], as in row #6, while others hold [1x0] items, as in row #3.

Is there any difference between them? (other than the fact that MATLAB displays them differently). Any differences in how MATLAB represents them in memory?
If the difference is only about how MATLAB internally represents them, why should the programmer be aware of this difference ? (i.e. why display them differently?). Is it a (harmless) bug? or is there any benefit in knowing that such arrays are represented differently?

Sidenote about the visual representation: A variable displayed as `[]` can, but need not be of type `uint16`. Think about how it got created or check before assuming it is of a certain datatype. — Dennis Jaheruddin, Oct 17 '13 at 14:34
Different answers to this question here: https://stackoverflow.com/q/64351256/7328782 — Cris Luengo, Aug 27 '23 at 13:33

gnovice · Accepted Answer · 2011-10-12T21:28:33.097

In most cases (see below for an exception) there is no real difference. Both are considered "empty", since at least one dimension has a size of 0. However, I wouldn't call this a bug, since as a programmer you may want to see this information in some cases.

Say, for example, you have a 2-D matrix and you want to index some rows and some columns to extract into a smaller matrix:

>> M = magic(4)  %# Create a 4-by-4 matrix

M =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

>> rowIndex = [1 3];  %# A set of row indices
>> columnIndex = [];  %# A set of column indices, which happen to be empty
>> subM = M(rowIndex,columnIndex)

subM =
   Empty matrix: 2-by-0

Note that the empty result still tells you some information, specifically that you tried to index 2 rows from the original matrix. If the result just showed [], you wouldn't know if it was empty because your row indices were empty, or your column indices were empty, or both.

The Caveat...

There are some cases when an empty matrix defined as [] (i.e. all of its dimensions are 0) may give you different results than an empty matrix that still has some non-zero dimensions. For example, matrix multiplication can give you different (and somewhat non-intuitive) results when dealing with different kinds of empty matrices. Let's consider these 3 empty matrices:

>> a = zeros(1,0);  %# A 1-by-0 empty matrix
>> b = zeros(0,1);  %# A 0-by-1 empty matrix
>> c = [];          %# A 0-by-0 empty matrix

Now, let's try multiplying these together in different ways:

>> b*a

ans =
     []  %# We get a 0-by-0 empty matrix. OK, makes sense.

>> a*b

ans =
     0   %# We get a 1-by-1 matrix of zeroes! Wah?!

>> a*c

ans =
   Empty matrix: 1-by-0  %# We get back the same empty matrix as a.

>> c*b

ans =
   Empty matrix: 0-by-1  %# We get back the same empty matrix as b.

>> b*c
??? Error using ==> mtimes
Inner matrix dimensions must agree.  %# The second dimension of the first
                                     %#   argument has to match the first
                                     %#   dimension of the second argument
                                     %#   when multiplying matrices.

Getting a non-empty matrix by multiplying two empty matrices is probably enough to make your head hurt, but it kinda makes sense since the result still doesn't really contain anything (i.e. it has a value of 0).

+1 actually all those cases make sense (at least to me).. The definition of matrix multiplying still applies: the product of an `m×p` matrix with a `p×n` matrix is an `m×n` matrix — Amro, Oct 14 '11 at 09:14
@gnovice Thank you for your anwser. Why does a*b=0? What does happen in memory? — bokabokaboka, Aug 28 '23 at 04:13

score 6 · Answer 2 · edited Oct 14 '11 at 09:00

When concatenating matrices, the common dimension has to match.

It's not currently an error if it doesn't match when one of the operands is empty, but you do get a nasty warning that future versions might be more strict.

Examples:

>> [ones(1,2);zeros(0,9)]
Warning: Concatenation involves an empty array with an incorrect number of columns.
This may not be allowed in a future release. 
ans =
     1     1

>> [ones(2,1),zeros(9,0)]
Warning: Concatenation involves an empty array with an incorrect number of rows.
This may not be allowed in a future release. 
ans =
     1
     1

@Amro: Thanks for providing the examples. – Ben Voigt Oct 14 '11 at 20:34 — Ben Voigt, Oct 14 '11 at 20:34

score 4 · Answer 3 · answered Oct 12 '11 at 21:22

Another difference is in the internal representation of both versions of empty. Especially when it comes to bundle together objects of the same class in an array.

Say you have a dummy class:

classdef A < handle
%A Summary of this class goes here
%   Detailed explanation goes here

properties
end

methods
end

end

If you try to start an array from empty and grow it into an array of A objects:

clear all
clc

% Try to use the default [] for an array of A objects.
my_array = [];
my_array(1) = A;

Then you get:

??? The following error occurred converting from A to double:
Error using ==> double
Conversion to double from A is not possible.

Error in ==> main2 at 6
my_array(1) = A;

But if you do:

% Now try to use the class dependent empty for an array of A objects.
my_array = A.empty;
my_array(1) = A;

Then all is fine.

I hope this adds to the explanations given before.

Here is another example of using `empty` to preallocate an empty vector of objects: http://stackoverflow.com/questions/6806344/storing-handles-of-objects-generated-by-imline-in-matlab/6807795#6807795 — Amro, Oct 14 '11 at 09:03

score 0 · Answer 4 · edited May 23 '17 at 12:00

If concatenation and multiplication is not enough to worry about, there is still looping. Here are two ways to observe the difference:

1. Loop over the variable size

for t = 1:size(zeros(0,0),1); % Or simply []
   'no'
end
for t = 1:size(zeros(1,0),1); % Or zeros(0,1)
   'yes'
end

Will print 'yes', if you replace size by length it will not print anything at all.

If this is not a surprise, perhaps the next one will be.

2. Iterating an empty matrix using a for loop

for t = []          %// Iterate an empty 0x0 matrix
    1
end
for t = ones(1, 0)  %// Iterate an empty 1x0 matrix
    2
end
for t = ones(0, 1)  %// Iterate an empty 0x1 matrix
    3
end

Will print:

ans =
    3

To conclude with a concise answer to both of your questions:

Yes there is definitely a difference between them
Indeed I believe the programmer will benefit from being aware of this difference as the difference may produce unexpected results

Difference between [] and [1x0] in MATLAB

4 Answers4

The Caveat...

Linked

Related