That looks well documented and formatted!

Thanks
Doug

function B = interleavedTranspose(A)
%INTERLEAVEDTRANSPOSE Interleaves alternate rows of input matrix and
%transposes to produce output matrix
%   % we wish to rearrange the input matrix as follows:
% 1) interleave every other row with the row above it
% 2) transpose the result
% So for example if we start with the matrix
% [11 12 13 ;
%  21 22 23;
%  31 32 33;
%  41 42 43]
% would first interleave every other row with the row above it to get
%
% [11 21 12 22 13 23;
%  31 41 32 42 33 43]
%
% and then transpose to get:
%
% [11 31;
%  21 41;
%  12 32;
%  22 42;
%  13 33;
%  23 43]
%
% We will do this by first separating alternate rows (odd and even row
% numbers into two matrices
% oddRows = [11 12 13 ;
%            31 32 33]
% evenRows = [21 22 23;
%             41 42 43]
% then make a new matrix to hold the result
% B = [ 0 0 0 0 0 0 ;
%       0 0 0 0 0 0 ]
%
% place the odd rows into new matrix leaving spaces to interleave even rows
% B = [ 11 0 12 0 13 0;
%       31 0 32 0 33 0]
% interleave the even rows
% B = [ 11 21 12 22 13 23 ;
%       31 41 32 42 33 43]
% transpose
% B = B'

% input matrix must have even number of rows

% get dimensions of input matrix for later use
[numRows,numCols] = size(A);

% first check that input matrix has even number of rows
if rem(numRows,2)~= 0
    error('input matrix must have even number of rows')
end

% separate alternate rows and put into two matrices
oddRows = A(1:2:numRows,:);
evenRows = A(2:2:numRows,:);

% make new matrix to hold interleaved rows
B = zeros(numRows/2,numCols*2)

% place odd rows into new matrix leaving spaces to interleave even rows
B(:,1:2:end) = oddRows;
%  interleave even rows
B(:,2:2:end) = evenRows;

% transpose to get final result
B = B'

end

Thank you for your comments. You make good points, there are trade-offs. I tend to work on smaller datasets, and am mostly concerned about readability. It sounds like you have other metrics to satisfy, so you use other techniques.

Thanks,
Doug

I’d think that all the original code needs is a replacement of “shiftdim” with “permute”. That gets you rid of the “shiftdata” function, since shiftdim can only circulate dimensions; permute is more general:

b1=magic(6)
b2=reshape(b1,2,3,6)
b3=permute(b2,[1 3 2])
b4=reshape(b3,12,3)

I like the idea of expansion into higher dimensions, I use it a lot. Loops are fine, but can be tedious for high-dimensional problems. If one prints out b2 (; left out), it becomes quite clear that the result is there already — all that needs to be done is reshuffling of dimensions for the next reshape. Also such code (hopefully) operates on indexes, rather than data and checks the dimensions for you, to some extend.

I would normally do this on one line to save memory. There are pros and cons, of course. When the array becomes too large, one might think of segmenting it and saving intermediate results within a loop.

Thanks,
Ludvik

Great idea for checking how code manipulates data, in stages

http://www.mathworks.com/support can answer all your questions.

Thanks,
Doug

Thanks a lot in advance.

I suspect the reason why MLint doesn’t warn about parenthesis is that they invoke no function call. Parenthesis are only used to group in this context. Brackets on the other hand, are used to concatenate. If there is only one array inside the brackets, there is nothing to concatenate, yet the internal concatenate function is called anyway! This is an inefficiency.