How to convert tables into numeric arrays?

Hi I have the data set C_512 (see attached) and I want to make the tables within the cells of the cell array into numeric arrays so that there are no longer any tables in C_512. I used this code below:

% Load the .mat file
load('/path/to/C_512.mat');

% Initialize a new cell array to store numeric arrays
C_512_numeric = cell(size(C_512));

% Loop through each cell and convert its content to numeric arrays
for i = 1:size(C_512, 1)
    for j = 1:size(C_512, 2)
        T = C_512{i, j};
        if istable(T)
            C_512_numeric{i, j} = table2array(T);
        else
            C_512_numeric{i, j} = T; % If it's already an array or matrix
        end
    end
end

% Save the numeric data to a new .mat file
save('C_512_numeric.mat', 'C_512_numeric');

Unfortunately, C_512_numeric still contains tables. Why is that?

[dpb]

whos -file C_512.mat

  Name       Size              Bytes  Class    Attributes

  C_512      7x4             2014704  cell               

load C_512
C_512

C_512 = 7x4 cell array
    {11x1 cell}    { 6x1 cell}    {14x1 cell}    {15x1 cell}
    { 7x1 cell}    {10x1 cell}    { 7x1 cell}    { 5x1 cell}
    {10x1 cell}    {12x1 cell}    {10x1 cell}    { 7x1 cell}
    { 7x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}
    {21x1 cell}    {10x1 cell}    {12x1 cell}    { 6x1 cell}
    { 6x1 cell}    { 6x1 cell}    { 7x1 cell}    { 5x1 cell}
    { 4x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}

C_512{1,1}

ans = 11x1 cell array
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {320x2 table}

C_512{1,1}{1}

ans = 512x2 table
    X1_X2_Left_Vel    X1_X3_Right_Vel
    ______________    _______________

        0.14123          -0.017276   
        0.14404         -0.0072018   
        0.16312          -0.013977   
       -0.10483            0.32546   
        0.16891         -0.0091148   
       -0.28198           -0.43283   
        0.16782         -0.0084964   
        0.17268          0.0089324   
        0.16818          0.0016339   
       -0.10804            0.34679   
        0.16285          0.0030559   
        0.16434          0.0088692   
       -0.28724           -0.41746   
        0.14216           0.011152   
       -0.11686              0.369   
        0.13089           0.018705   

C_512{1,1}{2}

ans = 512x2 table
    X1_X2_Left_Vel    X1_X3_Right_Vel
    ______________    _______________

      -0.073614            0.07282   
       -0.12633           0.049823   
        -0.1624           0.036972   
       -0.26839           0.033588   
       -0.30174           0.024633   
       -0.31731           0.018524   
       -0.32305           0.019752   
       -0.32482           0.021902   
       -0.31775           0.015268   
       -0.30664           0.026139   
       -0.32614           0.021981   
        0.27627           -0.11522   
       0.030817          -0.068823   
       -0.28556           0.090543   
        -0.2532            0.12199   
       -0.22438            0.13807   

Wowsers! What a mess! How did you manage to dig yourself into such a hole? My suggestion would be to go back to the code that generated this deeply nested thing and build a better data structure to start with and avoid the question as posed altogether.

[lil brain]

What? I dont understand

[dpb]

