typedef T value_type;

typedef T* pointer;

typedef std::size_t size_type;

typedef std::ptrdiff_t difference_type;

template<class U>

struct rebind {

typedef creator<U> other;

};

creator(int state)

: state_(state) { }

template<class U>

creator(const creator<U>& other)

: state_(other.state()) { }

T* allocate(std::size_t size) {

return static_cast<T*>(::operator new(sizeof(T) * size));

}

void deallocate(T* ptr, std::size_t) {

::operator delete(ptr);

}

int state() const {

return state_;

}

int state_;

unsigned elements)

{

BOOST_TEST(array.num_elements() == elements);

BOOST_TEST(array.size() == *sizes);

BOOST_TEST(std::equal(sizes, sizes + array.num_dimensions(), array.shape()));

BOOST_TEST(std::equal(strides, strides + array.num_dimensions(),

array.strides()));

test(array[0], ++sizes, ++strides, elements / array.size());

{

typename A1::const_iterator i1 = a1.begin();

typename A2::const_iterator i2 = a2.begin();

for (; i1 != a1.end(); ++i1, ++i2) {

if (!test(*i1, *i2)) {

return false;

}

}

return true;

{

typedef boost::multi_array<double, 3, creator<double> > type;

creator<double> state(1);

{

type array(state);

}

boost::array<type::size_type, 3> sizes = { { 3, 3, 3 } };

type::size_type elements = 27;

{

int strides[] = { 9, 3, 1 };

type array(sizes, state);

test(array, &sizes[0], strides, elements);

}

{

int strides[] = { 1, 3, 9 };

type array(sizes, boost::fortran_storage_order(), state);

test(array, &sizes[0], strides, elements);

}

{

int strides[] = { 9, 3, 1 };

type::extent_gen extents;

type array(extents[3][3][3], state);

test(array, &sizes[0], strides, elements);

}

{

type array1(sizes, state);

std::vector<double> values(elements, 4.5);

array1.assign(values.begin(), values.end());

type array2(array1);

int strides[] = { 9, 3, 1 };

test(array2, &sizes[0], strides, elements);

BOOST_TEST(test(array1, array2));

}

{

type array1(sizes, state);

type array2(sizes, state);

std::vector<double> values(elements, 4.5);

array1.assign(values.begin(), values.end());

array2 = array1;

int strides[] = { 9, 3, 1 };

test(array2, &sizes[0], strides, elements);

BOOST_TEST(test(array1, array2));

}

{

type array1(sizes, state);

std::vector<double> values(elements, 4.5);

array1.assign(values.begin(), values.end());

typedef type::subarray<2>::type other;

other array2 = array1[1];

other::value_type value = array2[0];

BOOST_TEST(test(array1[1][0], value));

BOOST_TEST(test(array2[0], value));

}

return boost::report_errors();