jsondecode should treat array-of-array as row or n-dimensional matrix

[mtmiller]

In Matlab, when decoding a JSON array-of-arrays where all values are numeric, it returns a numeric matrix of appropriate nested dimension.

Examples

jsondecode('[1, 2, 3]')  % 1-d column vector
jsondecode('[[1, 2, 3]]')  % 1-d row vector
jsondecode('[[1, 2], [1, 2]]')  % 2-d matrix
jsondecode('[[[1, 2], [1, 2]], [[1, 2], [1, 2]]]')  % 3-d matrix

I guess that this falls under the "condensation" logic. If any entries aren't numeric or are of inconsistent shape or size, then it falls back to returning cell arrays of cell arrays.

[apjanke]

Yep, the condensation logic should do this. This will take a bit of work to fix.

Since the dimensionality of numeric arrays is unlikely to get large (how often do you see a hundred-dimension array?), I think this can be done in a separate condensation step in the jsondecode M-code wrapper instead of the __jsonstuff_jsondecode_oct_- oct-file. That'll be easier to write.

(I think? Or will we have to pay for expensive negative cases, where we have to search all the members of a cell array to determine whether it is in fact a condensable array-of-numeric-arrays? In that case, maybe the logic should live in the oct-file after all.)

[mtmiller]

Yeah I think it would be a little wasteful, and probably slower, to return a cell only to examine its dimensions and types and see if it can be collapsed into a matrix.

[apjanke]

Wasteful, but easier to write: from what I can figure, doing the condensation means a recursive depth-first traversal through the object graph of the decoded JSON data, condensing as you go, and then doing a permute() and cat() in a post-order manner at each node. Easy to write in M-code; I'm still trying to figure out how I'd approach it in C++.

I've checked in an M-code implementation at 511404d. Please have a look and let me know what you think. After we've established correctness, then let's see about pushing this logic down into the oct-file for performance.

[mtmiller]

Cool, works for me for most examples of full higher order arrays.

Fails on some simpler and degenerate cases, for example

>> jsondecode ('[[1, 2]]')
ans =

   1
   2

should return a row vector. And empty or null arrays evidently aren't condensed, for example

>> jsondecode ('[[]]')
ans = [](0x0)

should return a cell array with an empty double array in it. Only gets condensed to a scalar if the innermost array consists of a scalar value.

Same with arrays of objects, [[[{}]]] should not get condensed (after fixing #9), but [[[{"a":1}]]] should (and does now) get condensed to a scalar struct.

[apjanke]

Argh, who designed the behavior for this stuff?

Okay, I'll special-case these caes.

[apjanke]

Okay. I pulled the condensation logic up into M-code until we can get the algorithm fully sorted out. (Leaving just the array-of-numerics-to-numeric-vector case in C++ for speed.) de8ec86

This made things clearer: Every level of [...] nesting around numeric or struct arrays causes them to get permuted/"rotated" one dimension higher. And then condensation is simply cat-ing the children along dimension 1 if they are conformant. (And always leaving char arrays as they are.)

Tests are passing now, and I think I've got all the cases you covered here. Closing this as fixed, and leaving #10 as a reminder to optimize this in C++ once we're sure we know what we're doing.

[mtmiller]

Cool! I'll try this in a little bit

[mtmiller]

Works great for me!