mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.whl

mqt/core/include/mqt-core/boost/multiprecision/logged_adaptor.hpp

@@ -0,0 +1,834 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_MP_LOGGED_ADAPTER_HPP
+#define BOOST_MP_LOGGED_ADAPTER_HPP
+
+#include <boost/multiprecision/detail/standalone_config.hpp>
+#include <boost/multiprecision/traits/extract_exponent_type.hpp>
+#include <boost/multiprecision/detail/integer_ops.hpp>
+
+namespace boost {
+namespace multiprecision {
+
+template <class Backend>
+inline void log_postfix_event(const Backend&, const char* /*event_description*/)
+{
+}
+template <class Backend, class T>
+inline void log_postfix_event(const Backend&, const T&, const char* /*event_description*/)
+{
+}
+template <class Backend>
+inline void log_prefix_event(const Backend&, const char* /*event_description*/)
+{
+}
+template <class Backend, class T>
+inline void log_prefix_event(const Backend&, const T&, const char* /*event_description*/)
+{
+}
+template <class Backend, class T, class U>
+inline void log_prefix_event(const Backend&, const T&, const U&, const char* /*event_description*/)
+{
+}
+template <class Backend, class T, class U, class V>
+inline void log_prefix_event(const Backend&, const T&, const U&, const V&, const char* /*event_description*/)
+{
+}
+
+namespace backends {
+
+template <class Backend>
+struct logged_adaptor
+{
+   using signed_types = typename Backend::signed_types  ;
+   using unsigned_types = typename Backend::unsigned_types;
+   using float_types = typename Backend::float_types   ;
+   using exponent_type = typename extract_exponent_type<Backend, number_category<Backend>::value>::type;
+
+ private:
+   Backend m_value;
+
+ public:
+   logged_adaptor()
+   {
+      log_postfix_event(m_value, "Default construct");
+   }
+   logged_adaptor(const logged_adaptor& o)
+   {
+      log_prefix_event(m_value, o.value(), "Copy construct");
+      m_value = o.m_value;
+      log_postfix_event(m_value, "Copy construct");
+   }
+   // rvalue copy
+   logged_adaptor(logged_adaptor&& o)
+   {
+      log_prefix_event(m_value, o.value(), "Move construct");
+      m_value = static_cast<Backend&&>(o.m_value);
+      log_postfix_event(m_value, "Move construct");
+   }
+   logged_adaptor& operator=(logged_adaptor&& o)
+   {
+      log_prefix_event(m_value, o.value(), "Move Assignment");
+      m_value = static_cast<Backend&&>(o.m_value);
+      log_postfix_event(m_value, "Move construct");
+      return *this;
+   }
+   logged_adaptor& operator=(const logged_adaptor& o)
+   {
+      log_prefix_event(m_value, o.value(), "Assignment");
+      m_value = o.m_value;
+      log_postfix_event(m_value, "Copy construct");
+      return *this;
+   }
+   template <class T>
+   logged_adaptor(const T& i, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
+       : m_value(i)
+   {
+      log_postfix_event(m_value, "construct from arithmetic type");
+   }
+   template <class T>
+   logged_adaptor(const logged_adaptor<T>& i, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
+       : m_value(i.value())
+   {
+      log_postfix_event(m_value, "construct from arithmetic type");
+   }
+   template <class T, class U>
+   logged_adaptor(const T& i, const U& j, typename std::enable_if<std::is_constructible<Backend, const T&, const U&>::value>::type* = nullptr)
+      : m_value(i, j)
+   {
+      log_postfix_event(m_value, "construct from a pair of arithmetic types");
+   }
+   template <class D = Backend>
+   logged_adaptor(const Backend& i, unsigned digits10, typename std::enable_if<std::is_constructible<D, Backend const&, unsigned>::value>::type const* = nullptr)
+      : m_value(i, digits10)
+   {
+      log_postfix_event(m_value, "construct from arithmetic type and precision");
+   }
+   template <class D = Backend>
+   logged_adaptor(const logged_adaptor<Backend>& i, unsigned digits10, typename std::enable_if<std::is_constructible<D, Backend const&, unsigned>::value>::type const* = nullptr)
+      : m_value(i.value(), digits10)
+   {
+      log_postfix_event(m_value, "construct from arithmetic type and precision");
+   }
+   template <class T>
+   typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value || std::is_assignable<Backend, T>::value, logged_adaptor&>::type operator=(const T& i)
+   {
+      log_prefix_event(m_value, i, "Assignment from arithmetic type");
+      m_value = i;
+      log_postfix_event(m_value, "Assignment from arithmetic type");
+      return *this;
+   }
+   logged_adaptor& operator=(const char* s)
+   {
+      log_prefix_event(m_value, s, "Assignment from string type");
+      m_value = s;
+      log_postfix_event(m_value, "Assignment from string type");
+      return *this;
+   }
+   void swap(logged_adaptor& o)
+   {
+      log_prefix_event(m_value, o.value(), "swap");
+      std::swap(m_value, o.value());
+      log_postfix_event(m_value, "swap");
+   }
+   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
+   {
+      log_prefix_event(m_value, "Conversion to string");
+      std::string s = m_value.str(digits, f);
+      log_postfix_event(m_value, s, "Conversion to string");
+      return s;
+   }
+   void negate()
+   {
+      log_prefix_event(m_value, "negate");
+      m_value.negate();
+      log_postfix_event(m_value, "negate");
+   }
+   int compare(const logged_adaptor& o) const
+   {
+      log_prefix_event(m_value, o.value(), "compare");
+      int r = m_value.compare(o.value());
+      log_postfix_event(m_value, r, "compare");
+      return r;
+   }
+   template <class T>
+   int compare(const T& i) const
+   {
+      log_prefix_event(m_value, i, "compare");
+      int r = m_value.compare(i);
+      log_postfix_event(m_value, r, "compare");
+      return r;
+   }
+   Backend& value()
+   {
+      return m_value;
+   }
+   const Backend& value() const
+   {
+      return m_value;
+   }
+   
+   #ifndef BOOST_MP_STANDALONE
+   template <class Archive>
+   void serialize(Archive& ar, const unsigned int /*version*/)
+   {
+      log_prefix_event(m_value, "serialize");
+      ar& boost::make_nvp("value", m_value);
+      log_postfix_event(m_value, "serialize");
+   }
+   #endif
+
+   static unsigned default_precision() noexcept
+   {
+      return Backend::default_precision();
+   }
+   static void default_precision(unsigned v) noexcept
+   {
+      Backend::default_precision(v);
+   }
+   static unsigned thread_default_precision() noexcept
+   {
+      return Backend::thread_default_precision();
+   }
+   static void thread_default_precision(unsigned v) noexcept
+   {
+      Backend::thread_default_precision(v);
+   }
+   unsigned precision() const noexcept
+   {
+      return value().precision();
+   }
+   void precision(unsigned digits10) noexcept
+   {
+      value().precision(digits10);
+   }
+   //
+   // Variable precision options:
+   // 
+   static constexpr variable_precision_options default_variable_precision_options()noexcept
+   {
+      return Backend::default_variable_precision_options();
+   }
+   static constexpr variable_precision_options thread_default_variable_precision_options()noexcept
+   {
+      return Backend::thread_default_variable_precision_options();
+   }
+   static BOOST_MP_CXX14_CONSTEXPR void default_variable_precision_options(variable_precision_options opts)
+   {
+      Backend::default_variable_precision_options(opts);
+   }
+   static BOOST_MP_CXX14_CONSTEXPR void thread_default_variable_precision_options(variable_precision_options opts)
+   {
+      Backend::thread_default_variable_precision_options(opts);
+   }
+};
+
+template <class T>
+inline const T& unwrap_logged_type(const T& a) { return a; }
+template <class Backend>
+inline const Backend& unwrap_logged_type(const logged_adaptor<Backend>& a) { return a.value(); }
+
+#define NON_MEMBER_OP1(name, str)                                        \
+   template <class Backend>                                              \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result) \
+   {                                                                     \
+      using default_ops::BOOST_JOIN(eval_, name);                        \
+      log_prefix_event(result.value(), str);                             \
+      BOOST_JOIN(eval_, name)                                            \
+      (result.value());                                                  \
+      log_postfix_event(result.value(), str);                            \
+   }
+
+#define NON_MEMBER_OP2(name, str)                                                                          \
+   template <class Backend, class T>                                                                       \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a)                       \
+   {                                                                                                       \
+      using default_ops::BOOST_JOIN(eval_, name);                                                          \
+      log_prefix_event(result.value(), unwrap_logged_type(a), str);                                        \
+      BOOST_JOIN(eval_, name)                                                                              \
+      (result.value(), unwrap_logged_type(a));                                                             \
+      log_postfix_event(result.value(), str);                                                              \
+   }                                                                                                       \
+   template <class Backend>                                                                                \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a) \
+   {                                                                                                       \
+      using default_ops::BOOST_JOIN(eval_, name);                                                          \
+      log_prefix_event(result.value(), unwrap_logged_type(a), str);                                        \
+      BOOST_JOIN(eval_, name)                                                                              \
+      (result.value(), unwrap_logged_type(a));                                                             \
+      log_postfix_event(result.value(), str);                                                              \
+   }
+
+#define NON_MEMBER_OP3(name, str)                                                                                                            \
+   template <class Backend, class T, class U>                                                                                                \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const U& b)                                             \
+   {                                                                                                                                         \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
+      BOOST_JOIN(eval_, name)                                                                                                                \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
+      log_postfix_event(result.value(), str);                                                                                                \
+   }                                                                                                                                         \
+   template <class Backend, class T>                                                                                                         \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const T& b)                       \
+   {                                                                                                                                         \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
+      BOOST_JOIN(eval_, name)                                                                                                                \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
+      log_postfix_event(result.value(), str);                                                                                                \
+   }                                                                                                                                         \
+   template <class Backend, class T>                                                                                                         \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const logged_adaptor<Backend>& b)                       \
+   {                                                                                                                                         \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
+      BOOST_JOIN(eval_, name)                                                                                                                \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
+      log_postfix_event(result.value(), str);                                                                                                \
+   }                                                                                                                                         \
+   template <class Backend>                                                                                                                  \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b) \
+   {                                                                                                                                         \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
+      BOOST_JOIN(eval_, name)                                                                                                                \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
+      log_postfix_event(result.value(), str);                                                                                                \
+   }
+
+#define NON_MEMBER_OP4(name, str)                                                                                                                                              \
+   template <class Backend, class T, class U, class V>                                                                                                                         \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const U& b, const V& c)                                                                   \
+   {                                                                                                                                                                           \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
+      BOOST_JOIN(eval_, name)                                                                                                                                                  \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
+      log_postfix_event(result.value(), str);                                                                                                                                  \
+   }                                                                                                                                                                           \
+   template <class Backend, class T>                                                                                                                                           \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b, const T& c)                       \
+   {                                                                                                                                                                           \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
+      BOOST_JOIN(eval_, name)                                                                                                                                                  \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
+      log_postfix_event(result.value(), str);                                                                                                                                  \
+   }                                                                                                                                                                           \
+   template <class Backend, class T>                                                                                                                                           \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const T& b, const logged_adaptor<Backend>& c)                       \
+   {                                                                                                                                                                           \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
+      BOOST_JOIN(eval_, name)                                                                                                                                                  \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
+      log_postfix_event(result.value(), str);                                                                                                                                  \
+   }                                                                                                                                                                           \
+   template <class Backend, class T>                                                                                                                                           \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const logged_adaptor<Backend>& b, const logged_adaptor<Backend>& c)                       \
+   {                                                                                                                                                                           \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
+      BOOST_JOIN(eval_, name)                                                                                                                                                  \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
+      log_postfix_event(result.value(), str);                                                                                                                                  \
+   }                                                                                                                                                                           \
+   template <class Backend>                                                                                                                                                    \
+   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) \
+   {                                                                                                                                                                           \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
+      BOOST_JOIN(eval_, name)                                                                                                                                                  \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
+      log_postfix_event(result.value(), str);                                                                                                                                  \
+   }                                                                                                                                                                           \
+   template <class Backend, class T, class U>                                                                                                                                  \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const T& b, const U& c)                                             \
+   {                                                                                                                                                                           \
+      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
+      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
+      BOOST_JOIN(eval_, name)                                                                                                                                                  \
+      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
+      log_postfix_event(result.value(), str);                                                                                                                                  \
+   }
+
+NON_MEMBER_OP2(add, "+=")
+NON_MEMBER_OP2(subtract, "-=")
+NON_MEMBER_OP2(multiply, "*=")
+NON_MEMBER_OP2(divide, "/=")
+
+template <class Backend, class R>
+inline void eval_convert_to(R* result, const logged_adaptor<Backend>& val)
+{
+   using default_ops::eval_convert_to;
+   log_prefix_event(val.value(), "convert_to");
+   eval_convert_to(result, val.value());
+   log_postfix_event(val.value(), *result, "convert_to");
+}
+
+template <class Backend, class R>
+inline void eval_convert_to(logged_adaptor<R>* result, const logged_adaptor<Backend>& val)
+{
+   using default_ops::eval_convert_to;
+   log_prefix_event(val.value(), "convert_to");
+   eval_convert_to(&result->value(), val.value());
+   log_postfix_event(val.value(), &result->value(), "convert_to");
+}
+template <class Backend, class R>
+inline void eval_convert_to(logged_adaptor<R>* result, const Backend& val)
+{
+   using default_ops::eval_convert_to;
+   log_prefix_event(val, "convert_to");
+   eval_convert_to(&result->value(), val);
+   log_postfix_event(val, &result->value(), "convert_to");
+}
+
+template <class Backend>
+inline void eval_convert_to(std::complex<float>* result, const logged_adaptor<Backend>& val)
+{
+   using default_ops::eval_convert_to;
+   log_prefix_event(val.value(), "convert_to");
+   eval_convert_to(result, val.value());
+   log_postfix_event(val.value(), *result, "convert_to");
+}
+template <class Backend>
+inline void eval_convert_to(std::complex<double>* result, const logged_adaptor<Backend>& val)
+{
+   using default_ops::eval_convert_to;
+   log_prefix_event(val.value(), "convert_to");
+   eval_convert_to(result, val.value());
+   log_postfix_event(val.value(), *result, "convert_to");
+}
+template <class Backend>
+inline void eval_convert_to(std::complex<long double>* result, const logged_adaptor<Backend>& val)
+{
+   using default_ops::eval_convert_to;
+   log_prefix_event(val.value(), "convert_to");
+   eval_convert_to(result, val.value());
+   log_postfix_event(val.value(), *result, "convert_to");
+}
+
+
+template <class Backend, class Exp>
+inline void eval_frexp(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp* exp)
+{
+   log_prefix_event(arg.value(), "frexp");
+   eval_frexp(result.value(), arg.value(), exp);
+   log_postfix_event(result.value(), *exp, "frexp");
+}
+
+template <class Backend, class Exp>
+inline void eval_ldexp(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp exp)
+{
+   log_prefix_event(arg.value(), "ldexp");
+   eval_ldexp(result.value(), arg.value(), exp);
+   log_postfix_event(result.value(), exp, "ldexp");
+}
+
+template <class Backend, class Exp>
+inline void eval_scalbn(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp exp)
+{
+   using default_ops::eval_scalbn;
+   log_prefix_event(arg.value(), "scalbn");
+   eval_scalbn(result.value(), arg.value(), exp);
+   log_postfix_event(result.value(), exp, "scalbn");
+}
+
+template <class Backend>
+inline typename Backend::exponent_type eval_ilogb(const logged_adaptor<Backend>& arg)
+{
+   using default_ops::eval_ilogb;
+   log_prefix_event(arg.value(), "ilogb");
+   typename Backend::exponent_type r = eval_ilogb(arg.value());
+   log_postfix_event(arg.value(), "ilogb");
+   return r;
+}
+
+NON_MEMBER_OP2(floor, "floor")
+NON_MEMBER_OP2(ceil, "ceil")
+NON_MEMBER_OP2(sqrt, "sqrt")
+
+template <class Backend>
+inline int eval_fpclassify(const logged_adaptor<Backend>& arg)
+{
+   using default_ops::eval_fpclassify;
+   log_prefix_event(arg.value(), "fpclassify");
+   int r = eval_fpclassify(arg.value());
+   log_postfix_event(arg.value(), r, "fpclassify");
+   return r;
+}
+
+/*********************************************************************
+*
+* Optional arithmetic operations come next:
+*
+*********************************************************************/
+
+NON_MEMBER_OP3(add, "+")
+NON_MEMBER_OP3(subtract, "-")
+NON_MEMBER_OP3(multiply, "*")
+NON_MEMBER_OP3(divide, "/")
+NON_MEMBER_OP3(multiply_add, "fused-multiply-add")
+NON_MEMBER_OP3(multiply_subtract, "fused-multiply-subtract")
+NON_MEMBER_OP4(multiply_add, "fused-multiply-add")
+NON_MEMBER_OP4(multiply_subtract, "fused-multiply-subtract")
+
+NON_MEMBER_OP1(increment, "increment")
+NON_MEMBER_OP1(decrement, "decrement")
+
+/*********************************************************************
+*
+* Optional integer operations come next:
+*
+*********************************************************************/
+
+NON_MEMBER_OP2(modulus, "%=")
+NON_MEMBER_OP3(modulus, "%")
+NON_MEMBER_OP2(bitwise_or, "|=")
+NON_MEMBER_OP3(bitwise_or, "|")
+NON_MEMBER_OP2(bitwise_and, "&=")
+NON_MEMBER_OP3(bitwise_and, "&")
+NON_MEMBER_OP2(bitwise_xor, "^=")
+NON_MEMBER_OP3(bitwise_xor, "^")
+NON_MEMBER_OP4(qr, "quotient-and-remainder")
+NON_MEMBER_OP2(complement, "~")
+
+template <class Backend>
+inline void eval_left_shift(logged_adaptor<Backend>& arg, std::size_t a)
+{
+   using default_ops::eval_left_shift;
+   log_prefix_event(arg.value(), a, "<<=");
+   eval_left_shift(arg.value(), a);
+   log_postfix_event(arg.value(), "<<=");
+}
+template <class Backend>
+inline void eval_left_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, std::size_t b)
+{
+   using default_ops::eval_left_shift;
+   log_prefix_event(arg.value(), a, b, "<<");
+   eval_left_shift(arg.value(), a.value(), b);
+   log_postfix_event(arg.value(), "<<");
+}
+template <class Backend>
+inline void eval_right_shift(logged_adaptor<Backend>& arg, std::size_t a)
+{
+   using default_ops::eval_right_shift;
+   log_prefix_event(arg.value(), a, ">>=");
+   eval_right_shift(arg.value(), a);
+   log_postfix_event(arg.value(), ">>=");
+}
+template <class Backend>
+inline void eval_right_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, std::size_t b)
+{
+   using default_ops::eval_right_shift;
+   log_prefix_event(arg.value(), a, b, ">>");
+   eval_right_shift(arg.value(), a.value(), b);
+   log_postfix_event(arg.value(), ">>");
+}
+
+template <class Backend, class T>
+inline T eval_integer_modulus(const logged_adaptor<Backend>& arg, const T& a)
+{
+   using default_ops::eval_integer_modulus;
+   log_prefix_event(arg.value(), a, "integer-modulus");
+   T r = eval_integer_modulus(arg.value(), a);
+   log_postfix_event(arg.value(), r, "integer-modulus");
+   return r;
+}
+
+template <class Backend>
+inline std::size_t eval_lsb(const logged_adaptor<Backend>& arg)
+{
+   using default_ops::eval_lsb;
+   log_prefix_event(arg.value(), "least-significant-bit");
+   std::size_t r = eval_lsb(arg.value());
+   log_postfix_event(arg.value(), r, "least-significant-bit");
+   return r;
+}
+
+template <class Backend>
+inline std::size_t eval_msb(const logged_adaptor<Backend>& arg)
+{
+   using default_ops::eval_msb;
+   log_prefix_event(arg.value(), "most-significant-bit");
+   std::size_t r = eval_msb(arg.value());
+   log_postfix_event(arg.value(), r, "most-significant-bit");
+   return r;
+}
+
+template <class Backend>
+inline bool eval_bit_test(const logged_adaptor<Backend>& arg, std::size_t a)
+{
+   using default_ops::eval_bit_test;
+   log_prefix_event(arg.value(), a, "bit-test");
+   bool r = eval_bit_test(arg.value(), a);
+   log_postfix_event(arg.value(), r, "bit-test");
+   return r;
+}
+
+template <class Backend>
+inline void eval_bit_set(const logged_adaptor<Backend>& arg, std::size_t a)
+{
+   using default_ops::eval_bit_set;
+   log_prefix_event(arg.value(), a, "bit-set");
+   eval_bit_set(arg.value(), a);
+   log_postfix_event(arg.value(), arg, "bit-set");
+}
+template <class Backend>
+inline void eval_bit_unset(const logged_adaptor<Backend>& arg, std::size_t a)
+{
+   using default_ops::eval_bit_unset;
+   log_prefix_event(arg.value(), a, "bit-unset");
+   eval_bit_unset(arg.value(), a);
+   log_postfix_event(arg.value(), arg, "bit-unset");
+}
+template <class Backend>
+inline void eval_bit_flip(const logged_adaptor<Backend>& arg, std::size_t a)
+{
+   using default_ops::eval_bit_flip;
+   log_prefix_event(arg.value(), a, "bit-flip");
+   eval_bit_flip(arg.value(), a);
+   log_postfix_event(arg.value(), arg, "bit-flip");
+}
+
+NON_MEMBER_OP3(gcd, "gcd")
+NON_MEMBER_OP3(lcm, "lcm")
+NON_MEMBER_OP4(powm, "powm")
+
+/*********************************************************************
+*
+* abs/fabs:
+*
+*********************************************************************/
+
+NON_MEMBER_OP2(abs, "abs")
+NON_MEMBER_OP2(fabs, "fabs")
+
+/*********************************************************************
+*
+* Floating point functions:
+*
+*********************************************************************/
+
+NON_MEMBER_OP2(trunc, "trunc")
+NON_MEMBER_OP2(round, "round")
+NON_MEMBER_OP2(exp, "exp")
+NON_MEMBER_OP2(log, "log")
+NON_MEMBER_OP2(log10, "log10")
+NON_MEMBER_OP2(sin, "sin")
+NON_MEMBER_OP2(cos, "cos")
+NON_MEMBER_OP2(tan, "tan")
+NON_MEMBER_OP2(asin, "asin")
+NON_MEMBER_OP2(acos, "acos")
+NON_MEMBER_OP2(atan, "atan")
+NON_MEMBER_OP2(sinh, "sinh")
+NON_MEMBER_OP2(cosh, "cosh")
+NON_MEMBER_OP2(tanh, "tanh")
+NON_MEMBER_OP2(logb, "logb")
+NON_MEMBER_OP3(fmod, "fmod")
+NON_MEMBER_OP3(pow, "pow")
+NON_MEMBER_OP3(atan2, "atan2")
+NON_MEMBER_OP2(asinh, "asinh")
+NON_MEMBER_OP2(acosh, "acosh")
+NON_MEMBER_OP2(atanh, "atanh")
+NON_MEMBER_OP2(conj, "conj")
+
+template <class Backend>
+int eval_signbit(const logged_adaptor<Backend>& val)
+{
+   using default_ops::eval_signbit;
+   return eval_signbit(val.value());
+}
+
+template <class Backend>
+std::size_t hash_value(const logged_adaptor<Backend>& val)
+{
+   return hash_value(val.value());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline typename std::enable_if<number_category<Backend>::value == number_kind_rational, typename number<logged_adaptor<Backend>, ExpressionTemplates>::value_type>::type
+numerator(const number<logged_adaptor<Backend>, ExpressionTemplates>& arg)
+{
+   number<Backend, ExpressionTemplates> t(arg.backend().value());
+   return numerator(t).backend();
+}
+template <class Backend, expression_template_option ExpressionTemplates>
+inline typename std::enable_if<number_category<Backend>::value == number_kind_rational, typename number<logged_adaptor<Backend>, ExpressionTemplates>::value_type>::type
+denominator(const number<logged_adaptor<Backend>, ExpressionTemplates>& arg)
+{
+   number<Backend, ExpressionTemplates> t(arg.backend().value());
+   return denominator(t).backend();
+}
+
+template <class To, class From>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(To& to, const logged_adaptor<From>& from)
+{
+   using default_ops::eval_set_real;
+   log_prefix_event(to, from.value(), "Set real part");
+   eval_set_real(to, from.value());
+   log_postfix_event(to, from.value(), "Set real part");
+}
+template <class To, class From>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(logged_adaptor<To>& to, const logged_adaptor<From>& from)
+{
+   using default_ops::eval_set_real;
+   log_prefix_event(to.value(), from.value(), "Set real part");
+   eval_set_real(to.value(), from.value());
+   log_postfix_event(to.value(), from.value(), "Set real part");
+}
+template <class To, class From>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(logged_adaptor<To>& to, const From& from)
+{
+   using default_ops::eval_set_real;
+   log_prefix_event(to.value(), from, "Set real part");
+   eval_set_real(to.value(), from);
+   log_postfix_event(to.value(), from, "Set real part");
+}
+
+template <class To, class From>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(To& to, const logged_adaptor<From>& from)
+{
+   using default_ops::eval_set_imag;
+   log_prefix_event(to, from.value(), "Set imag part");
+   eval_set_imag(to, from.value());
+   log_postfix_event(to, from.value(), "Set imag part");
+}
+template <class To, class From>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(logged_adaptor<To>& to, const logged_adaptor<From>& from)
+{
+   using default_ops::eval_set_imag;
+   log_prefix_event(to.value(), from.value(), "Set imag part");
+   eval_set_imag(to.value(), from.value());
+   log_postfix_event(to.value(), from.value(), "Set imag part");
+}
+template <class To, class From>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(logged_adaptor<To>& to, const From& from)
+{
+   using default_ops::eval_set_imag;
+   log_prefix_event(to.value(), from, "Set imag part");
+   eval_set_imag(to.value(), from);
+   log_postfix_event(to.value(), from, "Set imag part");
+}
+
+
+#define NON_MEMBER_COMPLEX_TO_REAL(name, str)                                                    \
+   template <class B1, class B2>                                                                 \
+   inline void BOOST_JOIN(eval_, name)(logged_adaptor<B1> & result, const logged_adaptor<B2>& a) \
+   {                                                                                             \
+      using default_ops::BOOST_JOIN(eval_, name);                                                \
+      log_prefix_event(a.value(), a.value(), str);                                               \
+      BOOST_JOIN(eval_, name)                                                                    \
+      (result.value(), a.value());                                                               \
+      log_postfix_event(result.value(), str);                                                    \
+   }                                                                                             \
+   template <class B1, class B2>                                                                 \
+   inline void BOOST_JOIN(eval_, name)(B1 & result, const logged_adaptor<B2>& a)                 \
+   {                                                                                             \
+      using default_ops::BOOST_JOIN(eval_, name);                                                \
+      log_prefix_event(a.value(), a.value(), str);                                               \
+      BOOST_JOIN(eval_, name)                                                                    \
+      (result, a.value());                                                                       \
+      log_postfix_event(result, str);                                                            \
+   }
+
+NON_MEMBER_COMPLEX_TO_REAL(real, "real")
+NON_MEMBER_COMPLEX_TO_REAL(imag, "imag")
+
+template <class T, class V, class U>
+inline void assign_components(logged_adaptor<T>& result, const V& v1, const U& v2)
+{
+   using default_ops::assign_components;
+   assign_components(result.value(), unwrap_logged_type(v1), unwrap_logged_type(v2));
+}
+
+} // namespace backends
+
+namespace detail {
+   template <class Backend>
+   struct is_variable_precision<logged_adaptor<Backend> > : public is_variable_precision<Backend>
+   {};
+#ifdef BOOST_HAS_INT128
+   template <class Backend>
+   struct is_convertible_arithmetic<int128_type, logged_adaptor<Backend> > : public is_convertible_arithmetic<int128_type, Backend>
+   {};
+   template <class Backend>
+   struct is_convertible_arithmetic<uint128_type, logged_adaptor<Backend> > : public is_convertible_arithmetic<uint128_type, Backend>
+   {};
+#endif
+#ifdef BOOST_HAS_FLOAT128
+   template <class Backend>
+   struct is_convertible_arithmetic<float128_type, logged_adaptor<Backend> > : public is_convertible_arithmetic<float128_type, Backend>
+   {};
+#endif
+   } // namespace detail
+
+template <class Backend>
+struct number_category<backends::logged_adaptor<Backend> > : public number_category<Backend>
+{};
+
+template <class Backend, expression_template_option ExpressionTemplates>
+struct component_type<number<logged_adaptor<Backend>, ExpressionTemplates>>
+{
+   //
+   // We'll make the component_type also a logged_adaptor:
+   //
+   using base_component_type = typename component_type<number<Backend, ExpressionTemplates>>::type;
+   using base_component_backend = typename base_component_type::backend_type;
+   using type = number<logged_adaptor<base_component_backend>, ExpressionTemplates>;
+};
+
+template <class Backend>
+struct is_interval_number<backends::logged_adaptor<Backend> > : public is_interval_number<Backend> {};
+
+}} // namespace boost::multiprecision
+
+namespace std {
+
+template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<Backend>, ExpressionTemplates> >
+    : public std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >
+{
+   using base_type = std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >                           ;
+   using number_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<Backend>, ExpressionTemplates>;
+
+ public:
+   static number_type(min)() noexcept { return (base_type::min)(); }
+   static number_type(max)() noexcept { return (base_type::max)(); }
+   static number_type lowest() noexcept { return -(max)(); }
+   static number_type epsilon() noexcept { return base_type::epsilon(); }
+   static number_type round_error() noexcept { return epsilon() / 2; }
+   static number_type infinity() noexcept { return base_type::infinity(); }
+   static number_type quiet_NaN() noexcept { return base_type::quiet_NaN(); }
+   static number_type signaling_NaN() noexcept { return base_type::signaling_NaN(); }
+   static number_type denorm_min() noexcept { return base_type::denorm_min(); }
+};
+
+} // namespace std
+
+#ifdef BOOST_MP_MATH_AVAILABLE
+namespace boost {
+namespace math {
+
+namespace policies {
+
+template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
+struct precision<boost::multiprecision::number<boost::multiprecision::logged_adaptor<Backend>, ExpressionTemplates>, Policy>
+    : public precision<boost::multiprecision::number<Backend, ExpressionTemplates>, Policy>
+{};
+
+}
+
+}} // namespace boost::math::policies
+#endif // BOOST_MP_MATH_AVAILABLE
+
+#undef NON_MEMBER_OP1
+#undef NON_MEMBER_OP2
+#undef NON_MEMBER_OP3
+#undef NON_MEMBER_OP4
+
+#endif