Boost.MultiArray Beginner: How to get a 4D-Array with dynamic inner-array-sizes?

Question

i want to store some kind of distance-matrix (2D), where each entry has some alternatives (different coordinates). So i want to access the distance for example x=1 with x_alt=3 and y=3 with y_alt=1, looking in a 4-dim multi-array with array[1][3][3][1].

The important thing to notice is the following: the 2 most inner arrays/vectors don't have the same size for different values of the outer ones.

After a first init step, where i calculate the values, no more modifying is needed!

This should be easily possible with the use of stl-vectors:

vector<vector<vector<vector<double> > > >`extended_distance_matrix;

where i can dynamically iterate over the outer 2 dimensions and fill only as much alternatives to the inner 2 dimensions as i need (e.g. with push_back()).

Questions:

• Is this kind of data-structure definition possible with Boost.MultiArray? How?
• Is it a good idea to use Boost.MultiArray instead of the nested vectors? Performance (especially lookups! (Memory-layout))? Easy of use?

Thanks for any input!

sascha

PS: The boost documentation didn't help me. Maybe one can use multi_array_ref to get already sized arrays into the whole 4D-structure?

Edit: At the moment i'm thinking of another approach: flattening the alternatives -> one bigger matrix with all the distances between the alternatives. Then i only need to calc the number of alternatives per node, build up the prefix sum (which is describing the matrix position/shift) and can then access the information in a 2-step-way.

But my questions are still open.

Answer 1

Boost.MultiArray deals with contiguous memory (arranged logically in many dimensions) so it is difficult to add elements in the inner dimensions. MultiArrays can be dynamically resized, e.g. to add elements in any dimension, but this is a costly operation that almost certainly need (internally) reallocation and copying.

Because of that requirement MultiArray is not the best option. But from what you say it looks like a combination of the two would be appropriate to you.

boost::multi_array<std::vector<std::vector<type>>, 2> data

The very nice thing is that the indexing interface doesn't change with respect to boost::multi_array<type, 4>. For example data[1][2][3][4] still makes sense.

I don't know from your post how you handle the inner dimension but it could even make sense to use this:

boost::multi_array<boost::multi_array<type>, 2>, 2> data

In any case, unless you really need to do linear algebra I would stay away from boost::ublas::array, or at most use it for the internal array if type is numeric. boost::multi_array<boost::ublas::array<type>, 2> data which is mentioned in the other answer.

Answer 2

it sounds like you need:

multi_array<ublas::matrix<type>,2>