integer.hpp

Go to the documentation of this file.

/*
    The Extended Integer (XInt) Library
    A fast, portable C++ library for multi-precision integer math
    Copyright 2010 by Chad Nelson

    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

    See http://www.boost.org/libs/xint for library home page.
*/

#ifndef BOOST_INCLUDED_XINT_INTEGER_HPP
#define BOOST_INCLUDED_XINT_INTEGER_HPP

#include "detail/internals.hpp"
#include "random.hpp"

namespace boost {
namespace xint {

template<BOOST_XINT_INITIAL_APARAMS>
class integer_t: virtual public detail::integer_t_data<BOOST_XINT_APARAMS>,
    public detail::nan_functions<detail::integer_t_data<BOOST_XINT_APARAMS>::
    NothrowType::value, integer_t<BOOST_XINT_APARAMS>, BOOST_XINT_APARAMS>,
    public detail::fixed_functions<detail::integer_t_data<BOOST_XINT_APARAMS>::
    BitsType::value, integer_t<BOOST_XINT_APARAMS>, BOOST_XINT_APARAMS>, public
    detail::unsigned_negative_functions<detail::integer_t_data<
    BOOST_XINT_APARAMS>::SignType::value, BOOST_XINT_APARAMS>
{
    typedef typename detail::integer_t_data<BOOST_XINT_APARAMS>::BitsType
        BitsType;
    typedef typename detail::integer_t_data<BOOST_XINT_APARAMS>::SecureType
        SecureType;
    typedef typename detail::integer_t_data<BOOST_XINT_APARAMS>::SignType
        SignType;
    typedef typename detail::integer_t_data<BOOST_XINT_APARAMS>::Alloc Alloc;

    public:
    #ifndef BOOST_XINT_DOXYGEN_IGNORE
    typedef integer_t<BOOST_XINT_APARAMS> type;
    typedef void (integer_t<BOOST_XINT_APARAMS>::*safe_bool_type)() const;
    void this_is_a_safe_bool_type() const { }

    typedef typename detail::integer_t_data<BOOST_XINT_APARAMS>::datatype
        datatype;

    using detail::integer_t_data<BOOST_XINT_APARAMS>::Threadsafe;
    using detail::integer_t_data<BOOST_XINT_APARAMS>::Nothrow;
    using detail::integer_t_data<BOOST_XINT_APARAMS>::Signed;

    using detail::integer_t_data<BOOST_XINT_APARAMS>::data;
    using detail::integer_t_data<BOOST_XINT_APARAMS>::_data;

    using typename detail::nan_functions<detail::integer_t_data<
        BOOST_XINT_APARAMS>::NothrowType::value, integer_t<
        BOOST_XINT_APARAMS>, BOOST_XINT_APARAMS>::is_nan;

    using typename detail::unsigned_negative_functions<detail::integer_t_data<
        BOOST_XINT_APARAMS>::SignType::value, BOOST_XINT_APARAMS>::
        _fix_negative_unsigned;
    #endif // BOOST_XINT_DOXYGEN_IGNORE

    integer_t();
    integer_t(const integer_t<BOOST_XINT_APARAMS>& b, bool force_thread_safety =
        false);
    integer_t(BOOST_XINT_RV_REF(type) b) { _swap(b); }
    template <typename charT>
    explicit integer_t(const charT *str, std::size_t base = 10);
    template <typename charT>
    integer_t(const charT *str, const charT*& endptr, std::size_t base = 10);
    template <typename charT, typename traitsT, typename allocT>
    explicit integer_t(const std::basic_string<charT, traitsT, allocT>& str,
        std::size_t base = 10);
    explicit integer_t(const xint::binary_t b, bitsize_t bits = 0);
    template <BOOST_XINT_CLASS_BPARAMS> explicit integer_t(const
        integer_t<BOOST_XINT_BPARAMS>& other, bool force_thread_safety = false);
    template <typename Type> integer_t(const Type n, typename
        boost::enable_if<boost::is_integral<Type> >::type* = 0);

    #ifndef BOOST_XINT_DOXYGEN_IGNORE

    explicit integer_t(const detail::raw_integer_t<BitsType::value,
        SecureType::value, Alloc> c):
        detail::integer_t_data<BOOST_XINT_APARAMS>(c) { if (Threadsafe == true)
        _data().make_unique(); }
    #endif // BOOST_XINT_DOXYGEN_IGNORE


    integer_t<BOOST_XINT_APARAMS>& operator=(BOOST_XINT_COPY_ASSIGN_REF(type)
        c);
    integer_t<BOOST_XINT_APARAMS>& operator=(BOOST_XINT_RV_REF(type) c) {
        _swap(c); return *this; }
    template <typename Type> integer_t<BOOST_XINT_APARAMS>& operator=(const Type
        n) { integer_t<BOOST_XINT_APARAMS> nn(n); _swap(nn); return *this; }

    operator safe_bool_type() const { return (data.is_zero() ? 0 :
        &integer_t<BOOST_XINT_APARAMS>::this_is_a_safe_bool_type); }
    bool operator!() const { return data.is_zero(); }
    integer_t<BOOST_XINT_APARAMS> operator-() const;
    integer_t<BOOST_XINT_APARAMS>& operator+() { return *this; }
    const integer_t<BOOST_XINT_APARAMS>& operator+() const { return *this; }

    #ifdef BOOST_XINT_DOXYGEN_IGNORE // inherited, only here for doxygen
    integer_t<BOOST_XINT_APARAMS> operator~() const;
    #endif

    integer_t<BOOST_XINT_APARAMS>& operator+=(const
        integer_t<BOOST_XINT_APARAMS> b);
    integer_t<BOOST_XINT_APARAMS>& operator-=(const
        integer_t<BOOST_XINT_APARAMS> b);
    integer_t<BOOST_XINT_APARAMS>& operator*=(const
        integer_t<BOOST_XINT_APARAMS> b);
    integer_t<BOOST_XINT_APARAMS>& operator/=(const
        integer_t<BOOST_XINT_APARAMS> b);
    integer_t<BOOST_XINT_APARAMS>& operator%=(const
        integer_t<BOOST_XINT_APARAMS> b);

    integer_t<BOOST_XINT_APARAMS>& operator++();
    integer_t<BOOST_XINT_APARAMS>& operator--();
    integer_t<BOOST_XINT_APARAMS>  operator++(int);
    integer_t<BOOST_XINT_APARAMS>  operator--(int);

    integer_t<BOOST_XINT_APARAMS>& operator&=(const
        integer_t<BOOST_XINT_APARAMS> n);
    integer_t<BOOST_XINT_APARAMS>& operator|=(const
        integer_t<BOOST_XINT_APARAMS> n);
    integer_t<BOOST_XINT_APARAMS>& operator^=(const
        integer_t<BOOST_XINT_APARAMS> n);
    integer_t<BOOST_XINT_APARAMS>  operator<<(bitsize_t shift) const;
    integer_t<BOOST_XINT_APARAMS>  operator>>(bitsize_t shift) const;
    integer_t<BOOST_XINT_APARAMS>& operator<<=(bitsize_t shift);
    integer_t<BOOST_XINT_APARAMS>& operator>>=(bitsize_t shift);

    bool is_odd() const;
    bool is_even() const;
    int  sign(bool signed_zero = false) const;
    std::size_t hex_digits() const;

    #ifdef BOOST_XINT_DOXYGEN_IGNORE // inherited, only here for doxygen
    bool is_nan() const;
    #endif


    typedef base_divide_t<integer_t<BOOST_XINT_APARAMS> > divide_t;


    static integer_t<BOOST_XINT_APARAMS> pow2(std::size_t exponent);
    static integer_t<BOOST_XINT_APARAMS> factorial(std::size_t n);

    #ifdef BOOST_XINT_DOXYGEN_IGNORE // inherited, only here for doxygen
    static integer_t<BOOST_XINT_APARAMS> nan();
    #endif

    template <class Type> static integer_t<BOOST_XINT_APARAMS>
        random_by_size(Type& gen, bitsize_t size_in_bits, bool high_bit_on =
        false, bool low_bit_on = false, bool can_be_negative = false);
    template <class Type> static integer_t<BOOST_XINT_APARAMS>
        random_prime(Type& gen, bitsize_t size_in_bits, callback_t callback =
        no_callback);

    #ifndef BOOST_XINT_DOXYGEN_IGNORE


    void _swap(integer_t<BOOST_XINT_APARAMS>& s) { using std::swap;
        swap(data, s.data); }
    #endif

    private:
    BOOST_XINT_COPYABLE_AND_MOVABLE(type)
};

// Member function template definitions

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>::integer_t() {
    // Don't need to do anything, already preinitialized to zero.
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>::integer_t(const integer_t<BOOST_XINT_APARAMS>& b,
    bool force_thread_safety)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            data = b.data;
            if (!data.is_nan()) {
                if (force_thread_safety && Threadsafe == false)
                    data.make_unique();
            }
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        data = b.data;
        if (force_thread_safety && Threadsafe == false) data.make_unique();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
template <typename charT>
integer_t<BOOST_XINT_APARAMS>::integer_t(const charT *str, std::size_t base) {
    if (Nothrow) {
        BOOST_XINT_TRY {
            const std::basic_string<charT>& tnan = detail::nan_text<charT>();
            if (str[0] == tnan[0] && std::basic_string<charT>(str) == tnan) {
                data.make_nan();
            } else {
                data.from_string(str, base);
                if (!Signed && data.negative) _fix_negative_unsigned();
            }
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        data.from_string(str, base);
        if (!Signed && data.negative) _fix_negative_unsigned();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
template <typename charT>
integer_t<BOOST_XINT_APARAMS>::integer_t(const charT *str, const charT*& endptr,
    std::size_t base)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            const std::basic_string<charT>& tnan = detail::nan_text<charT>();
            if (str[0] == tnan[0]) {
                std::basic_string<charT> s(str);
                if (s.substr(0, tnan.length()) == tnan) {
                    data.make_nan();
                    endptr = str + tnan.length();
                    return;
                }
            }
            data.from_string(str, endptr, base);
            if (!Signed && data.negative) _fix_negative_unsigned();
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        data.from_string(str, endptr, base);
        if (!Signed && data.negative) _fix_negative_unsigned();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
template <typename charT, typename traitsT, typename allocT>
integer_t<BOOST_XINT_APARAMS>::integer_t(const std::basic_string<charT, traitsT,
    allocT>& str, std::size_t base)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            if (str == detail::nan_text<charT>()) data.make_nan();
            else {
                data.from_string(str, base);
                if (!Signed && data.negative) _fix_negative_unsigned();
            }
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        data.from_string(str, base);
        if (!Signed && data.negative) _fix_negative_unsigned();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>::integer_t(const xint::binary_t b, bitsize_t bits)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            data.from_binary(b, bits);
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        data.from_binary(b, bits);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
template <BOOST_XINT_CLASS_BPARAMS>
integer_t<BOOST_XINT_APARAMS>::integer_t(const integer_t<BOOST_XINT_BPARAMS>& b,
    bool force_thread_safety)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            if (b.is_nan()) {
                data.make_nan();
            } else {
                data = b._data();
                if (!data.is_nan()) {
                    if (force_thread_safety && Threadsafe == false)
                        data.make_unique();
                    if (!Signed && data.negative) _fix_negative_unsigned();
                }
            }
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        if (b._data().is_nan()) detail::exception_handler<>::call(__FILE__,
            __LINE__, exceptions::not_a_number());
        data = b._data();
        if (force_thread_safety && Threadsafe == false) data.make_unique();
        if (!Signed && data.negative) _fix_negative_unsigned();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
template <typename Type> integer_t<BOOST_XINT_APARAMS>::integer_t(const Type n,
    typename boost::enable_if<boost::is_integral<Type> >::type*)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            if (std::numeric_limits<Type>::is_signed) {
                data.set_signed(n);
                if (!Signed && data.negative) _fix_negative_unsigned();
            } else data.set_unsigned(n);
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        if (std::numeric_limits<Type>::is_signed) {
            data.set_signed(n);
            if (!Signed && data.negative) _fix_negative_unsigned();
        } else data.set_unsigned(n);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::
    operator=(BOOST_XINT_COPY_ASSIGN_REF(type) c)
{
    if (Nothrow) {
        if (c._data().is_nan()) data.make_nan();
        else {
            BOOST_XINT_TRY {
                data = c.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data = c.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

#ifdef BOOST_XINT_DOXYGEN_IGNORE // Doesn't really exist, this is here for docs

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::operator~() const;
#endif // BOOST_XINT_DOXYGEN_IGNORE

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::operator-() const {
    if (Nothrow) {
        if (is_nan()) return *this;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(*this);
            if (Threadsafe == true) r._make_unique();
            r.data = -r.data;
            if (!Signed && r.data.negative) r._fix_negative_unsigned();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(*this);
        if (Threadsafe == true) r._make_unique();
        r.data = -r.data;
        if (!Signed && r.data.negative) r._fix_negative_unsigned();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator+=(const
    integer_t<BOOST_XINT_APARAMS> b)
{
    if (Nothrow) {
        if (b.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data += b.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data += b.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator-=(const
    integer_t<BOOST_XINT_APARAMS> b)
{
    if (Nothrow) {
        if (b.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data -= b.data;
                if (Threadsafe == true) data.make_unique();
                if (!Signed && data.negative) _fix_negative_unsigned();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data -= b.data;
        if (Threadsafe == true) data.make_unique();
        if (!Signed && data.negative) _fix_negative_unsigned();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator*=(const
    integer_t<BOOST_XINT_APARAMS> b)
{
    if (Nothrow) {
        if (b.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data *= b.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data *= b.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator/=(const
    integer_t<BOOST_XINT_APARAMS> b)
{
    if (Nothrow) {
        if (b.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data /= b.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data /= b.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator%=(const
    integer_t<BOOST_XINT_APARAMS> b)
{
    if (Nothrow) {
        if (b.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data %= b.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data %= b.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator++() {
    if (Nothrow) {
        if (!is_nan()) {
            BOOST_XINT_TRY {
                ++data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        ++data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator--() {
    if (Nothrow) {
        if (!is_nan()) {
            BOOST_XINT_TRY {
                --data;
                if (Threadsafe == true) data.make_unique();
                if (!Signed && data.negative) _fix_negative_unsigned();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        --data;
        if (Threadsafe == true) data.make_unique();
        if (!Signed && data.negative) _fix_negative_unsigned();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::operator++(int) {
    if (Nothrow) {
        if (is_nan()) return *this;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(data++);
            if (Threadsafe == true) { r._make_unique(); data.make_unique(); }
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(data++);
        if (Threadsafe == true) { r._make_unique(); data.make_unique(); }
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::operator--(int) {
    if (Nothrow) {
        if (is_nan()) return *this;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(data--);
            if (Threadsafe == true) { r._make_unique(); data.make_unique(); }
            if (!Signed && data.negative) _fix_negative_unsigned();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            data.make_nan();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(data--);
        if (Threadsafe == true) { r._make_unique(); data.make_unique(); }
        if (!Signed && data.negative) _fix_negative_unsigned();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator&=(const
    integer_t<BOOST_XINT_APARAMS> n)
{
    if (Nothrow) {
        if (n.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data &= n.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data &= n.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator|=(const
    integer_t<BOOST_XINT_APARAMS> n)
{
    if (Nothrow) {
        if (n.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data |= n.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data |= n.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>& integer_t<BOOST_XINT_APARAMS>::operator^=(const
    integer_t<BOOST_XINT_APARAMS> n)
{
    if (Nothrow) {
        if (n.is_nan()) data.make_nan();
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data ^= n.data;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data ^= n.data;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>
integer_t<BOOST_XINT_APARAMS>::operator<<(bitsize_t shift) const {
    if (Nothrow) {
        if (is_nan()) return *this;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(data << shift);
            if (Threadsafe == true) r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(data << shift);
        if (Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>
integer_t<BOOST_XINT_APARAMS>::operator>>(bitsize_t shift) const {
    if (Nothrow) {
        if (is_nan()) return *this;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(data >> shift);
            if (Threadsafe == true) r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(data >> shift);
        if (Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>&
integer_t<BOOST_XINT_APARAMS>::operator<<=(bitsize_t shift) {
    if (Nothrow) {
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data <<= shift;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data <<= shift;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>&
integer_t<BOOST_XINT_APARAMS>::operator>>=(bitsize_t shift) {
    if (Nothrow) {
        if (!is_nan()) {
            BOOST_XINT_TRY {
                data >>= shift;
                if (Threadsafe == true) data.make_unique();
            } BOOST_XINT_CATCH {
                data.make_nan();
            }
        }
    } else {
        data >>= shift;
        if (Threadsafe == true) data.make_unique();
    }
    return *this;
}

template<BOOST_XINT_CLASS_APARAMS>
bool integer_t<BOOST_XINT_APARAMS>::is_odd() const {
    if (Nothrow) {
        if (is_nan()) return false;
        return data.is_odd();
    } else {
        return data.is_odd();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
bool integer_t<BOOST_XINT_APARAMS>::is_even() const {
    if (Nothrow) {
        if (is_nan()) return false;
        return data.is_even();
    } else {
        return data.is_even();
    }
}

#ifdef BOOST_XINT_DOXYGEN_IGNORE // Doesn't really exist, this is here for docs

template<BOOST_XINT_CLASS_APARAMS>
bool integer_t<BOOST_XINT_APARAMS>::is_nan() const;
#endif // BOOST_XINT_DOXYGEN_IGNORE

template<BOOST_XINT_CLASS_APARAMS>
int integer_t<BOOST_XINT_APARAMS>::sign(bool signed_zero) const {
    if (Nothrow) {
        if (is_nan()) return 0;
        BOOST_XINT_TRY {
            return data.sign(signed_zero);
        } BOOST_XINT_CATCH {
            return 0;
        }
    } else {
        return data.sign(signed_zero);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
size_t integer_t<BOOST_XINT_APARAMS>::hex_digits() const {
    if (Nothrow) {
        if (is_nan()) return 0;
        BOOST_XINT_TRY {
            return data.hex_digits();
        } BOOST_XINT_CATCH {
            return 0;
        }
    } else {
        return data.hex_digits();
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::pow2(std::size_t
    exponent)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r;
            detail::pow2(r.data, exponent);
            if (Threadsafe == true) r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r;
        detail::pow2(r.data, exponent);
        if (Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS>
integer_t<BOOST_XINT_APARAMS>::factorial(std::size_t n) {
    if (Nothrow) {
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r;
            detail::factorial(r.data, n);
            if (Threadsafe == true) r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r;
        detail::factorial(r.data, n);
        if (Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

#ifdef BOOST_XINT_DOXYGEN_IGNORE // Doesn't really exist, this is here for docs

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::nan();
#endif // BOOST_XINT_DOXYGEN_IGNORE

template<BOOST_XINT_CLASS_APARAMS>
template <class Type>
integer_t<BOOST_XINT_APARAMS>integer_t<BOOST_XINT_APARAMS>::random_by_size(Type&
    gen, bitsize_t size_in_bits, bool high_bit_on, bool low_bit_on, bool
    can_be_negative)
{
    if (!Signed) can_be_negative = false;
    if (Nothrow) {
        BOOST_XINT_TRY {
            return integer_t<BOOST_XINT_APARAMS>(datatype::random_by_size(gen,
                size_in_bits, high_bit_on, low_bit_on, can_be_negative));
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        return integer_t<BOOST_XINT_APARAMS>(datatype::random_by_size(gen,
            size_in_bits, high_bit_on, low_bit_on, can_be_negative));
    }
}

template<BOOST_XINT_CLASS_APARAMS>
template <class Type>
integer_t<BOOST_XINT_APARAMS> integer_t<BOOST_XINT_APARAMS>::random_prime(Type&
    gen, bitsize_t size_in_bits, callback_t callback)
{
    if (Nothrow) {
        BOOST_XINT_TRY {
            return integer_t<BOOST_XINT_APARAMS>(datatype::random_prime(gen,
                size_in_bits, callback));
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        return integer_t<BOOST_XINT_APARAMS>(datatype::random_prime(gen,
            size_in_bits, callback));
    }
}

// Free function template definitions


template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> abs(const integer_t<BOOST_XINT_APARAMS> n) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n._data().abs());
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n._data().abs());
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
typename integer_t<BOOST_XINT_APARAMS>::divide_t divide(const
    integer_t<BOOST_XINT_APARAMS> dividend, const integer_t<BOOST_XINT_APARAMS>
    divisor)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (dividend.is_nan() || divisor.is_nan()) return typename
            integer_t<BOOST_XINT_APARAMS>::divide_t(detail::get_nan<
                integer_t<BOOST_XINT_APARAMS> >(), detail::get_nan<
                integer_t<BOOST_XINT_APARAMS> >());
        BOOST_XINT_TRY {
            typename integer_t<BOOST_XINT_APARAMS>::datatype::divide_t rr =
                detail::divide(dividend._data(), divisor._data());
            typename integer_t<BOOST_XINT_APARAMS>::divide_t
                r(integer_t<BOOST_XINT_APARAMS>(rr.quotient),
                integer_t<BOOST_XINT_APARAMS>(rr.remainder));
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return typename integer_t<BOOST_XINT_APARAMS>::divide_t(
                detail::get_nan<integer_t<BOOST_XINT_APARAMS> >(),
                detail::get_nan<integer_t<BOOST_XINT_APARAMS> >());
        }
    } else {
        typename integer_t<BOOST_XINT_APARAMS>::datatype::divide_t rr =
            detail::divide(dividend._data(), divisor._data());
        typename integer_t<BOOST_XINT_APARAMS>::divide_t
            r(integer_t<BOOST_XINT_APARAMS>(rr.quotient),
            integer_t<BOOST_XINT_APARAMS>(rr.remainder));
        return BOOST_XINT_MOVE(r);
    }
}

template <BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> difference(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    typename integer_t<BOOST_XINT_APARAMS>::datatype rdata = n1._data() -
        n2._data();
    rdata.negative = false;
    return integer_t<BOOST_XINT_APARAMS>(rdata);
}



template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> square(const integer_t<BOOST_XINT_APARAMS> n) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return n;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(detail::square(n._data()));
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(detail::square(n._data()));
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> pow(const integer_t<BOOST_XINT_APARAMS> n, const
    integer_t<BOOST_XINT_APARAMS> e)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan() || e.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r;
            pow(r._data(), n._data(), e._data());
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r;
        pow(r._data(), n._data(), e._data());
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> square_root(const integer_t<BOOST_XINT_APARAMS> n)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return n;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(square_root(n._data()));
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(square_root(n._data()));
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}



template <typename T, BOOST_XINT_CLASS_APARAMS>
T to(const integer_t<BOOST_XINT_APARAMS> n) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return T(0);
        BOOST_XINT_TRY {
            return to<T>(n._data());
        } BOOST_XINT_CATCH {
            return T(0);
        }
    } else {
        return to<T>(n._data());
    }
}

template<typename charT, BOOST_XINT_CLASS_APARAMS>
std::basic_string<charT> to_stringtype(const integer_t<BOOST_XINT_APARAMS> n,
    std::size_t base = 10, bool uppercase = false)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return detail::nan_text<charT>();
        BOOST_XINT_TRY {
            return detail::to_string<charT>(n._data(), base, uppercase);
        } BOOST_XINT_CATCH {
            return std::basic_string<charT>();
        }
    } else {
        return detail::to_string<charT>(n._data(), base, uppercase);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
std::string to_string(const integer_t<BOOST_XINT_APARAMS> n, std::size_t base =
    10, bool uppercase = false)
{
    return to_stringtype<char>(n, base, uppercase);
}

template<BOOST_XINT_CLASS_APARAMS>
std::wstring to_wstring(const integer_t<BOOST_XINT_APARAMS> n, std::size_t base
    = 10, bool uppercase = false)
{
    return to_stringtype<wchar_t>(n, base, uppercase);
}

template<BOOST_XINT_CLASS_APARAMS>
xint::binary_t to_binary(const integer_t<BOOST_XINT_APARAMS> n, bitsize_t bits =
    0)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return xint::binary_t();
        BOOST_XINT_TRY {
            return to_binary(n._data(), bits);
        } BOOST_XINT_CATCH {
            return xint::binary_t();
        }
    } else {
        return to_binary(n._data(), bits);
    }
}


template<BOOST_XINT_CLASS_APARAMS>
bool getbit(const integer_t<BOOST_XINT_APARAMS> n, bitsize_t bit) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return false;
        BOOST_XINT_TRY {
            return getbit(n._data(), bit);
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return getbit(n._data(), bit);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
void setbit(integer_t<BOOST_XINT_APARAMS>& n, bitsize_t bit) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (!n.is_nan()) {
            BOOST_XINT_TRY {
                setbit(n._data(), bit);
            } BOOST_XINT_CATCH {
                // Do nothing.
            }
        }
    } else {
        setbit(n._data(), bit);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
void clearbit(integer_t<BOOST_XINT_APARAMS>& n, bitsize_t bit) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (!n.is_nan()) {
            BOOST_XINT_TRY {
                clearbit(n._data(), bit);
            } BOOST_XINT_CATCH {
                // Do nothing.
            }
        }
    } else {
        clearbit(n._data(), bit);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
bitsize_t lowestbit(const integer_t<BOOST_XINT_APARAMS> n, bitsize_t
    return_if_zero = 0)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return return_if_zero;
        BOOST_XINT_TRY {
            return lowestbit(n._data(), return_if_zero);
        } BOOST_XINT_CATCH {
            return return_if_zero;
        }
    } else {
        return lowestbit(n._data(), return_if_zero);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
bitsize_t highestbit(const integer_t<BOOST_XINT_APARAMS> n, bitsize_t
    return_if_zero = 0)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return return_if_zero;
        BOOST_XINT_TRY {
            return highestbit(n._data(), return_if_zero);
        } BOOST_XINT_CATCH {
            return return_if_zero;
        }
    } else {
        return highestbit(n._data(), return_if_zero);
    }
}



template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> mulmod(const integer_t<BOOST_XINT_APARAMS> n,
    const integer_t<BOOST_XINT_APARAMS> by, const integer_t<BOOST_XINT_APARAMS>
    modulus)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan() || by.is_nan() || modulus.is_nan()) return
            detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(mulmod(n._data(), by._data(),
                modulus._data()));
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(mulmod(n._data(), by._data(),
            modulus._data()));
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> sqrmod(const integer_t<BOOST_XINT_APARAMS> n,
    const integer_t<BOOST_XINT_APARAMS> modulus)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return n;
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r = sqrmod(n._data(),
                modulus._data());
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r = sqrmod(n._data(), modulus._data());
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> powmod(const integer_t<BOOST_XINT_APARAMS> n,
    const integer_t<BOOST_XINT_APARAMS> exponent, const
    integer_t<BOOST_XINT_APARAMS> modulus, bool no_monty = false)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan() || exponent.is_nan() || modulus.is_nan()) return
            detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(powmod(n._data(), exponent._data(),
                modulus._data(), no_monty));
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(powmod(n._data(), exponent._data(),
            modulus._data(), no_monty));
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> invmod(const integer_t<BOOST_XINT_APARAMS> n,
    const integer_t<BOOST_XINT_APARAMS> modulus)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan() || modulus.is_nan()) return
            detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(invmod(n._data(), modulus._data()));
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(invmod(n._data(), modulus._data()));
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}



template<BOOST_XINT_CLASS_APARAMS>
int is_prime(const integer_t<BOOST_XINT_APARAMS> n, callback_t callback =
    no_callback)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return -2;
        BOOST_XINT_TRY {
            return is_prime(n._data(), callback);
        } BOOST_XINT_CATCH {
            return -2;
        }
    } else {
        return is_prime(n._data(), callback);
    }
}


template<BOOST_XINT_CLASS_APARAMS> bool operator<(const
    integer_t<BOOST_XINT_APARAMS> n1, const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return false;
        BOOST_XINT_TRY {
            return operator<(n1._data(), n2._data());
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return operator<(n1._data(), n2._data());
    }
}

template<BOOST_XINT_CLASS_APARAMS> bool operator>(const
    integer_t<BOOST_XINT_APARAMS> n1, const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return false;
        BOOST_XINT_TRY {
            return operator>(n1._data(), n2._data());
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return operator>(n1._data(), n2._data());
    }
}

template<BOOST_XINT_CLASS_APARAMS> bool operator<=(const
    integer_t<BOOST_XINT_APARAMS> n1, const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return false;
        BOOST_XINT_TRY {
            return operator<=(n1._data(), n2._data());
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return operator<=(n1._data(), n2._data());
    }
}

template<BOOST_XINT_CLASS_APARAMS> bool operator>=(const
    integer_t<BOOST_XINT_APARAMS> n1, const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return false;
        BOOST_XINT_TRY {
            return operator>=(n1._data(), n2._data());
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return operator>=(n1._data(), n2._data());
    }
}

template<BOOST_XINT_CLASS_APARAMS> bool operator==(const
    integer_t<BOOST_XINT_APARAMS> n1, const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return false;
        BOOST_XINT_TRY {
            return operator==(n1._data(), n2._data());
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return operator==(n1._data(), n2._data());
    }
}

template<BOOST_XINT_CLASS_APARAMS> bool operator!=(const
    integer_t<BOOST_XINT_APARAMS> n1, const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return false;
        BOOST_XINT_TRY {
            return operator!=(n1._data(), n2._data());
        } BOOST_XINT_CATCH {
            return false;
        }
    } else {
        return operator!=(n1._data(), n2._data());
    }
}



template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator+(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() + n2._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() + n2._data());
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator-(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() - n2._data());
            if (!integer_t<BOOST_XINT_APARAMS>::Signed && r._data().negative)
                r._fix_negative_unsigned();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() - n2._data());
        if (!integer_t<BOOST_XINT_APARAMS>::Signed && r._data().negative)
            r._fix_negative_unsigned();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator*(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() * n2._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() * n2._data());
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator/(const integer_t<BOOST_XINT_APARAMS>
    dividend, const integer_t<BOOST_XINT_APARAMS> divisor)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (dividend.is_nan() || divisor.is_nan()) return
            detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(dividend._data() / divisor._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(dividend._data() / divisor._data());
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator%(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() % n2._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() % n2._data());
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator&(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() & n2._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() & n2._data());
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator|(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() | n2._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() | n2._data());
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> operator^(const integer_t<BOOST_XINT_APARAMS> n1,
    const integer_t<BOOST_XINT_APARAMS> n2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan())
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r(n1._data() ^ n2._data());
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r(n1._data() ^ n2._data());
        return BOOST_XINT_MOVE(r);
    }
}


template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> gcd(const integer_t<BOOST_XINT_APARAMS> num1,
    const integer_t<BOOST_XINT_APARAMS> num2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (num1.is_nan() || num2.is_nan()) return
            detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r;
            gcd(r._data(), num1._data(), num2._data());
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r;
        gcd(r._data(), num1._data(), num2._data());
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
integer_t<BOOST_XINT_APARAMS> lcm(const integer_t<BOOST_XINT_APARAMS> num1,
    const integer_t<BOOST_XINT_APARAMS> num2)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (num1.is_nan() || num2.is_nan()) return
            detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        BOOST_XINT_TRY {
            integer_t<BOOST_XINT_APARAMS> r;
            lcm(r._data(), num1._data(), num2._data());
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true)
                r._make_unique();
            return BOOST_XINT_MOVE(r);
        } BOOST_XINT_CATCH {
            return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
        }
    } else {
        integer_t<BOOST_XINT_APARAMS> r;
        lcm(r._data(), num1._data(), num2._data());
        if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) r._make_unique();
        return BOOST_XINT_MOVE(r);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
int compare(const integer_t<BOOST_XINT_APARAMS> n1, const
    integer_t<BOOST_XINT_APARAMS> n2, bool ignoresign = false)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n1.is_nan() || n2.is_nan()) return 2;
        BOOST_XINT_TRY {
            return compare(n1._data(), n2._data(), ignoresign);
        } BOOST_XINT_CATCH {
            return 2;
        }
    } else {
        return compare(n1._data(), n2._data(), ignoresign);
    }
}

template<BOOST_XINT_CLASS_APARAMS>
size_t log2(const integer_t<BOOST_XINT_APARAMS> n) {
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        if (n.is_nan()) return 0;
        BOOST_XINT_TRY {
            return log2(n._data());
        } BOOST_XINT_CATCH {
            return 0;
        }
    } else {
        return log2(n._data());
    }
}

#define BOOST_XINT_ANY_COMPARE(rtype, op) \
    template <BOOST_XINT_CLASS_APARAMS, typename N> \
    rtype op(const integer_t<BOOST_XINT_APARAMS> n1, const N n2) { \
        if (integer_t<BOOST_XINT_APARAMS>::Nothrow) { \
            BOOST_XINT_TRY { \
                return op(n1, integer_t<BOOST_XINT_APARAMS>(n2)); \
            } BOOST_XINT_CATCH { \
                return rtype(0); \
            } \
        } else { \
            return op(n1, integer_t<BOOST_XINT_APARAMS>(n2)); \
        } \
    } \
    \
    template <typename N, BOOST_XINT_CLASS_APARAMS> \
    rtype op(const N n1, const integer_t<BOOST_XINT_APARAMS> n2) { \
        if (integer_t<BOOST_XINT_APARAMS>::Nothrow) { \
            BOOST_XINT_TRY { \
                return op(integer_t<BOOST_XINT_APARAMS>(n1), n2); \
            } BOOST_XINT_CATCH { \
                return rtype(0); \
            } \
        } else { \
            return op(integer_t<BOOST_XINT_APARAMS>(n1), n2); \
        } \
    }

BOOST_XINT_ANY_COMPARE(bool, operator<)
BOOST_XINT_ANY_COMPARE(bool, operator>)
BOOST_XINT_ANY_COMPARE(bool, operator<=)
BOOST_XINT_ANY_COMPARE(bool, operator>=)
BOOST_XINT_ANY_COMPARE(bool, operator==)
BOOST_XINT_ANY_COMPARE(bool, operator!=)
BOOST_XINT_ANY_COMPARE(int, compare)

#define BOOST_XINT_ANY_MATH(op) \
    template <BOOST_XINT_CLASS_APARAMS, typename N> \
    integer_t<BOOST_XINT_APARAMS> op(const integer_t<BOOST_XINT_APARAMS> n1, \
        const N n2) \
    { \
        if (integer_t<BOOST_XINT_APARAMS>::Nothrow) { \
            BOOST_XINT_TRY { \
                integer_t<BOOST_XINT_APARAMS> r(op(n1, \
                    integer_t<BOOST_XINT_APARAMS>(n2))); \
                if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) \
                    r._make_unique(); \
                if (!integer_t<BOOST_XINT_APARAMS>::Signed && \
                    r._data().negative) r._fix_negative_unsigned(); \
                return BOOST_XINT_MOVE(r); \
            } BOOST_XINT_CATCH { \
                return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >(); \
            } \
        } else { \
            integer_t<BOOST_XINT_APARAMS> r(op(n1, \
                integer_t<BOOST_XINT_APARAMS>(n2))); \
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) \
                r._make_unique(); \
            if (!integer_t<BOOST_XINT_APARAMS>::Signed && r._data().negative) \
                r._fix_negative_unsigned(); \
            return BOOST_XINT_MOVE(r); \
        } \
    } \
    \
    template <typename N, BOOST_XINT_CLASS_APARAMS> \
    integer_t<BOOST_XINT_APARAMS> op(const N n1, const \
        integer_t<BOOST_XINT_APARAMS> n2) \
    { \
        if (integer_t<BOOST_XINT_APARAMS>::Nothrow) { \
            BOOST_XINT_TRY { \
                integer_t<BOOST_XINT_APARAMS> \
                    r(op(integer_t<BOOST_XINT_APARAMS>(n1), n2)); \
                if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) \
                    r._make_unique(); \
                if (!integer_t<BOOST_XINT_APARAMS>::Signed && \
                    r._data().negative) r._fix_negative_unsigned(); \
                return BOOST_XINT_MOVE(r); \
            } BOOST_XINT_CATCH { \
                return detail::get_nan<integer_t<BOOST_XINT_APARAMS> >(); \
            } \
        } else { \
            integer_t<BOOST_XINT_APARAMS> \
                r(op(integer_t<BOOST_XINT_APARAMS>(n1), n2)); \
            if (integer_t<BOOST_XINT_APARAMS>::Threadsafe == true) \
                r._make_unique(); \
            if (!integer_t<BOOST_XINT_APARAMS>::Signed && r._data().negative) \
                r._fix_negative_unsigned(); \
            return BOOST_XINT_MOVE(r); \
        } \
    }

BOOST_XINT_ANY_MATH(pow)
BOOST_XINT_ANY_MATH(mulmod)
BOOST_XINT_ANY_MATH(sqrmod)
BOOST_XINT_ANY_MATH(powmod)
BOOST_XINT_ANY_MATH(invmod)
BOOST_XINT_ANY_MATH(operator+)
BOOST_XINT_ANY_MATH(operator-)
BOOST_XINT_ANY_MATH(operator*)
BOOST_XINT_ANY_MATH(operator/)
BOOST_XINT_ANY_MATH(operator%)
BOOST_XINT_ANY_MATH(operator&)
BOOST_XINT_ANY_MATH(operator|)
BOOST_XINT_ANY_MATH(operator^)
BOOST_XINT_ANY_MATH(gcd)
BOOST_XINT_ANY_MATH(lcm)

template <typename charT, typename traits, BOOST_XINT_CLASS_APARAMS> inline
    std::basic_ostream<charT,traits>& operator<<(std::basic_ostream<charT,
    traits>& out, const integer_t<BOOST_XINT_APARAMS> n)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow && n.is_nan()) return
        operator<<(out, detail::nan_text<charT>());
    return operator<<(out, n._data());
}

template <typename charT, typename traits, BOOST_XINT_CLASS_APARAMS> inline
    std::basic_istream<charT,traits>& operator>>(std::basic_istream<charT,
    traits>& in, integer_t<BOOST_XINT_APARAMS>& n)
{
    if (integer_t<BOOST_XINT_APARAMS>::Nothrow) {
        const std::basic_string<charT>& tnan = detail::nan_text<charT>();
        charT nextchar = charT(in.peek());
        if (nextchar == tnan[0]) {
            // Must be either #NaN# or an error
            std::vector<charT> buffer;

            charT p = 0;
            for (std::size_t i = 0; i < tnan.length(); ++i) {
                in >> p;
                buffer.push_back(p);
            }
            buffer.push_back(0);

            std::basic_string<charT> str(&buffer[0]);
            if (str == tnan)
                n = detail::get_nan<integer_t<BOOST_XINT_APARAMS> >();
            else in.setstate(std::ios::failbit);
            return in;
        }
    }
    operator>>(in, n._data());
    if (!integer_t<BOOST_XINT_APARAMS>::Signed && n._data().negative)
        n._fix_negative_unsigned();
    return in;
}

template<BOOST_XINT_CLASS_APARAMS>
inline void swap(integer_t<BOOST_XINT_APARAMS>& left,
    integer_t<BOOST_XINT_APARAMS>& right)
{
    left._swap(right);
}

typedef integer_t<> integer;

typedef integer_t<options::nothrow> nothrow_integer;

} // namespace xint
} // namespace boost

#ifndef BOOST_XINT_DOXYGEN_IGNORE
namespace std {

template<BOOST_XINT_CLASS_APARAMS>
class numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> > {
    public:
    static const bool is_specialized;

    static boost::xint::integer_t<BOOST_XINT_APARAMS> min
        BOOST_PREVENT_MACRO_SUBSTITUTION() throw()
    {
        if (boost::xint::integer_t<BOOST_XINT_APARAMS>::Bits)
            return -~(boost::xint::integer_t<BOOST_XINT_APARAMS>());
        else return 0;
    }
    static boost::xint::integer_t<BOOST_XINT_APARAMS> max
        BOOST_PREVENT_MACRO_SUBSTITUTION() throw()
    {
        if (boost::xint::integer_t<BOOST_XINT_APARAMS>::Bits)
            return ~(boost::xint::integer_t<BOOST_XINT_APARAMS>());
        else return 0;
    }

    static const int digits;
    static const int digits10;
    static const bool is_signed;
    static const bool is_integer;
    static const bool is_exact;
    static const int radix;
    static boost::xint::integer_t<BOOST_XINT_APARAMS> epsilon() throw() { return
        0; }
    static boost::xint::integer_t<BOOST_XINT_APARAMS> round_error() throw() {
        return 0; }

    static const int min_exponent; // N/A
    static const int min_exponent10; // N/A
    static const int max_exponent; // N/A
    static const int max_exponent10; // N/A

    static const bool has_infinity; // N/A
    static const bool has_quiet_NaN;
    static const bool has_signaling_NaN; // N/A
    static const float_denorm_style has_denorm; // N/A
    static const bool has_denorm_loss; // N/A

    static boost::xint::integer_t<BOOST_XINT_APARAMS> infinity() throw() {
        return 0; } // N/A
    static boost::xint::integer_t<BOOST_XINT_APARAMS> quiet_NaN() throw() {
        if (boost::xint::integer_t<BOOST_XINT_APARAMS>::Nothrow) return boost::
            xint::detail::get_nan<boost::xint::integer_t<BOOST_XINT_APARAMS> >();
        else return 0;
    }
    static boost::xint::integer_t<BOOST_XINT_APARAMS> signaling_NaN() throw() {
        return 0; } // N/A
    static boost::xint::integer_t<BOOST_XINT_APARAMS> denorm_min() throw() {
        return 0; } // N/A

    static const bool is_iec559; // N/A
    static const bool is_bounded;
    static const bool is_modulo;

    static const bool traps; // I assume this means exceptions?
    static const bool tinyness_before; // N/A
    static const float_round_style round_style; // N/A
};

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    is_specialized = true;

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::digits =
    static_cast<int>(boost::xint::integer_t<BOOST_XINT_APARAMS>::Bits);

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::digits10
    = static_cast<int>(boost::xint::detail::log10_bits(
    boost::xint::integer_t<BOOST_XINT_APARAMS>::Bits));

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    is_signed = (boost::xint::integer_t<BOOST_XINT_APARAMS>::Signed ? true :
    false);

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    is_integer = true;

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::is_exact
    = true;

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::radix =
    2;

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    min_exponent = 0;

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    min_exponent10 = 0;

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    max_exponent = 0;

template<BOOST_XINT_CLASS_APARAMS>
const int numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    max_exponent10 = 0;

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    has_infinity = false;

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    has_quiet_NaN = (boost::xint::integer_t<BOOST_XINT_APARAMS>::Nothrow ? true
    : false);

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    has_signaling_NaN = false;

template<BOOST_XINT_CLASS_APARAMS>
const float_denorm_style numeric_limits<boost::xint::integer_t<
    BOOST_XINT_APARAMS> >::has_denorm = denorm_absent;

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    has_denorm_loss = false;

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    is_iec559 = false;

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    is_bounded = (boost::xint::integer_t<BOOST_XINT_APARAMS>::Bits == 0 ? false
    : true);

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    is_modulo = (boost::xint::integer_t<BOOST_XINT_APARAMS>::Bits == 0 ? false :
    true);

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::traps =
    (boost::xint::integer_t<BOOST_XINT_APARAMS>::Nothrow ? false : true);

template<BOOST_XINT_CLASS_APARAMS>
const bool numeric_limits<boost::xint::integer_t<BOOST_XINT_APARAMS> >::
    tinyness_before = false;

template<BOOST_XINT_CLASS_APARAMS>
const float_round_style numeric_limits<boost::xint::integer_t<
    BOOST_XINT_APARAMS> >::round_style = round_indeterminate;

} // namespace std
#endif // BOOST_XINT_DOXYGEN_IGNORE
#endif // BOOST_INCLUDED_XINT_INTEGER_HPP