Instead of having to go to such levels of coding as @Voss showed, how was the original .mat file created? Unless it comes from an outside source (and if so, I'd rail at them for such an abomination), you should be able to create at least only a one-level array of tables (or arrays) instead of being doubly-nested.

Show us/explain to us the origination of the original file and let's see about cleaning it up to begin with instead of having to then straighten it out after the fact.

Answer 1

[Voss]

C_512 is not a cell array of tables; it is a cell array of cell arrays of tables.

% Load the .mat file
load('./C_512.mat');
C_512 % cell array containing cell arrays

C_512 = 7x4 cell array
    {11x1 cell}    { 6x1 cell}    {14x1 cell}    {15x1 cell}
    { 7x1 cell}    {10x1 cell}    { 7x1 cell}    { 5x1 cell}
    {10x1 cell}    {12x1 cell}    {10x1 cell}    { 7x1 cell}
    { 7x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}
    {21x1 cell}    {10x1 cell}    {12x1 cell}    { 6x1 cell}
    { 6x1 cell}    { 6x1 cell}    { 7x1 cell}    { 5x1 cell}
    { 4x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}

C_512{1} % cell array containing tables

ans = 11x1 cell array
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {512x2 table}
    {320x2 table}

So when your code checks whether C_512{i, j} is a table, it is not; it is a cell array. You'd need to add another loop to iterate over the cells of C_512{i, j} and check whether each cell contains a table.

% Initialize a new cell array to store numeric arrays
C_512_numeric = cell(size(C_512));

% Loop through each cell and convert its content to numeric arrays
for i = 1:size(C_512, 1)
    for j = 1:size(C_512, 2)
        C = C_512{i, j};
        % pre-allocate the cell array C_512_numeric{i, j}
        C_512_numeric{i, j} = cell(size(C));
        for k = 1:numel(C)
            T = C{k};
            if istable(T)
                C_512_numeric{i, j}{k,1} = table2array(T);
            else
                C_512_numeric{i, j}{k} = T; % If it's already an array or matrix
            end
        end
    end
end

C_512_numeric % cell array containing cell arrays

C_512_numeric = 7x4 cell array
    {11x1 cell}    { 6x1 cell}    {14x1 cell}    {15x1 cell}
    { 7x1 cell}    {10x1 cell}    { 7x1 cell}    { 5x1 cell}
    {10x1 cell}    {12x1 cell}    {10x1 cell}    { 7x1 cell}
    { 7x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}
    {21x1 cell}    {10x1 cell}    {12x1 cell}    { 6x1 cell}
    { 6x1 cell}    { 6x1 cell}    { 7x1 cell}    { 5x1 cell}
    { 4x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}

C_512_numeric{1} % cell array containing numeric matrices

ans = 11x1 cell array
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {320x2 double}

And you can reduce the number of loops by one by iterating over the elements of C_512 and using linear indexing, rather than iterating over the rows and columns in two loops and indexing with two subscripts:

% Initialize a new cell array to store numeric arrays
C_512_numeric = cell(size(C_512));

% Loop through each cell and convert its content to numeric arrays
for i = 1:numel(C_512)
    C = C_512{i};
    % pre-allocate the cell array C_512_numeric{i}
    C_512_numeric{i} = cell(size(C));
    for k = 1:numel(C)
        T = C{k};
        if istable(T)
            C_512_numeric{i}{k} = table2array(T);
        else
            C_512_numeric{i}{k} = T; % If it's already an array or matrix
        end
    end
end
C_512_numeric % cell array containing cell arrays

C_512_numeric = 7x4 cell array
    {11x1 cell}    { 6x1 cell}    {14x1 cell}    {15x1 cell}
    { 7x1 cell}    {10x1 cell}    { 7x1 cell}    { 5x1 cell}
    {10x1 cell}    {12x1 cell}    {10x1 cell}    { 7x1 cell}
    { 7x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}
    {21x1 cell}    {10x1 cell}    {12x1 cell}    { 6x1 cell}
    { 6x1 cell}    { 6x1 cell}    { 7x1 cell}    { 5x1 cell}
    { 4x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}

C_512_numeric{1} % cell array containing numeric matrices

ans = 11x1 cell array
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {320x2 double}

[Voss]

Also, you can have cellfun perform the loops, which makes the code more compact.

In this case, I've removed the istable() check since all cells of all cell arrays in C_512 contain tables.

load('./C_512.mat');

C_512_numeric = cellfun(@(c)cellfun(@table2array,c,'UniformOutput',false),C_512,'UniformOutput',false)

C_512_numeric = 7x4 cell array
    {11x1 cell}    { 6x1 cell}    {14x1 cell}    {15x1 cell}
    { 7x1 cell}    {10x1 cell}    { 7x1 cell}    { 5x1 cell}
    {10x1 cell}    {12x1 cell}    {10x1 cell}    { 7x1 cell}
    { 7x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}
    {21x1 cell}    {10x1 cell}    {12x1 cell}    { 6x1 cell}
    { 6x1 cell}    { 6x1 cell}    { 7x1 cell}    { 5x1 cell}
    { 4x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}

C_512_numeric{1}

ans = 11x1 cell array
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {320x2 double}

You can include the istable() check even if using cellfun, but you'd need to make your own little function:

C_512_numeric = cellfun(@convertTableCellsToMatrixCells,C_512,'UniformOutput',false)

C_512_numeric = 7x4 cell array
    {11x1 cell}    { 6x1 cell}    {14x1 cell}    {15x1 cell}
    { 7x1 cell}    {10x1 cell}    { 7x1 cell}    { 5x1 cell}
    {10x1 cell}    {12x1 cell}    {10x1 cell}    { 7x1 cell}
    { 7x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}
    {21x1 cell}    {10x1 cell}    {12x1 cell}    { 6x1 cell}
    { 6x1 cell}    { 6x1 cell}    { 7x1 cell}    { 5x1 cell}
    { 4x1 cell}    { 4x1 cell}    { 5x1 cell}    { 4x1 cell}

C_512_numeric{1}

ans = 11x1 cell array
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {512x2 double}
    {320x2 double}

function C = convertTableCellsToMatrixCells(C)
idx = cellfun(@istable,C);
C(idx) = cellfun(@table2array,C(idx),'UniformOutput',false);
end

[lil brain]

Awesome and very helpful thanks!

[Voss]

You're welcome!