source: NonGTP/Boost/boost/multi_array/view.hpp @ 857

Revision 857, 14.2 KB checked in by igarcia, 19 years ago (diff)
RevLine 
[857]1// Copyright 2002 The Trustees of Indiana University.
2
3// Use, modification and distribution is subject to the Boost Software
4// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
5// http://www.boost.org/LICENSE_1_0.txt)
6
7//  Boost.MultiArray Library
8//  Authors: Ronald Garcia
9//           Jeremy Siek
10//           Andrew Lumsdaine
11//  See http://www.boost.org/libs/multi_array for documentation.
12
13#ifndef BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
14#define BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
15
16//
17// view.hpp - code for creating "views" of array data.
18//
19
20#include "boost/multi_array/base.hpp"
21#include "boost/multi_array/concept_checks.hpp"
22#include "boost/multi_array/iterator.hpp"
23#include "boost/multi_array/storage_order.hpp"
24#include "boost/multi_array/subarray.hpp"
25#include "boost/multi_array/algorithm.hpp"
26#include "boost/array.hpp"
27#include "boost/limits.hpp"
28#include <algorithm>
29#include <cstddef>
30#include <functional>
31#include <numeric>
32
33namespace boost {
34namespace detail {
35namespace multi_array {
36
37// TPtr = const T* defaulted in base.hpp
38template <typename T, std::size_t NumDims, typename TPtr>
39class const_multi_array_view :
40    public boost::detail::multi_array::multi_array_impl_base<T,NumDims>
41{
42  typedef boost::detail::multi_array::multi_array_impl_base<T,NumDims> super_type;
43public:
44  typedef typename super_type::value_type value_type;
45  typedef typename super_type::const_reference const_reference;
46  typedef typename super_type::const_iterator const_iterator;
47  typedef typename super_type::const_reverse_iterator const_reverse_iterator;
48  typedef typename super_type::element element;
49  typedef typename super_type::size_type size_type;
50  typedef typename super_type::difference_type difference_type;
51  typedef typename super_type::index index;
52  typedef typename super_type::extent_range extent_range;
53
54  // template typedefs
55  template <std::size_t NDims>
56  struct const_array_view {
57    typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
58  };
59
60  template <std::size_t NDims>
61  struct array_view {
62    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
63  };
64
65  template <typename OPtr>
66  const_multi_array_view(const
67                         const_multi_array_view<T,NumDims,OPtr>& other) :
68    base_(other.base_), origin_offset_(other.origin_offset_),
69    num_elements_(other.num_elements_), extent_list_(other.extent_list_),
70    stride_list_(other.stride_list_), index_base_list_(other.index_base_list_)
71  { }
72
73
74  template <class BaseList>
75  void reindex(const BaseList& values) {
76    boost::detail::multi_array::
77      copy_n(values.begin(),num_dimensions(),index_base_list_.begin());
78    origin_offset_ =
79      this->calculate_indexing_offset(stride_list_,index_base_list_);
80  }
81
82  void reindex(index value) {
83    index_base_list_.assign(value);
84    origin_offset_ =
85      this->calculate_indexing_offset(stride_list_,index_base_list_);
86  }
87
88  size_type num_dimensions() const { return NumDims; }
89
90  size_type size() const { return extent_list_.front(); }
91  size_type max_size() const { return num_elements(); }
92  bool empty() const { return size() == 0; }
93
94  const size_type* shape() const {
95    return extent_list_.data();
96  }
97
98  const index* strides() const {
99    return stride_list_.data();
100  }
101
102  const T* origin() const { return base_+origin_offset_; }
103
104  size_type num_elements() const { return num_elements_; }
105
106  const index* index_bases() const {
107    return index_base_list_.data();
108  }
109
110  template <typename IndexList>
111  const element& operator()(IndexList indices) const {
112    return super_type::access_element(boost::type<const element&>(),
113                                      origin(),
114                                      indices,strides());
115  }
116
117  // Only allow const element access
118  const_reference operator[](index idx) const {
119    return super_type::access(boost::type<const_reference>(),
120                              idx,origin(),
121                              shape(),strides(),
122                              index_bases());
123  }
124
125  // see generate_array_view in base.hpp
126#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
127  template <int NDims>
128#else
129  template <int NumDims, int NDims> // else ICE
130#endif // BOOST_MSVC
131  typename const_array_view<NDims>::type
132  operator[](const boost::detail::multi_array::
133             index_gen<NumDims,NDims>& indices)
134    const {
135    typedef typename const_array_view<NDims>::type return_type;
136    return
137      super_type::generate_array_view(boost::type<return_type>(),
138                                      indices,
139                                      shape(),
140                                      strides(),
141                                      index_bases(),
142                                      origin());
143  }
144  const_iterator begin() const {
145    return const_iterator(*index_bases(),origin(),
146                          shape(),strides(),index_bases());
147  }
148
149  const_iterator end() const {
150    return const_iterator(*index_bases()+(index)*shape(),origin(),
151                          shape(),strides(),index_bases());
152  }
153 
154  const_reverse_iterator rbegin() const {
155    return const_reverse_iterator(end());
156  }
157
158  const_reverse_iterator rend() const {
159    return const_reverse_iterator(begin());
160  }
161
162
163  template <typename OPtr>
164  bool operator==(const
165                  const_multi_array_view<T,NumDims,OPtr>& rhs)
166    const {
167    if(std::equal(extent_list_.begin(),
168                  extent_list_.end(),
169                  rhs.extent_list_.begin()))
170      return std::equal(begin(),end(),rhs.begin());
171    else return false;
172  }
173
174  template <typename OPtr>
175  bool operator<(const
176                 const_multi_array_view<T,NumDims,OPtr>& rhs)
177    const {
178    return std::lexicographical_compare(begin(),end(),rhs.begin(),rhs.end());
179  }
180
181  template <typename OPtr>
182  bool operator!=(const
183                  const_multi_array_view<T,NumDims,OPtr>& rhs)
184    const {
185    return !(*this == rhs);
186  }
187
188  template <typename OPtr>
189  bool operator>(const
190                 const_multi_array_view<T,NumDims,OPtr>& rhs)
191    const {
192    return rhs < *this;
193  }
194
195  template <typename OPtr>
196  bool operator<=(const
197                 const_multi_array_view<T,NumDims,OPtr>& rhs)
198    const {
199    return !(*this > rhs);
200  }
201
202  template <typename OPtr>
203  bool operator>=(const
204                 const_multi_array_view<T,NumDims,OPtr>& rhs)
205    const {
206    return !(*this < rhs);
207  }
208
209
210#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
211protected:
212  template <typename,std::size_t> friend class multi_array_impl_base;
213  template <typename,std::size_t,typename> friend class const_multi_array_view;
214#else
215public: // should be protected
216#endif
217
218  // This constructor is used by multi_array_impl_base::generate_array_view
219  // to create strides 
220  template <typename ExtentList, typename Index>
221  explicit const_multi_array_view(TPtr base,
222                           const ExtentList& extents,
223                           const boost::array<Index,NumDims>& strides):
224    base_(base), origin_offset_(0) {
225
226    index_base_list_.assign(0);
227
228    // Get the extents and strides
229    boost::detail::multi_array::
230      copy_n(extents.begin(),NumDims,extent_list_.begin());
231    boost::detail::multi_array::
232      copy_n(strides.begin(),NumDims,stride_list_.begin());
233
234    // Calculate the array size
235    num_elements_ = std::accumulate(extent_list_.begin(),extent_list_.end(),
236                            size_type(1),std::multiplies<size_type>());
237#if 0
238    assert(num_elements_ != 0);
239#endif
240  }
241
242  typedef boost::array<size_type,NumDims> size_list;
243  typedef boost::array<index,NumDims> index_list;
244
245  TPtr base_;
246  index origin_offset_;
247  size_type num_elements_;
248  size_list extent_list_;
249  index_list stride_list_;
250  index_list index_base_list_;
251
252private:
253  // const_multi_array_view cannot be assigned to (no deep copies!)
254  const_multi_array_view& operator=(const const_multi_array_view& other);
255};
256
257
258template <typename T, std::size_t NumDims>
259class multi_array_view :
260  public const_multi_array_view<T,NumDims,T*>
261{
262  typedef const_multi_array_view<T,NumDims,T*> super_type;
263public:
264  typedef typename super_type::value_type value_type;
265  typedef typename super_type::reference reference;
266  typedef typename super_type::iterator iterator;
267  typedef typename super_type::reverse_iterator reverse_iterator;
268  typedef typename super_type::const_reference const_reference;
269  typedef typename super_type::const_iterator const_iterator;
270  typedef typename super_type::const_reverse_iterator const_reverse_iterator;
271  typedef typename super_type::element element;
272  typedef typename super_type::size_type size_type;
273  typedef typename super_type::difference_type difference_type;
274  typedef typename super_type::index index;
275  typedef typename super_type::extent_range extent_range;
276
277  // template typedefs
278  template <std::size_t NDims>
279  struct const_array_view {
280    typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
281  };
282
283  template <std::size_t NDims>
284  struct array_view {
285    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
286  };
287
288  // Assignment from other ConstMultiArray types.
289  template <typename ConstMultiArray>
290  multi_array_view& operator=(const ConstMultiArray& other) {
291    function_requires<
292      boost::detail::multi_array::
293      ConstMultiArrayConcept<ConstMultiArray,NumDims> >();
294
295    // make sure the dimensions agree
296    assert(other.num_dimensions() == this->num_dimensions());
297    assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
298                      this->shape()));
299    // iterator-based copy
300    std::copy(other.begin(),other.end(),begin());
301    return *this;
302  }
303
304
305  multi_array_view& operator=(const multi_array_view& other) {
306    if (&other != this) {
307      // make sure the dimensions agree
308      assert(other.num_dimensions() == this->num_dimensions());
309      assert(std::equal(other.shape(),other.shape()+this->num_dimensions(),
310                        this->shape()));
311      // iterator-based copy
312      std::copy(other.begin(),other.end(),begin());
313    }
314    return *this;
315  }
316
317  element* origin() { return this->base_+this->origin_offset_; }
318
319  template <class IndexList>
320  element& operator()(const IndexList& indices) {
321    return super_type::access_element(boost::type<element&>(),
322                                      origin(),
323                                      indices,this->strides());
324  }
325
326
327  reference operator[](index idx) {
328    return super_type::access(boost::type<reference>(),
329                              idx,origin(),
330                              this->shape(),this->strides(),
331                              this->index_bases());
332  }
333
334
335  // see generate_array_view in base.hpp
336#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
337  template <int NDims>
338#else
339  template <int NumDims, int NDims> // else ICE
340#endif // BOOST_MSVC
341  typename array_view<NDims>::type
342  operator[](const boost::detail::multi_array::
343             index_gen<NumDims,NDims>& indices) {
344    typedef typename array_view<NDims>::type return_type;
345    return
346      super_type::generate_array_view(boost::type<return_type>(),
347                                      indices,
348                                      this->shape(),
349                                      this->strides(),
350                                      this->index_bases(),
351                                      origin());
352  }
353 
354 
355  iterator begin() {
356    return iterator(*this->index_bases(),origin(),
357                    this->shape(),this->strides(),
358                    this->index_bases());
359  }
360
361  iterator end() {
362    return iterator(*this->index_bases()+(index)*this->shape(),origin(),
363                    this->shape(),this->strides(),
364                    this->index_bases());
365  }
366
367  reverse_iterator rbegin() {
368    return reverse_iterator(end());
369  }
370
371  reverse_iterator rend() {
372    return reverse_iterator(begin());
373  }
374
375  // Using declarations don't seem to work for g++
376  // These are the proxies to work around this.
377
378  const element* origin() const { return super_type::origin(); }
379
380  template <class IndexList>
381  const element& operator()(const IndexList& indices) const {
382    return super_type::operator()(indices);
383  }
384
385  const_reference operator[](index idx) const {
386    return super_type::operator[](idx);
387  }
388
389  // see generate_array_view in base.hpp
390#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
391  template <int NDims>
392#else
393  template <int NumDims, int NDims> // else ICE
394#endif // BOOST_MSVC
395  typename const_array_view<NDims>::type
396  operator[](const boost::detail::multi_array::
397             index_gen<NumDims,NDims>& indices)
398    const {
399    return super_type::operator[](indices);
400  }
401 
402  const_iterator begin() const {
403    return super_type::begin();
404  }
405
406  const_iterator end() const {
407    return super_type::end();
408  }
409
410  const_reverse_iterator rbegin() const {
411    return super_type::rbegin();
412  }
413
414  const_reverse_iterator rend() const {
415    return super_type::rend();
416  }
417
418#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
419private:
420  template <typename,std::size_t> friend class multi_array_impl_base;
421#else
422public: // should be private
423#endif
424
425  // constructor used by multi_array_impl_base::generate_array_view to
426  // generate array views
427  template <typename ExtentList, typename Index>
428  explicit multi_array_view(T* base,
429                            const ExtentList& extents,
430                            const boost::array<Index,NumDims>& strides) :
431    super_type(base,extents,strides) { }
432
433};
434
435} // namespace multi_array
436} // namespace detail
437
438//
439// traits classes to get array_view types
440//
441template <typename Array, int N>
442class array_view_gen {
443  typedef typename Array::element element;
444public:
445  typedef boost::detail::multi_array::multi_array_view<element,N> type;
446};
447
448template <typename Array, int N>
449class const_array_view_gen {
450  typedef typename Array::element element;
451public:
452  typedef boost::detail::multi_array::const_multi_array_view<element,N> type; 
453};
454
455} // namespace boost
456
457#endif // BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
458
Note: See TracBrowser for help on using the repository browser.