Divide matrix in subgroups based on rows and columns

Hello everyone,

I have a 51200x48 matrix that I would like to divide by rows. More specifically, every 256 rows should be saved into a new variable (so in total 200 variables). Furthermore, I would like to do this column per column.

Can anyone help me with this? Many thanks!

[Steven Lord]

How are you hoping to use these "new variables"? If you're planning to process each segment one at a time, in a for loop for example, you may not need to create lots of new variables.

x = reshape(randperm(24), 6, 4) % Shuffle the numbers from 1 to 24 to form a 6-by-4 matrix

x = 6×4

13 8 15 9 11 5 22 24 17 14 2 7 21 12 3 23 20 4 1 6 19 16 10 18

Here I'm not creating lots of small variables, I'm creating the one variable named data, processing the values in data, and reusing the name at the next iteration.

for r = 1:2:6
    data = x([r r+1], :)
    % now do stuff with data
    m = max(data, [], 'all')
end

data = 2×4

13 8 15 9 11 5 22 24

m = 24

data = 2×4

17 14 2 7 21 12 3 23

m = 23

data = 2×4

20 4 1 6 19 16 10 18

m = 20

[Joyce Oerlemans]

Hello, Steven

Thank you for your quick response. What I want to do with my data is the following: after dividing the matrix into 200 segments (every 256th row), I want to calculate the standard deviation for a certain index of every segment (so 256 standard deviations in total, based off 200 values).

Basically, the data I have now in the 15200x48 matrix are 200 ERP segments consisting of 256 timepoints for 48 channels. So I want to extact the ERP segments and calculate the standard deviation for every timepoint. That is why I thought it was necessary to save every segment into one variable.

Answer 1

[Matt J]

every 256 rows should be saved into a new variable (so in total 200 variables)

I assume you mean you want them split up into cells of a cell array, not distinctly named variables (because that would be bad).

Assuming this, then you could use mat2tiles from this FEX download,

https://www.mathworks.com/matlabcentral/fileexchange/35085-mat2tiles-divide-array-into-equal-sized-sub-arrays

A=rand(51200,48);

Acell=mat2tiles(A,[256,1])

Acell = 200×48 cell array
  Columns 1 through 11

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 12 through 22

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 23 through 33

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 34 through 44

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 45 through 48

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

[Joyce Oerlemans]

Hello, Matt

I have tried it this way:

Acell=mat2tiles(v_all,[256,])

This is the response I get:

>> Acell=mat2tiles(v_all,[256,])

Error: File: horzcat.m Line: 1 Column: 24

Invalid text character. Check for unsupported symbol, invisible character, or pasting of non-ASCII characters.

Error in mat2tiles (line 57)

tileSizes=[varargin{:}];

[Matt J]

I can't explain the error message, but you did mistype what I wrote. It should be,

Acell=mat2tiles(v_all,[256,1])

Answer 2

[Anjaneyulu Bairi]

Hi,

You can refer to the below code to create a new matrix as per the requirements mentioned below

• Every 256 rows should be saved into a new variable
• This operation should be performed column by column.

dataMatrix = rand(51200, 48); % Creates a random matrix of size (51200,48)
columnChunks = cell(48, 1); % Initialize the cell array 

% Loop through each column
for col = 1:48
    % Initialize a cell array for the current column
    columnChunks{col} = cell(200, 1);
    
    % Loop through each chunk for the current column and assign it to the cell array
    for i = 1:200
        columnChunks{col}{i} = dataMatrix((i-1)*256 + 1:i*256, col);
    end
end

Hope it helps to resolve your query

[Joyce Oerlemans]

Hello,

I tried it but it doesn't seem to work. I get the following error:

Invalid text character. Check for unsupported symbol, invisible character, or pasting of non-ASCII characters.

I think it referes to this part: {col}{i}

Answer 3

[Hassaan]

% Assuming your original matrix is named 'originalMatrix'
originalMatrix = rand(51200, 48);  % Example matrix. Replace this with your actual matrix.

