Inicializador de una línea para Boost.multiarray

Question

Tengo un impulso n-dimensional.

const int n=3, size=4; //# of dimensions and size of one dimension
boost::multi_array<char,n> arr;
boost::array<size_t,n> extents; //size of each dimension
extents.assign(size); //assign size to each dimension -> {{4, 4, 4}}
arr.resize(extents);

Así que tengo 4 líneas de código para obtener la multiarray, pero me gustaría hacerlo en una línea. ¿Hay alguna forma sencilla de generar una multiarray con n dimensiones cada una size longitud (para que pueda escribir arr(samevaluearray(n,size))) ¿O me perdí un constructor práctico para Multiarray?

Editar: Debería funcionar sin depender de un cierto valor de n, es decir arr({{size,size}} solo funcionaría para n=2.

Dado que puede no estar claro: boost::multi_array<char,n>(boost::extents[4][4][4]) Inicializa correctamente una matriz 4x4x4, pero cada vez n se cambia en el código de código, cada inicialización debe actualizarse a mano, por lo que no es una opción.

Answer 1

Resulta que std::vector tiene un constructor, que construye un vector con un valor constante repetido n veces, por lo que una posible solución se ve así:

const int n=2, size=4; //# of dimensions and size of one dimension
boost::multi_array<char,n> arr(std::vector<size_t>(n,size));

Esto inicializa un multi_array n-dimensional con el tamaño de cada dimensión establecido en tamaño.

Answer 2

Puede encapsular la creación de la matriz en una función de ayudante:

template <typename T, size_t N>
boost::multi_array<T, N> make_regular_matrix(const size_t m)
{
    boost::multi_array<T, N> arr;
    boost::array<size_t, N> extents;
    extents.assign(m);
    arr.resize(extents);

    return arr;
}

const int n = 3;
int size = 4; // Can be const as well, but this is not mandatory

auto arr = make_regular_matrix<char, n>(size);

Si no puedes usar auto, tendrás que duplicar los parámetros de la plantilla:

boost::multi_array<char, n> arr = make_regular_matrix<char, n>(size);

los make_regular_matrix la función podría acortarse para usar std::vector, como lo hiciste en tu respuesta; No sé si esta implementación sería mejor. El objetivo de la función ayudante es ocultar la creación de la matriz, pero otras versiones podrían escribirse, por ejemplo, para inicializar los elementos de la matriz con un valor dado:

template <size_t N, typename T> //switched order for deduction
boost::multi_array<T, N> make_regular_matrix(const size_t m, const T & value)
{
     boost::multi_array<T, N> arr(std::vector<size_t>(n, m));

     std::fill(arr.data(), arr.data() + arr.num_elements(), value);

     return arr;
}

auto arr = make_regular_matrix<4>(3, 'z'); //creates a 3x3x3x3 matrix
                                           //filled with 'z's

Answer 3

Desde el Impulsar la documentación de la matriz múltiple, sí, puede inicializarlo una línea:

typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type A(boost::extents[3][4][2]);

Los typedefs son para legibilidad, uno puede hacer con la misma facilidad para su ejemplo:

boost::multi_array<int, 2> arr(boost::extents[2][4]);