623 lines
20 KiB
Plaintext
623 lines
20 KiB
Plaintext
// Copyright 2002 The Trustees of Indiana University.
|
|
|
|
// Use, modification and distribution is subject to the Boost Software
|
|
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
// Boost.MultiArray Library
|
|
// Authors: Ronald Garcia
|
|
// Jeremy Siek
|
|
// Andrew Lumsdaine
|
|
// See http://www.boost.org/libs/multi_array for documentation.
|
|
|
|
#ifndef BOOST_MULTI_ARRAY_REF_RG071801_HPP
|
|
#define BOOST_MULTI_ARRAY_REF_RG071801_HPP
|
|
|
|
//
|
|
// multi_array_ref.hpp - code for creating "views" of array data.
|
|
//
|
|
|
|
#include "boost/multi_array/base.hpp"
|
|
#include "boost/multi_array/collection_concept.hpp"
|
|
#include "boost/multi_array/concept_checks.hpp"
|
|
#include "boost/multi_array/iterator.hpp"
|
|
#include "boost/multi_array/storage_order.hpp"
|
|
#include "boost/multi_array/subarray.hpp"
|
|
#include "boost/multi_array/view.hpp"
|
|
#include "boost/multi_array/algorithm.hpp"
|
|
#include "boost/type_traits/is_integral.hpp"
|
|
#include "boost/utility/enable_if.hpp"
|
|
#include "boost/array.hpp"
|
|
#include "boost/concept_check.hpp"
|
|
#include "boost/functional.hpp"
|
|
#include "boost/limits.hpp"
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <numeric>
|
|
|
|
namespace boost {
|
|
|
|
template <typename T, std::size_t NumDims,
|
|
typename TPtr = const T*
|
|
>
|
|
class const_multi_array_ref :
|
|
public detail::multi_array::multi_array_impl_base<T,NumDims>
|
|
{
|
|
typedef detail::multi_array::multi_array_impl_base<T,NumDims> super_type;
|
|
public:
|
|
typedef typename super_type::value_type value_type;
|
|
typedef typename super_type::const_reference const_reference;
|
|
typedef typename super_type::const_iterator const_iterator;
|
|
typedef typename super_type::const_reverse_iterator const_reverse_iterator;
|
|
typedef typename super_type::element element;
|
|
typedef typename super_type::size_type size_type;
|
|
typedef typename super_type::difference_type difference_type;
|
|
typedef typename super_type::index index;
|
|
typedef typename super_type::extent_range extent_range;
|
|
typedef general_storage_order<NumDims> storage_order_type;
|
|
|
|
// template typedefs
|
|
template <std::size_t NDims>
|
|
struct const_array_view {
|
|
typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
|
|
};
|
|
|
|
template <std::size_t NDims>
|
|
struct array_view {
|
|
typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
|
|
};
|
|
|
|
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
|
// make const_multi_array_ref a friend of itself
|
|
template <typename,std::size_t,typename>
|
|
friend class const_multi_array_ref;
|
|
#endif
|
|
|
|
// This ensures that const_multi_array_ref types with different TPtr
|
|
// types can convert to each other
|
|
template <typename OPtr>
|
|
const_multi_array_ref(const const_multi_array_ref<T,NumDims,OPtr>& other)
|
|
: base_(other.base_), storage_(other.storage_),
|
|
extent_list_(other.extent_list_),
|
|
stride_list_(other.stride_list_),
|
|
index_base_list_(other.index_base_list_),
|
|
origin_offset_(other.origin_offset_),
|
|
directional_offset_(other.directional_offset_),
|
|
num_elements_(other.num_elements_) { }
|
|
|
|
template <typename ExtentList>
|
|
explicit const_multi_array_ref(TPtr base, const ExtentList& extents) :
|
|
base_(base), storage_(c_storage_order()) {
|
|
boost::function_requires<
|
|
CollectionConcept<ExtentList> >();
|
|
|
|
index_base_list_.assign(0);
|
|
init_multi_array_ref(extents.begin());
|
|
}
|
|
|
|
template <typename ExtentList>
|
|
explicit const_multi_array_ref(TPtr base, const ExtentList& extents,
|
|
const general_storage_order<NumDims>& so) :
|
|
base_(base), storage_(so) {
|
|
boost::function_requires<
|
|
CollectionConcept<ExtentList> >();
|
|
|
|
index_base_list_.assign(0);
|
|
init_multi_array_ref(extents.begin());
|
|
}
|
|
|
|
explicit const_multi_array_ref(TPtr base,
|
|
const detail::multi_array::
|
|
extent_gen<NumDims>& ranges) :
|
|
base_(base), storage_(c_storage_order()) {
|
|
|
|
init_from_extent_gen(ranges);
|
|
}
|
|
|
|
explicit const_multi_array_ref(TPtr base,
|
|
const detail::multi_array::
|
|
extent_gen<NumDims>& ranges,
|
|
const general_storage_order<NumDims>& so) :
|
|
base_(base), storage_(so) {
|
|
|
|
init_from_extent_gen(ranges);
|
|
}
|
|
|
|
template <class InputIterator>
|
|
void assign(InputIterator begin, InputIterator end) {
|
|
boost::function_requires<InputIteratorConcept<InputIterator> >();
|
|
|
|
InputIterator in_iter = begin;
|
|
T* out_iter = base_;
|
|
std::size_t copy_count=0;
|
|
while (in_iter != end && copy_count < num_elements_) {
|
|
*out_iter++ = *in_iter++;
|
|
copy_count++;
|
|
}
|
|
}
|
|
|
|
template <class BaseList>
|
|
#ifdef BOOST_NO_SFINAE
|
|
void
|
|
#else
|
|
typename
|
|
disable_if<typename boost::is_integral<BaseList>::type,void >::type
|
|
#endif // BOOST_NO_SFINAE
|
|
reindex(const BaseList& values) {
|
|
boost::function_requires<
|
|
CollectionConcept<BaseList> >();
|
|
boost::detail::multi_array::
|
|
copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
|
|
origin_offset_ =
|
|
this->calculate_origin_offset(stride_list_,extent_list_,
|
|
storage_,index_base_list_);
|
|
}
|
|
|
|
void reindex(index value) {
|
|
index_base_list_.assign(value);
|
|
origin_offset_ =
|
|
this->calculate_origin_offset(stride_list_,extent_list_,
|
|
storage_,index_base_list_);
|
|
}
|
|
|
|
template <typename SizeList>
|
|
void reshape(const SizeList& extents) {
|
|
boost::function_requires<
|
|
CollectionConcept<SizeList> >();
|
|
BOOST_ASSERT(num_elements_ ==
|
|
std::accumulate(extents.begin(),extents.end(),
|
|
size_type(1),std::multiplies<size_type>()));
|
|
|
|
std::copy(extents.begin(),extents.end(),extent_list_.begin());
|
|
this->compute_strides(stride_list_,extent_list_,storage_);
|
|
|
|
origin_offset_ =
|
|
this->calculate_origin_offset(stride_list_,extent_list_,
|
|
storage_,index_base_list_);
|
|
}
|
|
|
|
size_type num_dimensions() const { return NumDims; }
|
|
|
|
size_type size() const { return extent_list_.front(); }
|
|
|
|
// given reshaping functionality, this is the max possible size.
|
|
size_type max_size() const { return num_elements(); }
|
|
|
|
bool empty() const { return size() == 0; }
|
|
|
|
const size_type* shape() const {
|
|
return extent_list_.data();
|
|
}
|
|
|
|
const index* strides() const {
|
|
return stride_list_.data();
|
|
}
|
|
|
|
const element* origin() const { return base_+origin_offset_; }
|
|
const element* data() const { return base_; }
|
|
|
|
size_type num_elements() const { return num_elements_; }
|
|
|
|
const index* index_bases() const {
|
|
return index_base_list_.data();
|
|
}
|
|
|
|
|
|
const storage_order_type& storage_order() const {
|
|
return storage_;
|
|
}
|
|
|
|
template <typename IndexList>
|
|
const element& operator()(IndexList indices) const {
|
|
boost::function_requires<
|
|
CollectionConcept<IndexList> >();
|
|
return super_type::access_element(boost::type<const element&>(),
|
|
indices,origin(),
|
|
shape(),strides(),index_bases());
|
|
}
|
|
|
|
// Only allow const element access
|
|
const_reference operator[](index idx) const {
|
|
return super_type::access(boost::type<const_reference>(),
|
|
idx,origin(),
|
|
shape(),strides(),index_bases());
|
|
}
|
|
|
|
// see generate_array_view in base.hpp
|
|
template <int NDims>
|
|
typename const_array_view<NDims>::type
|
|
operator[](const detail::multi_array::
|
|
index_gen<NumDims,NDims>& indices)
|
|
const {
|
|
typedef typename const_array_view<NDims>::type return_type;
|
|
return
|
|
super_type::generate_array_view(boost::type<return_type>(),
|
|
indices,
|
|
shape(),
|
|
strides(),
|
|
index_bases(),
|
|
origin());
|
|
}
|
|
|
|
const_iterator begin() const {
|
|
return const_iterator(*index_bases(),origin(),
|
|
shape(),strides(),index_bases());
|
|
}
|
|
|
|
const_iterator end() const {
|
|
return const_iterator(*index_bases()+(index)*shape(),origin(),
|
|
shape(),strides(),index_bases());
|
|
}
|
|
|
|
const_reverse_iterator rbegin() const {
|
|
return const_reverse_iterator(end());
|
|
}
|
|
|
|
const_reverse_iterator rend() const {
|
|
return const_reverse_iterator(begin());
|
|
}
|
|
|
|
|
|
template <typename OPtr>
|
|
bool operator==(const
|
|
const_multi_array_ref<T,NumDims,OPtr>& rhs)
|
|
const {
|
|
if(std::equal(extent_list_.begin(),
|
|
extent_list_.end(),
|
|
rhs.extent_list_.begin()))
|
|
return std::equal(begin(),end(),rhs.begin());
|
|
else return false;
|
|
}
|
|
|
|
template <typename OPtr>
|
|
bool operator<(const
|
|
const_multi_array_ref<T,NumDims,OPtr>& rhs)
|
|
const {
|
|
return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end());
|
|
}
|
|
|
|
template <typename OPtr>
|
|
bool operator!=(const
|
|
const_multi_array_ref<T,NumDims,OPtr>& rhs)
|
|
const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
template <typename OPtr>
|
|
bool operator>(const
|
|
const_multi_array_ref<T,NumDims,OPtr>& rhs)
|
|
const {
|
|
return rhs < *this;
|
|
}
|
|
|
|
template <typename OPtr>
|
|
bool operator<=(const
|
|
const_multi_array_ref<T,NumDims,OPtr>& rhs)
|
|
const {
|
|
return !(*this > rhs);
|
|
}
|
|
|
|
template <typename OPtr>
|
|
bool operator>=(const
|
|
const_multi_array_ref<T,NumDims,OPtr>& rhs)
|
|
const {
|
|
return !(*this < rhs);
|
|
}
|
|
|
|
|
|
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
|
protected:
|
|
#else
|
|
public:
|
|
#endif
|
|
|
|
typedef boost::array<size_type,NumDims> size_list;
|
|
typedef boost::array<index,NumDims> index_list;
|
|
|
|
// This is used by multi_array, which is a subclass of this
|
|
void set_base_ptr(TPtr new_base) { base_ = new_base; }
|
|
|
|
|
|
// This constructor supports multi_array's default constructor
|
|
// and constructors from multi_array_ref, subarray, and array_view
|
|
explicit
|
|
const_multi_array_ref(TPtr base,
|
|
const storage_order_type& so,
|
|
const index * index_bases,
|
|
const size_type* extents) :
|
|
base_(base), storage_(so), origin_offset_(0), directional_offset_(0)
|
|
{
|
|
// If index_bases or extents is null, then initialize the corresponding
|
|
// private data to zeroed lists.
|
|
if(index_bases) {
|
|
boost::detail::multi_array::
|
|
copy_n(index_bases,NumDims,index_base_list_.begin());
|
|
} else {
|
|
std::fill_n(index_base_list_.begin(),NumDims,0);
|
|
}
|
|
if(extents) {
|
|
init_multi_array_ref(extents);
|
|
} else {
|
|
boost::array<index,NumDims> extent_list;
|
|
extent_list.assign(0);
|
|
init_multi_array_ref(extent_list.begin());
|
|
}
|
|
}
|
|
|
|
|
|
TPtr base_;
|
|
storage_order_type storage_;
|
|
size_list extent_list_;
|
|
index_list stride_list_;
|
|
index_list index_base_list_;
|
|
index origin_offset_;
|
|
index directional_offset_;
|
|
size_type num_elements_;
|
|
|
|
private:
|
|
// const_multi_array_ref cannot be assigned to (no deep copies!)
|
|
const_multi_array_ref& operator=(const const_multi_array_ref& other);
|
|
|
|
void init_from_extent_gen(const
|
|
detail::multi_array::
|
|
extent_gen<NumDims>& ranges) {
|
|
|
|
typedef boost::array<index,NumDims> extent_list;
|
|
|
|
// get the index_base values
|
|
std::transform(ranges.ranges_.begin(),ranges.ranges_.end(),
|
|
index_base_list_.begin(),
|
|
boost::mem_fun_ref(&extent_range::start));
|
|
|
|
// calculate the extents
|
|
extent_list extents;
|
|
std::transform(ranges.ranges_.begin(),ranges.ranges_.end(),
|
|
extents.begin(),
|
|
boost::mem_fun_ref(&extent_range::size));
|
|
|
|
init_multi_array_ref(extents.begin());
|
|
}
|
|
|
|
|
|
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
|
protected:
|
|
#else
|
|
public:
|
|
#endif
|
|
// RG - move me!
|
|
template <class InputIterator>
|
|
void init_multi_array_ref(InputIterator extents_iter) {
|
|
boost::function_requires<InputIteratorConcept<InputIterator> >();
|
|
|
|
boost::detail::multi_array::
|
|
copy_n(extents_iter,num_dimensions(),extent_list_.begin());
|
|
|
|
// Calculate the array size
|
|
num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
|
|
size_type(1),std::multiplies<size_type>());
|
|
|
|
this->compute_strides(stride_list_,extent_list_,storage_);
|
|
|
|
origin_offset_ =
|
|
this->calculate_origin_offset(stride_list_,extent_list_,
|
|
storage_,index_base_list_);
|
|
directional_offset_ =
|
|
this->calculate_descending_dimension_offset(stride_list_,extent_list_,
|
|
storage_);
|
|
}
|
|
};
|
|
|
|
template <typename T, std::size_t NumDims>
|
|
class multi_array_ref :
|
|
public const_multi_array_ref<T,NumDims,T*>
|
|
{
|
|
typedef const_multi_array_ref<T,NumDims,T*> super_type;
|
|
public:
|
|
typedef typename super_type::value_type value_type;
|
|
typedef typename super_type::reference reference;
|
|
typedef typename super_type::iterator iterator;
|
|
typedef typename super_type::reverse_iterator reverse_iterator;
|
|
typedef typename super_type::const_reference const_reference;
|
|
typedef typename super_type::const_iterator const_iterator;
|
|
typedef typename super_type::const_reverse_iterator const_reverse_iterator;
|
|
typedef typename super_type::element element;
|
|
typedef typename super_type::size_type size_type;
|
|
typedef typename super_type::difference_type difference_type;
|
|
typedef typename super_type::index index;
|
|
typedef typename super_type::extent_range extent_range;
|
|
|
|
typedef typename super_type::storage_order_type storage_order_type;
|
|
typedef typename super_type::index_list index_list;
|
|
typedef typename super_type::size_list size_list;
|
|
|
|
template <std::size_t NDims>
|
|
struct const_array_view {
|
|
typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
|
|
};
|
|
|
|
template <std::size_t NDims>
|
|
struct array_view {
|
|
typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
|
|
};
|
|
|
|
template <class ExtentList>
|
|
explicit multi_array_ref(T* base, const ExtentList& extents) :
|
|
super_type(base,extents) {
|
|
boost::function_requires<
|
|
CollectionConcept<ExtentList> >();
|
|
}
|
|
|
|
template <class ExtentList>
|
|
explicit multi_array_ref(T* base, const ExtentList& extents,
|
|
const general_storage_order<NumDims>& so) :
|
|
super_type(base,extents,so) {
|
|
boost::function_requires<
|
|
CollectionConcept<ExtentList> >();
|
|
}
|
|
|
|
|
|
explicit multi_array_ref(T* base,
|
|
const detail::multi_array::
|
|
extent_gen<NumDims>& ranges) :
|
|
super_type(base,ranges) { }
|
|
|
|
|
|
explicit multi_array_ref(T* base,
|
|
const detail::multi_array::
|
|
extent_gen<NumDims>&
|
|
ranges,
|
|
const general_storage_order<NumDims>& so) :
|
|
super_type(base,ranges,so) { }
|
|
|
|
|
|
// Assignment from other ConstMultiArray types.
|
|
template <typename ConstMultiArray>
|
|
multi_array_ref& operator=(const ConstMultiArray& other) {
|
|
function_requires<
|
|
multi_array_concepts::
|
|
ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
|
|
|
|
// make sure the dimensions agree
|
|
BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
|
|
BOOST_ASSERT(std::equal(other.shape(),other.shape()+this->num_dimensions(),
|
|
this->shape()));
|
|
// iterator-based copy
|
|
std::copy(other.begin(),other.end(),this->begin());
|
|
return *this;
|
|
}
|
|
|
|
multi_array_ref& operator=(const multi_array_ref& other) {
|
|
if (&other != this) {
|
|
// make sure the dimensions agree
|
|
|
|
BOOST_ASSERT(other.num_dimensions() == this->num_dimensions());
|
|
BOOST_ASSERT(std::equal(other.shape(),
|
|
other.shape()+this->num_dimensions(),
|
|
this->shape()));
|
|
// iterator-based copy
|
|
std::copy(other.begin(),other.end(),this->begin());
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
element* origin() { return super_type::base_+super_type::origin_offset_; }
|
|
|
|
element* data() { return super_type::base_; }
|
|
|
|
template <class IndexList>
|
|
element& operator()(const IndexList& indices) {
|
|
boost::function_requires<
|
|
CollectionConcept<IndexList> >();
|
|
return super_type::access_element(boost::type<element&>(),
|
|
indices,origin(),
|
|
this->shape(),this->strides(),
|
|
this->index_bases());
|
|
}
|
|
|
|
|
|
reference operator[](index idx) {
|
|
return super_type::access(boost::type<reference>(),
|
|
idx,origin(),
|
|
this->shape(),this->strides(),
|
|
this->index_bases());
|
|
}
|
|
|
|
|
|
// See note attached to generate_array_view in base.hpp
|
|
template <int NDims>
|
|
typename array_view<NDims>::type
|
|
operator[](const detail::multi_array::
|
|
index_gen<NumDims,NDims>& indices) {
|
|
typedef typename array_view<NDims>::type return_type;
|
|
return
|
|
super_type::generate_array_view(boost::type<return_type>(),
|
|
indices,
|
|
this->shape(),
|
|
this->strides(),
|
|
this->index_bases(),
|
|
origin());
|
|
}
|
|
|
|
|
|
iterator begin() {
|
|
return iterator(*this->index_bases(),origin(),this->shape(),
|
|
this->strides(),this->index_bases());
|
|
}
|
|
|
|
iterator end() {
|
|
return iterator(*this->index_bases()+(index)*this->shape(),origin(),
|
|
this->shape(),this->strides(),
|
|
this->index_bases());
|
|
}
|
|
|
|
// rbegin() and rend() written naively to thwart MSVC ICE.
|
|
reverse_iterator rbegin() {
|
|
reverse_iterator ri(end());
|
|
return ri;
|
|
}
|
|
|
|
reverse_iterator rend() {
|
|
reverse_iterator ri(begin());
|
|
return ri;
|
|
}
|
|
|
|
// Using declarations don't seem to work for g++
|
|
// These are the proxies to work around this.
|
|
|
|
const element* origin() const { return super_type::origin(); }
|
|
const element* data() const { return super_type::data(); }
|
|
|
|
template <class IndexList>
|
|
const element& operator()(const IndexList& indices) const {
|
|
boost::function_requires<
|
|
CollectionConcept<IndexList> >();
|
|
return super_type::operator()(indices);
|
|
}
|
|
|
|
const_reference operator[](index idx) const {
|
|
return super_type::access(boost::type<const_reference>(),
|
|
idx,origin(),
|
|
this->shape(),this->strides(),
|
|
this->index_bases());
|
|
}
|
|
|
|
// See note attached to generate_array_view in base.hpp
|
|
template <int NDims>
|
|
typename const_array_view<NDims>::type
|
|
operator[](const detail::multi_array::
|
|
index_gen<NumDims,NDims>& indices)
|
|
const {
|
|
return super_type::operator[](indices);
|
|
}
|
|
|
|
const_iterator begin() const {
|
|
return super_type::begin();
|
|
}
|
|
|
|
const_iterator end() const {
|
|
return super_type::end();
|
|
}
|
|
|
|
const_reverse_iterator rbegin() const {
|
|
return super_type::rbegin();
|
|
}
|
|
|
|
const_reverse_iterator rend() const {
|
|
return super_type::rend();
|
|
}
|
|
|
|
protected:
|
|
// This is only supplied to support multi_array's default constructor
|
|
explicit multi_array_ref(T* base,
|
|
const storage_order_type& so,
|
|
const index* index_bases,
|
|
const size_type* extents) :
|
|
super_type(base,so,index_bases,extents) { }
|
|
|
|
};
|
|
|
|
} // namespace boost
|
|
|
|
#endif // BOOST_MULTI_ARRAY_REF_RG071801_HPP
|