A neat reliable way to add up section of a matrix

I am looking for a neat way to sum up the below matrix without using loops. Note that the A to E have dirrent sizes. I have tried to use accumarray function, however it is not intuitive. I have referenced the last position and counted backwards to the first position based on the size of the matrix. However, my question is about the best way to uploading matrices to a master array with some sort of flexibility on positions. Additionally I would like to know about an effecient way to upload several matrices, various sizes to a master array, maybe using array functions or cell arrays?

A = repmat(1:10,10,1)
B = repmat(1:8,10,1)
C = repmat(1:6,10,1)
D = repmat(1:4,10,1)
E = repmat(1:2,10,1)

Z=zeros(size(A)) + A
Z(:, 3:10) = Z(:, 3:10) + B
Z(:, 5:10) = Z(:, 5:10) + C
Z(:, 7:10) = Z(:, 7:10) + D
Z(:, 9:10) = Z(:, 9:10) + E

Answer 1

[Rik]

Loops tend to do the trick:

A = repmat(1:10,10,1);
B = repmat(1:8,10,1);
C = repmat(1:6,10,1);
D = repmat(1:4,10,1);
E = repmat(1:2,10,1);

data={A,B,C,D,E}; % put the data in 1 cell array

sz=[1 1];%pre-allocate the sz array
% cellfun('ndims',data) is faster than cellfun(@ndims,data), but there are only some functions supported
for n=1:max(cellfun('ndims',data)) % loop through all dimensions (taking the largest)
    sz(n)=max(cellfun('size',data,n));% store the maximum size of each dimension
end

%If sz is not a two-element vector at this point, the next loop should be edited.

Z=zeros(sz);
for n=1:numel(data)
    %find the indices to the last n columns
    ind=sz(2) + (1-size(data{n},2)):0;
    Z(:,ind)=Z(:,ind)+data{n};
end
disp(Z)

     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30

% confirming this is the same as your code:
A = repmat(1:10,10,1);
B = repmat(1:8,10,1);
C = repmat(1:6,10,1);
D = repmat(1:4,10,1);
E = repmat(1:2,10,1);

Z=zeros(size(A)) + A;
Z(:, 3:10) = Z(:, 3:10) + B;
Z(:, 5:10) = Z(:, 5:10) + C;
Z(:, 7:10) = Z(:, 7:10) + D;
Z(:, 9:10) = Z(:, 9:10) + E;
disp(Z)

     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30
     1     2     4     6     9    12    16    20    25    30

[maubars]

Your code works quite well, but I have a question. How do you select the index position for the additions? Does your code work for different index? Additionally, your code seems quite complicated, could you please add some explanation?

[Rik]

I will add some comments, but did you try running it line by line to see the effect? Did you read the documentation for each function I used?

You didn't explain your method either, so I assumed you wanted to add several arrays to the last columns of a master-array.

I agree with Image Analyst: don't use this method if you can hard-code the sizes of all matrices and only have a few.

[maubars]

Thank you very much for your explanation. You are right I wish to append or add several small arrays to a large master array and at designated indices. I have adjusted my question. As I understand, the basis your code is to reference the last position and to count backwards to the first position based on the size of the matrix in question. Indeed your code is highly efficient especially in case of a large array or large number of arrays. Just a little clarification about the flexibility of your code in selection of indices (ind). Can your code work for different reference positions or number of rows?

% this case 
B = repmat(1:4,10,1);
Z=A;
Z(:, 3:6) = Z(:, 3:6) + B;

% or this case
C = repmat(1:6,5,1);
Z(:, 5:10) = Z(:, 5:10) + C;

[Rik]

I'm not quite sure what you mean, but you can subtract a value from ind if you want to use a different reference position.

If you want a flexible number of rows, you will have to replace the colon operator with explicit indices. You should be able to adapt my code to create row_ind.

[maubars]

Thanks for the explanation.

[maubars]

One last query. How can I find the indices to the last rows and columns, simultaneously?

[Image Analyst]

For example:

Z = rand(4, 5); % Sample data
[rows, columns] = size(Z)
% Get a list of the indexes of the rightmost column
% in [row, column] format.
lastColumnIndexes = [(1:rows)', columns * ones(rows, 1)]

% Get a list of the indexes of the bottom row.
% in [row, column] format.
lastRowIndexes = [rows * ones(columns, 1), (1:columns)']

You'll see

lastColumnIndexes =

1 5

2 5

3 5

4 5

lastRowIndexes =

4 1

4 2

4 3

4 4

4 5

Note the first column is the row index and the second column is the column index of the elements.

[maubars]

Wooow. Thank you very much, neat.

Answer 2

[Image Analyst]

Not sure the looping method is any better, faster, simpler, or more intuitive. Clearly it isn't because you're asking how it works. Your original code was fine (for a low number of arrays like 5, though it could be simplified by getting rid of zeros().

Z = A % No zeros needed
Z(:, 3:10) = Z(:, 3:10) + B;
Z(:, 5:10) = Z(:, 5:10) + C;
Z(:, 7:10) = Z(:, 7:10) + D;
Z(:, 9:10) = Z(:, 9:10) + E

If you have only a small number of matrices, like 5 or so, then sometimes it's better to keep in simple and intuitive rather than try to do it in loops. Even if loops make the code shorter by 2 or 3 lines, the decrease in readability might make it not worth doing and better to keep it simple and readable. So, for this case, I disagree with you when you say "it is not intuitive". Now, if you had dozens of matrices, then you would want to do a looping way like Rik showed you, or better yet, just start with a properly indexed array to start with so you don't need to build it from separate variables.

[maubars]

Thanks for the explanation. Indeed, direct coding without the cell function or loops seems more intuitive, however, I am adding or appending multiple matrices(various sizes) to big matrix. So it's quite cumbersome.