xtensor
Loading...
Searching...
No Matches
xassign_proxy.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_ASSIGN_PROXY_HPP
11#define XTENSOR_ASSIGN_PROXY_HPP
12
13#include <concepts>
14
15#include "../core/xexpression.hpp"
16
17namespace xt
18{
19 /*****************
20 * assign_policy *
21 *****************/
22
23 struct alias_tag
24 {
25 };
26
28 {
29 };
30
32 {
33 };
34
36 {
37 };
38
40 {
41 };
42
44 {
45 };
46
47 struct tbb_tag
48 {
49 };
50
52 {
53 };
54
55 template <class A>
56 concept aliasing_policy = std::same_as<A, alias_tag> or std::same_as<A, noalias_tag>;
57
58 template <class A>
59 concept broadcasting_policy = std::same_as<A, broadcast_tag> or std::same_as<A, nobroadcast_tag>;
60
61 template <class A>
62 concept parallel_policy = std::same_as<A, default_parallel_tag> or std::same_as<A, noparallel_tag>
63 or std::same_as<A, tbb_tag> or std::same_as<A, openmp_tag>;
64
65 template <aliasing_policy A1, aliasing_policy A2>
66 constexpr auto operator|(A1, A2) noexcept;
67
68 template <broadcasting_policy B1, broadcasting_policy B2>
69 constexpr auto operator|(B1, B2) noexcept;
70
71 template <parallel_policy P1, parallel_policy P2>
72 constexpr auto operator|(P1, P2) noexcept;
73
74 template <aliasing_policy A = alias_tag, broadcasting_policy B = broadcast_tag, parallel_policy P = default_parallel_tag>
76 {
77 using aliasing = A;
78 using broadcasting = B;
79 using parallelism = P;
80
81 template <class AT>
82 auto operator()(AT&& arr) const noexcept;
83 };
84
85 template <aliasing_policy A1, broadcasting_policy B1, parallel_policy P1, aliasing_policy A2, broadcasting_policy B2, parallel_policy P2>
86 constexpr auto operator|(assign_policy<A1, B1, P1>, assign_policy<A2, B2, P2>) noexcept;
87
88 inline constexpr assign_policy<> default_assign{};
89 inline constexpr assign_policy<noalias_tag> noalias{};
90 inline constexpr assign_policy<alias_tag, nobroadcast_tag> nobroadcast{};
94
95 template <class P>
96 concept has_aliasing = std::same_as<typename P::aliasing, alias_tag>;
97
98 template <class P>
99 concept has_broadcasting = std::same_as<typename P::broadcasting, broadcast_tag>;
100
101 /****************
102 * assign_proxy *
103 ****************/
104
105 template <class A, class P>
106 class xassign_proxy
107 {
108 public:
109
110 xassign_proxy(A a) noexcept;
111
112 template <class E>
113 disable_xexpression<E, A> operator=(const E&);
114
115 template <class E>
116 disable_xexpression<E, A> operator+=(const E&);
117
118 template <class E>
119 disable_xexpression<E, A> operator-=(const E&);
120
121 template <class E>
122 disable_xexpression<E, A> operator*=(const E&);
123
124 template <class E>
125 disable_xexpression<E, A> operator/=(const E&);
126
127 template <class E>
128 disable_xexpression<E, A> operator%=(const E&);
129
130 template <class E>
131 disable_xexpression<E, A> operator&=(const E&);
132
133 template <class E>
134 disable_xexpression<E, A> operator|=(const E&);
135
136 template <class E>
137 disable_xexpression<E, A> operator^=(const E&);
138
139 template <class E>
140 A operator=(const xexpression<E>&);
141
142 template <class E>
143 A operator+=(const xexpression<E>&);
144
145 template <class E>
146 A operator-=(const xexpression<E>& e);
147
148 template <class E>
149 A operator*=(const xexpression<E>& e);
150
151 template <class E>
152 A operator/=(const xexpression<E>& e);
153
154 template <class E>
155 A operator%=(const xexpression<E>& e);
156
157 template <class E>
158 A operator&=(const xexpression<E>&);
159
160 template <class E>
161 A operator|=(const xexpression<E>&);
162
163 template <class E>
164 A operator^=(const xexpression<E>&);
165
166 private:
167
168 A m_array;
169 };
170
171 /********************************
172 * assign_policy implementation *
173 ********************************/
174
175 template <aliasing_policy A1, aliasing_policy A2>
176 constexpr auto operator|(A1, A2) noexcept
177 {
178 if constexpr (std::same_as<A1, alias_tag>)
179 {
180 return A2{};
181 }
182 else
183 {
184 return A1{};
185 }
186 }
187
188 template <broadcasting_policy B1, broadcasting_policy B2>
189 constexpr auto operator|(B1, B2) noexcept
190 {
191 if constexpr (std::same_as<B1, broadcast_tag>)
192 {
193 return B2{};
194 }
195 else
196 {
197 return B1{};
198 }
199 }
200
201 template <parallel_policy P1, parallel_policy P2>
202 constexpr auto operator|(P1, P2) noexcept
203 {
204 if constexpr (std::same_as<P1, default_parallel_tag>)
205 {
206 return P2{};
207 }
208 else
209 {
210 return P1{};
211 }
212 }
213
214 template <aliasing_policy A, broadcasting_policy B, parallel_policy P>
215 template <class AT>
216 inline auto assign_policy<A, B, P>::operator()(AT&& arr) const noexcept
217 {
218 return xassign_proxy<xtl::closure_type_t<AT>, assign_policy>{std::forward<AT>(arr)};
219 }
220
221 template <aliasing_policy A1, broadcasting_policy B1, parallel_policy P1, aliasing_policy A2, broadcasting_policy B2, parallel_policy P2>
222 constexpr auto operator|(assign_policy<A1, B1, P1>, assign_policy<A2, B2, P2>) noexcept
223 {
224 return assign_policy<
225 decltype(std::declval<A1>() | std::declval<A2>()),
226 decltype(std::declval<B1>() | std::declval<B2>()),
227 decltype(std::declval<P1>() | std::declval<P2>())>{};
228 }
229
230 /*******************************
231 * assign_proxy implementation *
232 *******************************/
233
234 template <class A, class P>
235 inline xassign_proxy<A, P>::xassign_proxy(A a) noexcept
236 : m_array(std::forward<A>(a))
237 {
238 }
239
240 template <class A, class P>
241 template <class E>
242 inline auto xassign_proxy<A, P>::operator=(const E& e) -> disable_xexpression<E, A>
243 {
244 return m_array.assign(xscalar<E>(e), P{});
245 }
246
247 template <class A, class P>
248 template <class E>
249 inline auto xassign_proxy<A, P>::operator+=(const E& e) -> disable_xexpression<E, A>
250 {
251 return m_array.scalar_computed_assign(e, std::plus<>{}, P{});
252 }
253
254 template <class A, class P>
255 template <class E>
256 inline auto xassign_proxy<A, P>::operator-=(const E& e) -> disable_xexpression<E, A>
257 {
258 return m_array.scalar_computed_assign(e, std::minus<>{}, P{});
259 }
260
261 template <class A, class P>
262 template <class E>
263 inline auto xassign_proxy<A, P>::operator*=(const E& e) -> disable_xexpression<E, A>
264 {
265 return m_array.scalar_computed_assign(e, std::multiplies<>{}, P{});
266 }
267
268 template <class A, class P>
269 template <class E>
270 inline auto xassign_proxy<A, P>::operator/=(const E& e) -> disable_xexpression<E, A>
271 {
272 return m_array.scalar_computed_assign(e, std::divides<>{}, P{});
273 }
274
275 template <class A, class P>
276 template <class E>
277 inline auto xassign_proxy<A, P>::operator%=(const E& e) -> disable_xexpression<E, A>
278 {
279 return m_array.scalar_computed_assign(e, std::modulus<>{}, P{});
280 }
281
282 template <class A, class P>
283 template <class E>
284 inline auto xassign_proxy<A, P>::operator&=(const E& e) -> disable_xexpression<E, A>
285 {
286 return m_array.scalar_computed_assign(e, std::bit_and<>{}, P{});
287 }
288
289 template <class A, class P>
290 template <class E>
291 inline auto xassign_proxy<A, P>::operator|=(const E& e) -> disable_xexpression<E, A>
292 {
293 return m_array.scalar_computed_assign(e, std::bit_or<>{}, P{});
294 }
295
296 template <class A, class P>
297 template <class E>
298 inline auto xassign_proxy<A, P>::operator^=(const E& e) -> disable_xexpression<E, A>
299 {
300 return m_array.scalar_computed_assign(e, std::bit_xor<>{}, P{});
301 }
302
303 template <class A, class P>
304 template <class E>
305 A xassign_proxy<A, P>::operator=(const xexpression<E>& e)
306 {
307 return m_array.assign(e, P{});
308 }
309
310 template <class A, class P>
311 template <class E>
312 A xassign_proxy<A, P>::operator+=(const xexpression<E>& e)
313 {
314 return m_array.plus_assign(e, P{});
315 }
316
317 template <class A, class P>
318 template <class E>
319 A xassign_proxy<A, P>::operator-=(const xexpression<E>& e)
320 {
321 return m_array.minus_assign(e, P{});
322 }
323
324 template <class A, class P>
325 template <class E>
326 A xassign_proxy<A, P>::operator*=(const xexpression<E>& e)
327 {
328 return m_array.multiplies_assign(e, P{});
329 }
330
331 template <class A, class P>
332 template <class E>
333 A xassign_proxy<A, P>::operator/=(const xexpression<E>& e)
334 {
335 return m_array.divides_assign(e, P{});
336 }
337
338 template <class A, class P>
339 template <class E>
340 A xassign_proxy<A, P>::operator%=(const xexpression<E>& e)
341 {
342 return m_array.modulus_assign(e, P{});
343 }
344
345 template <class A, class P>
346 template <class E>
347 A xassign_proxy<A, P>::operator&=(const xexpression<E>& e)
348 {
349 return m_array.bit_and_assign(e, P{});
350 }
351
352 template <class A, class P>
353 template <class E>
354 A xassign_proxy<A, P>::operator|=(const xexpression<E>& e)
355 {
356 return m_array.bit_or_assign(e, P{});
357 }
358
359 template <class A, class P>
360 template <class E>
361 A xassign_proxy<A, P>::operator^=(const xexpression<E>& e)
362 {
363 return m_array.bit_xor_assign(e, P{});
364 }
365}
366
367#endif
Base class for xexpressions.
standard mathematical functions for xexpressions