williamr@2
|
1 |
// Copyright 2002 The Trustees of Indiana University.
|
williamr@2
|
2 |
|
williamr@2
|
3 |
// Use, modification and distribution is subject to the Boost Software
|
williamr@2
|
4 |
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
williamr@2
|
5 |
// http://www.boost.org/LICENSE_1_0.txt)
|
williamr@2
|
6 |
|
williamr@2
|
7 |
// Boost.MultiArray Library
|
williamr@2
|
8 |
// Authors: Ronald Garcia
|
williamr@2
|
9 |
// Jeremy Siek
|
williamr@2
|
10 |
// Andrew Lumsdaine
|
williamr@2
|
11 |
// See http://www.boost.org/libs/multi_array for documentation.
|
williamr@2
|
12 |
|
williamr@2
|
13 |
#ifndef BASE_RG071801_HPP
|
williamr@2
|
14 |
#define BASE_RG071801_HPP
|
williamr@2
|
15 |
|
williamr@2
|
16 |
//
|
williamr@2
|
17 |
// base.hpp - some implementation base classes for from which
|
williamr@2
|
18 |
// functionality is acquired
|
williamr@2
|
19 |
//
|
williamr@2
|
20 |
|
williamr@2
|
21 |
#include "boost/multi_array/extent_range.hpp"
|
williamr@2
|
22 |
#include "boost/multi_array/extent_gen.hpp"
|
williamr@2
|
23 |
#include "boost/multi_array/index_range.hpp"
|
williamr@2
|
24 |
#include "boost/multi_array/index_gen.hpp"
|
williamr@2
|
25 |
#include "boost/multi_array/storage_order.hpp"
|
williamr@2
|
26 |
#include "boost/multi_array/types.hpp"
|
williamr@2
|
27 |
#include "boost/config.hpp"
|
williamr@2
|
28 |
#include "boost/multi_array/concept_checks.hpp" //for ignore_unused_...
|
williamr@2
|
29 |
#include "boost/mpl/eval_if.hpp"
|
williamr@2
|
30 |
#include "boost/mpl/if.hpp"
|
williamr@2
|
31 |
#include "boost/mpl/size_t.hpp"
|
williamr@2
|
32 |
#include "boost/mpl/aux_/msvc_eti_base.hpp"
|
williamr@2
|
33 |
#include "boost/iterator/reverse_iterator.hpp"
|
williamr@2
|
34 |
#include "boost/static_assert.hpp"
|
williamr@2
|
35 |
#include "boost/type.hpp"
|
williamr@2
|
36 |
#include "boost/assert.hpp"
|
williamr@2
|
37 |
#include <cstddef>
|
williamr@2
|
38 |
#include <memory>
|
williamr@2
|
39 |
|
williamr@2
|
40 |
namespace boost {
|
williamr@2
|
41 |
|
williamr@2
|
42 |
/////////////////////////////////////////////////////////////////////////
|
williamr@2
|
43 |
// class declarations
|
williamr@2
|
44 |
/////////////////////////////////////////////////////////////////////////
|
williamr@2
|
45 |
|
williamr@2
|
46 |
template<typename T, std::size_t NumDims,
|
williamr@2
|
47 |
typename Allocator = std::allocator<T> >
|
williamr@2
|
48 |
class multi_array;
|
williamr@2
|
49 |
|
williamr@2
|
50 |
// This is a public interface for use by end users!
|
williamr@2
|
51 |
namespace multi_array_types {
|
williamr@2
|
52 |
typedef boost::detail::multi_array::size_type size_type;
|
williamr@2
|
53 |
typedef std::ptrdiff_t difference_type;
|
williamr@2
|
54 |
typedef boost::detail::multi_array::index index;
|
williamr@2
|
55 |
typedef detail::multi_array::index_range<index,size_type> index_range;
|
williamr@2
|
56 |
typedef detail::multi_array::extent_range<index,size_type> extent_range;
|
williamr@2
|
57 |
typedef detail::multi_array::index_gen<0,0> index_gen;
|
williamr@2
|
58 |
typedef detail::multi_array::extent_gen<0> extent_gen;
|
williamr@2
|
59 |
}
|
williamr@2
|
60 |
|
williamr@2
|
61 |
|
williamr@2
|
62 |
// boost::extents and boost::indices are now a part of the public
|
williamr@2
|
63 |
// interface. That way users don't necessarily have to create their
|
williamr@2
|
64 |
// own objects. On the other hand, one may not want the overhead of
|
williamr@2
|
65 |
// object creation in small-memory environments. Thus, the objects
|
williamr@2
|
66 |
// can be left undefined by defining BOOST_MULTI_ARRAY_NO_GENERATORS
|
williamr@2
|
67 |
// before loading multi_array.hpp.
|
williamr@2
|
68 |
#if !BOOST_MULTI_ARRAY_NO_GENERATORS
|
williamr@2
|
69 |
namespace {
|
williamr@2
|
70 |
multi_array_types::extent_gen extents;
|
williamr@2
|
71 |
multi_array_types::index_gen indices;
|
williamr@2
|
72 |
}
|
williamr@2
|
73 |
#endif // BOOST_MULTI_ARRAY_NO_GENERATORS
|
williamr@2
|
74 |
|
williamr@2
|
75 |
namespace detail {
|
williamr@2
|
76 |
namespace multi_array {
|
williamr@2
|
77 |
|
williamr@2
|
78 |
template <typename T, std::size_t NumDims>
|
williamr@2
|
79 |
class sub_array;
|
williamr@2
|
80 |
|
williamr@2
|
81 |
template <typename T, std::size_t NumDims, typename TPtr = const T*>
|
williamr@2
|
82 |
class const_sub_array;
|
williamr@2
|
83 |
|
williamr@2
|
84 |
template <typename T, typename TPtr, typename NumDims, typename Reference>
|
williamr@2
|
85 |
class array_iterator;
|
williamr@2
|
86 |
|
williamr@2
|
87 |
template <typename T, std::size_t NumDims, typename TPtr = const T*>
|
williamr@2
|
88 |
class const_multi_array_view;
|
williamr@2
|
89 |
|
williamr@2
|
90 |
template <typename T, std::size_t NumDims>
|
williamr@2
|
91 |
class multi_array_view;
|
williamr@2
|
92 |
|
williamr@2
|
93 |
/////////////////////////////////////////////////////////////////////////
|
williamr@2
|
94 |
// class interfaces
|
williamr@2
|
95 |
/////////////////////////////////////////////////////////////////////////
|
williamr@2
|
96 |
|
williamr@2
|
97 |
class multi_array_base {
|
williamr@2
|
98 |
public:
|
williamr@2
|
99 |
typedef multi_array_types::size_type size_type;
|
williamr@2
|
100 |
typedef multi_array_types::difference_type difference_type;
|
williamr@2
|
101 |
typedef multi_array_types::index index;
|
williamr@2
|
102 |
typedef multi_array_types::index_range index_range;
|
williamr@2
|
103 |
typedef multi_array_types::extent_range extent_range;
|
williamr@2
|
104 |
typedef multi_array_types::index_gen index_gen;
|
williamr@2
|
105 |
typedef multi_array_types::extent_gen extent_gen;
|
williamr@2
|
106 |
};
|
williamr@2
|
107 |
|
williamr@2
|
108 |
//
|
williamr@2
|
109 |
// value_accessor_n
|
williamr@2
|
110 |
// contains the routines for accessing elements from
|
williamr@2
|
111 |
// N-dimensional views.
|
williamr@2
|
112 |
//
|
williamr@2
|
113 |
template<typename T, std::size_t NumDims>
|
williamr@2
|
114 |
class value_accessor_n : public multi_array_base {
|
williamr@2
|
115 |
typedef multi_array_base super_type;
|
williamr@2
|
116 |
public:
|
williamr@2
|
117 |
typedef typename super_type::index index;
|
williamr@2
|
118 |
|
williamr@2
|
119 |
//
|
williamr@2
|
120 |
// public typedefs used by classes that inherit from this base
|
williamr@2
|
121 |
//
|
williamr@2
|
122 |
typedef T element;
|
williamr@2
|
123 |
typedef boost::multi_array<T,NumDims-1> value_type;
|
williamr@2
|
124 |
typedef sub_array<T,NumDims-1> reference;
|
williamr@2
|
125 |
typedef const_sub_array<T,NumDims-1> const_reference;
|
williamr@2
|
126 |
|
williamr@2
|
127 |
protected:
|
williamr@2
|
128 |
// used by array operator[] and iterators to get reference types.
|
williamr@2
|
129 |
template <typename Reference, typename TPtr>
|
williamr@2
|
130 |
Reference access(boost::type<Reference>,index idx,TPtr base,
|
williamr@2
|
131 |
const size_type* extents,
|
williamr@2
|
132 |
const index* strides,
|
williamr@2
|
133 |
const index* index_bases) const {
|
williamr@2
|
134 |
|
williamr@2
|
135 |
BOOST_ASSERT(idx - index_bases[0] >= 0);
|
williamr@2
|
136 |
BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]);
|
williamr@2
|
137 |
// return a sub_array<T,NDims-1> proxy object
|
williamr@2
|
138 |
TPtr newbase = base + idx * strides[0];
|
williamr@2
|
139 |
return Reference(newbase,extents+1,strides+1,index_bases+1);
|
williamr@2
|
140 |
|
williamr@2
|
141 |
}
|
williamr@2
|
142 |
|
williamr@2
|
143 |
value_accessor_n() { }
|
williamr@2
|
144 |
~value_accessor_n() { }
|
williamr@2
|
145 |
};
|
williamr@2
|
146 |
|
williamr@2
|
147 |
|
williamr@2
|
148 |
|
williamr@2
|
149 |
//
|
williamr@2
|
150 |
// value_accessor_one
|
williamr@2
|
151 |
// contains the routines for accessing reference elements from
|
williamr@2
|
152 |
// 1-dimensional views.
|
williamr@2
|
153 |
//
|
williamr@2
|
154 |
template<typename T>
|
williamr@2
|
155 |
class value_accessor_one : public multi_array_base {
|
williamr@2
|
156 |
typedef multi_array_base super_type;
|
williamr@2
|
157 |
public:
|
williamr@2
|
158 |
typedef typename super_type::index index;
|
williamr@2
|
159 |
//
|
williamr@2
|
160 |
// public typedefs for use by classes that inherit it.
|
williamr@2
|
161 |
//
|
williamr@2
|
162 |
typedef T element;
|
williamr@2
|
163 |
typedef T value_type;
|
williamr@2
|
164 |
typedef T& reference;
|
williamr@2
|
165 |
typedef T const& const_reference;
|
williamr@2
|
166 |
|
williamr@2
|
167 |
protected:
|
williamr@2
|
168 |
// used by array operator[] and iterators to get reference types.
|
williamr@2
|
169 |
template <typename Reference, typename TPtr>
|
williamr@2
|
170 |
Reference access(boost::type<Reference>,index idx,TPtr base,
|
williamr@2
|
171 |
const size_type* extents,
|
williamr@2
|
172 |
const index* strides,
|
williamr@2
|
173 |
const index* index_bases) const {
|
williamr@2
|
174 |
|
williamr@2
|
175 |
ignore_unused_variable_warning(index_bases);
|
williamr@2
|
176 |
ignore_unused_variable_warning(extents);
|
williamr@2
|
177 |
BOOST_ASSERT(idx - index_bases[0] >= 0);
|
williamr@2
|
178 |
BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]);
|
williamr@2
|
179 |
return *(base + idx * strides[0]);
|
williamr@2
|
180 |
}
|
williamr@2
|
181 |
|
williamr@2
|
182 |
value_accessor_one() { }
|
williamr@2
|
183 |
~value_accessor_one() { }
|
williamr@2
|
184 |
};
|
williamr@2
|
185 |
|
williamr@2
|
186 |
|
williamr@2
|
187 |
/////////////////////////////////////////////////////////////////////////
|
williamr@2
|
188 |
// choose value accessor begins
|
williamr@2
|
189 |
//
|
williamr@2
|
190 |
|
williamr@2
|
191 |
template <typename T, std::size_t NumDims>
|
williamr@2
|
192 |
struct choose_value_accessor_n {
|
williamr@2
|
193 |
typedef value_accessor_n<T,NumDims> type;
|
williamr@2
|
194 |
};
|
williamr@2
|
195 |
|
williamr@2
|
196 |
template <typename T>
|
williamr@2
|
197 |
struct choose_value_accessor_one {
|
williamr@2
|
198 |
typedef value_accessor_one<T> type;
|
williamr@2
|
199 |
};
|
williamr@2
|
200 |
|
williamr@2
|
201 |
template <typename T, typename NumDims>
|
williamr@2
|
202 |
struct value_accessor_generator {
|
williamr@2
|
203 |
BOOST_STATIC_CONSTANT(std::size_t, dimensionality = NumDims::value);
|
williamr@2
|
204 |
|
williamr@2
|
205 |
typedef typename
|
williamr@2
|
206 |
mpl::eval_if_c<(dimensionality == 1),
|
williamr@2
|
207 |
choose_value_accessor_one<T>,
|
williamr@2
|
208 |
choose_value_accessor_n<T,dimensionality>
|
williamr@2
|
209 |
>::type type;
|
williamr@2
|
210 |
};
|
williamr@2
|
211 |
|
williamr@2
|
212 |
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
williamr@2
|
213 |
|
williamr@2
|
214 |
struct eti_value_accessor
|
williamr@2
|
215 |
{
|
williamr@2
|
216 |
typedef int index;
|
williamr@2
|
217 |
typedef int size_type;
|
williamr@2
|
218 |
typedef int element;
|
williamr@2
|
219 |
typedef int index_range;
|
williamr@2
|
220 |
typedef int value_type;
|
williamr@2
|
221 |
typedef int reference;
|
williamr@2
|
222 |
typedef int const_reference;
|
williamr@2
|
223 |
};
|
williamr@2
|
224 |
|
williamr@2
|
225 |
template <>
|
williamr@2
|
226 |
struct value_accessor_generator<int,int>
|
williamr@2
|
227 |
{
|
williamr@2
|
228 |
typedef eti_value_accessor type;
|
williamr@2
|
229 |
};
|
williamr@2
|
230 |
|
williamr@2
|
231 |
template <class T, class NumDims>
|
williamr@2
|
232 |
struct associated_types
|
williamr@2
|
233 |
: mpl::aux::msvc_eti_base<
|
williamr@2
|
234 |
typename value_accessor_generator<T,NumDims>::type
|
williamr@2
|
235 |
>::type
|
williamr@2
|
236 |
{};
|
williamr@2
|
237 |
|
williamr@2
|
238 |
template <>
|
williamr@2
|
239 |
struct associated_types<int,int> : eti_value_accessor {};
|
williamr@2
|
240 |
|
williamr@2
|
241 |
#else
|
williamr@2
|
242 |
|
williamr@2
|
243 |
template <class T, class NumDims>
|
williamr@2
|
244 |
struct associated_types
|
williamr@2
|
245 |
: value_accessor_generator<T,NumDims>::type
|
williamr@2
|
246 |
{};
|
williamr@2
|
247 |
|
williamr@2
|
248 |
#endif
|
williamr@2
|
249 |
|
williamr@2
|
250 |
//
|
williamr@2
|
251 |
// choose value accessor ends
|
williamr@2
|
252 |
/////////////////////////////////////////////////////////////////////////
|
williamr@2
|
253 |
|
williamr@2
|
254 |
|
williamr@2
|
255 |
|
williamr@2
|
256 |
////////////////////////////////////////////////////////////////////////
|
williamr@2
|
257 |
// multi_array_base
|
williamr@2
|
258 |
////////////////////////////////////////////////////////////////////////
|
williamr@2
|
259 |
template <typename T, std::size_t NumDims>
|
williamr@2
|
260 |
class multi_array_impl_base
|
williamr@2
|
261 |
:
|
williamr@2
|
262 |
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
williamr@2
|
263 |
public mpl::aux::msvc_eti_base<
|
williamr@2
|
264 |
typename value_accessor_generator<T,mpl::size_t<NumDims> >::type
|
williamr@2
|
265 |
>::type
|
williamr@2
|
266 |
#else
|
williamr@2
|
267 |
public value_accessor_generator<T,mpl::size_t<NumDims> >::type
|
williamr@2
|
268 |
#endif
|
williamr@2
|
269 |
{
|
williamr@2
|
270 |
typedef associated_types<T,mpl::size_t<NumDims> > types;
|
williamr@2
|
271 |
public:
|
williamr@2
|
272 |
typedef typename types::index index;
|
williamr@2
|
273 |
typedef typename types::size_type size_type;
|
williamr@2
|
274 |
typedef typename types::element element;
|
williamr@2
|
275 |
typedef typename types::index_range index_range;
|
williamr@2
|
276 |
typedef typename types::value_type value_type;
|
williamr@2
|
277 |
typedef typename types::reference reference;
|
williamr@2
|
278 |
typedef typename types::const_reference const_reference;
|
williamr@2
|
279 |
|
williamr@2
|
280 |
template <std::size_t NDims>
|
williamr@2
|
281 |
struct subarray {
|
williamr@2
|
282 |
typedef boost::detail::multi_array::sub_array<T,NDims> type;
|
williamr@2
|
283 |
};
|
williamr@2
|
284 |
|
williamr@2
|
285 |
template <std::size_t NDims>
|
williamr@2
|
286 |
struct const_subarray {
|
williamr@2
|
287 |
typedef boost::detail::multi_array::const_sub_array<T,NDims> type;
|
williamr@2
|
288 |
};
|
williamr@2
|
289 |
|
williamr@2
|
290 |
template <std::size_t NDims>
|
williamr@2
|
291 |
struct array_view {
|
williamr@2
|
292 |
typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
|
williamr@2
|
293 |
};
|
williamr@2
|
294 |
|
williamr@2
|
295 |
template <std::size_t NDims>
|
williamr@2
|
296 |
struct const_array_view {
|
williamr@2
|
297 |
public:
|
williamr@2
|
298 |
typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type;
|
williamr@2
|
299 |
};
|
williamr@2
|
300 |
|
williamr@2
|
301 |
//
|
williamr@2
|
302 |
// iterator support
|
williamr@2
|
303 |
//
|
williamr@2
|
304 |
typedef array_iterator<T,T*,mpl::size_t<NumDims>,reference> iterator;
|
williamr@2
|
305 |
typedef array_iterator<T,T const*,mpl::size_t<NumDims>,const_reference> const_iterator;
|
williamr@2
|
306 |
|
williamr@2
|
307 |
typedef ::boost::reverse_iterator<iterator> reverse_iterator;
|
williamr@2
|
308 |
typedef ::boost::reverse_iterator<const_iterator> const_reverse_iterator;
|
williamr@2
|
309 |
|
williamr@2
|
310 |
BOOST_STATIC_CONSTANT(std::size_t, dimensionality = NumDims);
|
williamr@2
|
311 |
protected:
|
williamr@2
|
312 |
|
williamr@2
|
313 |
multi_array_impl_base() { }
|
williamr@2
|
314 |
~multi_array_impl_base() { }
|
williamr@2
|
315 |
|
williamr@2
|
316 |
// Used by operator() in our array classes
|
williamr@2
|
317 |
template <typename Reference, typename IndexList, typename TPtr>
|
williamr@2
|
318 |
Reference access_element(boost::type<Reference>,
|
williamr@2
|
319 |
const IndexList& indices,
|
williamr@2
|
320 |
TPtr base,
|
williamr@2
|
321 |
const size_type* extents,
|
williamr@2
|
322 |
const index* strides,
|
williamr@2
|
323 |
const index* index_bases) const {
|
williamr@2
|
324 |
|
williamr@2
|
325 |
ignore_unused_variable_warning(index_bases);
|
williamr@2
|
326 |
ignore_unused_variable_warning(extents);
|
williamr@2
|
327 |
#if !defined(NDEBUG) && !defined(BOOST_DISABLE_ASSERTS)
|
williamr@2
|
328 |
for (size_type i = 0; i != NumDims; ++i) {
|
williamr@2
|
329 |
BOOST_ASSERT(indices[i] - index_bases[i] >= 0);
|
williamr@2
|
330 |
BOOST_ASSERT(size_type(indices[i] - index_bases[i]) < extents[i]);
|
williamr@2
|
331 |
}
|
williamr@2
|
332 |
#endif
|
williamr@2
|
333 |
|
williamr@2
|
334 |
index offset = 0;
|
williamr@2
|
335 |
for (size_type n = 0; n != NumDims; ++n)
|
williamr@2
|
336 |
offset += indices[n] * strides[n];
|
williamr@2
|
337 |
|
williamr@2
|
338 |
return base[offset];
|
williamr@2
|
339 |
}
|
williamr@2
|
340 |
|
williamr@2
|
341 |
template <typename StrideList, typename ExtentList>
|
williamr@2
|
342 |
void compute_strides(StrideList& stride_list, ExtentList& extent_list,
|
williamr@2
|
343 |
const general_storage_order<NumDims>& storage)
|
williamr@2
|
344 |
{
|
williamr@2
|
345 |
// invariant: stride = the stride for dimension n
|
williamr@2
|
346 |
index stride = 1;
|
williamr@2
|
347 |
for (size_type n = 0; n != NumDims; ++n) {
|
williamr@2
|
348 |
index stride_sign = +1;
|
williamr@2
|
349 |
|
williamr@2
|
350 |
if (!storage.ascending(storage.ordering(n)))
|
williamr@2
|
351 |
stride_sign = -1;
|
williamr@2
|
352 |
|
williamr@2
|
353 |
// The stride for this dimension is the product of the
|
williamr@2
|
354 |
// lengths of the ranks minor to it.
|
williamr@2
|
355 |
stride_list[storage.ordering(n)] = stride * stride_sign;
|
williamr@2
|
356 |
|
williamr@2
|
357 |
stride *= extent_list[storage.ordering(n)];
|
williamr@2
|
358 |
}
|
williamr@2
|
359 |
}
|
williamr@2
|
360 |
|
williamr@2
|
361 |
// This calculates the offset to the array base pointer due to:
|
williamr@2
|
362 |
// 1. dimensions stored in descending order
|
williamr@2
|
363 |
// 2. non-zero dimension index bases
|
williamr@2
|
364 |
template <typename StrideList, typename ExtentList, typename BaseList>
|
williamr@2
|
365 |
index
|
williamr@2
|
366 |
calculate_origin_offset(const StrideList& stride_list,
|
williamr@2
|
367 |
const ExtentList& extent_list,
|
williamr@2
|
368 |
const general_storage_order<NumDims>& storage,
|
williamr@2
|
369 |
const BaseList& index_base_list)
|
williamr@2
|
370 |
{
|
williamr@2
|
371 |
return
|
williamr@2
|
372 |
calculate_descending_dimension_offset(stride_list,extent_list,
|
williamr@2
|
373 |
storage) +
|
williamr@2
|
374 |
calculate_indexing_offset(stride_list,index_base_list);
|
williamr@2
|
375 |
}
|
williamr@2
|
376 |
|
williamr@2
|
377 |
// This calculates the offset added to the base pointer that are
|
williamr@2
|
378 |
// caused by descending dimensions
|
williamr@2
|
379 |
template <typename StrideList, typename ExtentList>
|
williamr@2
|
380 |
index
|
williamr@2
|
381 |
calculate_descending_dimension_offset(const StrideList& stride_list,
|
williamr@2
|
382 |
const ExtentList& extent_list,
|
williamr@2
|
383 |
const general_storage_order<NumDims>& storage)
|
williamr@2
|
384 |
{
|
williamr@2
|
385 |
index offset = 0;
|
williamr@2
|
386 |
if (!storage.all_dims_ascending())
|
williamr@2
|
387 |
for (size_type n = 0; n != NumDims; ++n)
|
williamr@2
|
388 |
if (!storage.ascending(n))
|
williamr@2
|
389 |
offset -= (extent_list[n] - 1) * stride_list[n];
|
williamr@2
|
390 |
|
williamr@2
|
391 |
return offset;
|
williamr@2
|
392 |
}
|
williamr@2
|
393 |
|
williamr@2
|
394 |
// This is used to reindex array_views, which are no longer
|
williamr@2
|
395 |
// concerned about storage order (specifically, whether dimensions
|
williamr@2
|
396 |
// are ascending or descending) since the viewed array handled it.
|
williamr@2
|
397 |
|
williamr@2
|
398 |
template <typename StrideList, typename BaseList>
|
williamr@2
|
399 |
index
|
williamr@2
|
400 |
calculate_indexing_offset(const StrideList& stride_list,
|
williamr@2
|
401 |
const BaseList& index_base_list)
|
williamr@2
|
402 |
{
|
williamr@2
|
403 |
index offset = 0;
|
williamr@2
|
404 |
for (size_type n = 0; n != NumDims; ++n)
|
williamr@2
|
405 |
offset -= stride_list[n] * index_base_list[n];
|
williamr@2
|
406 |
return offset;
|
williamr@2
|
407 |
}
|
williamr@2
|
408 |
|
williamr@2
|
409 |
// Slicing using an index_gen.
|
williamr@2
|
410 |
// Note that populating an index_gen creates a type that encodes
|
williamr@2
|
411 |
// both the number of dimensions in the current Array (NumDims), and
|
williamr@2
|
412 |
// the Number of dimensions for the resulting view. This allows the
|
williamr@2
|
413 |
// compiler to fail if the dimensions aren't completely accounted
|
williamr@2
|
414 |
// for. For reasons unbeknownst to me, a BOOST_STATIC_ASSERT
|
williamr@2
|
415 |
// within the member function template does not work. I should add a
|
williamr@2
|
416 |
// note to the documentation specifying that you get a damn ugly
|
williamr@2
|
417 |
// error message if you screw up in your slicing code.
|
williamr@2
|
418 |
template <typename ArrayRef, int NDims, typename TPtr>
|
williamr@2
|
419 |
ArrayRef
|
williamr@2
|
420 |
generate_array_view(boost::type<ArrayRef>,
|
williamr@2
|
421 |
const boost::detail::multi_array::
|
williamr@2
|
422 |
index_gen<NumDims,NDims>& indices,
|
williamr@2
|
423 |
const size_type* extents,
|
williamr@2
|
424 |
const index* strides,
|
williamr@2
|
425 |
const index* index_bases,
|
williamr@2
|
426 |
TPtr base) const {
|
williamr@2
|
427 |
|
williamr@2
|
428 |
boost::array<index,NDims> new_strides;
|
williamr@2
|
429 |
boost::array<index,NDims> new_extents;
|
williamr@2
|
430 |
|
williamr@2
|
431 |
index offset = 0;
|
williamr@2
|
432 |
size_type dim = 0;
|
williamr@2
|
433 |
for (size_type n = 0; n != NumDims; ++n) {
|
williamr@2
|
434 |
const index default_start = index_bases[n];
|
williamr@2
|
435 |
const index default_finish = default_start+extents[n];
|
williamr@2
|
436 |
const index_range& current_range = indices.ranges_[n];
|
williamr@2
|
437 |
index start = current_range.get_start(default_start);
|
williamr@2
|
438 |
index finish = current_range.get_finish(default_finish);
|
williamr@2
|
439 |
index index_factor = current_range.stride();
|
williamr@2
|
440 |
index len = (finish - start + (index_factor - 1)) / index_factor;
|
williamr@2
|
441 |
|
williamr@2
|
442 |
BOOST_ASSERT(index_bases[n] <= start &&
|
williamr@2
|
443 |
start <= index_bases[n]+index(extents[n]));
|
williamr@2
|
444 |
BOOST_ASSERT(index_bases[n] <= finish &&
|
williamr@2
|
445 |
finish <= index_bases[n]+index(extents[n]));
|
williamr@2
|
446 |
BOOST_ASSERT(index_factor > 0);
|
williamr@2
|
447 |
|
williamr@2
|
448 |
// the array data pointer is modified to account for non-zero
|
williamr@2
|
449 |
// bases during slicing (see [Garcia] for the math involved)
|
williamr@2
|
450 |
offset += start * strides[n];
|
williamr@2
|
451 |
|
williamr@2
|
452 |
if (!current_range.is_degenerate()) {
|
williamr@2
|
453 |
|
williamr@2
|
454 |
// The index_factor for each dimension is included into the
|
williamr@2
|
455 |
// strides for the array_view (see [Garcia] for the math involved).
|
williamr@2
|
456 |
new_strides[dim] = index_factor * strides[n];
|
williamr@2
|
457 |
|
williamr@2
|
458 |
// calculate new extents
|
williamr@2
|
459 |
new_extents[dim] = len;
|
williamr@2
|
460 |
++dim;
|
williamr@2
|
461 |
}
|
williamr@2
|
462 |
}
|
williamr@2
|
463 |
BOOST_ASSERT(dim == NDims);
|
williamr@2
|
464 |
|
williamr@2
|
465 |
return
|
williamr@2
|
466 |
ArrayRef(base+offset,
|
williamr@2
|
467 |
new_extents,
|
williamr@2
|
468 |
new_strides);
|
williamr@2
|
469 |
}
|
williamr@2
|
470 |
|
williamr@2
|
471 |
|
williamr@2
|
472 |
};
|
williamr@2
|
473 |
|
williamr@2
|
474 |
} // namespace multi_array
|
williamr@2
|
475 |
} // namespace detail
|
williamr@2
|
476 |
|
williamr@2
|
477 |
} // namespace boost
|
williamr@2
|
478 |
|
williamr@2
|
479 |
#endif // BASE_RG071801_HPP
|