Abandon MATLAB

Programatically creating a struct

August 12, 2009 at 2:14 am (crap data structures, trouble with small numbers, unexpressive language)

Say you are parsing a file and you read a list of column names, then a list of values to put into those column names. Simple enough, obviously you are going to put them into a 1×1 struct array. Perhaps use the ‘struct’ function to do this. Given a cell array of field names snames, and a cell array of values to associate with those field names svals, we can just use struct() to cook up a struct:

arglist = {snames{:};svals{:}}
s = struct(arglist{:})

Goodness there’s a lot of matlab-ism’s packed into that. To work out how that works you need to know: that x{} extracts cell array contents into a “comma separated list,” which is not an actual list like a data structure you can access (there aren’t any of those) but a syntax that unpacks a cell array or struct field access (but not a regular array or function call) into a place where the parser otherwise expects expressions separated by commas; that putting comma-separated expressions like {x, y, z; a, b, c} orders an array in row-major order BUT : orders an array in column-major order, and so on. Let’s ignore the fact that reasonable goddamn languages like Python or R write the above simply as s = dict(zip(snames, svalues)) or s = svalues; names(s)<-snames, respectively, and press on. Did you notice the condition in which the above will fail and break horribly?

You do remember how struct() works, right? You give the field name, then the value, then the second field name, then the second value, the good old ersatz broken named arguments pattern. And the GREAT thing about the broken ersatz named arguments pattern is that every function that implements it does the input parsing just a LITTLE BIT differently. (After writing dozens of name-value parsers, each working a little bit differently, MathWorks went ahead and came up with an InputParser class which gives you all the flexibility to continue making every argument list parser work just a little different.)

Take struct(), for instance. (Please!). Just as an exercise, try making this struct by writing an invocation of struct():

s =
    a: 1
    b: 2

The answer to this exercise is:

s = struct('a', 1, 'b', 2)

But your data are complicated: Some of the structure fields are themselves cell arrays. Now try using struct to make this struct with a singleton cell array:

s =
    a: 1
    b: {[2]}

Got that? Let’s try this one with an empty cell array.

s =
    a: 1
    b: {}

And this one with multiple elements in a cell in a member of the structure:

s =
    a: 1
    b: {'foo', 'bar'}

If you’ve tried this and were surprised, read on.

%There being no cell2struct, MATLAB's builtin function struct() seems to
%be the only simple way to efficiently programatically initialize a
%structure. But the behavior of struct() is not simple. It has
%*astonishing* behavior on cell array arguments.
%
%>> struct('a', 1)
%ans =
%    a: 1
%>> struct('a', {1})
%ans =
%    a: 1
%>> struct('a', {1, 2})
%ans =
%1x2 struct array with fields:
%    a
%>> struct('a', {})
%ans =
%0x0 struct array with fields:
%    a
%
% There are two overlapping behaviors: the behavior when the value to put
% in a field is a cell array, and the value when it is any other type. This
% makes it tricky to use struct() to make scalar whose field values are
% themselves cell arrays:
%
% >> struct('a', {1, 2}, 'b', {3, 4, 5})
%??? Error using ==> struct
%Array dimensions of input 4 must match those of input 2 or be scalar.
%
% To acheive the intended effect, you must double-wrap such arguments:
%
%>> struct('a', {{1, 2}}, 'b', {{3, 4, 5}})
%ans =
%    a: {[1]  [2]}
%    b: {[3]  [4]  [5]}
%
% Further complicating this is that struct() does 'scalar expansion' of
% non-cell or singleton cell arguments
%
%>> struct('a', {1, 2}, 'b', {3}, 'c', [2 4 5])
%ans =
%1x2 struct array with fields:
%    a
%    b
%>> ans.b
%ans =
%     3
%ans =
%     3
%>> ans.c
%ans =
%     2    4    5
%ans =
%     2    4    5
%
%From this we can conclude that the only consistent, general way to use
%struct() is to wrap all value arguments in cell arrays.

All right! So now you know how to REALLY combine a list of names and a list of values into a structure.

In Python:

s = dict(zip(snames, svalues))

In R:

names(svalues) <- snames

And in MATLAB:

svals = num2cell(svals);

arglist = {snames{:};svals{:}};

s = struct(arglist{:});

Permalink 3 Comments