| // 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/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 |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| template <int NDims> |
| #else |
| template <int NumDims, int NDims> // else ICE |
| #endif // BOOST_MSVC |
| 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 |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| template <int NDims> |
| #else |
| template <int NumDims, int NDims> // else ICE |
| #endif // BOOST_MSVC |
| 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 |
| #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 |
| template <int NDims> |
| #else |
| template <int NumDims, int NDims> // else ICE |
| #endif // BOOST_MSVC |
| 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 |