Chris@16: ///////////////////////////////////////////////////////////////
Chris@16: //  Copyright 2012 John Maddock. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
Chris@16: 
Chris@16: #ifndef BOOST_MATH_LOGGED_ADAPTER_HPP
Chris@16: #define BOOST_MATH_LOGGED_ADAPTER_HPP
Chris@16: 
Chris@16: #include <boost/multiprecision/traits/extract_exponent_type.hpp>
Chris@16: #include <boost/multiprecision/detail/integer_ops.hpp>
Chris@16: 
Chris@16: namespace boost{
Chris@16: namespace multiprecision{
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline void log_postfix_event(const Backend&, const char* /*event_description*/)
Chris@16: {
Chris@16: }
Chris@16: template <class Backend, class T>
Chris@16: inline void log_postfix_event(const Backend&, const T&, const char* /*event_description*/)
Chris@16: {
Chris@16: }
Chris@16: template <class Backend>
Chris@16: inline void log_prefix_event(const Backend&, const char* /*event_description*/)
Chris@16: {
Chris@16: }
Chris@16: template <class Backend, class T>
Chris@16: inline void log_prefix_event(const Backend&, const T&, const char* /*event_description*/)
Chris@16: {
Chris@16: }
Chris@16: template <class Backend, class T, class U>
Chris@16: inline void log_prefix_event(const Backend&, const T&, const U&, const char* /*event_description*/)
Chris@16: {
Chris@16: }
Chris@16: template <class Backend, class T, class U, class V>
Chris@16: inline void log_prefix_event(const Backend&, const T&, const U&, const V&, const char* /*event_description*/)
Chris@16: {
Chris@16: }
Chris@16: 
Chris@16: namespace backends{
Chris@16: 
Chris@16: template <class Backend>
Chris@16: struct logged_adaptor
Chris@16: {
Chris@16:    typedef typename Backend::signed_types              signed_types;
Chris@16:    typedef typename Backend::unsigned_types            unsigned_types;
Chris@16:    typedef typename Backend::float_types               float_types;
Chris@16:    typedef typename extract_exponent_type<
Chris@16:       Backend, number_category<Backend>::value>::type  exponent_type;
Chris@16: 
Chris@16: private:
Chris@16: 
Chris@16:    Backend m_value;
Chris@16: public:
Chris@16:    logged_adaptor()
Chris@16:    {
Chris@16:       log_postfix_event(m_value, "Default construct");
Chris@16:    }
Chris@16:    logged_adaptor(const logged_adaptor& o)
Chris@16:    {
Chris@16:       log_prefix_event(m_value, o.value(), "Copy construct");
Chris@16:       m_value = o.m_value;
Chris@16:       log_postfix_event(m_value, "Copy construct");
Chris@16:    }
Chris@16:    logged_adaptor& operator = (const logged_adaptor& o)
Chris@16:    {
Chris@16:       log_prefix_event(m_value, o.value(), "Assignment");
Chris@16:       m_value = o.m_value;
Chris@16:       log_postfix_event(m_value, "Copy construct");
Chris@16:       return *this;
Chris@16:    }
Chris@16:    template <class T>
Chris@16:    logged_adaptor(const T& i, const typename enable_if_c<is_convertible<T, Backend>::value>::type* = 0)
Chris@16:       : m_value(i)
Chris@16:    {
Chris@16:       log_postfix_event(m_value, "construct from arithmetic type");
Chris@16:    }
Chris@16:    template <class T>
Chris@16:    typename enable_if_c<is_arithmetic<T>::value || is_convertible<T, Backend>::value, logged_adaptor&>::type operator = (const T& i)
Chris@16:    {
Chris@16:       log_prefix_event(m_value, i, "Assignment from arithmetic type");
Chris@16:       m_value = i;
Chris@16:       log_postfix_event(m_value, "Assignment from arithmetic type");
Chris@16:       return *this;
Chris@16:    }
Chris@16:    logged_adaptor& operator = (const char* s)
Chris@16:    {
Chris@16:       log_prefix_event(m_value, s, "Assignment from string type");
Chris@16:       m_value = s;
Chris@16:       log_postfix_event(m_value, "Assignment from string type");
Chris@16:       return *this;
Chris@16:    }
Chris@16:    void swap(logged_adaptor& o)
Chris@16:    {
Chris@16:       log_prefix_event(m_value, o.value(), "swap");
Chris@16:       std::swap(m_value, o.value());
Chris@16:       log_postfix_event(m_value, "swap");
Chris@16:    }
Chris@16:    std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
Chris@16:    {
Chris@16:       log_prefix_event(m_value, "Conversion to string");
Chris@16:       std::string s = m_value.str(digits, f);
Chris@16:       log_postfix_event(m_value, s, "Conversion to string");
Chris@16:       return s;
Chris@16:    }
Chris@16:    void negate()
Chris@16:    {
Chris@16:       log_prefix_event(m_value, "negate");
Chris@16:       m_value.negate();
Chris@16:       log_postfix_event(m_value, "negate");
Chris@16:    }
Chris@16:    int compare(const logged_adaptor& o)const
Chris@16:    {
Chris@16:       log_prefix_event(m_value, o.value(), "compare");
Chris@16:       int r = m_value.compare(o.value());
Chris@16:       log_postfix_event(m_value, r, "compare");
Chris@16:       return r;
Chris@16:    }
Chris@16:    template <class T>
Chris@16:    int compare(const T& i)const
Chris@16:    {
Chris@16:       log_prefix_event(m_value, i, "compare");
Chris@16:       int r = m_value.compare(i);
Chris@16:       log_postfix_event(m_value, r, "compare");
Chris@16:       return r;
Chris@16:    }
Chris@16:    Backend& value()
Chris@16:    {
Chris@16:       return m_value;
Chris@16:    }
Chris@16:    const Backend& value()const
Chris@16:    {
Chris@16:       return m_value;
Chris@16:    }
Chris@16:    template <class Archive>
Chris@16:    void serialize(Archive& ar, const unsigned int /*version*/)
Chris@16:    {
Chris@16:       log_prefix_event(m_value, "serialize");
Chris@16:       ar & m_value;
Chris@16:       log_postfix_event(m_value, "serialize");
Chris@16:    }
Chris@16: };
Chris@16: 
Chris@16: template <class T>
Chris@16: inline const T& unwrap_logged_type(const T& a) { return a; }
Chris@16: template <class Backend>
Chris@16: inline const Backend& unwrap_logged_type(const logged_adaptor<Backend>& a) { return a.value(); }
Chris@16: 
Chris@16: #define NON_MEMBER_OP1(name, str) \
Chris@16:    template <class Backend>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value());\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }
Chris@16: 
Chris@16: #define NON_MEMBER_OP2(name, str) \
Chris@16:    template <class Backend, class T>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const T& a)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }
Chris@16: 
Chris@16: #define NON_MEMBER_OP3(name, str) \
Chris@16:    template <class Backend, class T, class U>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const T& a, const U& b)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend, class T>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a, const T& b)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend, class T>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const T& a, const logged_adaptor<Backend>& b)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }
Chris@16: 
Chris@16: #define NON_MEMBER_OP4(name, str) \
Chris@16:    template <class Backend, class T, class U, class V>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const T& a, const U& b, const V& c)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend, class T>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b, const T& c)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend, class T>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a, const T& b, const logged_adaptor<Backend>& c)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend, class T>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const T& a, const logged_adaptor<Backend>& b, const logged_adaptor<Backend>& c)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b, const logged_adaptor<Backend>& c)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16:    template <class Backend, class T, class U>\
Chris@16:    inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& a, const T& b, const U& c)\
Chris@16:    {\
Chris@16:       using default_ops::BOOST_JOIN(eval_, name);\
Chris@16:       log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);\
Chris@16:       BOOST_JOIN(eval_, name)(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));\
Chris@16:       log_postfix_event(result.value(), str);\
Chris@16:    }\
Chris@16: 
Chris@16: NON_MEMBER_OP2(add, "+=");
Chris@16: NON_MEMBER_OP2(subtract, "-=");
Chris@16: NON_MEMBER_OP2(multiply, "*=");
Chris@16: NON_MEMBER_OP2(divide, "/=");
Chris@16: 
Chris@16: template <class Backend, class R>
Chris@16: inline void eval_convert_to(R* result, const logged_adaptor<Backend>& val)
Chris@16: {
Chris@16:    using default_ops::eval_convert_to;
Chris@16:    log_prefix_event(val.value(), "convert_to");
Chris@16:    eval_convert_to(result, val.value());
Chris@16:    log_postfix_event(val.value(), *result, "convert_to");
Chris@16: }
Chris@16: 
Chris@16: template <class Backend, class Exp>
Chris@16: inline void eval_frexp(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp* exp)
Chris@16: {
Chris@16:    log_prefix_event(arg.value(), "frexp");
Chris@16:    eval_frexp(result.value(), arg.value(), exp);
Chris@16:    log_postfix_event(result.value(), *exp, "frexp");
Chris@16: }
Chris@16: 
Chris@16: template <class Backend, class Exp>
Chris@16: inline void eval_ldexp(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp exp)
Chris@16: {
Chris@16:    log_prefix_event(arg.value(), "ldexp");
Chris@16:    eval_ldexp(result.value(), arg.value(), exp);
Chris@16:    log_postfix_event(result.value(), exp, "ldexp");
Chris@16: }
Chris@16: 
Chris@101: template <class Backend, class Exp>
Chris@101: inline void eval_scalbn(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp exp)
Chris@101: {
Chris@101:    log_prefix_event(arg.value(), "scalbn");
Chris@101:    eval_scalbn(result.value(), arg.value(), exp);
Chris@101:    log_postfix_event(result.value(), exp, "scalbn");
Chris@101: }
Chris@101: 
Chris@101: template <class Backend>
Chris@101: inline typename Backend::exponent_type eval_ilogb(const logged_adaptor<Backend>& arg)
Chris@101: {
Chris@101:    log_prefix_event(arg.value(), "ilogb");
Chris@101:    typename Backend::exponent_type r = eval_ilogb(arg.value());
Chris@101:    log_postfix_event(arg.value(), "ilogb");
Chris@101:    return r;
Chris@101: }
Chris@101: 
Chris@16: NON_MEMBER_OP2(floor, "floor");
Chris@16: NON_MEMBER_OP2(ceil, "ceil");
Chris@16: NON_MEMBER_OP2(sqrt, "sqrt");
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline int eval_fpclassify(const logged_adaptor<Backend>& arg)
Chris@16: {
Chris@16:    using default_ops::eval_fpclassify;
Chris@16:    log_prefix_event(arg.value(), "fpclassify");
Chris@16:    int r = eval_fpclassify(arg.value());
Chris@16:    log_postfix_event(arg.value(), r, "fpclassify");
Chris@16:    return r;
Chris@16: }
Chris@16: 
Chris@16: /*********************************************************************
Chris@16: *
Chris@16: * Optional arithmetic operations come next:
Chris@16: *
Chris@16: *********************************************************************/
Chris@16: 
Chris@16: NON_MEMBER_OP3(add, "+");
Chris@16: NON_MEMBER_OP3(subtract, "-");
Chris@16: NON_MEMBER_OP3(multiply, "*");
Chris@16: NON_MEMBER_OP3(divide, "/");
Chris@16: NON_MEMBER_OP3(multiply_add, "fused-multiply-add");
Chris@16: NON_MEMBER_OP3(multiply_subtract, "fused-multiply-subtract");
Chris@16: NON_MEMBER_OP4(multiply_add, "fused-multiply-add");
Chris@16: NON_MEMBER_OP4(multiply_subtract, "fused-multiply-subtract");
Chris@16: 
Chris@16: NON_MEMBER_OP1(increment, "increment");
Chris@16: NON_MEMBER_OP1(decrement, "decrement");
Chris@16: 
Chris@16: /*********************************************************************
Chris@16: *
Chris@16: * Optional integer operations come next:
Chris@16: *
Chris@16: *********************************************************************/
Chris@16: 
Chris@16: NON_MEMBER_OP2(modulus, "%=");
Chris@16: NON_MEMBER_OP3(modulus, "%");
Chris@16: NON_MEMBER_OP2(bitwise_or, "|=");
Chris@16: NON_MEMBER_OP3(bitwise_or, "|");
Chris@16: NON_MEMBER_OP2(bitwise_and, "&=");
Chris@16: NON_MEMBER_OP3(bitwise_and, "&");
Chris@16: NON_MEMBER_OP2(bitwise_xor, "^=");
Chris@16: NON_MEMBER_OP3(bitwise_xor, "^");
Chris@16: NON_MEMBER_OP4(qr, "quotient-and-remainder");
Chris@16: NON_MEMBER_OP2(complement, "~");
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline void eval_left_shift(logged_adaptor<Backend>& arg, unsigned a)
Chris@16: {
Chris@16:    using default_ops::eval_left_shift;
Chris@16:    log_prefix_event(arg.value(), a, "<<=");
Chris@16:    eval_left_shift(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), "<<=");
Chris@16: }
Chris@16: template <class Backend>
Chris@16: inline void eval_left_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, unsigned b)
Chris@16: {
Chris@16:    using default_ops::eval_left_shift;
Chris@16:    log_prefix_event(arg.value(), a, b, "<<");
Chris@16:    eval_left_shift(arg.value(), a.value(), b);
Chris@16:    log_postfix_event(arg.value(), "<<");
Chris@16: }
Chris@16: template <class Backend>
Chris@16: inline void eval_right_shift(logged_adaptor<Backend>& arg, unsigned a)
Chris@16: {
Chris@16:    using default_ops::eval_right_shift;
Chris@16:    log_prefix_event(arg.value(), a, ">>=");
Chris@16:    eval_right_shift(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), ">>=");
Chris@16: }
Chris@16: template <class Backend>
Chris@16: inline void eval_right_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, unsigned b)
Chris@16: {
Chris@16:    using default_ops::eval_right_shift;
Chris@16:    log_prefix_event(arg.value(), a, b, ">>");
Chris@16:    eval_right_shift(arg.value(), a.value(), b);
Chris@16:    log_postfix_event(arg.value(), ">>");
Chris@16: }
Chris@16: 
Chris@16: template <class Backend, class T>
Chris@16: inline unsigned eval_integer_modulus(const logged_adaptor<Backend>& arg, const T& a)
Chris@16: {
Chris@16:    using default_ops::eval_integer_modulus;
Chris@16:    log_prefix_event(arg.value(), a, "integer-modulus");
Chris@16:    unsigned r = eval_integer_modulus(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), r, "integer-modulus");
Chris@16:    return r;
Chris@16: }
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline unsigned eval_lsb(const logged_adaptor<Backend>& arg)
Chris@16: {
Chris@16:    using default_ops::eval_lsb;
Chris@16:    log_prefix_event(arg.value(), "least-significant-bit");
Chris@16:    unsigned r = eval_lsb(arg.value());
Chris@16:    log_postfix_event(arg.value(), r, "least-significant-bit");
Chris@16:    return r;
Chris@16: }
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline unsigned eval_msb(const logged_adaptor<Backend>& arg)
Chris@16: {
Chris@16:    using default_ops::eval_msb;
Chris@16:    log_prefix_event(arg.value(), "most-significant-bit");
Chris@16:    unsigned r = eval_msb(arg.value());
Chris@16:    log_postfix_event(arg.value(), r, "most-significant-bit");
Chris@16:    return r;
Chris@16: }
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline bool eval_bit_test(const logged_adaptor<Backend>& arg, unsigned a)
Chris@16: {
Chris@16:    using default_ops::eval_bit_test;
Chris@16:    log_prefix_event(arg.value(), a, "bit-test");
Chris@16:    bool r = eval_bit_test(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), r, "bit-test");
Chris@16:    return r;
Chris@16: }
Chris@16: 
Chris@16: template <class Backend>
Chris@16: inline void eval_bit_set(const logged_adaptor<Backend>& arg, unsigned a)
Chris@16: {
Chris@16:    using default_ops::eval_bit_set;
Chris@16:    log_prefix_event(arg.value(), a, "bit-set");
Chris@16:    eval_bit_set(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), arg, "bit-set");
Chris@16: }
Chris@16: template <class Backend>
Chris@16: inline void eval_bit_unset(const logged_adaptor<Backend>& arg, unsigned a)
Chris@16: {
Chris@16:    using default_ops::eval_bit_unset;
Chris@16:    log_prefix_event(arg.value(), a, "bit-unset");
Chris@16:    eval_bit_unset(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), arg, "bit-unset");
Chris@16: }
Chris@16: template <class Backend>
Chris@16: inline void eval_bit_flip(const logged_adaptor<Backend>& arg, unsigned a)
Chris@16: {
Chris@16:    using default_ops::eval_bit_flip;
Chris@16:    log_prefix_event(arg.value(), a, "bit-flip");
Chris@16:    eval_bit_flip(arg.value(), a);
Chris@16:    log_postfix_event(arg.value(), arg, "bit-flip");
Chris@16: }
Chris@16: 
Chris@16: NON_MEMBER_OP3(gcd, "gcd");
Chris@16: NON_MEMBER_OP3(lcm, "lcm");
Chris@16: NON_MEMBER_OP4(powm, "powm");
Chris@16: 
Chris@16: /*********************************************************************
Chris@16: *
Chris@16: * abs/fabs:
Chris@16: *
Chris@16: *********************************************************************/
Chris@16: 
Chris@16: NON_MEMBER_OP2(abs, "abs");
Chris@16: NON_MEMBER_OP2(fabs, "fabs");
Chris@16: 
Chris@16: /*********************************************************************
Chris@16: *
Chris@16: * Floating point functions:
Chris@16: *
Chris@16: *********************************************************************/
Chris@16: 
Chris@16: NON_MEMBER_OP2(trunc, "trunc");
Chris@16: NON_MEMBER_OP2(round, "round");
Chris@16: NON_MEMBER_OP2(exp, "exp");
Chris@16: NON_MEMBER_OP2(log, "log");
Chris@16: NON_MEMBER_OP2(log10, "log10");
Chris@16: NON_MEMBER_OP2(sin, "sin");
Chris@16: NON_MEMBER_OP2(cos, "cos");
Chris@16: NON_MEMBER_OP2(tan, "tan");
Chris@16: NON_MEMBER_OP2(asin, "asin");
Chris@16: NON_MEMBER_OP2(acos, "acos");
Chris@16: NON_MEMBER_OP2(atan, "atan");
Chris@16: NON_MEMBER_OP2(sinh, "sinh");
Chris@16: NON_MEMBER_OP2(cosh, "cosh");
Chris@16: NON_MEMBER_OP2(tanh, "tanh");
Chris@101: NON_MEMBER_OP2(logb, "logb");
Chris@16: NON_MEMBER_OP3(fmod, "fmod");
Chris@16: NON_MEMBER_OP3(pow, "pow");
Chris@16: NON_MEMBER_OP3(atan2, "atan2");
Chris@16: 
Chris@16: } // namespace backends
Chris@16: 
Chris@16: using backends::logged_adaptor;
Chris@16: 
Chris@16: template<class Backend>
Chris@16: struct number_category<backends::logged_adaptor<Backend> > : public number_category<Backend> {};
Chris@16: 
Chris@16: }} // namespaces
Chris@16: 
Chris@16: namespace std{
Chris@16: 
Chris@16: template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<Backend>, ExpressionTemplates> >
Chris@16:    : public std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >
Chris@16: {
Chris@16:    typedef std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> > base_type;
Chris@16:    typedef boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<Backend>, ExpressionTemplates> number_type;
Chris@16: public:
Chris@16:    static number_type (min)() BOOST_NOEXCEPT { return (base_type::min)(); }
Chris@16:    static number_type (max)() BOOST_NOEXCEPT { return (base_type::max)(); }
Chris@16:    static number_type lowest() BOOST_NOEXCEPT { return -(max)(); }
Chris@16:    static number_type epsilon() BOOST_NOEXCEPT { return base_type::epsilon(); }
Chris@16:    static number_type round_error() BOOST_NOEXCEPT { return epsilon() / 2; }
Chris@16:    static number_type infinity() BOOST_NOEXCEPT { return base_type::infinity(); }
Chris@16:    static number_type quiet_NaN() BOOST_NOEXCEPT { return base_type::quiet_NaN(); }
Chris@16:    static number_type signaling_NaN() BOOST_NOEXCEPT { return base_type::signaling_NaN(); }
Chris@16:    static number_type denorm_min() BOOST_NOEXCEPT { return base_type::denorm_min(); }
Chris@16: };
Chris@16: 
Chris@16: } // namespace std
Chris@16: 
Chris@16: namespace boost{ namespace math{
Chris@16: 
Chris@16: namespace policies{
Chris@16: 
Chris@16: template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
Chris@16: struct precision< boost::multiprecision::number<boost::multiprecision::logged_adaptor<Backend>, ExpressionTemplates>, Policy>
Chris@16:    : public precision<boost::multiprecision::number<Backend, ExpressionTemplates>, Policy>
Chris@16: {};
Chris@16: 
Chris@16: } // namespace policies
Chris@16: 
Chris@16: }} // namespaces boost::math
Chris@16: 
Chris@16: #undef NON_MEMBER_OP1
Chris@16: #undef NON_MEMBER_OP2
Chris@16: #undef NON_MEMBER_OP3
Chris@16: #undef NON_MEMBER_OP4
Chris@16: 
Chris@16: #endif