10#ifndef XTENSOR_ASSIGN_PROXY_HPP
11#define XTENSOR_ASSIGN_PROXY_HPP
15#include "../core/xexpression.hpp"
56 concept aliasing_policy = std::same_as<A, alias_tag> or std::same_as<A, noalias_tag>;
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>;
65 template <aliasing_policy A1, aliasing_policy A2>
66 constexpr auto operator|(A1, A2)
noexcept;
68 template <broadcasting_policy B1, broadcasting_policy B2>
69 constexpr auto operator|(B1, B2)
noexcept;
71 template <parallel_policy P1, parallel_policy P2>
72 constexpr auto operator|(P1, P2)
noexcept;
74 template <aliasing_policy A = alias_tag, broadcasting_policy B = broadcast_tag, parallel_policy P = default_parallel_tag>
78 using broadcasting = B;
79 using parallelism = P;
82 auto operator()(AT&& arr)
const noexcept;
85 template <aliasing_policy A1, broadcasting_policy B1, parallel_policy P1, aliasing_policy A2, broadcasting_policy B2, parallel_policy P2>
89 inline constexpr assign_policy<noalias_tag> noalias{};
96 concept has_aliasing = std::same_as<typename P::aliasing, alias_tag>;
105 template <
class A,
class P>
110 xassign_proxy(A a)
noexcept;
113 disable_xexpression<E, A> operator=(
const E&);
116 disable_xexpression<E, A> operator+=(
const E&);
119 disable_xexpression<E, A> operator-=(
const E&);
122 disable_xexpression<E, A> operator*=(
const E&);
125 disable_xexpression<E, A> operator/=(
const E&);
128 disable_xexpression<E, A> operator%=(
const E&);
131 disable_xexpression<E, A> operator&=(
const E&);
134 disable_xexpression<E, A> operator|=(
const E&);
137 disable_xexpression<E, A> operator^=(
const E&);
175 template <aliasing_policy A1, aliasing_policy A2>
176 constexpr auto operator|(A1, A2)
noexcept
178 if constexpr (std::same_as<A1, alias_tag>)
188 template <broadcasting_policy B1, broadcasting_policy B2>
189 constexpr auto operator|(B1, B2)
noexcept
191 if constexpr (std::same_as<B1, broadcast_tag>)
201 template <parallel_policy P1, parallel_policy P2>
202 constexpr auto operator|(P1, P2)
noexcept
204 if constexpr (std::same_as<P1, default_parallel_tag>)
214 template <aliasing_policy A, broadcasting_policy B, parallel_policy P>
216 inline auto assign_policy<A, B, P>::operator()(AT&& arr)
const noexcept
221 template <aliasing_policy A1, broadcasting_policy B1, parallel_policy P1, aliasing_policy A2, broadcasting_policy B2, parallel_policy P2>
225 decltype(std::declval<A1>() | std::declval<A2>()),
226 decltype(std::declval<B1>() | std::declval<B2>()),
227 decltype(std::declval<P1>() | std::declval<P2>())>{};
234 template <
class A,
class P>
235 inline xassign_proxy<A, P>::xassign_proxy(A a) noexcept
236 : m_array(std::forward<A>(a))
240 template <
class A,
class P>
242 inline auto xassign_proxy<A, P>::operator=(
const E& e) -> disable_xexpression<E, A>
247 template <
class A,
class P>
249 inline auto xassign_proxy<A, P>::operator+=(
const E& e) -> disable_xexpression<E, A>
251 return m_array.scalar_computed_assign(e, std::plus<>{}, P{});
254 template <
class A,
class P>
256 inline auto xassign_proxy<A, P>::operator-=(
const E& e) -> disable_xexpression<E, A>
258 return m_array.scalar_computed_assign(e, std::minus<>{}, P{});
261 template <
class A,
class P>
263 inline auto xassign_proxy<A, P>::operator*=(
const E& e) -> disable_xexpression<E, A>
265 return m_array.scalar_computed_assign(e, std::multiplies<>{}, P{});
268 template <
class A,
class P>
270 inline auto xassign_proxy<A, P>::operator/=(
const E& e) -> disable_xexpression<E, A>
272 return m_array.scalar_computed_assign(e, std::divides<>{}, P{});
275 template <
class A,
class P>
277 inline auto xassign_proxy<A, P>::operator%=(
const E& e) -> disable_xexpression<E, A>
279 return m_array.scalar_computed_assign(e, std::modulus<>{}, P{});
282 template <
class A,
class P>
284 inline auto xassign_proxy<A, P>::operator&=(
const E& e) -> disable_xexpression<E, A>
286 return m_array.scalar_computed_assign(e, std::bit_and<>{}, P{});
289 template <
class A,
class P>
291 inline auto xassign_proxy<A, P>::operator|=(
const E& e) -> disable_xexpression<E, A>
293 return m_array.scalar_computed_assign(e, std::bit_or<>{}, P{});
296 template <
class A,
class P>
298 inline auto xassign_proxy<A, P>::operator^=(
const E& e) -> disable_xexpression<E, A>
300 return m_array.scalar_computed_assign(e, std::bit_xor<>{}, P{});
303 template <
class A,
class P>
307 return m_array.assign(e, P{});
310 template <
class A,
class P>
314 return m_array.plus_assign(e, P{});
317 template <
class A,
class P>
321 return m_array.minus_assign(e, P{});
324 template <
class A,
class P>
328 return m_array.multiplies_assign(e, P{});
331 template <
class A,
class P>
335 return m_array.divides_assign(e, P{});
338 template <
class A,
class P>
342 return m_array.modulus_assign(e, P{});
345 template <
class A,
class P>
349 return m_array.bit_and_assign(e, P{});
352 template <
class A,
class P>
356 return m_array.bit_or_assign(e, P{});
359 template <
class A,
class P>
363 return m_array.bit_xor_assign(e, P{});
Base class for xexpressions.
standard mathematical functions for xexpressions