comparison DEPENDENCIES/generic/include/boost/multiprecision/rational_adaptor.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 
    typedef typename IntBackend::signed_types    signed_types;
    typedef typename IntBackend::unsigned_types  unsigned_types;
    typedef typename IntBackend::float_types     float_types;
 
-   rational_adaptor(){}
-   rational_adaptor(const rational_adaptor& o)
+   rational_adaptor() BOOST_NOEXCEPT_IF(noexcept(rational_type())) {}
+   rational_adaptor(const rational_adaptor& o) BOOST_NOEXCEPT_IF(noexcept(std::declval<rational_type&>() = std::declval<const rational_type&>()))
    {
       m_value = o.m_value;
    }
-   rational_adaptor(const IntBackend& o) : m_value(o) {}
+   rational_adaptor(const IntBackend& o) BOOST_NOEXCEPT_IF(noexcept(rational_type(std::declval<const IntBackend&>()))) : m_value(o) {}
 
    template <class U>
    rational_adaptor(const U& u, typename enable_if_c<is_convertible<U, IntBackend>::value>::type* = 0) 
-      : m_value(IntBackend(u)){}
+      : m_value(static_cast<integer_type>(u)){}
    template <class U>
    explicit rational_adaptor(const U& u, 
       typename enable_if_c<
          boost::multiprecision::detail::is_explicitly_convertible<U, IntBackend>::value && !is_convertible<U, IntBackend>::value
       >::type* = 0) 

    {
       m_value = IntBackend(u);
    }
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-   rational_adaptor(rational_adaptor&& o) : m_value(o.m_value) {}
-   rational_adaptor(IntBackend&& o) : m_value(o) {}
-   rational_adaptor& operator = (rational_adaptor&& o)
+   rational_adaptor(rational_adaptor&& o) BOOST_NOEXCEPT_IF(noexcept(rational_type(std::declval<rational_type>()))) : m_value(static_cast<rational_type&&>(o.m_value)) {}
+   rational_adaptor(IntBackend&& o) BOOST_NOEXCEPT_IF(noexcept(rational_type(std::declval<IntBackend>()))) : m_value(static_cast<IntBackend&&>(o)) {}
+   rational_adaptor& operator = (rational_adaptor&& o) BOOST_NOEXCEPT_IF(noexcept(std::declval<rational_type&>() = std::declval<rational_type>()))
    {
       m_value = static_cast<rational_type&&>(o.m_value);
       return *this;
    }
 #endif

    int compare(const rational_adaptor& o)const
    {
       return m_value > o.m_value ? 1 : (m_value < o.m_value ? -1 : 0);
    }
    template <class Arithmatic>
-   typename enable_if<is_arithmetic<Arithmatic>, int>::type compare(Arithmatic i)const
+   typename enable_if_c<is_arithmetic<Arithmatic>::value && !is_floating_point<Arithmatic>::value, int>::type compare(Arithmatic i)const
    {
       return m_value > i ? 1 : (m_value < i ? -1 : 0);
+   }
+   template <class Arithmatic>
+   typename enable_if_c<is_floating_point<Arithmatic>::value, int>::type compare(Arithmatic i)const
+   {
+      rational_adaptor r;
+      r = i;
+      return this->compare(r);
    }
    rational_type& data() { return m_value; }
    const rational_type& data()const { return m_value; }
 
    template <class Archive>

    }
    result.data() /= o.data();
 }
 
 template <class R, class IntBackend>
-inline void eval_convert_to(R* result, const rational_adaptor<IntBackend>& backend)
-{
-   *result = backend.data().numerator().template convert_to<R>();
-   *result /= backend.data().denominator().template convert_to<R>();
+inline typename enable_if_c<number_category<R>::value == number_kind_floating_point>::type eval_convert_to(R* result, const rational_adaptor<IntBackend>& backend)
+{
+   //
+   // The generic conversion is as good as anything we can write here:
+   //
+   ::boost::multiprecision::detail::generic_convert_rational_to_float(*result, backend);
+}
+
+template <class R, class IntBackend>
+inline typename enable_if_c<(number_category<R>::value != number_kind_integer) && (number_category<R>::value != number_kind_floating_point)>::type eval_convert_to(R* result, const rational_adaptor<IntBackend>& backend)
+{
+   typedef typename component_type<number<rational_adaptor<IntBackend> > >::type comp_t;
+   comp_t num(backend.data().numerator());
+   comp_t denom(backend.data().denominator());
+   *result = num.template convert_to<R>();
+   *result /= denom.template convert_to<R>();
+}
+
+template <class R, class IntBackend>
+inline typename enable_if_c<number_category<R>::value == number_kind_integer>::type eval_convert_to(R* result, const rational_adaptor<IntBackend>& backend)
+{
+   typedef typename component_type<number<rational_adaptor<IntBackend> > >::type comp_t;
+   comp_t t = backend.data().numerator();
+   t /= backend.data().denominator();
+   *result = t.template convert_to<R>();
 }
 
 template <class IntBackend>
 inline bool eval_is_zero(const rational_adaptor<IntBackend>& val)
 {