Does MATLAB support truly 1d arrays?

Question

It would really help me reason about my MATLAB code if I didn't have to worry about accidental 2d operations. For instance, if I want to do element-wise multiplication of 1d arrays, but one is a row and another is a column, I end up with a 2d result.

>> a = 1:8;
>> a = a(:);
>> a .* cumsum(ones(8))

ans =

     1     1     1     1     1     1     1     1
     4     4     4     4     4     4     4     4
     9     9     9     9     9     9     9     9
    16    16    16    16    16    16    16    16
    25    25    25    25    25    25    25    25
    36    36    36    36    36    36    36    36
    49    49    49    49    49    49    49    49
    64    64    64    64    64    64    64    64

I'd like to prevent this type of thing, and likely other problems that I can't foresee, by keeping all my arrays 1d wherever I can. But every time I check the size() of vector, I get at least 2 elements back:

>> size(1:1:6)

ans =

     1     6

>> size(linspace(0, 5, 10))

ans =

     1    10

I've tried the suggestions at How to create single dimensional array in matlab? and some of the options here (PDF download), and I can't get a "truly" 1d array. How would you deal with this type of issue?

Answer 1

There is no such thing as 1D array. The documentation says (emphasis mine):

All MATLAB variables are multidimensional arrays, no matter what type of data. A matrix is a two-dimensional array often used for linear algebra.

You may use isvector, isrow and iscolumn to identify vectors, row vectors and column vectors respectively.

Answer 2

@Sardar has already said the last word. Another clue is ndims:

N = ndims(A) returns the number of dimensions in the array A. The number of dimensions is always greater than or equal to 2. ...

But about your other question:

How would you deal with this type of issue?

There's not much you can do. Debug, find the mistake and fix it. If it's some one-time script, you are done. But if you are writing functions that may be used later, it's better to protect them from accepting arguments with unequal dimensions:

function myFunc(A, B)
if ndims(A)~=ndims(B) || any(size(A)~=size(B))
    error('Matrix dimensions must agree.');
end
% ...
end

Or, if your function really needs them to be vectors:

function myFunc(A, B)
if ~isvector(A) || ~isvector(B) || any(size(A)~=size(B))
    error('A and B must be vectors with same dimensions.');
end
% ...
end

You can also validate different attributes of arguments using validateattributes:

function myFunc(A, B)
validateattributes(A, {'numeric'},{'vector'}, 'myFunc', 'A')
validateattributes(B, {'numeric'},{'size', size(A)}, 'myFunc', 'B')
% ...
end

Edit:

Also, if the function only needs the inputs to be vectors and their orientation does not matter, you can modify them inside the function (thanks to @CrisLuengo for commenting).

function myFunc(A, B)
if ~isvector(A) || ~isvector(B) || length(A)~=length(B)
    error('A and B must be vectors with the same length.');
end
A = A(:);
B = B(:);
% ...
end

However, this is not recommended when the output of the function is also a vector with the same size as the inputs. This is because the caller expects the output to be in the same orientation as the inputs, and if this is not the case, problems may arise.