1///////////////////////////////////////////////////////////////////////////////
2// Copyright 2011 John Maddock. Distributed under the Boost
3// Software License, Version 1.0. (See accompanying file
4// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6#ifndef BOOST_MP_ET_OPS_HPP
7#define BOOST_MP_ET_OPS_HPP
8
9namespace boost { namespace multiprecision {
10
11//
12// Non-member operators for number which return expression templates.
13//
14// Note that operators taking rvalue-references DO NOT return expression templates
15// as this can lead to dangling references, see https://github.com/boostorg/multiprecision/issues/175.
16//
17// Unary operators first.
18// Note that these *must* return by value, even though that's somewhat against
19// existing practice. The issue is that in C++11 land one could easily and legitimately
20// write:
21// auto x = +1234_my_user_defined_suffix;
22// which would result in a dangling-reference-to-temporary if unary + returned a reference
23// to it's argument. While return-by-value is obviously inefficient in other situations
24// the reality is that no one ever uses unary operator+ anyway...!
25//
26template <class B, expression_template_option ExpressionTemplates>
27inline constexpr const number<B, ExpressionTemplates> operator+(const number<B, ExpressionTemplates>& v) { return v; }
28template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
29inline constexpr const detail::expression<tag, Arg1, Arg2, Arg3, Arg4> operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return v; }
30template <class B>
31inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, number<B, et_on> > operator-(const number<B, et_on>& v)
32{
33 static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
34 return detail::expression<detail::negate, number<B, et_on> >(v);
35}
36// rvalue ops:
37template <class B>
38inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on> operator-(number<B, et_on>&& v)
39{
40 static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
41 v.backend().negate();
42 return std::move(v);
43}
44
45template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
46inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v)
47{
48 static_assert((is_signed_number<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value), "Negating an unsigned type results in ill-defined behavior.");
49 return detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v);
50}
51template <class B>
52inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
53 detail::expression<detail::complement_immediates, number<B, et_on> > >::type
54operator~(const number<B, et_on>& v) { return detail::expression<detail::complement_immediates, number<B, et_on> >(v); }
55
56template <class B>
57inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
58 number<B, et_on> >::type
59operator~(number<B, et_on>&& v)
60{
61 using default_ops::eval_complement;
62 eval_complement(v.backend(), v.backend());
63 return std::move(v);
64}
65
66template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
67inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
68 detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
69operator~(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
70//
71// Then addition:
72//
73template <class B>
74inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
75operator+(const number<B, et_on>& a, const number<B, et_on>& b)
76{
77 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
78}
79
80template <class B>
81inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
82operator+(number<B, et_on>&& a, const number<B, et_on>& b)
83{
84 using default_ops::eval_add;
85 eval_add(a.backend(), b.backend());
86 return std::move(a);
87}
88template <class B>
89inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
90operator+(const number<B, et_on>& a, number<B, et_on>&& b)
91{
92 using default_ops::eval_add;
93 eval_add(b.backend(), a.backend());
94 return std::move(b);
95}
96template <class B>
97inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
98operator+(number<B, et_on>&& a, number<B, et_on>&& b)
99{
100 using default_ops::eval_add;
101 eval_add(a.backend(), b.backend());
102 return std::move(a);
103}
104
105template <class B, class V>
106inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::add_immediates, number<B, et_on>, V> >::type
107operator+(const number<B, et_on>& a, const V& b)
108{
109 return detail::expression<detail::add_immediates, number<B, et_on>, V>(a, b);
110}
111
112template <class B, class V>
113inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
114operator+(number<B, et_on>&& a, const V& b)
115{
116 using default_ops::eval_add;
117 eval_add(a.backend(), number<B, et_on>::canonical_value(b));
118 return std::move(a);
119}
120
121template <class V, class B>
122inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
123operator+(const V& a, const number<B, et_on>& b)
124{
125 return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b);
126}
127
128template <class V, class B>
129inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
130operator+(const V& a, number<B, et_on>&& b)
131{
132 using default_ops::eval_add;
133 eval_add(b.backend(), number<B, et_on>::canonical_value(a));
134 return std::move(b);
135}
136
137template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
138inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
139operator+(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
140{
141 return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
142}
143
144template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
145inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
146 std::is_same<typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET> >::value,
147 typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
148operator+(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
149{
150 a += b;
151 return std::move(a);
152}
153template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
154inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
155 !std::is_same<typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET> >::value,
156 typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
157operator+(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
158{
159 return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
160}
161
162template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
163inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
164operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
165{
166 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
167}
168
169template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
170inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
171 std::is_same<typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
172 typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
173operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
174{
175 b += a;
176 return std::move(b);
177}
178template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
179inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
180 !std::is_same<typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
181 typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
182operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
183{
184 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
185}
186
187template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
188inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
189operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
190{
191 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
192}
193template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
194inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
195operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
196{
197 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
198}
199template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
200inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
201operator+(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
202{
203 return detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
204}
205//
206// Fused multiply add:
207//
208template <class V, class Arg1, class Arg2, class Arg3, class Arg4>
209inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
210 detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
211operator+(const V& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
212{
213 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(b.left(), b.right(), a);
214}
215template <class Arg1, class Arg2, class Arg3, class Arg4, class V>
216inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
217 detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
218operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
219{
220 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(a.left(), a.right(), b);
221}
222template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
223inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
224operator+(const number<B, ET>& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
225{
226 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a);
227}
228
229template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
230inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
231 std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
232 typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
233operator+(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
234{
235 a += b;
236 return std::move(a);
237}
238template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
239inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
240 !std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
241 typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
242operator+(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
243{
244 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a);
245}
246
247template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
248inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
249operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
250{
251 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
252}
253
254template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
255inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
256 std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
257 typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
258operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
259{
260 b += a;
261 return std::move(b);
262}
263template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
264inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
265 !std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
266 typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
267operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
268{
269 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
270}
271
272//
273// Fused multiply subtract:
274//
275template <class V, class Arg1, class Arg2, class Arg3, class Arg4>
276inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
277 detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> > >::type
278operator-(const V& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
279{
280 return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(b.left(), b.right(), a));
281}
282template <class Arg1, class Arg2, class Arg3, class Arg4, class V>
283inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
284 detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
285operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
286{
287 return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(a.left(), a.right(), b);
288}
289template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
290inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >
291operator-(const number<B, ET>& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
292{
293 return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a));
294}
295
296template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
297inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
298 std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type, number<B, ET>>::value,
299 typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type>::type
300operator-(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
301{
302 a -= b;
303 return std::move(a);
304}
305template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
306inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
307 !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type, number<B, ET>>::value,
308 typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type>::type
309operator-(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
310{
311 return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a));
312}
313
314template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
315inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
316operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
317{
318 return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
319}
320
321template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
322inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type
323operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
324{
325 return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
326}
327
328//
329// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
330//
331template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
332inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, Arg1>
333operator+(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
334{
335 return detail::expression<detail::minus, number<B, ET>, Arg1>(a, b.left_ref());
336}
337
338template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
339inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
340 std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
341 typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
342operator+(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
343{
344 a -= b.left_ref();
345 return std::move(a);
346}
347template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
348inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
349 !std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
350 typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
351operator+(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
352{
353 return detail::expression<detail::minus, number<B, ET>, Arg1>(a, b.left_ref());
354}
355
356template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
357inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, Arg1>
358operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
359{
360 return detail::expression<detail::minus, number<B, ET>, Arg1>(b, a.left_ref());
361}
362
363template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
364inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
365 std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
366 typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
367operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
368{
369 b -= a.left_ref();
370 return std::move(b);
371}
372template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
373inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
374 !std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
375 typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
376operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
377{
378 return detail::expression<detail::minus, number<B, ET>, Arg1>(b, a.left_ref());
379}
380
381template <class B>
382inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
383operator+(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
384{
385 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
386}
387
388template <class B>
389inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >::result_type
390operator+(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
391{
392 using default_ops::eval_subtract;
393 eval_subtract(a.backend(), b.left_ref().backend());
394 return std::move(a);
395}
396
397template <class B>
398inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
399operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
400{
401 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref());
402}
403
404template <class B>
405inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >::result_type
406operator+(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
407{
408 using default_ops::eval_subtract;
409 eval_subtract(b.backend(), a.left_ref().backend());
410 return std::move(b);
411}
412
413template <class B, class V>
414inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
415operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
416{
417 return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(b, a.left_ref());
418}
419template <class B, class B2, expression_template_option ET>
420inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
421operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
422{
423 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
424}
425
426template <class B, class B2, expression_template_option ET>
427inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
428operator+(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
429{
430 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
431}
432
433template <class B2, expression_template_option ET, class B>
434inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
435operator+(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
436{
437 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
438}
439
440template <class B2, expression_template_option ET, class B>
441inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
442operator+(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
443{
444 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
445}
446
447template <class B>
448inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
449operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const detail::expression<detail::negate, number<B, et_on> >& b)
450{
451 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b.left_ref()));
452}
453//
454// Subtraction:
455//
456template <class B>
457inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
458operator-(const number<B, et_on>& a, const number<B, et_on>& b)
459{
460 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
461}
462
463template <class B>
464inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
465operator-(number<B, et_on>&& a, const number<B, et_on>& b)
466{
467 using default_ops::eval_subtract;
468 eval_subtract(a.backend(), b.backend());
469 return std::move(a);
470}
471template <class B>
472inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
473operator-(const number<B, et_on>& a, number<B, et_on>&& b)
474{
475 using default_ops::eval_subtract;
476 eval_subtract(b.backend(), a.backend());
477 b.backend().negate();
478 return std::move(b);
479}
480template <class B>
481inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
482operator-(number<B, et_on>&& a, number<B, et_on>&& b)
483{
484 using default_ops::eval_subtract;
485 eval_subtract(a.backend(), b.backend());
486 return std::move(a);
487}
488
489template <class B, class V>
490inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, number<B, et_on>, V> >::type
491operator-(const number<B, et_on>& a, const V& b)
492{
493 return detail::expression<detail::subtract_immediates, number<B, et_on>, V>(a, b);
494}
495
496template <class B, class V>
497inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
498operator-(number<B, et_on>&& a, const V& b)
499{
500 using default_ops::eval_subtract;
501 eval_subtract(a.backend(), number<B, et_on>::canonical_value(b));
502 return std::move(a);
503}
504
505template <class V, class B>
506inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
507operator-(const V& a, const number<B, et_on>& b)
508{
509 return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(a, b);
510}
511
512template <class V, class B>
513inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
514operator-(const V& a, number<B, et_on>&& b)
515{
516 using default_ops::eval_subtract;
517 eval_subtract(b.backend(), number<B, et_on>::canonical_value(a));
518 b.backend().negate();
519 return std::move(b);
520}
521
522template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
523inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
524operator-(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
525{
526 return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
527}
528
529template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
530inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
531 std::is_same<typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
532 typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
533operator-(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
534{
535 a -= b;
536 return std::move(a);
537}
538template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
539inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
540 !std::is_same<typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
541 typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
542operator-(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
543{
544 return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
545}
546
547template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
548inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
549operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
550{
551 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
552}
553
554template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
555inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
556 std::is_same<typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
557 typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
558operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
559{
560 b -= a;
561 b.backend().negate();
562 return std::move(b);
563}
564template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
565inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
566 !std::is_same<typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
567 typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
568operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
569{
570 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
571}
572
573template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
574inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
575operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
576{
577 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
578}
579template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
580inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
581operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
582{
583 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
584}
585template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
586inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
587operator-(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
588{
589 return detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
590}
591//
592// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
593//
594template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
595inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, number<B, ET>, Arg1>
596operator-(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
597{
598 return detail::expression<detail::plus, number<B, ET>, Arg1>(a, b.left_ref());
599}
600
601template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
602inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
603 std::is_same<typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
604 typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type>::type
605operator-(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
606{
607 a += b.left_ref();
608 return std::move(a);
609}
610template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
611inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
612 !std::is_same<typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
613 typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type>::type
614operator-(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
615{
616 return detail::expression<detail::plus, number<B, ET>, Arg1>(a, b.left_ref());
617}
618
619template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
620inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >
621operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
622{
623 return detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >(
624 detail::expression<detail::plus, number<B, ET>, Arg1>(b, a.left_ref()));
625}
626
627template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
628inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
629 std::is_same<typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
630 typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type>::type
631operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
632{
633 b += a.left_ref();
634 b.backend().negate();
635 return std::move(b);
636}
637template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
638inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
639 !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
640 typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type>::type
641operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
642{
643 return detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >(detail::expression<detail::plus, number<B, ET>, Arg1>(b, a.left_ref()));
644}
645
646template <class B>
647inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
648operator-(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
649{
650 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
651}
652
653template <class B>
654inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >::result_type
655operator-(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
656{
657 using default_ops::eval_add;
658 eval_add(a.backend(), b.left_ref().backend());
659 return std::move(a);
660}
661
662template <class B>
663inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
664operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
665{
666 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
667 detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
668}
669
670template <class B>
671inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
672 std::is_same<typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
673 typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
674operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
675{
676 using default_ops::eval_add;
677 eval_add(b.backend(), a.left_ref().backend());
678 b.backend().negate();
679 return std::move(b);
680}
681template <class B>
682inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
683 !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
684 typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
685operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
686{
687 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
688 detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
689}
690
691template <class B, class V>
692inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V> > >::type
693operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
694{
695 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V> >(detail::expression<detail::add_immediates, number<B, et_on>, V>(a.left_ref(), b));
696}
697template <class B, class B2, expression_template_option ET>
698inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > > >::type
699operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
700{
701 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
702}
703
704template <class B, class B2, expression_template_option ET>
705inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
706operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
707{
708 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
709}
710
711template <class V, class B>
712inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
713operator-(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
714{
715 return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b.left_ref());
716}
717template <class B2, expression_template_option ET, class B>
718inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> > >::type
719operator-(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
720{
721 return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
722}
723
724template <class B2, expression_template_option ET, class B>
725inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
726operator-(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
727{
728 return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
729}
730
731//
732// Multiplication:
733//
734template <class B>
735inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >
736operator*(const number<B, et_on>& a, const number<B, et_on>& b)
737{
738 return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
739}
740
741template <class B>
742inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
743operator*(number<B, et_on>&& a, const number<B, et_on>& b)
744{
745 using default_ops::eval_multiply;
746 eval_multiply(a.backend(), b.backend());
747 return std::move(a);
748}
749template <class B>
750inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
751operator*(const number<B, et_on>& a, number<B, et_on>&& b)
752{
753 using default_ops::eval_multiply;
754 eval_multiply(b.backend(), a.backend());
755 return std::move(b);
756}
757template <class B>
758inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
759operator*(number<B, et_on>&& a, number<B, et_on>&& b)
760{
761 using default_ops::eval_multiply;
762 eval_multiply(a.backend(), b.backend());
763 return std::move(a);
764}
765
766template <class B, class V>
767inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >::type
768operator*(const number<B, et_on>& a, const V& b)
769{
770 return detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a, b);
771}
772
773template <class B, class V>
774inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
775operator*(number<B, et_on>&& a, const V& b)
776{
777 using default_ops::eval_multiply;
778 eval_multiply(a.backend(), number<B, et_on>::canonical_value(b));
779 return std::move(a);
780}
781
782template <class V, class B>
783inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::multiply_immediates, V, number<B, et_on> > >::type
784operator*(const V& a, const number<B, et_on>& b)
785{
786 return detail::expression<detail::multiply_immediates, V, number<B, et_on> >(a, b);
787}
788
789template <class V, class B>
790inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
791operator*(const V& a, number<B, et_on>&& b)
792{
793 using default_ops::eval_multiply;
794 eval_multiply(b.backend(), number<B, et_on>::canonical_value(a));
795 return std::move(b);
796}
797
798template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
799inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
800operator*(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
801{
802 return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
803}
804
805template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
806inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
807 std::is_same<typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
808 typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
809operator*(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
810{
811 a *= b;
812 return std::move(a);
813}
814template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
815inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
816 !std::is_same<typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
817 typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
818operator*(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
819{
820 return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
821}
822
823template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
824inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
825operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
826{
827 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
828}
829
830template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
831inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
832 std::is_same<typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
833 typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
834operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
835{
836 b *= a;
837 return std::move(b);
838}
839template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
840inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
841 !std::is_same<typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
842 typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
843operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
844{
845 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
846}
847
848template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
849inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
850operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
851{
852 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
853}
854template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
855inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
856operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
857{
858 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
859}
860template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
861inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
862operator*(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
863{
864 return detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
865}
866//
867// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
868//
869template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
870inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >
871operator*(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
872{
873 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
874 detail::expression<detail::multiplies, number<B, ET>, Arg1>(a, b.left_ref()));
875}
876
877template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
878inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >::result_type
879operator*(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
880{
881 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
882 detail::expression<detail::multiplies, number<B, ET>, Arg1>(a, b.left_ref()));
883}
884
885template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
886inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >
887operator*(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
888{
889 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
890 detail::expression<detail::multiplies, number<B, ET>, Arg1>(b, a.left_ref()));
891}
892
893template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
894inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >::result_type
895operator*(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
896{
897 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
898 detail::expression<detail::multiplies, number<B, ET>, Arg1>(b, a.left_ref()));
899}
900
901template <class B>
902inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
903operator*(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
904{
905 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
906 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
907}
908
909template <class B>
910inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
911 std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
912 typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
913operator*(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
914{
915 a *= b.left_ref();
916 a.backend().negate();
917 return std::move(a);
918}
919template <class B>
920inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
921 !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
922 typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
923operator*(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
924{
925 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
926 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
927}
928
929template <class B>
930inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
931operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
932{
933 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
934 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
935}
936
937template <class B>
938inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
939 std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
940 typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
941operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
942{
943 b *= a.left_ref();
944 b.backend().negate();
945 return std::move(b);
946}
947template <class B>
948inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
949 !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
950 typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
951operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
952{
953 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
954 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
955}
956
957template <class B, class V>
958inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> > >::type
959operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
960{
961 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >(
962 detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a.left_ref(), b));
963}
964template <class B, class B2, expression_template_option ET>
965inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
966operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
967{
968 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
969 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
970}
971
972template <class B, class B2, expression_template_option ET>
973inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
974operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
975{
976 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
977 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
978}
979
980template <class V, class B>
981inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> > >::type
982operator*(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
983{
984 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >(
985 detail::expression<detail::multiply_immediates, number<B, et_on>, V>(b.left_ref(), a));
986}
987template <class B2, expression_template_option ET, class B>
988inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
989operator*(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
990{
991 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
992 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
993}
994
995template <class B2, expression_template_option ET, class B>
996inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
997operator*(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
998{
999 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
1000 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
1001}
1002
1003//
1004// Division:
1005//
1006template <class B>
1007inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >
1008operator/(const number<B, et_on>& a, const number<B, et_on>& b)
1009{
1010 return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1011}
1012template <class B>
1013inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
1014operator/(number<B, et_on>&& a, const number<B, et_on>& b)
1015{
1016 using default_ops::eval_divide;
1017 eval_divide(a.backend(), b.backend());
1018 return std::move(a);
1019}
1020template <class B>
1021inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
1022operator/(const number<B, et_on>& a, number<B, et_on>&& b)
1023{
1024 return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1025}
1026template <class B>
1027inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
1028operator/(number<B, et_on>&& a, number<B, et_on>&& b)
1029{
1030 using default_ops::eval_divide;
1031 eval_divide(a.backend(), b.backend());
1032 return std::move(a);
1033}
1034template <class B, class V>
1035inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::divide_immediates, number<B, et_on>, V> >::type
1036operator/(const number<B, et_on>& a, const V& b)
1037{
1038 return detail::expression<detail::divide_immediates, number<B, et_on>, V>(a, b);
1039}
1040template <class B, class V>
1041inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
1042operator/(number<B, et_on>&& a, const V& b)
1043{
1044 using default_ops::eval_divide;
1045 eval_divide(a.backend(), number<B, et_on>::canonical_value(b));
1046 return std::move(a);
1047}
1048template <class V, class B>
1049inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::divide_immediates, V, number<B, et_on> > >::type
1050operator/(const V& a, const number<B, et_on>& b)
1051{
1052 return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
1053}
1054template <class V, class B>
1055inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
1056operator/(const V& a, number<B, et_on>&& b)
1057{
1058 return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
1059}
1060template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1061inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
1062operator/(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1063{
1064 return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1065}
1066template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1067inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1068 std::is_same<typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
1069 typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
1070operator/(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1071{
1072 a /= b;
1073 return std::move(a);
1074}
1075template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1076inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1077 !std::is_same<typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
1078 typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
1079operator/(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1080{
1081 return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1082}
1083template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
1084inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
1085operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
1086{
1087 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
1088}
1089template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
1090inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type
1091operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
1092{
1093 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
1094}
1095template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
1096inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
1097operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
1098{
1099 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
1100}
1101template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
1102inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
1103operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
1104{
1105 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
1106}
1107template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1108inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1109operator/(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1110{
1111 return detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1112}
1113//
1114// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
1115//
1116template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
1117inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >
1118operator/(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
1119{
1120 return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >(
1121 detail::expression<detail::divides, number<B, ET>, Arg1>(a, b.left_ref()));
1122}
1123template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
1124inline typename std::enable_if<
1125 std::is_same<typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
1126 typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type>::type
1127operator/(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
1128{
1129 a /= b.left_ref();
1130 a.backend().negate();
1131 return std::move(a);
1132}
1133template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
1134inline typename std::enable_if<
1135 !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
1136 typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type>::type
1137operator/(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
1138{
1139 return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >(
1140 detail::expression<detail::divides, number<B, ET>, Arg1>(a, b.left_ref()));
1141}
1142template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
1143inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >
1144operator/(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
1145{
1146 return detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >(
1147 detail::expression<detail::divides, Arg1, number<B, ET> >(a.left_ref(), b));
1148}
1149template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
1150inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >::result_type
1151operator/(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
1152{
1153 return detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >(
1154 detail::expression<detail::divides, Arg1, number<B, ET> >(a.left_ref(), b));
1155}
1156template <class B>
1157inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
1158operator/(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
1159{
1160 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
1161 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
1162}
1163template <class B>
1164inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >::result_type
1165operator/(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
1166{
1167 a /= b.left_ref();
1168 a.backend().negate();
1169 return std::move(a);
1170}
1171template <class B>
1172inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
1173operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
1174{
1175 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
1176 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
1177}
1178template <class B>
1179inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >::result_type
1180operator/(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
1181{
1182 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
1183 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
1184}
1185template <class B, class V>
1186inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V> > >::type
1187operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
1188{
1189 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V> >(
1190 detail::expression<detail::divide_immediates, number<B, et_on>, V>(a.left_ref(), b));
1191}
1192template <class B, class B2, expression_template_option ET>
1193inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > > >::type
1194operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
1195{
1196 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
1197 detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
1198}
1199template <class B, class B2, expression_template_option ET>
1200inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
1201operator/(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
1202{
1203 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
1204 detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
1205}
1206template <class V, class B>
1207inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > > >::type
1208operator/(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
1209{
1210 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > >(
1211 detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b.left_ref()));
1212}
1213template <class B2, expression_template_option ET, class B>
1214inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > > >::type
1215operator/(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
1216{
1217 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
1218 detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
1219}
1220template <class B2, expression_template_option ET, class B>
1221inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >::result_type>::value, number<B, et_on> >::type
1222operator/(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
1223{
1224 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
1225 detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
1226}
1227//
1228// Modulus:
1229//
1230template <class B>
1231inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1232 detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> > >::type
1233operator%(const number<B, et_on>& a, const number<B, et_on>& b)
1234{
1235 return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1236}
1237template <class B>
1238inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1239 number<B, et_on> >::type
1240operator%(number<B, et_on>&& a, const number<B, et_on>& b)
1241{
1242 using default_ops::eval_modulus;
1243 eval_modulus(a.backend(), b.backend());
1244 return std::move(a);
1245}
1246template <class B>
1247inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1248 number<B, et_on> >::type
1249operator%(const number<B, et_on>& a, number<B, et_on>&& b)
1250{
1251 return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1252}
1253template <class B>
1254inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1255 number<B, et_on> >::type
1256operator%(number<B, et_on>&& a, number<B, et_on>&& b)
1257{
1258 using default_ops::eval_modulus;
1259 eval_modulus(a.backend(), b.backend());
1260 return std::move(a);
1261}
1262template <class B, class V>
1263inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, number<B, et_on> >::value,
1264 detail::expression<detail::modulus_immediates, number<B, et_on>, V> >::type
1265operator%(const number<B, et_on>& a, const V& b)
1266{
1267 return detail::expression<detail::modulus_immediates, number<B, et_on>, V>(a, b);
1268}
1269template <class B, class V>
1270inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, number<B, et_on> >::value,
1271 number<B, et_on> >::type
1272operator%(number<B, et_on>&& a, const V& b)
1273{
1274 using default_ops::eval_modulus;
1275 eval_modulus(a.backend(), number<B, et_on>::canonical_value(b));
1276 return std::move(a);
1277}
1278template <class V, class B>
1279inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1280 detail::expression<detail::modulus_immediates, V, number<B, et_on> > >::type
1281operator%(const V& a, const number<B, et_on>& b)
1282{
1283 return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
1284}
1285template <class V, class B>
1286inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1287 number<B, et_on> >::type
1288operator%(const V& a, number<B, et_on>&& b)
1289{
1290 return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
1291}
1292template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1293inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1294 detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1295operator%(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1296{
1297 return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1298}
1299template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1300inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1301 std::is_same<typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1302 && number_category<B>::value == number_kind_integer,
1303 typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
1304operator%(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1305{
1306 a %= b;
1307 return std::move(a);
1308}
1309template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1310inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1311 !std::is_same<typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1312 && number_category<B>::value == number_kind_integer,
1313 typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
1314operator%(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1315{
1316 return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1317}
1318template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1319inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1320 detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
1321operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
1322{
1323 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1324}
1325template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1326inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1327 typename detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
1328operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1329{
1330 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1331}
1332template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
1333inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
1334 detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
1335operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
1336{
1337 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
1338}
1339template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
1340inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1341 detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
1342operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
1343{
1344 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
1345}
1346template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1347inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1348 detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1349operator%(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1350{
1351 return detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1352}
1353//
1354// Left shift:
1355//
1356template <class B, class I>
1357inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), detail::expression<detail::shift_left, number<B, et_on>, I> >::type
1358operator<<(const number<B, et_on>& a, const I& b)
1359{
1360 return detail::expression<detail::shift_left, number<B, et_on>, I>(a, b);
1361}
1362template <class B, class I>
1363inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_on> >::type
1364operator<<(number<B, et_on>&& a, const I& b)
1365{
1366 using default_ops::eval_left_shift;
1367 eval_left_shift(a.backend(), b);
1368 return std::move(a);
1369}
1370template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
1371inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1372 detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
1373operator<<(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
1374{
1375 return detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
1376}
1377//
1378// Right shift:
1379//
1380template <class B, class I>
1381inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer),
1382 detail::expression<detail::shift_right, number<B, et_on>, I> >::type
1383operator>>(const number<B, et_on>& a, const I& b)
1384{
1385 return detail::expression<detail::shift_right, number<B, et_on>, I>(a, b);
1386}
1387template <class B, class I>
1388inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer),
1389 number<B, et_on> >::type
1390operator>>(number<B, et_on>&& a, const I& b)
1391{
1392 using default_ops::eval_right_shift;
1393 eval_right_shift(a.backend(), b);
1394 return std::move(a);
1395}
1396template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
1397inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1398 detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
1399operator>>(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
1400{
1401 return detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
1402}
1403//
1404// Bitwise AND:
1405//
1406template <class B>
1407inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1408 detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> > >::type
1409operator&(const number<B, et_on>& a, const number<B, et_on>& b)
1410{
1411 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1412}
1413template <class B>
1414inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1415 number<B, et_on> >::type
1416operator&(number<B, et_on>&& a, const number<B, et_on>& b)
1417{
1418 using default_ops::eval_bitwise_and;
1419 eval_bitwise_and(a.backend(), b.backend());
1420 return std::move(a);
1421}
1422template <class B>
1423inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1424 number<B, et_on> >::type
1425operator&(const number<B, et_on>& a, number<B, et_on>&& b)
1426{
1427 using default_ops::eval_bitwise_and;
1428 eval_bitwise_and(b.backend(), a.backend());
1429 return std::move(b);
1430}
1431template <class B>
1432inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1433 number<B, et_on> >::type
1434operator&(number<B, et_on>&& a, number<B, et_on>&& b)
1435{
1436 using default_ops::eval_bitwise_and;
1437 eval_bitwise_and(a.backend(), b.backend());
1438 return std::move(a);
1439}
1440template <class B, class V>
1441inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1442 detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V> >::type
1443operator&(const number<B, et_on>& a, const V& b)
1444{
1445 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V>(a, b);
1446}
1447template <class B, class V>
1448inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1449 number<B, et_on> >::type
1450operator&(number<B, et_on>&& a, const V& b)
1451{
1452 using default_ops::eval_bitwise_and;
1453 eval_bitwise_and(a.backend(), number<B, et_on>::canonical_value(b));
1454 return std::move(a);
1455}
1456template <class V, class B>
1457inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1458 detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> > >::type
1459operator&(const V& a, const number<B, et_on>& b)
1460{
1461 return detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> >(a, b);
1462}
1463template <class V, class B>
1464inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1465 number<B, et_on> >::type
1466operator&(const V& a, number<B, et_on>&& b)
1467{
1468 using default_ops::eval_bitwise_and;
1469 eval_bitwise_and(b.backend(), number<B, et_on>::canonical_value(a));
1470 return std::move(b);
1471}
1472template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1473inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1474 detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1475operator&(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1476{
1477 return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1478}
1479template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1480inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1481 std::is_same<typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1482 && number_category<B>::value == number_kind_integer,
1483 typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
1484operator&(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1485{
1486 a &= b;
1487 return std::move(a);
1488}
1489template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1490inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1491 !std::is_same<typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1492 && number_category<B>::value == number_kind_integer,
1493 typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
1494operator&(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1495{
1496 return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1497}
1498template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1499inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1500 detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
1501operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
1502{
1503 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1504}
1505template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1506inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1507 std::is_same<typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
1508 && number_category<B>::value == number_kind_integer,
1509 typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
1510operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1511{
1512 b &= a;
1513 return std::move(b);
1514}
1515template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1516inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1517 !std::is_same<typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
1518 && number_category<B>::value == number_kind_integer,
1519 typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
1520operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1521{
1522 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1523}
1524template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
1525inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
1526 detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
1527operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
1528{
1529 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
1530}
1531template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
1532inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1533 detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
1534operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
1535{
1536 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
1537}
1538template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1539inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1540 detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1541operator&(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1542{
1543 return detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1544}
1545//
1546// Bitwise OR:
1547//
1548template <class B>
1549inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1550 detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> > >::type
1551operator|(const number<B, et_on>& a, const number<B, et_on>& b)
1552{
1553 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1554}
1555template <class B>
1556inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1557 number<B, et_on> >::type
1558operator|(number<B, et_on>&& a, const number<B, et_on>& b)
1559{
1560 using default_ops::eval_bitwise_or;
1561 eval_bitwise_or(a.backend(), b.backend());
1562 return std::move(a);
1563}
1564template <class B>
1565inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1566 number<B, et_on> >::type
1567operator|(const number<B, et_on>& a, number<B, et_on>&& b)
1568{
1569 using default_ops::eval_bitwise_or;
1570 eval_bitwise_or(b.backend(), a.backend());
1571 return std::move(b);
1572}
1573template <class B>
1574inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1575 number<B, et_on> >::type
1576operator|(number<B, et_on>&& a, number<B, et_on>&& b)
1577{
1578 using default_ops::eval_bitwise_or;
1579 eval_bitwise_or(a.backend(), b.backend());
1580 return std::move(a);
1581}
1582template <class B, class V>
1583inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1584 detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V> >::type
1585operator|(const number<B, et_on>& a, const V& b)
1586{
1587 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V>(a, b);
1588}
1589template <class B, class V>
1590inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1591 number<B, et_on> >::type
1592operator|(number<B, et_on>&& a, const V& b)
1593{
1594 using default_ops::eval_bitwise_or;
1595 eval_bitwise_or(a.backend(), number<B, et_on>::canonical_value(b));
1596 return std::move(a);
1597}
1598template <class V, class B>
1599inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1600 detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> > >::type
1601operator|(const V& a, const number<B, et_on>& b)
1602{
1603 return detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> >(a, b);
1604}
1605template <class V, class B>
1606inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1607 number<B, et_on> >::type
1608operator|(const V& a, number<B, et_on>&& b)
1609{
1610 using default_ops::eval_bitwise_or;
1611 eval_bitwise_or(b.backend(), number<B, et_on>::canonical_value(a));
1612 return std::move(b);
1613}
1614template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1615inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1616 detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1617operator|(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1618{
1619 return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1620}
1621template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1622inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1623 std::is_same<typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1624 && number_category<B>::value == number_kind_integer,
1625 typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
1626operator|(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1627{
1628 a |= b;
1629 return std::move(a);
1630}
1631template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1632inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1633 !std::is_same<typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1634 && number_category<B>::value == number_kind_integer,
1635 typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
1636operator|(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1637{
1638 return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1639}
1640template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1641inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1642 detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
1643operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
1644{
1645 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1646}
1647template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1648inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1649 std::is_same<typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
1650 && number_category<B>::value == number_kind_integer,
1651 typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
1652operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1653{
1654 b |= a;
1655 return std::move(b);
1656}
1657template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1658inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1659 !std::is_same<typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
1660 && number_category<B>::value == number_kind_integer,
1661 typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
1662operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1663{
1664 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1665}
1666template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
1667inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
1668 detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
1669operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
1670{
1671 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
1672}
1673template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
1674inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1675 detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
1676operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
1677{
1678 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
1679}
1680template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1681inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1682 detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1683operator|(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1684{
1685 return detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1686}
1687//
1688// Bitwise XOR:
1689//
1690template <class B>
1691inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1692 detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> > >::type
1693operator^(const number<B, et_on>& a, const number<B, et_on>& b)
1694{
1695 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
1696}
1697template <class B>
1698inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1699 number<B, et_on> >::type
1700operator^(number<B, et_on>&& a, const number<B, et_on>& b)
1701{
1702 using default_ops::eval_bitwise_xor;
1703 eval_bitwise_xor(a.backend(), b.backend());
1704 return std::move(a);
1705}
1706template <class B>
1707inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1708 number<B, et_on> >::type
1709operator^(const number<B, et_on>& a, number<B, et_on>&& b)
1710{
1711 using default_ops::eval_bitwise_xor;
1712 eval_bitwise_xor(b.backend(), a.backend());
1713 return std::move(b);
1714}
1715template <class B>
1716inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1717 number<B, et_on> >::type
1718operator^(number<B, et_on>&& a, number<B, et_on>&& b)
1719{
1720 using default_ops::eval_bitwise_xor;
1721 eval_bitwise_xor(a.backend(), b.backend());
1722 return std::move(a);
1723}
1724template <class B, class V>
1725inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1726 detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V> >::type
1727operator^(const number<B, et_on>& a, const V& b)
1728{
1729 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V>(a, b);
1730}
1731template <class B, class V>
1732inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1733 number<B, et_on> >::type
1734operator^(number<B, et_on>&& a, const V& b)
1735{
1736 using default_ops::eval_bitwise_xor;
1737 eval_bitwise_xor(a.backend(), number<B, et_on>::canonical_value(b));
1738 return std::move(a);
1739}
1740template <class V, class B>
1741inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1742 detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> > >::type
1743operator^(const V& a, const number<B, et_on>& b)
1744{
1745 return detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> >(a, b);
1746}
1747template <class V, class B>
1748inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
1749 number<B, et_on> >::type
1750operator^(const V& a, number<B, et_on>&& b)
1751{
1752 using default_ops::eval_bitwise_xor;
1753 eval_bitwise_xor(b.backend(), number<B, et_on>::canonical_value(a));
1754 return std::move(b);
1755}
1756template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1757inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1758 detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1759operator^(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1760{
1761 return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1762}
1763template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1764inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1765 std::is_same<typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1766 && number_category<B>::value == number_kind_integer,
1767 typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
1768operator^(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1769{
1770 a ^= b;
1771 return std::move(a);
1772}
1773template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1774inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1775 !std::is_same<typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
1776 && number_category<B>::value == number_kind_integer,
1777 typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
1778operator^(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1779{
1780 return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1781}
1782template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1783inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
1784 detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
1785operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
1786{
1787 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1788}
1789template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1790inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1791 std::is_same<typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
1792 && number_category<B>::value == number_kind_integer,
1793 typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
1794operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1795{
1796 b ^= a;
1797 return std::move(b);
1798}
1799template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
1800inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
1801 !std::is_same<typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
1802 && number_category<B>::value == number_kind_integer,
1803 typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
1804operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
1805{
1806 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
1807}
1808template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
1809inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
1810 detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
1811operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
1812{
1813 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
1814}
1815template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
1816inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
1817 detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
1818operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
1819{
1820 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
1821}
1822template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
1823inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer), detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
1824operator^(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
1825{
1826 return detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
1827}
1828
1829}} // namespace boost::multiprecision
1830
1831#endif
1832

source code of boost/libs/multiprecision/include/boost/multiprecision/detail/et_ops.hpp