{

T* m_data;

size_t dim[Rank];

size_t m_stride=1;

friend void advance<T,Rank>(MultiArray<T,Rank>&,std::ptrdiff_t);

#if defined(__cplusplus) && __cplusplus>=201703L

void constructDim(size_t& d, size_t dd)

{

dim[d++]=dd;

m_stride*=dd;

}

template <class... Args>

void constructDims(size_t d, Args... args)

{

m_stride=1;

(constructDim(d,args),...);

// fold expression multiplies m_stride by one too many dimensions

if (d>0) m_stride/=dim[d-1];

}

#else

void constructDims(size_t d, size_t d1)

{

assert(d==Rank-1);

dim[d]=d1;

}

template <class... Args>

void constructDims(size_t d, size_t d1, Args... args)

{

dim[d]=d1;

m_stride*=d1;

constructDims(d+1, args...);

}

#endif

public:

typedef MultiArray<T,Rank-1> value_type;

typedef size_t size_type;

static const int rank=Rank;

/// Create a MultiArray given data and dimensions passed as arguments

///

template <class... Args>

MultiArray(T* data, Args... args): m_data(data)

{

constructDims(0, args...);

}

/// Create a MultiArray given data and vector of dimensions:

/// @param must be of length \prod_i a_dim[i]

/// @param a_dim must be of length Rank

MultiArray(T* data, const size_t a_dim[]): m_data(data)

{

memcpy(dim, a_dim, sizeof(dim));

}

size_t size() const {return dim[Rank-1];}

size_t stride() const {return m_stride;}

const MultiArray<T,Rank-1> operator[](size_t i) const {

return MultiArray<T,Rank-1>(m_data+i*m_stride, dim);

}

MultiArray<T,Rank-1> operator[](size_t i) {

return MultiArray<T,Rank-1>(m_data+i*m_stride, dim);

}

/// return if this refers to the same memory location as x

bool same(const MultiArray& x) const {return m_data==x.m_data;}

struct iterator: public MultiArrayIterator

{

using difference_type=std::ptrdiff_t;

using value_type=MultiArray<T,Rank-1>;

using pointer=MultiArray<T,Rank-1>*;

using reference=MultiArray<T,Rank-1>&;

using iterator_category=std::random_access_iterator_tag;

using underlying_type=T;

static const int rank=Rank;

MultiArray<T,Rank-1> array;

size_t stride;

iterator(const MultiArray& array): array(array.m_data,array.dim),

stride(array.stride()) {}

iterator operator++() {advance(array,stride); return *this;}

iterator operator++(int)

{auto tmp=*this; advance(array,stride); return tmp;}

iterator operator--() {advance(array,-stride); return *this;}

iterator operator--(int)

{auto tmp=*this; advance(array,-stride); return tmp;}

iterator operator+=(size_t i) {advance(array,i*stride); return *this;}

MultiArray<T,Rank-1>& operator*() {return array;}

bool operator==(const iterator& x) const {return array.same(x.array);}

bool operator!=(const iterator& x) const {return !operator==(x);}

};

struct const_iterator: public iterator

{

const_iterator(const MultiArray& array): iterator(array) {}

const MultiArray<T,Rank-1>& operator*() {return iterator::operator*();}

};

iterator begin() {return MultiArray(*this);}

iterator end() {auto tmp=begin(); tmp+=dim[Rank-1]; return tmp;}

const_iterator begin() const {return MultiArray(*this);}

const_iterator end() const {auto tmp=begin(); tmp+=dim[Rank-1]; return tmp;}