xtensor
Loading...
Searching...
No Matches
xchunked_view.hpp
1/***************************************************************************
2 * Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht *
3 * Copyright (c) QuantStack *
4 * *
5 * Distributed under the terms of the BSD 3-Clause License. *
6 * *
7 * The full license is in the file LICENSE, distributed with this software. *
8 ****************************************************************************/
9
10#ifndef XTENSOR_CHUNKED_VIEW_HPP
11#define XTENSOR_CHUNKED_VIEW_HPP
12
13#include <xtl/xsequence.hpp>
14
15#include "../chunk/xchunked_array.hpp"
16#include "../containers/xstorage.hpp"
17#include "../views/xstrided_view.hpp"
18
19namespace xt
20{
21
22 template <class E>
23 struct is_chunked_t : detail::chunk_helper<E>::is_chunked
24 {
25 };
26
27 /*****************
28 * xchunked_view *
29 *****************/
30
31 template <class E>
32 class xchunk_iterator;
33
34 template <class E>
35 class xchunked_view
36 {
37 public:
38
39 using self_type = xchunked_view<E>;
40 using expression_type = std::decay_t<E>;
41 using value_type = typename expression_type::value_type;
42 using reference = typename expression_type::reference;
43 using const_reference = typename expression_type::const_reference;
44 using pointer = typename expression_type::pointer;
45 using const_pointer = typename expression_type::const_pointer;
46 using size_type = typename expression_type::size_type;
47 using difference_type = typename expression_type::difference_type;
48 using shape_type = svector<size_type>;
49 using chunk_iterator = xchunk_iterator<self_type>;
50 using const_chunk_iterator = xchunk_iterator<const self_type>;
51
52 template <class OE, class S>
53 xchunked_view(OE&& e, S&& chunk_shape);
54
55 template <class OE>
56 xchunked_view(OE&& e);
57
58 void init();
59
60 template <class OE>
61 typename std::enable_if_t<!is_chunked_t<OE>::value, xchunked_view<E>&> operator=(const OE& e);
62
63 template <class OE>
64 typename std::enable_if_t<is_chunked_t<OE>::value, xchunked_view<E>&> operator=(const OE& e);
65
66 size_type dimension() const noexcept;
67 const shape_type& shape() const noexcept;
68 const shape_type& chunk_shape() const noexcept;
69 size_type grid_size() const noexcept;
70 const shape_type& grid_shape() const noexcept;
71
72 expression_type& expression() noexcept;
73 const expression_type& expression() const noexcept;
74
75 chunk_iterator chunk_begin();
76 chunk_iterator chunk_end();
77
78 const_chunk_iterator chunk_begin() const;
79 const_chunk_iterator chunk_end() const;
80 const_chunk_iterator chunk_cbegin() const;
81 const_chunk_iterator chunk_cend() const;
82
83 private:
84
85 E m_expression;
86 shape_type m_shape;
87 shape_type m_chunk_shape;
88 shape_type m_grid_shape;
89 size_type m_chunk_nb;
90 };
91
92 template <class E, class S>
93 xchunked_view<E> as_chunked(E&& e, S&& chunk_shape);
94
95 /********************************
96 * xchunked_view implementation *
97 ********************************/
98
99 template <class E>
100 template <class OE, class S>
101 inline xchunked_view<E>::xchunked_view(OE&& e, S&& chunk_shape)
102 : m_expression(std::forward<OE>(e))
103 , m_chunk_shape(xtl::forward_sequence<shape_type, S>(chunk_shape))
104 {
105 m_shape.resize(e.dimension());
106 const auto& s = e.shape();
107 std::copy(s.cbegin(), s.cend(), m_shape.begin());
108 init();
109 }
110
111 template <class E>
112 template <class OE>
113 inline xchunked_view<E>::xchunked_view(OE&& e)
114 : m_expression(std::forward<OE>(e))
115 {
116 m_shape.resize(e.dimension());
117 const auto& s = e.shape();
118 std::copy(s.cbegin(), s.cend(), m_shape.begin());
119 }
120
121 template <class E>
122 void xchunked_view<E>::init()
123 {
124 // compute chunk number in each dimension
125 m_grid_shape.resize(m_shape.size());
126 std::transform(
127 m_shape.cbegin(),
128 m_shape.cend(),
129 m_chunk_shape.cbegin(),
130 m_grid_shape.begin(),
131 [](auto s, auto cs)
132 {
133 std::size_t cn = s / cs;
134 if (s % cs > 0)
135 {
136 cn++; // edge_chunk
137 }
138 return cn;
139 }
140 );
141 m_chunk_nb = std::accumulate(
142 std::begin(m_grid_shape),
143 std::end(m_grid_shape),
144 std::size_t(1),
145 std::multiplies<>()
146 );
147 }
148
149 template <class E>
150 template <class OE>
151 typename std::enable_if_t<!is_chunked_t<OE>::value, xchunked_view<E>&>
152 xchunked_view<E>::operator=(const OE& e)
153 {
154 auto end = chunk_end();
155 for (auto it = chunk_begin(); it != end; ++it)
156 {
157 auto el = *it;
158 noalias(el) = strided_view(e, it.get_slice_vector());
159 }
160 return *this;
161 }
162
163 template <class E>
164 template <class OE>
165 typename std::enable_if_t<is_chunked_t<OE>::value, xchunked_view<E>&>
166 xchunked_view<E>::operator=(const OE& e)
167 {
168 m_chunk_shape.resize(e.dimension());
169 const auto& cs = e.chunk_shape();
170 std::copy(cs.cbegin(), cs.cend(), m_chunk_shape.begin());
171 init();
172 auto it2 = e.chunks().begin();
173 auto end1 = chunk_end();
174 for (auto it1 = chunk_begin(); it1 != end1; ++it1, ++it2)
175 {
176 auto el1 = *it1;
177 auto el2 = *it2;
178 auto lhs_shape = el1.shape();
179 if (lhs_shape != el2.shape())
180 {
181 xstrided_slice_vector esv(el2.dimension()); // element slice in edge chunk
182 std::transform(
183 lhs_shape.begin(),
184 lhs_shape.end(),
185 esv.begin(),
186 [](auto size)
187 {
188 return range(0, size);
189 }
190 );
191 noalias(el1) = strided_view(el2, esv);
192 }
193 else
194 {
195 noalias(el1) = el2;
196 }
197 }
198 return *this;
199 }
200
201 template <class E>
202 inline auto xchunked_view<E>::dimension() const noexcept -> size_type
203 {
204 return m_shape.size();
205 }
206
207 template <class E>
208 inline auto xchunked_view<E>::shape() const noexcept -> const shape_type&
209 {
210 return m_shape;
211 }
212
213 template <class E>
214 inline auto xchunked_view<E>::chunk_shape() const noexcept -> const shape_type&
215 {
216 return m_chunk_shape;
217 }
218
219 template <class E>
220 inline auto xchunked_view<E>::grid_size() const noexcept -> size_type
221 {
222 return m_chunk_nb;
223 }
224
225 template <class E>
226 inline auto xchunked_view<E>::grid_shape() const noexcept -> const shape_type&
227 {
228 return m_grid_shape;
229 }
230
231 template <class E>
232 inline auto xchunked_view<E>::expression() noexcept -> expression_type&
233 {
234 return m_expression;
235 }
236
237 template <class E>
238 inline auto xchunked_view<E>::expression() const noexcept -> const expression_type&
239 {
240 return m_expression;
241 }
242
243 template <class E>
244 inline auto xchunked_view<E>::chunk_begin() -> chunk_iterator
245 {
246 shape_type chunk_index(m_shape.size(), size_type(0));
247 return chunk_iterator(*this, std::move(chunk_index), 0u);
248 }
249
250 template <class E>
251 inline auto xchunked_view<E>::chunk_end() -> chunk_iterator
252 {
253 return chunk_iterator(*this, shape_type(grid_shape()), grid_size());
254 }
255
256 template <class E>
257 inline auto xchunked_view<E>::chunk_begin() const -> const_chunk_iterator
258 {
259 shape_type chunk_index(m_shape.size(), size_type(0));
260 return const_chunk_iterator(*this, std::move(chunk_index), 0u);
261 }
262
263 template <class E>
264 inline auto xchunked_view<E>::chunk_end() const -> const_chunk_iterator
265 {
266 return const_chunk_iterator(*this, shape_type(grid_shape()), grid_size());
267 }
268
269 template <class E>
270 inline auto xchunked_view<E>::chunk_cbegin() const -> const_chunk_iterator
271 {
272 return chunk_begin();
273 }
274
275 template <class E>
276 inline auto xchunked_view<E>::chunk_cend() const -> const_chunk_iterator
277 {
278 return chunk_end();
279 }
280
281 template <class E, class S>
282 inline xchunked_view<E> as_chunked(E&& e, S&& chunk_shape)
283 {
284 return xchunked_view<E>(std::forward<E>(e), std::forward<S>(chunk_shape));
285 }
286
287 template <class E>
288 inline xchunked_view<E> as_chunked(E&& e)
289 {
290 return xchunked_view<E>(std::forward<E>(e));
291 }
292}
293
294#endif
standard mathematical functions for xexpressions
std::vector< xstrided_slice< std::ptrdiff_t > > xstrided_slice_vector
vector of slices used to build a xstrided_view
auto strided_view(E &&e, S &&shape, X &&stride, std::size_t offset=0, layout_type layout=L) noexcept
Construct a strided view from an xexpression, shape, strides and offset.