Inserting One Row Each Time in a Sequence from Matrix into Another Matrix After Every nth Row in Matlab

Question

I have matrix A and matrix B. Matrix A is 100*3. Matrix B is 10*3. I need to insert one row from matrix B each time in a sequence into matrix A after every 10th row. The result would be Matrix A with 110*3. How can I do this in Matlab?

Setsu · Answer 1 · 2015-06-15T23:51:36.693

4

Here's an index-based approach:

%//pre-allocate output matrix
matrixC = zeros(110, 3);

%//create index array for the locations in matrixC that would be populated by matrixB
idxArr = (1:10) * 11;

%//place matrixB into matrixC
matrixC(idxArr,:) = matrixB;

%//place matrixA into matrixC
%//setdiff is used to exclude indexes already populated by values from matrixB
matrixC(setdiff(1:110, idxArr),:) = matrixA;

And just for fun here's the same approach sans magic numbers:

%//define how many rows to take from matrixA at once
numRows = 10;

%//get dimensions of input matrices
lengthA = size(matrixA, 1);
lengthB = size(matrixB, 1);

matrixC = zeros(lengthA + lengthB, 3);
idxArr = (1:lengthB) * (numRows + 1);
matrixC(idxArr,:) = matrixB;
matrixC(setdiff(1:size(matrixC, 1), idxArr),:) = matrixA;

edited Jun 15 '15 at 23:51

answered Jun 15 '15 at 23:21

Setsu

1,188
13
26

Heh. I was literally about to push submit when you posted your answer. This is exactly what I did.... now to think of something else. – rayryeng Jun 15 '15 at 23:24
@rayryeng In Chinese there is a saying "拋磚引玉", which literally translates to throwing a brick to get a jade back. It means to give something humble to inspire greatness out of someone else. – Setsu Jun 15 '15 at 23:31
LOL. How appropriate. Thank you :) I'm working on something else. +1 btw. – rayryeng Jun 15 '15 at 23:34

score 4 · Answer 2 · answered Jun 15 '15 at 23:38

4

For canonical purposes, here's how you'd do it via loops. This is a bit inefficient since you're mutating the array at each iteration, but it's really simple to read. Given that your two matrices are stored in A (100 x 3) and B (10 x 3), you would do:

out = [];
for idx = 1 : 10
    out = [out; A((idx-1)*10 + 1 : 10*idx,:); B(idx,:)];
end

At each iteration, we pick out 10 rows of A and 1 row of B and we concatenate these 11 rows onto out. This happens 10 times, resulting in 330 rows with 3 columns.

answered Jun 15 '15 at 23:38

rayryeng

102,964
22
184
193

Nothing wrong with good 'ol `for` loop. In fact, this is what I'd probably do if the concatenation is expected to be minimal. – Setsu Jun 15 '15 at 23:54
1

This approach could use some pre-allocation :-P – Luis Mendo Jun 16 '15 at 00:10
Took the liberty of making it generic and have put it in the benchmarking that I just added. Hope that reflects the idea discussed here :) – Divakar Jun 18 '15 at 06:51

beaker · Answer 3 · 2015-06-18T18:30:13.077

4

Just for fun... Now with more robust test matrices!

A = ones(3, 100);
A(:) = 1:300;
A = A.'

B = ones(3, 10);
B(:) = 1:30;
B = B.' + 1000

