Matlab: Efficient storage of n 2x2 matrices - matlab

Question

I have a recursive procedure that generates a 2x2 matrix each time the loop iterates. I want to be able to call upon each of these matrices at a later point but I'm not sure how to store them all together efficiently.
If the procedure iterates n times, should I store them in a 2nx2 matrix? But then how would I call upon say the jth matrix (rows 2j-1 and 2j) within this long matrix?
Thanks!

Answer 1

You can use cell arrays:
matrices = cell(n,1);
for ii = 1:n
% generate your matrix
matrix_ii = rand(2);
% store it for later
matrices{ii} = matrix_ii;
% [do your stuff]
end
Recalling the jth matrix is then as simple as
matrix_j = matrices{j}
(note the curly braces).
You could also store it in a large 2D array (as you suggested),
matrices = zeros(2*n,2);
for ii = 1:n
% generate your 2x2 matrix
matrix_ii = rand(2);
% store it for later
matrices(2*(ii-1)+[0 1]+1,:) = matrix_ii;
% [do your stuff]
end
recalling values later like so:
matrix_j = matrices(2*(j-1)+[0 1]+1,:)
or in a 3D array like so,
matrices = zeros(2,2,n);
for ii = 1:n
% generate your 2x2 matrix
matrix_ii = rand(2);
% store it for later
matrices(:,:,ii) = matrix_ii;
% [do your stuff]
end
recalling values later like so:
matrix_j = matrices(:,:,j);
Comparing the methods for n = 1e5:
Elapsed time is 0.282959 seconds. % cell arrays
Elapsed time is 0.856801 seconds. % 2*n x 2 matrix
Elapsed time is 0.293186 seconds. % 2x2xn array
Memory: 9200000 bytes % Cell arrays
Memory: 3200000 bytes % 2*n x 2 matrix
Memory: 3200000 bytes % 2x2xn array
You might want to test these things on your own computer, but it appears the large 3D array is the best way to go here.

Answer 2

Rody Oldenhuis gave three great alternatives to store the matrices in his answer (which I already upvoted). I just wanted to improve upon the slowest of the three.
MATLAB matrices are indexed faster by columns rather than by rows, so I'm building a big wide matrix (2-by-2*n) rather than a tall matrix (2*n-by-2). Also building the index in the iterations can be simplified.
Here is the result of that, with a slightly more convenient benchmark (you will need the TIMEIT function from the File Exchange)
function [t,b] = test_2d_matrices_container()
N = 1e5;
f = {#()func_cell(N), #()func_wide_2d_mat(N), #()func_3d_mat(N)};
t = cellfun(#timeit, f);
b = cellfun(#get_mem, f);
end
function b = get_mem(f)
x = feval(f); %#ok<NASGU>
S = whos('x');
b = S.bytes;
end
function M = func_cell(N)
M = cell(N,1);
for i=1:N
M{i} = rand(2);
end
end
function M = func_wide_2d_mat(N)
M = zeros(2,2*N);
for i=1:2:2*N
M(:,[i i+1]) = rand(2);
end
end
function M = func_3d_mat(N)
M = zeros(2,2,N);
for i=1:N
M(:,:,i) = rand(2);
end
end
The results I get on my machine:
>> [t,b] = test_2d_matrices_container
t =
0.13963 0.22997 0.23434
b =
9200000 3200000 3200000
Now the "wide" 2D matrix case is as fast as the 3D "slices" method (even lightly faster, but the difference is really negligible)