numRows = 256;                     % Number of rows in each smaller matrix
totalRows = size(originalMatrix, 1);  
totalColumns = size(originalMatrix, 2);
numMatrices = totalRows / numRows; % Total number of smaller matrices

% Pre-allocate a cell array to store the smaller matrices
smallerMatrices = cell(numMatrices, totalColumns);

for col = 1:totalColumns
    for i = 1:numMatrices
        startRow = (i - 1) * numRows + 1;
        endRow = i * numRows;
        smallerMatrices{i, col} = originalMatrix(startRow:endRow, col);
    end
end

disp(smallerMatrices(1:5))

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

-----------------------------------------------------------------------------------------------------------------------------------------------------

If you find the solution helpful and it resolves your issue, it would be greatly appreciated if you could accept the answer. Also, leaving an upvote and a comment are also wonderful ways to provide feedback.

It's important to note that the advice and code are based on limited information and meant for educational purposes. Users should verify and adapt the code to their specific needs, ensuring compatibility and adherence to ethical standards.

Professional Interests

• Technical Services and Consulting
• Embedded Systems | Firmware Developement | Simulations
• Electrical and Electronics Engineering

Feel free to contact me.

[Joyce Oerlemans]

Hello, Muhammad

This seems to work pretty well! This is the output I get:

With the values available when I click on each tab.

My question now is: is it possible to select the first element of every smaller matrix to calculate the standard deviation over the 200 matrices? And to do this for the second, third, ... 256th element?

Many thanks!

[Hassaan]

@Joyce Oerlemans

% Assuming your original matrix is named 'originalMatrix'
originalMatrix = rand(51200, 48);  % Example matrix. Replace this with your actual matrix.

numRows = 256;                     % Number of rows in each smaller matrix
totalRows = size(originalMatrix, 1);  
totalColumns = size(originalMatrix, 2);
numMatrices = totalRows / numRows; % Total number of smaller matrices

% Pre-allocate a cell array to store the smaller matrices
smallerMatrices = cell(numMatrices, totalColumns);

for col = 1:totalColumns
    for i = 1:numMatrices
        startRow = (i - 1) * numRows + 1;
        endRow = i * numRows;
        smallerMatrices{i, col} = originalMatrix(startRow:endRow, col);
    end
end

disp(smallerMatrices(1:5))

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

% Assuming you have the 'smallerMatrices' from your previous code

% Pre-allocate an array to store the standard deviations
stdDeviations = zeros(numRows, 1);

for elementIdx = 1:numRows
    elements = zeros(numMatrices, 1);
    for matrixIdx = 1:numMatrices
        % Extract the 'elementIdx'-th element from each matrix
        elements(matrixIdx) = smallerMatrices{matrixIdx}(elementIdx);
    end
    % Calculate the standard deviation for this element across all matrices
    stdDeviations(elementIdx) = std(elements);
end