C = reshape(A.', 3, 10, []);
C(:,end+1,:) = permute(B, [2 3 1]);
D = permute(C, [2 3 1]);
E = reshape(D, 110, 3)

Input:

A =

     1     2     3
     4     5     6
     7     8     9
    10    11    12
    13    14    15
    16    17    18
    19    20    21
    22    23    24
    25    26    27
    28    29    30
    31    32    33
    34    35    36
    ...

B =

   1001   1002   1003
   1004   1005   1006
   ...

Output:

E =

      1      2      3
      4      5      6
      7      8      9
     10     11     12
     13     14     15
     16     17     18
     19     20     21
     22     23     24
     25     26     27
     28     29     30
   1001   1002   1003
     31     32     33
     34     35     36
   ...

Thanks to @Divakar for pointing out my previous error.

edited Jun 18 '15 at 18:30

answered Jun 15 '15 at 23:50

beaker

16,331
3
32
49

Interesting approach adding a 3rd dimension! BTW is the dot in `A.'` a typo? – Setsu Jun 16 '15 at 00:04
This would have been my preferred approach. Now I had to think of something else! – Luis Mendo Jun 16 '15 at 00:08
1

@Setsu Not at all! See for example [here](http://stackoverflow.com/q/25150027/2586922) – Luis Mendo Jun 16 '15 at 00:09
@LuisMendo Never even thought of complex numbers, interesting! – Setsu Jun 16 '15 at 00:11
@LuisMendo Yes, I was channeling your methods! ;) – beaker Jun 16 '15 at 03:16
1

Think the last line needed some changes. Edited those in the benchmarking that I just added. Hope that is a correct edit there. Basically the last line needed something like this I think - `reshape(permute(D,[1 3 2]),110,3)`. – Divakar Jun 18 '15 at 06:50
@Divakar You're right! I've updated the permutation for `D`, so it should be correct now. – beaker Jun 18 '15 at 15:18

score 4 · Accepted Answer · answered Jun 16 '15 at 00:06

4

Here's another indexing-based approach:

n = 10;
C = [A; B];
[~, ind] = sort([1:size(A,1) n*(1:size(B,1))+.5]);
C = C(ind,:);

answered Jun 16 '15 at 00:06

Luis Mendo

110,752
13
76
147

score 2 · Answer 5 · answered Jun 18 '15 at 06:49

Solution Code

Here's an implementation based on logical indexing also known as masking and must be pretty efficient when working with large arrays -

%// Get sizes of A and B
[M,d] = size(A);
N = size(B,1);

%// Mask of row indices where rows from A would be placed
mask_idx = reshape([true(A_cutrow,M/A_cutrow) ; false(1,N)],[],1);

%// Pre-allocate with zeros: 
%// http://undocumentedmatlab.com/blog/preallocation-performance
out(M+N,d) = 0; 

%// Insert A and B using mask and ~mask
out(mask_idx,:) = A;
out(~mask_idx,:) = B;

Benchmarking

%// Setup inputs
A = rand(100000,3);
B = rand(10000,3);
A_cutrow = 10;

num_iter = 200; %// Number of iterations to be run for each approach

%// Warm up tic/toc.
for k = 1:50000
    tic(); elapsed = toc();
end

disp(' ------------------------------- With MASKING')
tic
for iter = 1:num_iter
    [M,d] = size(A);
    N = size(B,1);
    mask_idx = reshape([true(A_cutrow,M/A_cutrow) ; false(1,N)],[],1);

    out(M+N,d) = 0;
    out(mask_idx,:) = A;
    out(~mask_idx,:) = B;
    clear out
end
toc, clear mask_idx N M d iter

disp(' ------------------------------- With SORT')
tic
for iter = 1:num_iter
    C = [A; B];
    [~, ind] = sort([1:size(A,1) A_cutrow*(1:size(B,1))+.5]);
    C = C(ind,:);
end
toc, clear C ind iter

disp(' ------------------------------- With RESHAPE+PERMUTE')
tic
for iter = 1:num_iter
    [M,d] = size(A);
    N = size(B,1);
    C = reshape(A.', d, A_cutrow , []);
    C(:,end+1,:) = permute(B, [2 3 1]);
    D = permute(C, [2 1 3]);
    out = reshape(permute(D,[1 3 2]),M+N,[]);
end
toc, clear out D C N M d iter

disp(' ------------------------------- With SETDIFF')
tic
for iter = 1:num_iter
    lengthA = size(A, 1);
    lengthB = size(B, 1);

    matrixC = zeros(lengthA + lengthB, 3);
    idxArr = (1:lengthB) * (A_cutrow + 1);
    matrixC(idxArr,:) = B;
    matrixC(setdiff(1:size(matrixC, 1), idxArr),:) = A;
end
toc, clear matrixC idxArr lengthA lengthB

disp(' ------------------------------- With FOR-LOOP')
tic
for iter = 1:num_iter
    [M,d] = size(A);
    N = size(B,1);
    Mc = M/A_cutrow;
    out(M+N,d) = 0;
    for idx = 1 : Mc
        out( 1+(idx-1)*(A_cutrow +1): idx*(A_cutrow+1), :) = ...
        [A( 1+(idx-1)*A_cutrow : idx*A_cutrow , : ) ; B(idx,:)];
    end
    clear out
end
toc

Runtimes

Case #1: A as 100 x 3 and B as 10 x 3

 ------------------------------- With MASKING
Elapsed time is 4.987088 seconds.
 ------------------------------- With SORT
Elapsed time is 5.056301 seconds.
 ------------------------------- With RESHAPE+PERMUTE
Elapsed time is 5.170416 seconds.
 ------------------------------- With SETDIFF
Elapsed time is 35.063020 seconds.
 ------------------------------- With FOR-LOOP
Elapsed time is 12.118992 seconds.

Case #2: A as 100000 x 3 and B as 10000 x 3

 ------------------------------- With MASKING
Elapsed time is 1.167707 seconds.
 ------------------------------- With SORT
Elapsed time is 2.667149 seconds.
 ------------------------------- With RESHAPE+PERMUTE
Elapsed time is 2.603110 seconds.
 ------------------------------- With SETDIFF
Elapsed time is 3.153900 seconds.
 ------------------------------- With FOR-LOOP
Elapsed time is 19.822912 seconds.

Please note that num_iter was different for these two cases, as the idea was to keep the runtimes > 1 sec mark to compensate for tic-toc overheads.

@LuisMendo Figured that's my job! ;) – Divakar Jun 18 '15 at 09:49 — Divakar, Jun 18 '15 at 09:49

Inserting One Row Each Time in a Sequence from Matrix into Another Matrix After Every nth Row in Matlab

5 Answers5

Solution Code

Benchmarking

Runtimes