{"id":366,"date":"2011-03-29T15:20:00","date_gmt":"2011-03-29T19:20:00","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/2011\/03\/29\/even-more-information-about-the-size-function\/"},"modified":"2019-10-29T16:33:03","modified_gmt":"2019-10-29T20:33:03","slug":"even-more-information-about-the-size-function","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2011\/03\/29\/even-more-information-about-the-size-function\/","title":{"rendered":"Even more information about the size function"},"content":{"rendered":"
\r\n

I'm terrible at predicting what kind of topic will generate a lot of comments. I was sure that last week's post on size<\/tt> esoterica<\/a> would put most everyone to sleep. But no, it quickly gathered quite a few comments containing several interesting ideas and\r\n questions. So I thought it would be useful to follow up with another post instead of replying with my own comments.\r\n <\/p>\r\n

First, there was some discussion in the comments about the \"best\" way to call size<\/tt>. Let's quickly review the basic ways to call size<\/tt>:\r\n <\/p>\r\n

The call sz = size(A)<\/tt> returns a size vector of length ndims(A)<\/tt>.\r\n <\/p>

A = rand(3,4,5);\r\nsz = size(A)<\/pre>
sz =\r\n     3     4     5\r\n<\/pre>
The call d = size(A,n)<\/tt> returns the size of the n-th dimension of A<\/tt>. n<\/tt> can be greater than ndims(A)<\/tt>.\r\n   <\/p>
d = size(A,2)<\/pre>
d =\r\n     4\r\n<\/pre>
d = size(A,6)<\/pre>
d =\r\n     1\r\n<\/pre>
The call [m,n,p] = size(A)<\/tt> returns the sizes along the first three dimensions as m<\/tt>, n<\/tt>, and p<\/tt>. If A<\/tt> has more than three dimensions, then p<\/tt> is the product of the sizes along the third and all higher dimensions.  If you call size(A)<\/tt> with more output arguments than ndims(A)<\/tt>, the value of all the \"extra\" output arguments is 1.\r\n   <\/p>
[m,n,p] = size(A)<\/pre>
m =\r\n     3\r\nn =\r\n     4\r\np =\r\n     5\r\n<\/pre>
[m,n] = size(A)<\/pre>
m =\r\n     3\r\nn =\r\n    20\r\n<\/pre>
[m,n,p,q,r] = size(A)<\/pre>
m =\r\n     3\r\nn =\r\n     4\r\np =\r\n     5\r\nq =\r\n     1\r\nr =\r\n     1\r\n<\/pre>
So which of these forms is best? I don't think there is a single best choice. I regularly use all three, and my particular\r\n      choice in any one instance depends on how the output of size<\/tt> is used in the subsequent code. Also, keep in mind that every variable assignment is an opportunity to name something well\r\n      (or not).\r\n   <\/p>\r\n   
Sometimes, for example, I just need a size vector to pass to something like reshape<\/tt>, like this:\r\n   <\/p>
   size_in = size(in);\r\n   % work with input as a single column vector\r\n   in = in(:);<\/pre>
   ... lots o' code<\/pre>
   % reshape output to be the same size as input\r\n   out = reshape(out,size_in);<\/pre>
Or I might need to refer several times in the code to the number of color-space components in an array, and I don't need other\r\n      information about the size:\r\n   <\/p>
   num_components = size(in,3);<\/pre>
   for k = 1:num_components\r\n      ... do something interesting with each component\r\n   end<\/pre>
If I need to refer to the sizes along several dimensions separately in the code, then I'll do something like this in order\r\n      to have readable names:\r\n   <\/p>
   [num_rows, num_cols, num_planes] = size(A);<\/pre>
Jonathan<\/a> didn't want to use the tilde technique I showed because of code portability with older versions of MATLAB:\r\n   <\/p>
   [num_rows, num_cols, ~] = size(A);<\/pre>
I acknowledge that is sometimes a concern, but for any given feature this issue doesn't last forever. MATLAB xUnit Test Framework is by far my post popular contribution to the MATLAB Central File Exchange (147 downloads in the last 30 days), and it requires\r\n      R2008a or later to run. When I started at MathWorks, there were no multidimensional arrays, integer arrays, cell arrays, structs,\r\n      subfunctions, object-oriented programming, function handles, try\/catch, etc.\r\n   <\/p>\r\n   
João suggested<\/a> that we enhance size<\/tt> so that the dim<\/tt> argument can be a vector. For example:\r\n   <\/p>
   sz = size(A,1:2);<\/pre>
I like this idea a lot in principle, but I would personally be cautious about putting it into MATLAB. There are a lot of functions\r\n      that take dim<\/tt> arguments, and we want them to be as consistent as possible in the way they treat the dim<\/tt> argument. So making this change to size<\/tt> has possible implications well beyond size<\/tt> that we would have to consider.\r\n   <\/p>\r\n   
If I think about the size-related code I've written many times for handling multidimensional arrays, I think I'd like to have\r\n      a function that allows me to specify how many elements the output size vector should have. It would work something like this:\r\n   <\/p>
   sz = sizen(A,5);  % sz has five elements<\/pre>
Then, if I'm working with two multidimensional arrays, A and B, and I want size vectors that are guaranteed to be compatible,\r\n      I could do it like this:\r\n   <\/p>
   num_dims = max(ndims(A), ndims(B));\r\n   size_A = sizen(A, num_dims);\r\n   size_B = sizen(B, num_dims);<\/pre>
I could even imagine a sizes<\/tt> function that would handle that logic for me automatically:\r\n   <\/p>
   [size_A, size_B] = sizes(A, B);<\/pre>
There were other comments that had to do with general multidimensional array manipulation and indexing techniques. I'll explore\r\n      some of those ideas in a future post. While you're waiting, look at the code for flipdim<\/tt> and see if you can figure out how it works.\r\n   <\/p>