5-dimensional vector declaration - c++

Question

I am looking for an elegant way to declare a 5-dimensional array in C++.
Each nested vectors have known sizes so I started doing :
std::vector<std::vector<std::vector<std::vector<double>>>> myDblVec;
Then assuming I know all dimension sizes :
myDblVec.resize(dim1);
for (int d1 = 0; d1 != dim1; d1++) {
myDblVec[d1].resize[dim2];
for (int d2 = 0; d2 != dim2; d2++) {
myDblVec[d1][d2].resize(dim3)
for (int d3 = 0; d3 != dim3; d3++) {
myDblVec[d1][d2][d3].resize(dim4);
}
}
}
I am looking for a 1-liner or something less 'heavy' to declare this array.

Answer 1

If you get the dimensions run-time, like
myDblVec = std::vector<std::vector<std::vector<std::vector<double>>>>(dim1,
std::vector<std::vector<std::vector<double>>>(dim2,
std::vector<std::vector<double>>(dim3,
std::vector<double>>(dim4, 0.0))));

Answer 2

You could use std::array, assuming the sizes are known at compile time:
std::array<std::array<std::array<std::array<double, dim4>, dim3>, dim2>, dim1> myDblArray;

Answer 3

If you aren't too attached to pre-C++11, you could write a simple variadic template :
template <typename T, size_t... N> struct NestedArray;
template <typename T, size_t N> struct NestedArray<T, N> {
using type = array<T, N>;
};
template <typename T, size_t N, size_t... Rest>
struct NestedArray<T, N, Rest...> {
using type = array<typename NestedArray<T, Rest...>::type, N>;
};
Now, you can define your array as NestedArray<double, dim1, dim2, dim3, dim4>::type.

Answer 4

std::vector<T> takes the size as first constructor argument. You could take advantage of that and use somethign along the lines of
make_vector_t<double, 5> myDblVec(init_vector<double, 5>(dim1, dim2, dim3, dim4, dim5));
That'll rquire a bit of infrastructure to create the types and initialize the elements. Of course, this infrastructure is reasonable straight forward (although I haven't compiled it - currently I'm just using a mobile device, i.e., there is almost certainly a typo somewheter but the overall approach should owrk):
template <typename T, int Dim> struct make_vector;
template <typename T, int Dim>
using make_vector_t = typename make_vector<T, Dim>::type;
template <typename T>
struct make_vector<T, 0> { using type = T; }
template <typename T, int Dim>
struct make_vector { using type = std::vector<make_vector_t<T, Dim-1>>; }
template <typename T, int Dim, typename Arg, typename... Args>
auto init_vector(Arg size, Args... sizes) -> make_vector_t<T, Dim-1> {
return make_vector_t<T, Dim>(size, init_vector<T, Dim-1>(sizes...);
}

Answer 5

If you are in heavy need for multidimensional arrays, consider moving the stuff that has to deal with them into a separate source file that uses C instead of C++. You can interface quite easily between the languages, and allocating a 5D array of dynamical size in C is as simple as
double (*fiveDArray)[dim2][dim3][dim4][dim5] = malloc(dim1 * sizeof(*fiveDArray));
Usage is virtually the same as with your nested std::vector<>s, all you need to remember is the call to free() when you are done with your array. If you need a zero initialized array, replace malloc() by calloc(). As an added bonus, the contiguous nature of a C multidimensional array is nicer on the CPU caches than use of std::vector<>, and indexing is quicker since there is only one pointer to chase.
C++ does not allow this, because this language restricts array dimensions to be compile time constants. C, on the other hand, has lifted this restriction in the C99 standard, and even allows dynamic array sizes in a typedef:
void foo(size_t dim1, size_t dim2, size_t dim3, size_t dim4, size_t dim5) {
typedef double FourDSlice[dim2][dim3][dim4][dim5];
FourDSlice *fiveDArray = malloc(dim1 * sizeof(*fiveDArray));
...
}
is perfectly legal C99, and impossible to do in C++.

Answer 6

well... vector<vector> is it really a good thing? are you thinking to a matrix whose rows can have independent length? If the answer is "no", then consider the idea that all you need is a plain vector, whose size is the product of the 5 dimensions, and whose elements are located at
size_t at(size_t a, size_t b, size_t c, size_t d, size_t e, size_t A, size_t B, size_t C, size_t D, size_t E)
{ return e+d*E+c*D*E+b*C*D*E+a*B*C*D*E; }
(note: capital letters are the sizes).
You can easily generalize this to whatever number of dimensions by using varadics:
template<class... I>
size_t at(size_t r, size_t R, size_t c, size_t C, I... i)
{ return size_at(r*C+c,i...); }
size_t at(size_t c, size_t C)
{ return c; }
And you can also embed all this into a recurring class
template<class T, size_t Rank>
class grid
{
grid<T,Rank-1> m; size_t C;
public:
template<class... I>
grid(size_t r, size_t c, I... i) :m(r*c,i...) :C(c) {}
template<class... I>
T& operator()(size_t r, size_t c, I... i)
{ return m(r*C+c,i...); }
template<class... I>
const T& operator()(size_t r, size_t c, I... i) const
{ return m(r*C+c,i...); }
};
template<class T>
class grid<T,1>
{
std::vector<T> m;
public:
explicit grid(size_t n) :m(n) {}
T& operator()(size_t i) { return m[i]; }
const T& operator()(size_t i) const { return m[i]; }
};
You can just declare a grid<5> a(3,2,4,5,3);
and access its elements as a(x,y,z,w,t); whatever x in 0..2, y in 0..1, z in 0..3 w in 0..4 and t in 0..2;