1 ///////////////////////////////////////////////////////////////////////////////
2 // Copyright 2012 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)
6 #ifndef BOOST_MP_COMPARE_HPP
7 #define BOOST_MP_COMPARE_HPP
9 #include <boost/multiprecision/traits/is_backend.hpp>
12 // Comparison operators for number.
15 namespace boost { namespace multiprecision {
17 namespace default_ops {
20 // The dispatching mechanism used here to deal with differently typed arguments
21 // could be better replaced with enable_if overloads, but that breaks MSVC-12
22 // under strange and hard to reproduce circumstances.
25 inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq(const B& a, const B& b)
27 return a.compare(b) == 0;
29 template <class T, class U>
30 inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq_imp(const T& a, const U& b, const mpl::true_&)
32 typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
33 return eval_eq(a, t.backend());
35 template <class T, class U>
36 inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq_imp(const T& a, const U& b, const mpl::false_&)
38 typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
39 return eval_eq(t.backend(), b);
41 template <class T, class U>
42 inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq(const T& a, const U& b)
44 typedef mpl::bool_<boost::multiprecision::detail::is_first_backend<T, U>::value> tag_type;
45 return eval_eq_imp(a, b, tag_type());
49 inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const B& a, const B& b)
51 return a.compare(b) < 0;
53 template <class T, class U>
54 inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt_imp(const T& a, const U& b, const mpl::true_&)
56 typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
57 return eval_lt(a, t.backend());
59 template <class T, class U>
60 inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt_imp(const T& a, const U& b, const mpl::false_&)
62 typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
63 return eval_lt(t.backend(), b);
65 template <class T, class U>
66 inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const T& a, const U& b)
68 typedef mpl::bool_<boost::multiprecision::detail::is_first_backend<T, U>::value> tag_type;
69 return eval_lt_imp(a, b, tag_type());
73 inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const B& a, const B& b)
75 return a.compare(b) > 0;
77 template <class T, class U>
78 inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt_imp(const T& a, const U& b, const mpl::true_&)
80 typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
81 return eval_gt(a, t.backend());
83 template <class T, class U>
84 inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt_imp(const T& a, const U& b, const mpl::false_&)
86 typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
87 return eval_gt(t.backend(), b);
89 template <class T, class U>
90 inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const T& a, const U& b)
92 typedef mpl::bool_<boost::multiprecision::detail::is_first_backend<T, U>::value> tag_type;
93 return eval_gt_imp(a, b, tag_type());
96 } // namespace default_ops
100 template <class Num, class Val>
101 struct is_valid_mixed_compare : public mpl::false_
104 template <class B, expression_template_option ET, class Val>
105 struct is_valid_mixed_compare<number<B, ET>, Val> : public is_convertible<Val, number<B, ET> >
108 template <class B, expression_template_option ET>
109 struct is_valid_mixed_compare<number<B, ET>, number<B, ET> > : public mpl::false_
112 template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
113 struct is_valid_mixed_compare<number<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> >
114 : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value>
117 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
118 struct is_valid_mixed_compare<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
119 : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value>
122 template <class Backend, expression_template_option ExpressionTemplates>
123 inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Backend>::value != number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>&)
127 template <class Backend, expression_template_option ExpressionTemplates>
129 #if !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
132 typename boost::enable_if_c<number_category<Backend>::value == number_kind_floating_point, bool>::type
133 is_unordered_value(const number<Backend, ExpressionTemplates>& a)
135 using default_ops::eval_fpclassify;
136 return eval_fpclassify(a.backend()) == FP_NAN;
139 template <class Arithmetic>
140 inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Arithmetic>::value != number_kind_floating_point, bool>::type is_unordered_value(const Arithmetic&)
144 template <class Arithmetic>
146 #ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
147 BOOST_MP_CXX14_CONSTEXPR
149 typename boost::enable_if_c < number_category < Arithmetic> ::value == number_kind_floating_point, bool> ::type
150 is_unordered_value(const Arithmetic& a)
152 #ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
153 if (BOOST_MP_IS_CONST_EVALUATED(a))
160 return (boost::math::isnan)(a);
164 template <class T, class U>
165 inline BOOST_CONSTEXPR bool is_unordered_comparison(const T& a, const U& b)
167 return is_unordered_value(a) || is_unordered_value(b);
170 } // namespace detail
172 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
173 inline BOOST_MP_CXX14_CONSTEXPR bool operator==(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
175 using default_ops::eval_eq;
176 if (detail::is_unordered_comparison(a, b))
178 return eval_eq(a.backend(), b.backend());
180 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
181 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
182 operator==(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
184 using default_ops::eval_eq;
185 if (detail::is_unordered_comparison(a, b))
187 return eval_eq(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
189 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
190 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
191 operator==(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
193 using default_ops::eval_eq;
194 if (detail::is_unordered_comparison(a, b))
196 return eval_eq(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
198 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
199 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
200 operator==(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
202 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
203 using default_ops::eval_eq;
205 if (detail::is_unordered_comparison(a, t))
207 return eval_eq(t.backend(), result_type::canonical_value(a));
209 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
210 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
211 operator==(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
213 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
214 using default_ops::eval_eq;
216 if (detail::is_unordered_comparison(t, b))
218 return eval_eq(t.backend(), result_type::canonical_value(b));
220 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
221 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
222 operator==(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
224 using default_ops::eval_eq;
225 typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
226 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
227 if (detail::is_unordered_comparison(t, t2))
229 return eval_eq(t.backend(), t2.backend());
232 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
233 inline BOOST_MP_CXX14_CONSTEXPR bool operator!=(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
235 using default_ops::eval_eq;
236 if (detail::is_unordered_comparison(a, b))
238 return !eval_eq(a.backend(), b.backend());
240 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
241 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
242 operator!=(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
244 using default_ops::eval_eq;
245 if (detail::is_unordered_comparison(a, b))
247 return !eval_eq(a.backend(), number<Backend, et_on>::canonical_value(b));
249 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
250 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
251 operator!=(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
253 using default_ops::eval_eq;
254 if (detail::is_unordered_comparison(a, b))
256 return !eval_eq(b.backend(), number<Backend, et_on>::canonical_value(a));
258 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
259 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
260 operator!=(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
262 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
263 using default_ops::eval_eq;
265 if (detail::is_unordered_comparison(a, t))
267 return !eval_eq(t.backend(), result_type::canonical_value(a));
269 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
270 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
271 operator!=(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
273 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
274 using default_ops::eval_eq;
276 if (detail::is_unordered_comparison(t, b))
278 return !eval_eq(t.backend(), result_type::canonical_value(b));
280 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
281 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
282 operator!=(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
284 using default_ops::eval_eq;
285 typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
286 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
287 if (detail::is_unordered_comparison(t, t2))
289 return !eval_eq(t.backend(), t2.backend());
292 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
293 inline BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
294 operator<(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
296 using default_ops::eval_lt;
297 if (detail::is_unordered_comparison(a, b))
299 return eval_lt(a.backend(), b.backend());
301 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
302 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
303 operator<(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
305 using default_ops::eval_lt;
306 if (detail::is_unordered_comparison(a, b))
308 return eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
310 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
311 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
312 operator<(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
314 using default_ops::eval_gt;
315 if (detail::is_unordered_comparison(a, b))
317 return eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
319 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
320 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
321 operator<(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
323 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
324 using default_ops::eval_gt;
326 if (detail::is_unordered_comparison(a, t))
328 return eval_gt(t.backend(), result_type::canonical_value(a));
330 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
331 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
332 operator<(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
334 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
335 using default_ops::eval_lt;
337 if (detail::is_unordered_comparison(t, b))
339 return eval_lt(t.backend(), result_type::canonical_value(b));
341 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
342 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
343 operator<(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
345 using default_ops::eval_lt;
346 typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
347 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
348 if (detail::is_unordered_comparison(t, t2))
350 return eval_lt(t.backend(), t2.backend());
353 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
354 inline BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
355 operator>(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
357 using default_ops::eval_gt;
358 if (detail::is_unordered_comparison(a, b))
360 return eval_gt(a.backend(), b.backend());
362 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
363 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
364 operator>(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
366 using default_ops::eval_gt;
367 if (detail::is_unordered_comparison(a, b))
369 return eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
371 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
372 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
373 operator>(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
375 using default_ops::eval_lt;
376 if (detail::is_unordered_comparison(a, b))
378 return eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
380 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
381 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
382 operator>(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
384 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
385 using default_ops::eval_lt;
387 if (detail::is_unordered_comparison(a, t))
391 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
392 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
393 operator>(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
395 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
396 using default_ops::eval_gt;
398 if (detail::is_unordered_comparison(t, b))
402 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
403 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
404 operator>(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
406 using default_ops::eval_gt;
407 typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
408 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
409 if (detail::is_unordered_comparison(t, t2))
414 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
415 inline BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
416 operator<=(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
418 using default_ops::eval_gt;
419 if (detail::is_unordered_comparison(a, b))
421 return !eval_gt(a.backend(), b.backend());
423 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
424 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
425 operator<=(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
427 using default_ops::eval_gt;
428 if (detail::is_unordered_comparison(a, b))
430 return !eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
432 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
433 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
434 operator<=(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
436 using default_ops::eval_lt;
437 if (detail::is_unordered_comparison(a, b))
439 return !eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
441 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
442 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
443 operator<=(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
445 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
446 using default_ops::eval_lt;
447 if (detail::is_unordered_value(a) || detail::is_unordered_value(b))
450 if (detail::is_unordered_comparison(a, t))
452 return !eval_lt(t.backend(), result_type::canonical_value(a));
454 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
455 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
456 operator<=(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
458 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
459 using default_ops::eval_gt;
461 if (detail::is_unordered_comparison(t, b))
463 return !eval_gt(t.backend(), result_type::canonical_value(b));
465 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
466 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
467 operator<=(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
469 using default_ops::eval_gt;
470 typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
471 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
472 if (detail::is_unordered_comparison(t, t2))
474 return !eval_gt(t.backend(), t2.backend());
477 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
478 inline BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
479 operator>=(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
481 using default_ops::eval_lt;
482 if (detail::is_unordered_comparison(a, b))
484 return !eval_lt(a.backend(), b.backend());
486 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
487 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
488 operator>=(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
490 using default_ops::eval_lt;
491 if (detail::is_unordered_comparison(a, b))
493 return !eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
495 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
496 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex), bool>::type
497 operator>=(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
499 using default_ops::eval_gt;
500 if (detail::is_unordered_comparison(a, b))
502 return !eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
504 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
505 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
506 operator>=(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
508 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
509 using default_ops::eval_gt;
511 if (detail::is_unordered_comparison(a, t))
513 return !eval_gt(t.backend(), result_type::canonical_value(a));
515 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
516 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
517 operator>=(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
519 typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
520 using default_ops::eval_lt;
522 if (detail::is_unordered_comparison(t, b))
524 return !eval_lt(t.backend(), result_type::canonical_value(b));
526 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
527 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
528 operator>=(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
530 using default_ops::eval_lt;
531 typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
532 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
533 if (detail::is_unordered_comparison(t, t2))
535 return !eval_lt(t.backend(), t2.backend());
539 // C99 comparison macros as functions:
541 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
542 inline BOOST_MP_CXX14_CONSTEXPR bool isgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a > b; }
544 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
545 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
547 BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a > b; }
549 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
550 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
552 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a > b; }
554 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
555 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
557 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a > b; }
559 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
560 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
562 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a > b; }
564 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
565 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
567 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a > b; }
569 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
570 inline BOOST_MP_CXX14_CONSTEXPR bool isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a >= b; }
572 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
573 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
575 BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a >= b; }
577 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
578 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
580 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a >= b; }
582 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
583 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
585 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a >= b; }
587 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
588 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
590 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a >= b; }
592 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
593 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
595 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a >= b; }
597 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
598 inline BOOST_MP_CXX14_CONSTEXPR bool islessequal BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a <= b; }
600 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
601 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
603 BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a <= b; }
605 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
606 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
608 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a <= b; }
610 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
611 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
613 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a <= b; }
615 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
616 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
618 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a <= b; }
620 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
621 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
623 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a <= b; }
625 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
626 inline BOOST_MP_CXX14_CONSTEXPR bool isless BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a < b; }
628 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
629 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
631 BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a < b; }
633 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
634 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
636 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a < b; }
638 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
639 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
641 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a < b; }
643 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
644 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
646 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a < b; }
648 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
649 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
651 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a < b; }
653 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
654 inline BOOST_MP_CXX14_CONSTEXPR bool islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
656 if (detail::is_unordered_comparison(a, b))
661 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
662 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
664 BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
666 if (detail::is_unordered_comparison(a, b))
671 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
672 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
674 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
676 if (detail::is_unordered_comparison(a, b))
681 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
682 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
684 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& bb)
686 typename detail::expression<Tag, A1, A2, A3, A4>::result_type b(bb);
687 return islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
690 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
691 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
693 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const Arithmetic& b)
695 typename detail::expression<Tag, A1, A2, A3, A4>::result_type a(aa);
696 return islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
699 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
700 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
702 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& bb)
704 typename detail::expression<Tag, A1, A2, A3, A4>::result_type a(aa);
705 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type b(bb);
706 return islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
709 template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
710 inline BOOST_MP_CXX14_CONSTEXPR bool isunordered BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return detail::is_unordered_comparison(a, b); }
712 template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
713 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
715 BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return detail::is_unordered_comparison(a, b); }
717 template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
718 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
720 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return detail::is_unordered_comparison(a, b); }
722 template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
723 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
725 BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& bb)
727 typename detail::expression<Tag, A1, A2, A3, A4>::result_type b(bb);
728 return detail::is_unordered_comparison(a, b);
731 template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
732 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
734 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const Arithmetic& b)
736 typename detail::expression<Tag, A1, A2, A3, A4>::result_type a(aa);
737 return detail::is_unordered_comparison(a, b);
740 template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
741 inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
743 BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& bb)
745 typename detail::expression<Tag, A1, A2, A3, A4>::result_type a(aa);
746 typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type b(bb);
747 return detail::is_unordered_comparison(a, b);
750 }} // namespace boost::multiprecision
752 #endif // BOOST_MP_COMPARE_HPP