diff DEPENDENCIES/generic/include/boost/multiprecision/detail/number_compare.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/multiprecision/detail/number_compare.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,388 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MP_COMPARE_HPP
+#define BOOST_MP_COMPARE_HPP
+
+//
+// Comparison operators for number.
+//
+
+namespace boost{ namespace multiprecision{
+
+namespace default_ops{
+
+template <class B>
+inline bool eval_eq(const B& a, const B& b)
+{
+   return a.compare(b) == 0;
+}
+//
+// For the default version which compares to some arbitrary type convertible to
+// our number type, we don't know what value the ExpressionTemplates parameter to
+// class number should be.  We generally prefer ExpressionTemplates to be enabled
+// in case type A is itself an expression template, but we need to test both options
+// with is_convertible in case A has an implicit conversion operator to number<B,something>.
+// This is the case with many uBlas types for example.
+//
+template <class B, class A>
+inline bool eval_eq(const B& a, const A& b)
+{
+   typedef typename mpl::if_c<
+      is_convertible<A, number<B, et_on> >::value,
+      number<B, et_on>,
+      number<B, et_off> >::type mp_type;
+   mp_type t(b);
+   return eval_eq(a, t.backend());
+}
+
+template <class B>
+inline bool eval_lt(const B& a, const B& b)
+{
+   return a.compare(b) < 0;
+}
+template <class B, class A>
+inline bool eval_lt(const B& a, const A& b)
+{
+   typedef typename mpl::if_c<
+      is_convertible<A, number<B, et_on> >::value,
+      number<B, et_on>,
+      number<B, et_off> >::type mp_type;
+   mp_type t(b);
+   return eval_lt(a, t.backend());
+}
+
+template <class B>
+inline bool eval_gt(const B& a, const B& b)
+{
+   return a.compare(b) > 0;
+}
+template <class B, class A>
+inline bool eval_gt(const B& a, const A& b)
+{
+   typedef typename mpl::if_c<
+      is_convertible<A, number<B, et_on> >::value,
+      number<B, et_on>,
+      number<B, et_off> >::type mp_type;
+   mp_type t(b);
+   return eval_gt(a, t.backend());
+}
+
+} // namespace default_ops
+
+namespace detail{
+
+template <class Num, class Val>
+struct is_valid_mixed_compare : public mpl::false_ {};
+
+template <class B, expression_template_option ET, class Val>
+struct is_valid_mixed_compare<number<B, ET>, Val> : public is_convertible<Val, number<B, ET> > {};
+
+template <class B, expression_template_option ET>
+struct is_valid_mixed_compare<number<B, ET>, number<B, ET> > : public mpl::false_ {};
+
+template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+struct is_valid_mixed_compare<number<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> > 
+   : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};
+
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
+struct is_valid_mixed_compare<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> > 
+   : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};
+
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline bool operator == (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_eq;
+   return eval_eq(a.backend(), b.backend());
+}
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator == (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+{
+   using default_ops::eval_eq;
+   return eval_eq(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
+}
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator == (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_eq;
+   return eval_eq(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
+}
+template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator == (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_eq;
+   result_type t(b);
+   return eval_eq(t.backend(), result_type::canonical_value(a));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_eq;
+   result_type t(a);
+   return eval_eq(t.backend(), result_type::canonical_value(b));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
+inline 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 
+   operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
+{
+   using default_ops::eval_eq;
+   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+   return eval_eq(t.backend(), t2.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline bool operator != (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_eq;
+   return !eval_eq(a.backend(), b.backend());
+}
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator != (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+{
+   using default_ops::eval_eq;
+   return !eval_eq(a.backend(), number<Backend, et_on>::canonical_value(b));
+}
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator != (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_eq;
+   return !eval_eq(b.backend(), number<Backend, et_on>::canonical_value(a));
+}
+template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator != (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_eq;
+   result_type t(b);
+   return !eval_eq(t.backend(), result_type::canonical_value(a));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_eq;
+   result_type t(a);
+   return !eval_eq(t.backend(), result_type::canonical_value(b));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
+inline 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 
+   operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
+{
+   using default_ops::eval_eq;
+   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+   return !eval_eq(t.backend(), t2.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline bool operator < (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_lt;
+   return eval_lt(a.backend(), b.backend());
+}
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator < (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+{
+   using default_ops::eval_lt;
+   return eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
+}
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator < (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_gt;
+   return eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
+}
+template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator < (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_gt;
+   result_type t(b);
+   return eval_gt(t.backend(), result_type::canonical_value(a));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_lt;
+   result_type t(a);
+   return eval_lt(t.backend(), result_type::canonical_value(b));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
+inline 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 
+   operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
+{
+   using default_ops::eval_lt;
+   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+   return eval_lt(t.backend(), t2.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline bool operator > (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_gt;
+   return eval_gt(a.backend(), b.backend());
+}
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator > (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+{
+   using default_ops::eval_gt;
+   return eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
+}
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator > (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_lt;
+   return eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
+}
+template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator > (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_lt;
+   result_type t(b);
+   return eval_lt(t.backend(), result_type::canonical_value(a));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_gt;
+   result_type t(a);
+   return eval_gt(t.backend(), result_type::canonical_value(b));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
+inline 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 
+   operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
+{
+   using default_ops::eval_gt;
+   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+   return eval_gt(t.backend(), t2.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline bool operator <= (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_gt;
+   return !eval_gt(a.backend(), b.backend());
+}
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator <= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+{
+   using default_ops::eval_gt;
+   return !eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
+}
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator <= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_lt;
+   return !eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
+}
+template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator <= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_lt;
+   result_type t(b);
+   return !eval_lt(t.backend(), result_type::canonical_value(a));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_gt;
+   result_type t(a);
+   return !eval_gt(t.backend(), result_type::canonical_value(b));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
+inline 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 
+   operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
+{
+   using default_ops::eval_gt;
+   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+   return !eval_gt(t.backend(), t2.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline bool operator >= (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_lt;
+   return !eval_lt(a.backend(), b.backend());
+}
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator >= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+{
+   using default_ops::eval_lt;
+   return !eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
+}
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
+inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type 
+   operator >= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
+{
+   using default_ops::eval_gt;
+   return !eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
+}
+template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator >= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_gt;
+   result_type t(b);
+   return !eval_gt(t.backend(), result_type::canonical_value(a));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
+inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type 
+   operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+{
+   typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
+   using default_ops::eval_lt;
+   result_type t(a);
+   return !eval_lt(t.backend(), result_type::canonical_value(b));
+}
+template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
+inline 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 
+   operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
+{
+   using default_ops::eval_lt;
+   typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+   return !eval_lt(t.backend(), t2.backend());
+}
+
+
+}} // namespaces
+
+#endif // BOOST_MP_COMPARE_HPP
+