disp(stdDeviations)

    0.2751
    0.2831
    0.2992
    0.2829
    0.2863
    0.2794
    0.2776
    0.2850
    0.2866
    0.2777
    0.2770
    0.2971
    0.2904
    0.2947
    0.2948
    0.2899
    0.2675
    0.2882
    0.2793
    0.3066
    0.2856
    0.2910
    0.2957
    0.2938
    0.2909
    0.3046
    0.2710
    0.2881
    0.2904
    0.2929
    0.2872
    0.2832
    0.2949
    0.3006
    0.3030
    0.2783
    0.3018
    0.3014
    0.2844
    0.2836
    0.2762
    0.3013
    0.2843
    0.2864
    0.2890
    0.2843
    0.2941
    0.2965
    0.2990
    0.2864
    0.2863
    0.2900
    0.2912
    0.2888
    0.2834
    0.2994
    0.2859
    0.2888
    0.2948
    0.2834
    0.2909
    0.2905
    0.2801
    0.3078
    0.2933
    0.2733
    0.2895
    0.2975
    0.2871
    0.2914
    0.2819
    0.2852
    0.2741
    0.3131
    0.2982
    0.2813
    0.3019
    0.2975
    0.2937
    0.2852
    0.2857
    0.2947
    0.2796
    0.2795
    0.2800
    0.2836
    0.2912
    0.2958
    0.2884
    0.2926
    0.3024
    0.2621
    0.2777
    0.2734
    0.2924
    0.2978
    0.2984
    0.2805
    0.2759
    0.2821
    0.2977
    0.2745
    0.2883
    0.2883
    0.3011
    0.2765
    0.2854
    0.3010
    0.2695
    0.2807
    0.2983
    0.2716
    0.3019
    0.3032
    0.2980
    0.2824
    0.2694
    0.3030
    0.2856
    0.2714
    0.3081
    0.2821
    0.2914
    0.2936
    0.2882
    0.3000
    0.2825
    0.3076
    0.2924
    0.2963
    0.2806
    0.2946
    0.2953
    0.2975
    0.2978
    0.2921
    0.2873
    0.2802
    0.3060
    0.2990
    0.2754
    0.2854
    0.2922
    0.3021
    0.2842
    0.2717
    0.2730
    0.2847
    0.2816
    0.2785
    0.3028
    0.2868
    0.2974
    0.2717
    0.2804
    0.2857
    0.2696
    0.2833
    0.2933
    0.2872
    0.2929
    0.2713
    0.2853
    0.2882
    0.2805
    0.2910
    0.2869
    0.2773
    0.2729
    0.2804
    0.2869
    0.3029
    0.3095
    0.2834
    0.2832
    0.2844
    0.2945
    0.3061
    0.2937
    0.2937
    0.2798
    0.3084
    0.2899
    0.3167
    0.2926
    0.2838
    0.3050
    0.2954
    0.2845
    0.2986
    0.2714
    0.2950
    0.2675
    0.2939
    0.2900
    0.2861
    0.2872
    0.2915
    0.2846
    0.2839
    0.3002
    0.2792
    0.2968
    0.2746
    0.2875
    0.2879
    0.2752
    0.2974
    0.2947
    0.2937
    0.3014
    0.2888
    0.2906
    0.2842
    0.2935
    0.2854
    0.2870
    0.2910
    0.2823
    0.2788
    0.2770
    0.2702
    0.2870
    0.2903
    0.2914
    0.2817
    0.2967
    0.2791
    0.2807
    0.2882
    0.2909
    0.3074
    0.2817
    0.2927
    0.2787
    0.2925
    0.2903
    0.3000
    0.2922
    0.2942
    0.2853
    0.2863
    0.2842
    0.2854
    0.2854
    0.2718
    0.2893
    0.2883
    0.2848
    0.2916
    0.2877
    0.2788
    0.2683
    0.3018
    0.2654
    0.2820

-----------------------------------------------------------------------------------------------------------------------------------------------------

If you find the solution helpful and it resolves your issue, it would be greatly appreciated if you could accept the answer. Also, leaving an upvote and a comment are also wonderful ways to provide feedback.

It's important to note that the advice and code are based on limited information and meant for educational purposes. Users should verify and adapt the code to their specific needs, ensuring compatibility and adherence to ethical standards.

Professional Interests

• Technical Services and Consulting
• Embedded Systems | Firmware Developement | Simulations
• Electrical and Electronics Engineering

Feel free to contact me.

Answer 4

[Voss]

A = rand(51200,48);

n_rows_per_cell = 256;
n_cols_per_cell = 1;

[n_rows,n_cols] = size(A);

Acell = mat2cell(A, ...
    n_rows_per_cell*ones(1,n_rows/n_rows_per_cell), ...
    n_cols_per_cell*ones(1,n_cols/n_cols_per_cell))

Acell = 200×48 cell array
  Columns 1 through 11

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 12 through 22

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 23 through 33

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 34 through 44

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}

  Columns 45 through 48

    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}
    {256×1 double}    {256×1 double}    {256×1 double}    {256×1 double}