Question

My question refers to a question I’ve asked previously for a single-dimensional array:

for loop elimination

Can someone please help me extend the use of the indices trick to multiple dimensional arrays, such as in this example:

template<unsigned...> struct indices
{
};

template<unsigned M, unsigned... Is> struct indices_gen
  : indices_gen<M - 1, M - 1, Is...>
{
};

template<unsigned... Is> struct indices_gen<0, Is...> : indices<Is...>
{
};

template <typename T>
struct example
{
  template<typename ...U, typename
    = typename std::enable_if<all_of<std::is_same<U, T>...>::value>::type>
  example(U... args)
  {
    static_assert(3 * 2 == sizeof...(U),
      "wrong number of arguments in assignment");
    assign(indices_gen<M * N>(), args...);
  }

  template<size_type... Is, class... U>
  void assign(indices<Is...>, U... args)
  {
    [](...){}(((&array[0][0])[Is] = args)...);
  }

  T array[3][2];
};

int main()
{
  example<int> ex(1, 2, 3, 4, 5, 6);
  return 0;
}

Currently I depend on the requirement, that arrays are contiguous, but I’d like to assign array using pairs of indices, not just a single index (this way I’d be able to support types other than arrays, in particular, types that override operator[]). If I use 2 argument packs for assignment, I’ll assign only at indices (0, 0), (1, 1), …, also there is a small problem with argument packs not having the same lengths when dimensions of the array differ (as in the example).

Answer 1

This can be made a lot easier by changing the code to access the array, not the indices generation. What you basically want is a 1D to 2D access mapping.

Normally, people need it the other way around (2D to 1D), when they implement a 2D array in terms of a 1D array^†:

template<class T, unsigned M, unsigned N>
struct md_array{
  T elems[M * N]; // same layout as 'T elems[M][N];'
};

The formula to get the 1D index i from the 2D index (x,y) is then i == x * N + y. We can explain this if we imagine our 1D elems from above as a 2D array (using M == 2 and N == 3):

 0, 1, 2, 3, 4, 5 // indices (i)
[a, b, c, d, e, f]
v // we want them as M (2) packs of N (3) elements
 0, 1, 2   0, 1, 2 // element indices (y)
[a, b, c] [d, e, f]
\___0___/ \___1___/ // pack indices (x)
v // fusing the packs back together, we can see that we have
  // a constant offset for the packs, which is the N (3) times x
0*3+0, 0*3+1, 0*3+2, 1*3+0, 1*3+1, 1*3+2
[ a,     b,     c,     d,     e,     f ]

Thus, we get i == x * N + y. We now need to solve this formula not for i but for x and y. For x, it’s rather easy (using math notation):

i = x * N + y | -y
i - y = x * N | *(1/N)
i - y
----- = x
  N

So x == (i - y) / N. Now, sadly, I don’t know how to solve this for y using pure math, but we don’t need that. Taking a look at the element indices, we can see that they wrap around N, and that can easily be done using the modulo operator. Thus, y == i % N.

Now we can implement a method that takes a linear index i and returns the element at the solved (x, y) from that:

template<unsigned I>
T& get(){ constexpr auto y = I % 3; return array[(I-y)/3][y]; }

and generalizing that:

template<unsigned I>
T& get(){ constexpr auto y = I % N, x = (I-y)/N; return array[x][y]; }

Using constexpr to ensure that all the computation is done at compile-time.
Now you can simply write assign as follows:

template<unsigned... Is, class... U>
void assign(indices<Is...>, U... args)
{
  [](...){}((get<Is>() = args)...);
}

Q.E.D. (Live example.)

---

† Now, you can make this easier on yourself by actually implementing the 2D array as a 1D array. 🙂 This way, you can straight-forwardly use (array[Is] = args)... and for the other cases use a simple access function that does the mapping:

T& get(unsigned x, unsigned y){ return array[x * N + y]; }

Live example.