In MATLAB how can I write out a multidimensional array as a string that looks like a raw numpy array?

The Goal

(Forgive me for length of this, it's mostly background and detail.)

I'm contributing to a TOML encoder/decoder for MATLAB and I'm working with numerical arrays right now. I want to input (and then be able to write out) the numerical array in the same format. This format is the nested square-bracket format that is used by *numpy.array*. For example, to make multi-dimensional arrays in numpy:

The following is in python, just to be clear. It is a useful example though my work is in MATLAB.

2D arrays

```python
>> x = np.array([1,2])
>> x
array([1, 2])

>> x = np.array([[1],[2]])
>> x
array([[1],
       [2]])
```

3D array

```python
>> x = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
>> x
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])
```

4D array

```python
>> x = np.array([[[[1,2],[3,4]],[[5,6],[7,8]]],[[[9,10],[11,12]],[[13,14],[15,16]]]])
>> x
array([[[[ 1,  2],
         [ 3,  4]],

        [[ 5,  6],
         [ 7,  8]]],


       [[[ 9, 10],
         [11, 12]],

        [[13, 14],
         [15, 16]]]])
```

The input is a logical construction of the dimensions by nested brackets. Turns out this works pretty well with the TOML array structure. I can already successfully parse and decode any size/any dimension numeric array with this format from TOML to MATLAB numerical array data type.

Now, I want to encode that MATLAB numerical array back into this char/string structure to write back out to TOML (or whatever string).

So I have the following 4D array in MATLAB (same 4D array as with numpy):

```matlab
>> x = permute(reshape([1:16],2,2,2,2),[2,1,3,4])
x(:,:,1,1) =
     1     2
     3     4
x(:,:,2,1) =
     5     6
     7     8
x(:,:,1,2) =
     9    10
    11    12
x(:,:,2,2) =
    13    14
    15    16
```

And I want to turn that into a string that has the same format as the 4D numpy input (with some function named *bracketarray* or something):

```matlab
>> str = bracketarray(x)
str =
    '[[[[1,2],[3,4]],[[5,6],[7,8]]],[[[9,10],[11,12]],[[13,14],[15,16]]]]'
```

I can then write out the string to a file.

EDIT: I should add, that the function numpy.array2string() basically does exactly what I want, though it adds some other whitespace characters. But I can't use that as part of the solution, though it is basically the functionality I'm looking for.

The Problem

Here's my problem. I have successfully solved this problem for up to 3 dimensions using the following function, but I cannot for the life of me figure out how to extend it to N-dimensions. I feel like it's an issue of the right kind of counting for each dimension, making sure to not skip any and to nest the brackets correctly.

Current bracketarray.m that works up to 3D

```matlab
function out = bracketarray(in, internal)
  in_size = size(in);
  in_dims = ndims(in);
  
  % if array has only 2 dimensions, create the string
  if in_dims == 2
    storage = cell(in_size(1), 1);
    for jj = 1:in_size(1)
      storage{jj} = strcat('[', strjoin(split(num2str(in(jj, :)))', ','), ']');
    end
    if exist('internal', 'var') || in_size(1) > 1 || (in_size(1) == 1 && in_dims >= 3)
      out = {strcat('[', strjoin(storage, ','), ']')};
    else
      out = storage;
    end
    return
    % if array has more than 2 dimensions, recursively send planes of 2 dimensions for encoding
  else
    out = cell(in_size(end), 1);
    for ii = 1:in_size(end) %<--- this doesn't track dimensions or counts of them
      out(ii) = bracketarray(in(:,:,ii), 'internal'); %<--- this is limited to 3 dimensions atm. and out(indexing) need help
    end
  end
  % bracket the final bit together
  if in_size(1) > 1 || (in_size(1) == 1 && in_dims >= 3)
    out = {strcat('[', strjoin(out, ','), ']')};
  end
end
```

Help me Obi-wan Kenobis, y'all are my only hope!

EDIT 2: Added test suite below and modified current code a bit.

Test Suite

Here is a test suite to use to see if the output is what it should be. Basically just copy and paste it into the MATLAB command window. For my current posted code, they all return true except the ones more than 3D. My current code outputs as a cell. If your solution output differently (like a string), then you'll have to remove the curly brackets from the test suite.

disp({1, isequal(bracketarray(ones(1,1)), {'[1]'})})
disp({2, isequal(bracketarray(ones(2,1)), {'[[1],[1]]'})})
disp({3, isequal(bracketarray(ones(1,2)), {'[1,1]'})})
disp({4, isequal(bracketarray(ones(2,2)), {'[[1,1],[1,1]]'})})
disp({5, isequal(bracketarray(ones(3,2)), {'[[1,1],[1,1],[1,1]]'})})
disp({6, isequal(bracketarray(ones(2,3)), {'[[1,1,1],[1,1,1]]'})})
disp({7, isequal(bracketarray(ones(1,1,2)), {'[[[1]],[[1]]]'})})
disp({8, isequal(bracketarray(ones(2,1,2)), {'[[[1],[1]],[[1],[1]]]'})})
disp({9, isequal(bracketarray(ones(1,2,2)), {'[[[1,1]],[[1,1]]]'})})
disp({10,isequal(bracketarray(ones(2,2,2)), {'[[[1,1],[1,1]],[[1,1],[1,1]]]'})})
disp({11,isequal(bracketarray(ones(1,1,1,2)), {'[[[[1]]],[[[1]]]]'})})
disp({12,isequal(bracketarray(ones(2,1,1,2)), {'[[[[1],[1]]],[[[1],[1]]]]'})})
disp({13,isequal(bracketarray(ones(1,2,1,2)), {'[[[[1,1]]],[[[1,1]]]]'})})
disp({14,isequal(bracketarray(ones(1,1,2,2)), {'[[[[1]],[[1]]],[[[1]],[[1]]]]'})})
disp({15,isequal(bracketarray(ones(2,1,2,2)), {'[[[[1],[1]],[[1],[1]]],[[[1],[1]],[[1],[1]]]]'})})
disp({16,isequal(bracketarray(ones(1,2,2,2)), {'[[[[1,1]],[[1,1]]],[[[1,1]],[[1,1]]]]'})})
disp({17,isequal(bracketarray(ones(2,2,2,2)), {'[[[[1,1],[1,1]],[[1,1],[1,1]]],[[[1,1],[1,1]],[[1,1],[1,1]]]]'})})
disp({18,isequal(bracketarray(permute(reshape([1:16],2,2,2,2),[2,1,3,4])), {'[[[[1,2],[3,4]],[[5,6],[7,8]]],[[[9,10],[11,12]],[[13,14],[15,16]]]]'})})
disp({19,isequal(bracketarray(ones(1,1,1,1,2)), {'[[[[[1]]]],[[[[1]]]]]'})})

[dpb]

That syntax entirely exceeds my ability to assimilate...probably easy to parse, but terrible to read and to try to count paren's if either reading or coding. "Bend the human to the computer" went out in the 70s and 80s, I thought. :)

Editorial comments aside, can you not see the source for the numpy.array2string() method to see their algorithm?

[gwoo]

Yea I know all the brackets are crazy, they aren't necessarily meant to be readable, just something that is encoded corrected so it can be decoded correctly. I wouldn't expect someone to make a large complicated array like that by hand.

As for the numpy code, it is not a simple task. The code that pertains is likely in C and scattered around different locations. It's not a simple method one can read and port. I've really tried to find the code but it's incredibly difficult to track it down.

[dpb]

Would an expedient be to package a call to it somehow, maybe, while continue to develop the real thing? I've never used python so know absolutely nothing about it, so it's possibly a dumb idea. PythonLibraries

[gwoo]

I thought about that but I can't have any non-matlab dependancies.

Answer 1

[Steven Lord]

To iterate over the nth dimension of an array where n is not fixed, there is an indexing trick you can use.

ndim = randi([4 7]);
dims = randi([2 5], 1, ndim);
A = randi(10, dims);

A is an array with either 4, 5, 6, or 7 dimensions. Its size in each of its dimensions is between 2 and 5. Its values are all integer values between 1 and 10. I constrained the size of A, but I did not fix it.

inds = repmat({':'}, 1, ndims(A));
inds{end-1} = 2;
Q = A(inds{:})

Q is the same size as A except in its next to last dimension, where it has size 1. It is the second slice in that dimension. [This is safe to do, since I know the size of A is at least two in that dimension due to the way I constructed dims.] When I tried this, my results were as follows. I compared Q to the result of manually indexing into A to extract that slice and they are the same.

>> size(A)
ans =
     2     2     2     5     5     3     2
>> size(Q)
ans =
     2     2     2     5     5     1     2
>> isequal(A(:, :, :, :, :, 2, :), Q)
ans =
  logical
   1

[gwoo]

Thank you for your response. I really appreicate your time, however it's not clear to me how to apply this to my particular task. What I'm doing is taking 2-D planes at a time and bracketing them. The brackets then need to nest accordingly if those 2-D planes are in stacks or stacks-of-stacks, etc.

[Steven Lord]

A 3-D array can be thought of like 2-D matrices stacked on top of one another, like pages in a book.

A 4-D array can be thought of like 3-D arrays stacked "on top" of one another, like books on a bookshelf. [Okay, that's not really stretching into the 4th dimension, but it's a simile not literal.]

So a 4-D array is a stack of stacks of 2-D matrices. Use recursion.

[gwoo]

Thanks for the help!