|  | Home | Libraries | People | FAQ | More | 
There are some traits classes which authors of new backends should be aware of:
namespace boost{ namespace multiprecision{ namespace detail{ template<typename From, typename To> struct is_explicitly_convertible; }}}
        Inherits from std::integral_constant<bool,true> if type From
        has an explicit conversion from To.
      
template <class From, class To> struct is_lossy_conversion { static const bool value = see below; };
        Member value is true if the
        conversion from From to
        To would result in a loss
        of precision, and false otherwise.
      
        The default version of this trait simply checks whether the kind
        of conversion (for example from a floating-point to an integer type) is inherently
        lossy. Note that if either of the types From
        or To are of an unknown number
        category (because number_category
        is not specialised for that type) then this trait will be true.
      
template<typename From, typename To> struct is_restricted_conversion { static const bool value = see below; };
        Member value is true if From
        is only explicitly convertible to To
        and not implicitly convertible, or if is_lossy_conversion<From, To>::value is true.
        Otherwise false.
      
        Note that while this trait is the ultimate arbiter of which constructors
        are marked as explicit in class
        number, authors of backend
        types should generally specialise one of the traits above, rather than this
        one directly.
      
template <class T> is_signed_number; template <class T> is_unsigned_number;
        These two traits inherit from either std::integral_constant<bool,
        true>
        or std::integral_constant<bool, false>, by default types are assumed to be signed
        unless is_unsigned_number
        is specialized for that type.