Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r79859 - in sandbox/big_number: boost/multiprecision boost/multiprecision/detail libs/multiprecision/performance
From: john_at_[hidden]
Date: 2012-08-03 14:24:54

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r79860 - sandbox/type_erasure/boost/type_erasure"
Previous message: steven_at_[hidden]: "[Boost-commit] svn:boost r79858 - in sandbox/type_erasure: boost/type_erasure libs/type_erasure/test"

Author: johnmaddock
Date: 2012-08-03 14:24:53 EDT (Fri, 03 Aug 2012)
New Revision: 79859
URL: http://svn.boost.org/trac/boost/changeset/79859

Log:
Mark up some functions as being forced inline.
Text files modified:
   sandbox/big_number/boost/multiprecision/cpp_int.hpp | 310 ++++++++++++++++++++--------------------
   sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp | 66 ++++----
   sandbox/big_number/boost/multiprecision/mp_number.hpp | 120 +++++++-------
   sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp | 7
   4 files changed, 252 insertions(+), 251 deletions(-)

Modified: sandbox/big_number/boost/multiprecision/cpp_int.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/cpp_int.hpp (original)
+++ sandbox/big_number/boost/multiprecision/cpp_int.hpp 2012-08-03 14:24:53 EDT (Fri, 03 Aug 2012)
@@ -98,26 +98,26 @@
 //
 // Direct construction:
 //
- BOOST_CONSTEXPR cpp_int_base(limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(limb_type i)BOOST_NOEXCEPT
 : m_data(i), m_limbs(1), m_sign(false), m_internal(true) { }
- BOOST_CONSTEXPR cpp_int_base(signed_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(signed_limb_type i)BOOST_NOEXCEPT
 : m_data(i), m_limbs(1), m_sign(i < 0), m_internal(true) { }
#if defined(BOOST_LITTLE_ENDIAN)
- BOOST_CONSTEXPR cpp_int_base(double_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(double_limb_type i)BOOST_NOEXCEPT
 : m_data(i), m_limbs(i > max_limb_value ? 2 : 1), m_sign(false), m_internal(true) { }
- BOOST_CONSTEXPR cpp_int_base(signed_double_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(signed_double_limb_type i)BOOST_NOEXCEPT
 : m_data(i), m_limbs(i < 0 ? (-i > max_limb_value ? 2 : 1) : (i > max_limb_value ? 2 : 1)), m_sign(i < 0), m_internal(true) { }
#endif
 //
 // Helper functions for getting at our internal data, and manipulating storage:
 //
- allocator_type& allocator() BOOST_NOEXCEPT { return *this; }
- const allocator_type& allocator()const BOOST_NOEXCEPT { return *this; }
- unsigned size()const BOOST_NOEXCEPT { return m_limbs; }
- limb_pointer limbs() BOOST_NOEXCEPT { return m_internal ? m_data.la : m_data.ld.data; }
- const_limb_pointer limbs()const BOOST_NOEXCEPT { return m_internal ? m_data.la : m_data.ld.data; }
- unsigned capacity()const BOOST_NOEXCEPT { return m_internal ? internal_limb_count : m_data.ld.capacity; }
- bool sign()const BOOST_NOEXCEPT { return m_sign; }
+ BOOST_FORCEINLINE allocator_type& allocator() BOOST_NOEXCEPT { return *this; }
+ BOOST_FORCEINLINE const allocator_type& allocator()const BOOST_NOEXCEPT { return *this; }
+ BOOST_FORCEINLINE unsigned size()const BOOST_NOEXCEPT { return m_limbs; }
+ BOOST_FORCEINLINE limb_pointer limbs() BOOST_NOEXCEPT { return m_internal ? m_data.la : m_data.ld.data; }
+ BOOST_FORCEINLINE const_limb_pointer limbs()const BOOST_NOEXCEPT { return m_internal ? m_data.la : m_data.ld.data; }
+ BOOST_FORCEINLINE unsigned capacity()const BOOST_NOEXCEPT { return m_internal ? internal_limb_count : m_data.ld.capacity; }
+ BOOST_FORCEINLINE bool sign()const BOOST_NOEXCEPT { return m_sign; }
 void sign(bool b) BOOST_NOEXCEPT
 {
 m_sign = b;
@@ -149,13 +149,13 @@
 m_limbs = new_size;
 }
 }
- void normalize() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void normalize() BOOST_NOEXCEPT
 {
 limb_pointer p = limbs();
 while((m_limbs-1) && !p[m_limbs - 1])--m_limbs;
 }
- BOOST_CONSTEXPR cpp_int_base() BOOST_NOEXCEPT : m_data(), m_limbs(1), m_sign(false), m_internal(true) {}
- cpp_int_base(const cpp_int_base& o) : allocator_type(o), m_limbs(0), m_internal(true)
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base() BOOST_NOEXCEPT : m_data(), m_limbs(1), m_sign(false), m_internal(true) {}
+ BOOST_FORCEINLINE cpp_int_base(const cpp_int_base& o) : allocator_type(o), m_limbs(0), m_internal(true)
 {
 resize(o.size());
 std::copy(o.limbs(), o.limbs() + o.size(), limbs());
@@ -196,7 +196,7 @@
 return *this;
 }
#endif
- ~cpp_int_base() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE ~cpp_int_base() BOOST_NOEXCEPT
 {
 if(!m_internal)
 allocator().deallocate(limbs(), capacity());
@@ -212,7 +212,7 @@
 m_sign = o.m_sign;
 }
 }
- void negate() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void negate() BOOST_NOEXCEPT
 {
 m_sign = !m_sign;
 // Check for zero value:
@@ -222,11 +222,11 @@
 m_sign = false;
 }
 }
- bool isneg()const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool isneg()const BOOST_NOEXCEPT
 {
 return m_sign;
 }
- void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
 {
 std::swap(m_data, o.m_data);
 std::swap(m_sign, o.m_sign);
@@ -272,24 +272,24 @@
 //
 // Direct construction:
 //
- BOOST_CONSTEXPR cpp_int_base(limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(limb_type i)BOOST_NOEXCEPT
 : m_wrapper(i), m_limbs(1), m_sign(false) {}
- BOOST_CONSTEXPR cpp_int_base(signed_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(signed_limb_type i)BOOST_NOEXCEPT
 : m_wrapper(limb_type(i < 0 ? -i : i)), m_limbs(1), m_sign(i < 0) {}
#if defined(BOOST_LITTLE_ENDIAN)
- BOOST_CONSTEXPR cpp_int_base(double_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(double_limb_type i)BOOST_NOEXCEPT
 : m_wrapper(i), m_limbs(i > max_limb_value ? 2 : 1), m_sign(false) {}
- BOOST_CONSTEXPR cpp_int_base(signed_double_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(signed_double_limb_type i)BOOST_NOEXCEPT
 : m_wrapper(double_limb_type(i < 0 ? -i : i)), m_limbs(i < 0 ? (-i > max_limb_value ? 2 : 1) : (i > max_limb_value ? 2 : 1)), m_sign(i < 0) {}
#endif
 //
 // Helper functions for getting at our internal data, and manipulating storage:
 //
- unsigned size()const BOOST_NOEXCEPT { return m_limbs; }
- limb_pointer limbs() BOOST_NOEXCEPT { return m_wrapper.m_data; }
- const_limb_pointer limbs()const BOOST_NOEXCEPT { return m_wrapper.m_data; }
- bool sign()const BOOST_NOEXCEPT { return m_sign; }
- void sign(bool b) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE unsigned size()const BOOST_NOEXCEPT { return m_limbs; }
+ BOOST_FORCEINLINE limb_pointer limbs() BOOST_NOEXCEPT { return m_wrapper.m_data; }
+ BOOST_FORCEINLINE const_limb_pointer limbs()const BOOST_NOEXCEPT { return m_wrapper.m_data; }
+ BOOST_FORCEINLINE bool sign()const BOOST_NOEXCEPT { return m_sign; }
+ BOOST_FORCEINLINE void sign(bool b) BOOST_NOEXCEPT
 {
 m_sign = b;
 // Check for zero value:
@@ -299,11 +299,11 @@
 m_sign = false;
 }
 }
- void resize(unsigned new_size) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void resize(unsigned new_size) BOOST_NOEXCEPT
 {
 m_limbs = static_cast<boost::uint16_t>((std::min)(new_size, internal_limb_count));
 }
- void normalize() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void normalize() BOOST_NOEXCEPT
 {
 limb_pointer p = limbs();
 p[internal_limb_count-1] &= upper_limb_mask;
@@ -311,8 +311,8 @@
 if((m_limbs == 1) && (!*p)) m_sign = false; // zero is always unsigned
 }

- BOOST_CONSTEXPR cpp_int_base() : m_wrapper(limb_type(0u)), m_limbs(1), m_sign(false) {}
- cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_limbs(o.m_limbs), m_sign(o.m_sign)
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base() : m_wrapper(limb_type(0u)), m_limbs(1), m_sign(false) {}
+ BOOST_FORCEINLINE cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_limbs(o.m_limbs), m_sign(o.m_sign)
 {
 std::copy(o.limbs(), o.limbs() + o.size(), limbs());
 }
@@ -326,7 +326,7 @@
 m_sign = o.m_sign;
 }
 }
- void negate() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void negate() BOOST_NOEXCEPT
 {
 m_sign = !m_sign;
 // Check for zero value:
@@ -336,11 +336,11 @@
 m_sign = false;
 }
 }
- bool isneg()const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool isneg()const BOOST_NOEXCEPT
 {
 return m_sign;
 }
- void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
 {
 for(unsigned i = 0; i < (std::max)(size(), o.size()); ++i)
 std::swap(m_wrapper.m_data[i], o.m_wrapper.m_data[i]);
@@ -385,42 +385,42 @@
 //
 // Direct construction:
 //
- BOOST_CONSTEXPR cpp_int_base(limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(limb_type i)BOOST_NOEXCEPT
 : m_wrapper(i), m_limbs(1) {}
- cpp_int_base(signed_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE cpp_int_base(signed_limb_type i)BOOST_NOEXCEPT
 : m_wrapper(limb_type(i < 0 ? -i : i)), m_limbs(1) { if(i < 0) negate(); }
#ifdef BOOST_LITTLE_ENDIAN
- BOOST_CONSTEXPR cpp_int_base(double_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(double_limb_type i)BOOST_NOEXCEPT
 : m_wrapper(i), m_limbs(i > max_limb_value ? 2 : 1) {}
- cpp_int_base(signed_double_limb_type i)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE cpp_int_base(signed_double_limb_type i)BOOST_NOEXCEPT
 : m_wrapper(double_limb_type(i < 0 ? -i : i)), m_limbs(i < 0 ? (-i > max_limb_value ? 2 : 1) : (i > max_limb_value ? 2 : 1)) { if(i < 0) negate(); }
#endif
 //
 // Helper functions for getting at our internal data, and manipulating storage:
 //
- unsigned size()const BOOST_NOEXCEPT { return m_limbs; }
- limb_pointer limbs() BOOST_NOEXCEPT { return m_wrapper.m_data; }
- const_limb_pointer limbs()const BOOST_NOEXCEPT { return m_wrapper.m_data; }
- BOOST_CONSTEXPR bool sign()const BOOST_NOEXCEPT { return false; }
- void sign(bool b) BOOST_NOEXCEPT { if(b) negate(); }
- void resize(unsigned new_size) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE unsigned size()const BOOST_NOEXCEPT { return m_limbs; }
+ BOOST_FORCEINLINE limb_pointer limbs() BOOST_NOEXCEPT { return m_wrapper.m_data; }
+ BOOST_FORCEINLINE const_limb_pointer limbs()const BOOST_NOEXCEPT { return m_wrapper.m_data; }
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool sign()const BOOST_NOEXCEPT { return false; }
+ BOOST_FORCEINLINE void sign(bool b) BOOST_NOEXCEPT { if(b) negate(); }
+ BOOST_FORCEINLINE void resize(unsigned new_size) BOOST_NOEXCEPT
 {
 m_limbs = (std::min)(new_size, internal_limb_count);
 }
- void normalize() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void normalize() BOOST_NOEXCEPT
 {
 limb_pointer p = limbs();
 p[internal_limb_count-1] &= upper_limb_mask;
 while((m_limbs-1) && !p[m_limbs - 1])--m_limbs;
 }

- BOOST_CONSTEXPR cpp_int_base() BOOST_NOEXCEPT : m_wrapper(limb_type(0u)), m_limbs(1) {}
- cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_limbs(o.m_limbs)
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base() BOOST_NOEXCEPT : m_wrapper(limb_type(0u)), m_limbs(1) {}
+ BOOST_FORCEINLINE cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_limbs(o.m_limbs)
 {
 std::copy(o.limbs(), o.limbs() + o.size(), limbs());
 }
 //~cpp_int_base() BOOST_NOEXCEPT {}
- void assign(const cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void assign(const cpp_int_base& o) BOOST_NOEXCEPT
 {
 if(this != &o)
 {
@@ -441,11 +441,11 @@
 normalize();
 eval_increment(static_cast<cpp_int_backend<MinBits, false, void>& >(*this));
 }
- BOOST_CONSTEXPR bool isneg()const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool isneg()const BOOST_NOEXCEPT
 {
 return false;
 }
- void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
 {
 for(unsigned i = 0; i < (std::max)(size(), o.size()); ++i)
 std::swap(m_wrapper.m_data[i], o.m_wrapper.m_data[i]);
@@ -496,22 +496,22 @@
 // Direct construction:
 //
 template <class SI>
- BOOST_CONSTEXPR cpp_int_base(SI i, typename enable_if<is_signed<SI> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(SI i, typename enable_if<is_signed<SI> >::type const* = 0) BOOST_NOEXCEPT
 : m_data(i < 0 ? -i : i), m_sign(i < 0) {}
 template <class UI>
- BOOST_CONSTEXPR cpp_int_base(UI i, typename enable_if<is_unsigned<UI> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(UI i, typename enable_if<is_unsigned<UI> >::type const* = 0) BOOST_NOEXCEPT
 : m_data(i), m_sign(false) {}
 template <class F>
- cpp_int_base(F i, typename enable_if<is_floating_point<F> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE cpp_int_base(F i, typename enable_if<is_floating_point<F> >::type const* = 0) BOOST_NOEXCEPT
 : m_data(std::fabs(i)), m_sign(i < 0) {}
 //
 // Helper functions for getting at our internal data, and manipulating storage:
 //
- BOOST_CONSTEXPR unsigned size()const BOOST_NOEXCEPT { return 1; }
- limb_pointer limbs() BOOST_NOEXCEPT { return &m_data; }
- const_limb_pointer limbs()const BOOST_NOEXCEPT { return &m_data; }
- bool sign()const BOOST_NOEXCEPT { return m_sign; }
- void sign(bool b) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR unsigned size()const BOOST_NOEXCEPT { return 1; }
+ BOOST_FORCEINLINE limb_pointer limbs() BOOST_NOEXCEPT { return &m_data; }
+ BOOST_FORCEINLINE const_limb_pointer limbs()const BOOST_NOEXCEPT { return &m_data; }
+ BOOST_FORCEINLINE bool sign()const BOOST_NOEXCEPT { return m_sign; }
+ BOOST_FORCEINLINE void sign(bool b) BOOST_NOEXCEPT
 {
 m_sign = b;
 // Check for zero value:
@@ -520,23 +520,23 @@
 m_sign = false;
 }
 }
- void resize(unsigned new_size) BOOST_NOEXCEPT {}
- void normalize() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void resize(unsigned new_size) BOOST_NOEXCEPT {}
+ BOOST_FORCEINLINE void normalize() BOOST_NOEXCEPT
 {
 if(!m_data)
 m_sign = false; // zero is always unsigned
 m_data &= limb_mask;
 }

- BOOST_CONSTEXPR cpp_int_base() : m_data(0), m_sign(false) {}
- BOOST_CONSTEXPR cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_data(o.m_data), m_sign(o.m_sign) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base() : m_data(0), m_sign(false) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_data(o.m_data), m_sign(o.m_sign) {}
 //~cpp_int_base() BOOST_NOEXCEPT {}
- void assign(const cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void assign(const cpp_int_base& o) BOOST_NOEXCEPT
 {
 m_data = o.m_data;
 m_sign = o.m_sign;
 }
- void negate() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void negate() BOOST_NOEXCEPT
 {
 m_sign = !m_sign;
 // Check for zero value:
@@ -545,11 +545,11 @@
 m_sign = false;
 }
 }
- bool isneg()const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool isneg()const BOOST_NOEXCEPT
 {
 return m_sign;
 }
- void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
 {
 std::swap(m_sign, o.m_sign);
 std::swap(m_data, o.m_data);
@@ -578,13 +578,13 @@
 // Direct construction:
 //
 template <class SI>
- BOOST_CONSTEXPR cpp_int_base(SI i, typename enable_if<is_signed<SI> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(SI i, typename enable_if<is_signed<SI> >::type const* = 0) BOOST_NOEXCEPT
 : m_data(i < 0 ? 1 + ~static_cast<local_limb_type>(-i) : static_cast<local_limb_type>(i)) {}
 template <class UI>
- BOOST_CONSTEXPR cpp_int_base(UI i, typename enable_if<is_unsigned<UI> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(UI i, typename enable_if<is_unsigned<UI> >::type const* = 0) BOOST_NOEXCEPT
 : m_data(i) {}
 template <class F>
- cpp_int_base(F i, typename enable_if<is_floating_point<F> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE cpp_int_base(F i, typename enable_if<is_floating_point<F> >::type const* = 0) BOOST_NOEXCEPT
 : m_data(std::fabs(i))
 {
 if(i < 0)
@@ -593,38 +593,38 @@
 //
 // Helper functions for getting at our internal data, and manipulating storage:
 //
- BOOST_CONSTEXPR unsigned size()const BOOST_NOEXCEPT { return 1; }
- limb_pointer limbs() BOOST_NOEXCEPT { return &m_data; }
- const_limb_pointer limbs()const BOOST_NOEXCEPT { return &m_data; }
- BOOST_CONSTEXPR bool sign()const BOOST_NOEXCEPT { return false; }
- void sign(bool b) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR unsigned size()const BOOST_NOEXCEPT { return 1; }
+ BOOST_FORCEINLINE limb_pointer limbs() BOOST_NOEXCEPT { return &m_data; }
+ BOOST_FORCEINLINE const_limb_pointer limbs()const BOOST_NOEXCEPT { return &m_data; }
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool sign()const BOOST_NOEXCEPT { return false; }
+ BOOST_FORCEINLINE void sign(bool b) BOOST_NOEXCEPT
 {
 if(b)
 negate();
 }
- void resize(unsigned new_size) BOOST_NOEXCEPT {}
- void normalize() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void resize(unsigned new_size) BOOST_NOEXCEPT {}
+ BOOST_FORCEINLINE void normalize() BOOST_NOEXCEPT
 {
 m_data &= limb_mask;
 }

- BOOST_CONSTEXPR cpp_int_base() : m_data(0) {}
- BOOST_CONSTEXPR cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_data(o.m_data) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base() : m_data(0) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_base(const cpp_int_base& o) BOOST_NOEXCEPT : m_data(o.m_data) {}
 //~cpp_int_base() BOOST_NOEXCEPT {}
- void assign(const cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void assign(const cpp_int_base& o) BOOST_NOEXCEPT
 {
 m_data = o.m_data;
 }
- void negate() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void negate() BOOST_NOEXCEPT
 {
 m_data = ~m_data;
 ++m_data;
 }
- BOOST_CONSTEXPR bool isneg()const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool isneg()const BOOST_NOEXCEPT
 {
 return false;
 }
- void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void do_swap(cpp_int_base& o) BOOST_NOEXCEPT
 {
 std::swap(m_data, o.m_data);
 }
@@ -678,45 +678,45 @@
 typedef mpl::list<limb_type, double_limb_type> unsigned_types;
 typedef mpl::list<long double> float_types;

- BOOST_CONSTEXPR cpp_int_backend() BOOST_NOEXCEPT{}
- BOOST_CONSTEXPR cpp_int_backend(const cpp_int_backend& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value) : base_type(o) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend() BOOST_NOEXCEPT{}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(const cpp_int_backend& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value) : base_type(o) {}
#ifndef BOOST_NO_RVALUE_REFERENCES
- BOOST_CONSTEXPR cpp_int_backend(cpp_int_backend&& o) BOOST_NOEXCEPT : base_type(static_cast<base_type&&>(o)) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(cpp_int_backend&& o) BOOST_NOEXCEPT : base_type(static_cast<base_type&&>(o)) {}
#endif
 template <class LT>
- BOOST_CONSTEXPR cpp_int_backend(LT i, typename enable_if<is_same<LT, limb_type> >::type const* = 0)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(LT i, typename enable_if<is_same<LT, limb_type> >::type const* = 0)BOOST_NOEXCEPT
 : base_type(i) {}
 template <class SLT>
- BOOST_CONSTEXPR cpp_int_backend(SLT i, typename enable_if<is_same<SLT, signed_limb_type> >::type const* = 0)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(SLT i, typename enable_if<is_same<SLT, signed_limb_type> >::type const* = 0)BOOST_NOEXCEPT
 : base_type(i) {}
#if defined(BOOST_LITTLE_ENDIAN)
 template <class LT>
- BOOST_CONSTEXPR cpp_int_backend(LT i, typename enable_if<is_same<LT, double_limb_type> >::type const* = 0)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(LT i, typename enable_if<is_same<LT, double_limb_type> >::type const* = 0)BOOST_NOEXCEPT
 : base_type(i) {}
 template <class SLT>
- BOOST_CONSTEXPR cpp_int_backend(SLT i, typename enable_if<is_same<SLT, signed_double_limb_type> >::type const* = 0)BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(SLT i, typename enable_if<is_same<SLT, signed_double_limb_type> >::type const* = 0)BOOST_NOEXCEPT
 : base_type(i) {}
#endif
- cpp_int_backend& operator = (const cpp_int_backend& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+ BOOST_FORCEINLINE cpp_int_backend& operator = (const cpp_int_backend& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
 {
 this->assign(o);
 return *this;
 }
#ifndef BOOST_NO_RVALUE_REFERENCES
- cpp_int_backend& operator = (cpp_int_backend&& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+ BOOST_FORCEINLINE cpp_int_backend& operator = (cpp_int_backend&& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
 {
 *static_cast<base_type*>(this) = static_cast<base_type&&>(o);
 return *this;
 }
#endif
- cpp_int_backend& operator = (limb_type i) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE cpp_int_backend& operator = (limb_type i) BOOST_NOEXCEPT
 {
 this->resize(1);
 *this->limbs() = i;
 this->sign(false);
 return *this;
 }
- cpp_int_backend& operator = (signed_limb_type i) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE cpp_int_backend& operator = (signed_limb_type i) BOOST_NOEXCEPT
 {
 this->resize(1);
 *this->limbs() = static_cast<limb_type>(std::abs(i));
@@ -898,7 +898,7 @@
 this->negate();
 return *this;
 }
- void swap(cpp_int_backend& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void swap(cpp_int_backend& o) BOOST_NOEXCEPT
 {
 this->do_swap(o);
 }
@@ -1026,7 +1026,7 @@
 return 0;
 }
 template <class Arithmatic>
- typename enable_if<is_arithmetic<Arithmatic>, int>::type compare(Arithmatic i)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE typename enable_if<is_arithmetic<Arithmatic>, int>::type compare(Arithmatic i)const BOOST_NOEXCEPT
 {
 // braindead version:
 cpp_int_backend t;
@@ -1051,33 +1051,33 @@

 BOOST_STATIC_CONSTANT(unsigned, limb_bits = sizeof(typename base_type::local_limb_type) * CHAR_BIT);

- BOOST_CONSTEXPR cpp_int_backend() BOOST_NOEXCEPT{}
- BOOST_CONSTEXPR cpp_int_backend(const cpp_int_backend& o) BOOST_NOEXCEPT : base_type(o) {}
- cpp_int_backend& operator = (const cpp_int_backend& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend() BOOST_NOEXCEPT{}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(const cpp_int_backend& o) BOOST_NOEXCEPT : base_type(o) {}
+ BOOST_FORCEINLINE cpp_int_backend& operator = (const cpp_int_backend& o) BOOST_NOEXCEPT
 {
 this->assign(o);
 return *this;
 }

 template <class A>
- BOOST_CONSTEXPR cpp_int_backend(A i, typename enable_if<is_arithmetic<A> >::type const* = 0) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR cpp_int_backend(A i, typename enable_if<is_arithmetic<A> >::type const* = 0) BOOST_NOEXCEPT
 : base_type(i) {}

 template <class SI>
- typename enable_if<is_signed<SI>, cpp_int_backend&>::type operator = (SI i) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE typename enable_if<is_signed<SI>, cpp_int_backend&>::type operator = (SI i) BOOST_NOEXCEPT
 {
 *this->limbs() = static_cast<typename base_type::local_limb_type>(std::abs(i));
 this->sign(i < 0);
 return *this;
 }
 template <class UI>
- typename enable_if<is_unsigned<UI>, cpp_int_backend&>::type operator = (UI i) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE typename enable_if<is_unsigned<UI>, cpp_int_backend&>::type operator = (UI i) BOOST_NOEXCEPT
 {
 *this->limbs() = static_cast<typename base_type::local_limb_type>(i);
 return *this;
 }
 template <class F>
- typename enable_if<is_floating_point<F>, cpp_int_backend&>::type operator = (F i) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE typename enable_if<is_floating_point<F>, cpp_int_backend&>::type operator = (F i) BOOST_NOEXCEPT
 {
 *this->limbs() = static_cast<typename base_type::local_limb_type>(std::abs(i));
 this->sign(i < 0);
@@ -1094,7 +1094,7 @@
 }
 return *this;
 }
- void swap(cpp_int_backend& o) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void swap(cpp_int_backend& o) BOOST_NOEXCEPT
 {
 this->do_swap(o);
 }
@@ -1209,7 +1209,7 @@
 return result;
 }
 template <class Arithmatic>
- typename enable_if<is_arithmetic<Arithmatic>, int>::type compare(Arithmatic i)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE typename enable_if<is_arithmetic<Arithmatic>, int>::type compare(Arithmatic i)const BOOST_NOEXCEPT
 {
 // braindead version:
 cpp_int_backend t;
@@ -1219,40 +1219,40 @@
};

template <unsigned MinBits, bool Signed, class Allocator>
-inline bool eval_eq(const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b) BOOST_NOEXCEPT
{
 return (a.sign() == b.sign())
 && (a.size() == b.size())
 && std::equal(a.limbs(), a.limbs() + a.size(), b.limbs());
}
template <unsigned MinBits, class Allocator>
-inline bool eval_eq(const cpp_int_backend<MinBits, true, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, true, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
{
 return (a.sign() == false)
 && (a.size() == 1)
 && (*a.limbs() == b);
}
template <unsigned MinBits, class Allocator>
-inline bool eval_eq(const cpp_int_backend<MinBits, true, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, true, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
{
 return (a.sign() == (b < 0))
 && (a.size() == 1)
 && (*a.limbs() == static_cast<limb_type>(std::abs(b)));
}
template <unsigned MinBits, class Allocator>
-inline bool eval_eq(const cpp_int_backend<MinBits, false, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, false, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
{
 return (a.size() == 1)
 && (*a.limbs() == b);
}
template <unsigned MinBits, class Allocator>
-inline bool eval_eq(const cpp_int_backend<MinBits, false, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, false, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
{
 return (b < 0) ? eval_eq(a, cpp_int_backend<MinBits, false, Allocator, false>(b)) : eval_eq(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison
}

template <unsigned MinBits, class Allocator>
-inline bool eval_lt(const cpp_int_backend<MinBits, true, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_lt(const cpp_int_backend<MinBits, true, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
{
 if(a.sign())
 return true;
@@ -1280,20 +1280,20 @@
}

template <unsigned MinBits, class Allocator>
-inline bool eval_lt(const cpp_int_backend<MinBits, false, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_lt(const cpp_int_backend<MinBits, false, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
{
 if(a.size() > 1)
 return false;
 return *a.limbs() < b;
}
template <unsigned MinBits, class Allocator>
-inline bool eval_lt(const cpp_int_backend<MinBits, false, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_lt(const cpp_int_backend<MinBits, false, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
{
 return (b < 0) ? a.compare(b) < 0 : eval_lt(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison
}

template <unsigned MinBits, class Allocator>
-inline bool eval_gt(const cpp_int_backend<MinBits, true, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_gt(const cpp_int_backend<MinBits, true, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
{
 if(a.sign())
 return false;
@@ -1323,20 +1323,20 @@
}

template <unsigned MinBits, class Allocator>
-inline bool eval_gt(const cpp_int_backend<MinBits, false, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_gt(const cpp_int_backend<MinBits, false, Allocator, false>& a, limb_type b) BOOST_NOEXCEPT
{
 if(a.size() > 1)
 return true;
 return *a.limbs() > b;
}
template <unsigned MinBits, class Allocator>
-inline bool eval_gt(const cpp_int_backend<MinBits, false, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_gt(const cpp_int_backend<MinBits, false, Allocator, false>& a, signed_limb_type b) BOOST_NOEXCEPT
{
 return (b < 0) ? a.compare(b) > 0 : eval_gt(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison.
}

template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_add(result, result, o);
}
@@ -1445,7 +1445,7 @@
 result.sign(a.sign());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(result.sign())
 {
@@ -1455,7 +1455,7 @@
 add_unsigned(result, result, o);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(a.sign())
 {
@@ -1466,7 +1466,7 @@
 add_unsigned(result, a, o);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(o < 0)
 eval_subtract(result, static_cast<limb_type>(-o));
@@ -1474,7 +1474,7 @@
 eval_add(result, static_cast<limb_type>(o));
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_add(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(o < 0)
 eval_subtract(result, a, static_cast<limb_type>(-o));
@@ -1514,7 +1514,7 @@
 }
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(result.sign())
 {
@@ -1524,7 +1524,7 @@
 subtract_unsigned(result, o);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(a.sign())
 {
@@ -1537,7 +1537,7 @@
 }
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(o)
 {
@@ -1548,7 +1548,7 @@
 }
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const signed_limb_type& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(o)
 {
@@ -1561,7 +1561,7 @@
 result = a;
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_increment(cpp_int_backend<MinBits, Signed, Allocator, false>& result) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_increment(cpp_int_backend<MinBits, Signed, Allocator, false>& result) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 static const limb_type one = 1;
 if(!result.sign() && (result.limbs()[0] < cpp_int_backend<MinBits, Signed, Allocator, false>::max_limb_value))
@@ -1572,7 +1572,7 @@
 eval_add(result, one);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_decrement(cpp_int_backend<MinBits, Signed, Allocator, false>& result) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_decrement(cpp_int_backend<MinBits, Signed, Allocator, false>& result) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 static const limb_type one = 1;
 if(!result.sign() && result.limbs()[0])
@@ -1583,7 +1583,7 @@
 eval_subtract(result, one);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_subtract(result, result, o);
}
@@ -1665,7 +1665,7 @@
 result.negate();
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(a.sign() != b.sign())
 {
@@ -1757,7 +1757,7 @@
 result.sign(a.sign() != b.sign());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_multiply(result, result, a);
}
@@ -1794,12 +1794,12 @@
 result.normalize();
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_multiply(result, result, val);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const double_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const double_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(val <= (std::numeric_limits<limb_type>::max)())
 {
@@ -1812,12 +1812,12 @@
 }
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const double_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const double_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_multiply(result, result, val);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const signed_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const signed_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 if(val > 0)
 eval_multiply(result, a, static_cast<limb_type>(val));
@@ -1828,7 +1828,7 @@
 }
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_multiply(result, result, val);
}
@@ -1853,7 +1853,7 @@
 eval_multiply(result, a, t);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_double_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const signed_double_limb_type& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 eval_multiply(result, result, val);
}
@@ -2270,20 +2270,20 @@
}

template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
{
 cpp_int_backend<MinBits, Signed, Allocator, false> r;
 divide_unsigned_helper(&result, a, b, r);
 result.sign(a.sign() != b.sign());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, limb_type& b)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, limb_type& b)
{
 cpp_int_backend<MinBits, Signed, Allocator, false> r;
 divide_unsigned_helper(&result, a, b, r);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, signed_limb_type& b)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, signed_limb_type& b)
{
 cpp_int_backend<MinBits, Signed, Allocator, false> r;
 divide_unsigned_helper(&result, a, std::abs(b), r);
@@ -2291,58 +2291,58 @@
 result.negate();
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
{
 // There is no in place divide:
 cpp_int_backend<MinBits, Signed, Allocator, false> a(result);
 eval_divide(result, a, b);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, limb_type b)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, limb_type b)
{
 // There is no in place divide:
 cpp_int_backend<MinBits, Signed, Allocator, false> a(result);
 eval_divide(result, a, b);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, signed_limb_type b)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, Signed, Allocator, false>& result, signed_limb_type b)
{
 // There is no in place divide:
 cpp_int_backend<MinBits, Signed, Allocator, false> a(result);
 eval_divide(result, a, b);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
{
 divide_unsigned_helper(static_cast<cpp_int_backend<MinBits, Signed, Allocator, false>* >(0), a, b, result);
 result.sign(a.sign());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, limb_type b)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, limb_type b)
{
 divide_unsigned_helper(static_cast<cpp_int_backend<MinBits, Signed, Allocator, false>* >(0), a, b, result);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, signed_limb_type b)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& a, signed_limb_type b)
{
 divide_unsigned_helper(static_cast<cpp_int_backend<MinBits, Signed, Allocator, false>* >(0), a, static_cast<limb_type>(std::abs(b)), result);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& b)
{
 // There is no in place divide:
 cpp_int_backend<MinBits, Signed, Allocator, false> a(result);
 eval_modulus(result, a, b);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, limb_type b)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, limb_type b)
{
 // There is no in place divide:
 cpp_int_backend<MinBits, Signed, Allocator, false> a(result);
 eval_modulus(result, a, b);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, signed_limb_type b)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, Allocator, false>& result, signed_limb_type b)
{
 // There is no in place divide:
 cpp_int_backend<MinBits, Signed, Allocator, false> a(result);
@@ -2479,22 +2479,22 @@
struct bit_xor{ limb_type operator()(limb_type a, limb_type b)const BOOST_NOEXCEPT { return a ^ b; } };

template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_bitwise_and(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o)BOOST_NOEXCEPT_IF(is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_bitwise_and(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o)BOOST_NOEXCEPT_IF(is_void<Allocator>::value)
{
 bitwise_op(result, o, bit_and());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_bitwise_or(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_bitwise_or(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(is_void<Allocator>::value)
{
 bitwise_op(result, o, bit_or());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_bitwise_xor(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_bitwise_xor(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(is_void<Allocator>::value)
{
 bitwise_op(result, o, bit_xor());
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_complement(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_complement(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& o) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 // Increment and negate:
 result = o;
@@ -2720,17 +2720,17 @@
}

template <unsigned MinBits, bool Signed, class Allocator>
-inline bool eval_is_zero(const cpp_int_backend<MinBits, Signed, Allocator, false>& val) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_is_zero(const cpp_int_backend<MinBits, Signed, Allocator, false>& val) BOOST_NOEXCEPT
{
 return (val.size() == 1) && (val.limbs()[0] == 0);
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline int eval_get_sign(const cpp_int_backend<MinBits, Signed, Allocator, false>& val) BOOST_NOEXCEPT
+BOOST_FORCEINLINE int eval_get_sign(const cpp_int_backend<MinBits, Signed, Allocator, false>& val) BOOST_NOEXCEPT
{
 return eval_is_zero(val) ? 0 : val.sign() ? -1 : 1;
}
template <unsigned MinBits, bool Signed, class Allocator>
-inline void eval_abs(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE void eval_abs(cpp_int_backend<MinBits, Signed, Allocator, false>& result, const cpp_int_backend<MinBits, Signed, Allocator, false>& val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 result = val;
 result.sign(false);
@@ -2927,7 +2927,7 @@
 }
}
template <unsigned MinBits, bool Signed, class Allocator, class Integer>
-inline typename enable_if<is_signed<Integer>, Integer>::type eval_integer_modulus(const cpp_int_backend<MinBits, Signed, Allocator, false>& x, Integer val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
+BOOST_FORCEINLINE typename enable_if<is_signed<Integer>, Integer>::type eval_integer_modulus(const cpp_int_backend<MinBits, Signed, Allocator, false>& x, Integer val) BOOST_NOEXCEPT_IF(boost::is_void<Allocator>::value)
{
 typedef typename make_unsigned<Integer>::type unsigned_type;
 return eval_integer_modulus(x, static_cast<unsigned_type>(std::abs(val)));

Modified: sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp 2012-08-03 14:24:53 EDT (Fri, 03 Aug 2012)
@@ -11,106 +11,106 @@
namespace boost{ namespace multiprecision{ namespace backends{

template <unsigned MinBits>
-inline bool eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
{
 return (a.sign() == b.sign()) && (*a.limbs() == *b.limbs());
}
template <unsigned MinBits>
-inline bool eval_eq(const cpp_int_backend<MinBits, false, void, true>& a, const cpp_int_backend<MinBits, false, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, false, void, true>& a, const cpp_int_backend<MinBits, false, void, true>& b) BOOST_NOEXCEPT
{
 return *a.limbs() == *b.limbs();
}
template <unsigned MinBits, class U>
-inline typename enable_if<is_unsigned, bool>::type eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, U b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_unsigned, bool>::type eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, U b) BOOST_NOEXCEPT
{
 return !a.sign() && (*a.limbs() == b);
}
template <unsigned MinBits, class S>
-inline typename enable_if<is_signed<S>, bool>::type eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, S b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_signed<S>, bool>::type eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, S b) BOOST_NOEXCEPT
{
 return (a.sign() == (b < 0)) && (*a.limbs() == std::abs(b));
}
template <unsigned MinBits, class U>
-inline typename enable_if<is_unsigned, bool>::type eval_eq(const cpp_int_backend<MinBits, false, void, true>& a, U b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_unsigned, bool>::type eval_eq(const cpp_int_backend<MinBits, false, void, true>& a, U b) BOOST_NOEXCEPT
{
 return *a.limbs() == b;
}
template <unsigned MinBits, class S>
-inline typename enable_if<is_signed<S>, bool>::type eval_eq(const cpp_int_backend<MinBits, false, void, true>& a, S b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_signed<S>, bool>::type eval_eq(const cpp_int_backend<MinBits, false, void, true>& a, S b) BOOST_NOEXCEPT
{
 return *a.limbs() == b;
}

template <unsigned MinBits>
-inline bool eval_lt(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_lt(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
{
 if(a.sign() != b.sign())
 return a.sign();
 return a.sign() ? *a.limbs() > *b.limbs() : *a.limbs() < *b.limbs();
}
template <unsigned MinBits>
-inline bool eval_lt(const cpp_int_backend<MinBits, false, void, true>& a, const cpp_int_backend<MinBits, false, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_lt(const cpp_int_backend<MinBits, false, void, true>& a, const cpp_int_backend<MinBits, false, void, true>& b) BOOST_NOEXCEPT
{
 return *a.limbs() < *b.limbs();
}
template <unsigned MinBits, class U>
-inline typename enable_if<is_unsigned, bool>::type eval_lt(const cpp_int_backend<MinBits, true, void, true>& a, U b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_unsigned, bool>::type eval_lt(const cpp_int_backend<MinBits, true, void, true>& a, U b) BOOST_NOEXCEPT
{
 if(a.sign())
 return true;
 return *a.limbs() < b;
}
template <unsigned MinBits, class S>
-inline typename enable_if<is_signed<S>, bool>::type eval_lt(const cpp_int_backend<MinBits, true, void, true>& a, S b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_signed<S>, bool>::type eval_lt(const cpp_int_backend<MinBits, true, void, true>& a, S b) BOOST_NOEXCEPT
{
 if(a.sign() != (b < 0))
 return a.sign();
 return a.sign() ? (*a.limbs() > std::abs(b)) : (*a.limbs() < std::abs(b));
}
template <unsigned MinBits, class U>
-inline typename enable_if<is_unsigned, bool>::type eval_lt(const cpp_int_backend<MinBits, false, void, true>& a, U b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_unsigned, bool>::type eval_lt(const cpp_int_backend<MinBits, false, void, true>& a, U b) BOOST_NOEXCEPT
{
 return *a.limbs() < b;
}
template <unsigned MinBits, class S>
-inline typename enable_if<is_signed<S>, bool>::type eval_lt(const cpp_int_backend<MinBits, false, void, true>& a, S b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_signed<S>, bool>::type eval_lt(const cpp_int_backend<MinBits, false, void, true>& a, S b) BOOST_NOEXCEPT
{
 return *a.limbs() < b;
}

template <unsigned MinBits>
-inline bool eval_gt(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_gt(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
{
 if(a.sign() != b.sign())
 return !a.sign();
 return a.sign() ? *a.limbs() < *b.limbs() : *a.limbs() > *b.limbs();
}
template <unsigned MinBits>
-inline bool eval_gt(const cpp_int_backend<MinBits, false, void, true>& a, const cpp_int_backend<MinBits, false, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE bool eval_gt(const cpp_int_backend<MinBits, false, void, true>& a, const cpp_int_backend<MinBits, false, void, true>& b) BOOST_NOEXCEPT
{
 return *a.limbs() > *b.limbs();
}
template <unsigned MinBits, class U>
-inline typename enable_if<is_unsigned, bool>::type eval_gt(const cpp_int_backend<MinBits, true, void, true>& a, U b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_unsigned, bool>::type eval_gt(const cpp_int_backend<MinBits, true, void, true>& a, U b) BOOST_NOEXCEPT
{
 if(a.sign())
 return false;
 return *a.limbs() > b;
}
template <unsigned MinBits, class S>
-inline typename enable_if<is_signed<S>, bool>::type eval_gt(const cpp_int_backend<MinBits, true, void, true>& a, S b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_signed<S>, bool>::type eval_gt(const cpp_int_backend<MinBits, true, void, true>& a, S b) BOOST_NOEXCEPT
{
 if(a.sign() != (b < 0))
 return !a.sign();
 return a.sign() ? (*a.limbs() < std::abs(b)) : (*a.limbs() > std::abs(b));
}
template <unsigned MinBits, class U>
-inline typename enable_if<is_unsigned, bool>::type eval_gt(const cpp_int_backend<MinBits, false, void, true>& a, U b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_unsigned, bool>::type eval_gt(const cpp_int_backend<MinBits, false, void, true>& a, U b) BOOST_NOEXCEPT
{
 return *a.limbs() > b;
}
template <unsigned MinBits, class S>
-inline typename enable_if<is_signed<S>, bool>::type eval_gt(const cpp_int_backend<MinBits, false, void, true>& a, S b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE typename enable_if<is_signed<S>, bool>::type eval_gt(const cpp_int_backend<MinBits, false, void, true>& a, S b) BOOST_NOEXCEPT
{
 return *a.limbs() > b;
}
@@ -133,7 +133,7 @@
}

template <unsigned MinBits>
-inline void eval_add(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_add(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() += *o.limbs();
}
@@ -155,26 +155,26 @@
}

template <unsigned MinBits>
-inline void eval_subtract(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_subtract(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() -= *o.limbs();
}

template <unsigned MinBits>
-inline void eval_multiply(cpp_int_backend<MinBits, true, void, true>& result, const cpp_int_backend<MinBits, true, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, true, void, true>& result, const cpp_int_backend<MinBits, true, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() *= *o.limbs();
 result.sign(result.sign() != o.sign());
}

template <unsigned MinBits>
-inline void eval_multiply(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_multiply(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() *= *o.limbs();
}

template <unsigned MinBits>
-inline void eval_divide(cpp_int_backend<MinBits, true, void, true>& result, const cpp_int_backend<MinBits, true, void, true>& o)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, true, void, true>& result, const cpp_int_backend<MinBits, true, void, true>& o)
{
 if(!*o.limbs())
 BOOST_THROW_EXCEPTION(std::runtime_error("Division by zero."));
@@ -183,7 +183,7 @@
}

template <unsigned MinBits>
-inline void eval_divide(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o)
+BOOST_FORCEINLINE void eval_divide(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o)
{
 if(!*o.limbs())
 BOOST_THROW_EXCEPTION(std::runtime_error("Division by zero."));
@@ -191,7 +191,7 @@
}

template <unsigned MinBits, bool Signed>
-inline void eval_modulus(cpp_int_backend<MinBits, Signed, void, true>& result, const cpp_int_backend<MinBits, Signed, void, true>& o)
+BOOST_FORCEINLINE void eval_modulus(cpp_int_backend<MinBits, Signed, void, true>& result, const cpp_int_backend<MinBits, Signed, void, true>& o)
{
 if(!*o.limbs())
 BOOST_THROW_EXCEPTION(std::runtime_error("Division by zero."));
@@ -200,13 +200,13 @@
}

template <unsigned MinBits, bool Signed, class T>
-inline void eval_left_shift(cpp_int_backend<MinBits, Signed, void, true>& result, T s) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_left_shift(cpp_int_backend<MinBits, Signed, void, true>& result, T s) BOOST_NOEXCEPT
{
 *result.limbs() <<= s;
}

template <unsigned MinBits, bool Signed, class T>
-inline void eval_right_shift(cpp_int_backend<MinBits, Signed, void, true>& result, T s) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_right_shift(cpp_int_backend<MinBits, Signed, void, true>& result, T s) BOOST_NOEXCEPT
{
 *result.limbs() >>= s;
}
@@ -241,7 +241,7 @@
}

template <unsigned MinBits>
-inline void eval_bitwise_and(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_bitwise_and(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() &= *o.limbs();
}
@@ -276,7 +276,7 @@
}

template <unsigned MinBits>
-inline void eval_bitwise_or(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_bitwise_or(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() |= *o.limbs();
}
@@ -311,7 +311,7 @@
}

template <unsigned MinBits>
-inline void eval_bitwise_xor(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_bitwise_xor(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() ^= *o.limbs();
}
@@ -340,19 +340,19 @@
}

template <unsigned MinBits>
-inline void eval_complement(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_complement(cpp_int_backend<MinBits, false, void, true>& result, const cpp_int_backend<MinBits, false, void, true>& o) BOOST_NOEXCEPT
{
 *result.limbs() = ~*o.limbs();
}

template <unsigned MinBits, bool Signed>
-inline void eval_gcd(cpp_int_backend<MinBits, Signed, void, true>& result, const cpp_int_backend<MinBits, Signed, void, true>& a, const cpp_int_backend<MinBits, Signed, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_gcd(cpp_int_backend<MinBits, Signed, void, true>& result, const cpp_int_backend<MinBits, Signed, void, true>& a, const cpp_int_backend<MinBits, Signed, void, true>& b) BOOST_NOEXCEPT
{
 *result.limbs() = boost::math::gcd(*a.limbs(), *b.limbs());
}

template <unsigned MinBits, bool Signed>
-inline void eval_lcm(cpp_int_backend<MinBits, Signed, void, true>& result, const cpp_int_backend<MinBits, Signed, void, true>& a, const cpp_int_backend<MinBits, Signed, void, true>& b) BOOST_NOEXCEPT
+BOOST_FORCEINLINE void eval_lcm(cpp_int_backend<MinBits, Signed, void, true>& result, const cpp_int_backend<MinBits, Signed, void, true>& a, const cpp_int_backend<MinBits, Signed, void, true>& b) BOOST_NOEXCEPT
{
 *result.limbs() = boost::math::lcm(*a.limbs(), *b.limbs());
}

Modified: sandbox/big_number/boost/multiprecision/mp_number.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mp_number.hpp (original)
+++ sandbox/big_number/boost/multiprecision/mp_number.hpp 2012-08-03 14:24:53 EDT (Fri, 03 Aug 2012)
@@ -38,21 +38,21 @@
 typedef mp_number<Backend, ExpressionTemplates> self_type;
public:
 typedef Backend backend_type;
- BOOST_CONSTEXPR mp_number() BOOST_NOEXCEPT_IF(noexcept(Backend())) {}
- BOOST_CONSTEXPR mp_number(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(e.m_backend){}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number() BOOST_NOEXCEPT_IF(noexcept(Backend())) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(e.m_backend){}
 template <class V>
- mp_number(V v, typename enable_if_c<
+ BOOST_FORCEINLINE mp_number(V v, typename enable_if_c<
 (boost::is_arithmetic<V>::value || is_same<std::string, V>::value || is_convertible<V, const char*>::value)
 && !is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value >::type* = 0)
 {
 m_backend = canonical_value(v);
 }
 template <class V>
- BOOST_CONSTEXPR mp_number(V v, typename enable_if_c<
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(V v, typename enable_if_c<
 (boost::is_arithmetic<V>::value || is_same<std::string, V>::value || is_convertible<V, const char*>::value)
 && is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value >::type* = 0)
 : m_backend(canonical_value(v)) {}
- BOOST_CONSTEXPR mp_number(const mp_number& e, unsigned digits10)
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number& e, unsigned digits10)
 : m_backend(e.m_backend, digits10){}
 /*
 //
@@ -67,10 +67,10 @@
 }
 */
 template<bool ET>
- BOOST_CONSTEXPR mp_number(const mp_number<Backend, ET>& val) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(val.m_backend) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number<Backend, ET>& val) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(val.m_backend) {}

 template <class Other, bool ET>
- mp_number(const mp_number<Other, ET>& val, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<Other>()))
+ BOOST_FORCEINLINE mp_number(const mp_number<Other, ET>& val, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<Other>()))
 {
 m_backend = val.backend();
 }
@@ -83,20 +83,20 @@
 detail::generic_interconvert(backend(), val.backend(), number_category<Backend>(), number_category<Other>());
 }
 template <class V>
- mp_number(V v1, V v2, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* = 0)
+ BOOST_FORCEINLINE mp_number(V v1, V v2, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* = 0)
 {
 using default_ops::assign_components;
 assign_components(m_backend, canonical_value(v1), canonical_value(v2));
 }
 template <class Other, bool ET>
- mp_number(const mp_number<Other, ET>& v1, const mp_number<Other, ET>& v2, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0)
+ BOOST_FORCEINLINE mp_number(const mp_number<Other, ET>& v1, const mp_number<Other, ET>& v2, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0)
 {
 using default_ops::assign_components;
 assign_components(m_backend, v1.backend(), v2.backend());
 }

 template <class V>
- BOOST_CONSTEXPR mp_number(V v, typename enable_if<mpl::and_<is_convertible<V, Backend>, mpl::not_<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > > > >::type* = 0)
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(V v, typename enable_if<mpl::and_<is_convertible<V, Backend>, mpl::not_<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > > > >::type* = 0)
 BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const V&>(std::declval<V>()))))
 : m_backend(v){}

@@ -108,14 +108,14 @@
 return *this;
 }

- mp_number& operator=(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Backend&>(std::declval<Backend>())))
+ BOOST_FORCEINLINE mp_number& operator=(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Backend&>(std::declval<Backend>())))
 {
 m_backend = e.m_backend;
 return *this;
 }

 template <class V>
- typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> >, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> >, mp_number<Backend, ExpressionTemplates>& >::type
 operator=(const V& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<typename boost::multiprecision::detail::canonical<V, Backend>::type>()))
 {
 m_backend = canonical_value(v);
@@ -123,7 +123,7 @@
 }

 template <class V>
- typename enable_if<mpl::and_<is_convertible<V, Backend>, mpl::not_<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > > >, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<mpl::and_<is_convertible<V, Backend>, mpl::not_<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > > >, mp_number<Backend, ExpressionTemplates>& >::type
 operator=(const V& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const V&>(std::declval<V>())))
 {
 m_backend = v;
@@ -131,14 +131,14 @@
 }

 template <bool ET>
- mp_number& operator=(const mp_number<Backend, ET>& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Backend&>(std::declval<Backend>())))
+ BOOST_FORCEINLINE mp_number& operator=(const mp_number<Backend, ET>& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Backend&>(std::declval<Backend>())))
 {
 m_backend = v.backend();
 return *this;
 }

 template <class Other>
- typename enable_if<is_convertible<Other, Backend>, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<is_convertible<Other, Backend>, mp_number<Backend, ExpressionTemplates>& >::type
 operator=(const mp_number<Other>& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Other&>(std::declval<Other>())))
 {
 m_backend = v.backend();
@@ -163,8 +163,8 @@
 }

#ifndef BOOST_NO_RVALUE_REFERENCES
- BOOST_CONSTEXPR mp_number(mp_number&& r) BOOST_NOEXCEPT : m_backend(static_cast<Backend&&>(r.m_backend)){}
- mp_number& operator=(mp_number&& r) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(mp_number&& r) BOOST_NOEXCEPT : m_backend(static_cast<Backend&&>(r.m_backend)){}
+ BOOST_FORCEINLINE mp_number& operator=(mp_number&& r) BOOST_NOEXCEPT
 {
 m_backend = static_cast<Backend&&>(r.m_backend);
 return *this;
@@ -307,21 +307,21 @@
 // execute the increment/decrement on destruction, but
 // correct implemetation will be tricky, so defered for now...
 //
- mp_number& operator++()
+ BOOST_FORCEINLINE mp_number& operator++()
 {
 using default_ops::eval_increment;
 eval_increment(m_backend);
 return *this;
 }

- mp_number& operator--()
+ BOOST_FORCEINLINE mp_number& operator--()
 {
 using default_ops::eval_decrement;
 eval_decrement(m_backend);
 return *this;
 }

- mp_number operator++(int)
+ BOOST_FORCEINLINE mp_number operator++(int)
 {
 using default_ops::eval_increment;
 self_type temp(*this);
@@ -329,7 +329,7 @@
 return BOOST_MP_MOVE(temp);
 }

- mp_number operator--(int)
+ BOOST_FORCEINLINE mp_number operator--(int)
 {
 using default_ops::eval_decrement;
 self_type temp(*this);
@@ -338,7 +338,7 @@
 }

 template <class V>
- typename enable_if<is_integral<V>, mp_number&>::type operator <<= (V val)
+ BOOST_FORCEINLINE typename enable_if<is_integral<V>, mp_number&>::type operator <<= (V val)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The left-shift operation is only valid for integer types");
 check_shift_range(val, mpl::bool_<(sizeof(V) > sizeof(std::size_t))>(), is_signed<V>());
@@ -347,7 +347,7 @@
 }

 template <class V>
- typename enable_if<is_integral<V>, mp_number&>::type operator >>= (V val)
+ BOOST_FORCEINLINE typename enable_if<is_integral<V>, mp_number&>::type operator >>= (V val)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The right-shift operation is only valid for integer types");
 check_shift_range(val, mpl::bool_<(sizeof(V) > sizeof(std::size_t))>(), is_signed<V>());
@@ -355,7 +355,7 @@
 return *this;
 }

- mp_number& operator /= (const self_type& e)
+ BOOST_FORCEINLINE mp_number& operator /= (const self_type& e)
 {
 do_divide(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
 return *this;
@@ -378,7 +378,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
 operator/=(const V& v)
 {
 using default_ops::eval_divide;
@@ -386,7 +386,7 @@
 return *this;
 }

- mp_number& operator&=(const self_type& e)
+ BOOST_FORCEINLINE mp_number& operator&=(const self_type& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
 do_bitwise_and(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
@@ -412,7 +412,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
 operator&=(const V& v)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
@@ -421,7 +421,7 @@
 return *this;
 }

- mp_number& operator|=(const self_type& e)
+ BOOST_FORCEINLINE mp_number& operator|=(const self_type& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
 do_bitwise_or(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
@@ -447,7 +447,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
 operator|=(const V& v)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
@@ -456,7 +456,7 @@
 return *this;
 }

- mp_number& operator^=(const self_type& e)
+ BOOST_FORCEINLINE mp_number& operator^=(const self_type& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
 do_bitwise_xor(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
@@ -480,7 +480,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
 operator^=(const V& v)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
@@ -493,7 +493,7 @@
 //
 typedef bool (self_type::*unmentionable_type)()const;

- operator unmentionable_type()const
+ BOOST_FORCEINLINE operator unmentionable_type()const
 {
 return is_zero() ? 0 : &self_type::is_zero;
 }
@@ -501,19 +501,19 @@
 //
 // swap:
 //
- void swap(self_type& other) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE void swap(self_type& other) BOOST_NOEXCEPT
 {
 m_backend.swap(other.backend());
 }
 //
 // Zero and sign:
 //
- bool is_zero()const
+ BOOST_FORCEINLINE bool is_zero()const
 {
 using default_ops::eval_is_zero;
 return eval_is_zero(m_backend);
 }
- int sign()const
+ BOOST_FORCEINLINE int sign()const
 {
 using default_ops::eval_get_sign;
 return eval_get_sign(m_backend);
@@ -555,24 +555,24 @@
 //
 // Comparison:
 //
- int compare(const mp_number<Backend, ExpressionTemplates>& o)const
+ BOOST_FORCEINLINE int compare(const mp_number<Backend, ExpressionTemplates>& o)const
 BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>().compare(std::declval<Backend>())))
 {
 return m_backend.compare(o.m_backend);
 }
 template <class V>
- typename enable_if<is_arithmetic<V>, int>::type compare(const V& o)const
+ BOOST_FORCEINLINE typename enable_if<is_arithmetic<V>, int>::type compare(const V& o)const
 {
 using default_ops::eval_get_sign;
 if(o == 0)
 return eval_get_sign(m_backend);
 return m_backend.compare(canonical_value(o));
 }
- Backend& backend() BOOST_NOEXCEPT
+ BOOST_FORCEINLINE Backend& backend() BOOST_NOEXCEPT
 {
 return m_backend;
 }
- const Backend& backend()const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE const Backend& backend()const BOOST_NOEXCEPT
 {
 return m_backend;
 }
@@ -1471,23 +1471,23 @@

 // Tests if the expression contains a reference to *this:
 template <class Exp>
- bool contains_self(const Exp& e)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool contains_self(const Exp& e)const BOOST_NOEXCEPT
 {
 return contains_self(e, typename Exp::arity());
 }
 template <class Exp>
- bool contains_self(const Exp& e, mpl::int_<0> const&)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<0> const&)const BOOST_NOEXCEPT
 {
 return is_realy_self(e.value());
 }
 template <class Exp>
- bool contains_self(const Exp& e, mpl::int_<1> const&)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<1> const&)const BOOST_NOEXCEPT
 {
 typedef typename Exp::left_type child_type;
 return contains_self(e.left(), typename child_type::arity());
 }
 template <class Exp>
- bool contains_self(const Exp& e, mpl::int_<2> const&)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<2> const&)const BOOST_NOEXCEPT
 {
 typedef typename Exp::left_type child0_type;
 typedef typename Exp::right_type child1_type;
@@ -1495,7 +1495,7 @@
 || contains_self(e.right(), typename child1_type::arity());
 }
 template <class Exp>
- bool contains_self(const Exp& e, mpl::int_<3> const&)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<3> const&)const BOOST_NOEXCEPT
 {
 typedef typename Exp::left_type child0_type;
 typedef typename Exp::middle_type child1_type;
@@ -1507,51 +1507,52 @@

 // Test if the expression is a reference to *this:
 template <class Exp>
- BOOST_CONSTEXPR bool is_self(const Exp& e)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_self(const Exp& e)const BOOST_NOEXCEPT
 {
 return is_self(e, typename Exp::arity());
 }
 template <class Exp>
- BOOST_CONSTEXPR bool is_self(const Exp& e, mpl::int_<0> const&)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_self(const Exp& e, mpl::int_<0> const&)const BOOST_NOEXCEPT
 {
 return is_realy_self(e.value());
 }
 template <class Exp, int v>
- BOOST_CONSTEXPR bool is_self(const Exp&, mpl::int_<v> const&)const BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_self(const Exp&, mpl::int_<v> const&)const BOOST_NOEXCEPT
 {
 return false;
 }

 template <class Val>
- BOOST_CONSTEXPR bool is_realy_self(const Val&)const BOOST_NOEXCEPT{ return false; }
- BOOST_CONSTEXPR bool is_realy_self(const self_type& v)const BOOST_NOEXCEPT{ return &v == this; }
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_realy_self(const Val&)const BOOST_NOEXCEPT{ return false; }
+ BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_realy_self(const self_type& v)const BOOST_NOEXCEPT{ return &v == this; }

- static BOOST_CONSTEXPR const Backend& canonical_value(const self_type& v) BOOST_NOEXCEPT { return v.m_backend; }
+ static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& canonical_value(const self_type& v) BOOST_NOEXCEPT { return v.m_backend; }
 template <class V>
- static BOOST_CONSTEXPR typename detail::canonical<V, Backend>::type canonical_value(const V& v) BOOST_NOEXCEPT { return static_cast<typename detail::canonical<V, Backend>::type>(v); }
- static typename detail::canonical<std::string, Backend>::type canonical_value(const std::string& v) BOOST_NOEXCEPT { return v.c_str(); }
+ static BOOST_FORCEINLINE BOOST_CONSTEXPR typename detail::canonical<V, Backend>::type canonical_value(const V& v) BOOST_NOEXCEPT { return static_cast<typename detail::canonical<V, Backend>::type>(v); }
+ static BOOST_FORCEINLINE typename detail::canonical<std::string, Backend>::type canonical_value(const std::string& v) BOOST_NOEXCEPT { return v.c_str(); }

- static BOOST_CONSTEXPR const Backend& function_arg_value(const self_type& v) BOOST_NOEXCEPT { return v.backend(); }
+ static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& function_arg_value(const self_type& v) BOOST_NOEXCEPT { return v.backend(); }
 template <class V>
- static BOOST_CONSTEXPR const V& function_arg_value(const V& v) BOOST_NOEXCEPT { return v; }
+ static BOOST_FORCEINLINE BOOST_CONSTEXPR const V& function_arg_value(const V& v) BOOST_NOEXCEPT { return v; }
 template <class A1, class A2, class A3, class A4>
- static const A1& function_arg_value(const detail::mp_exp<detail::terminal, A1, A2, A3, A4>& exp) BOOST_NOEXCEPT { return exp.value(); }
+ static BOOST_FORCEINLINE const A1& function_arg_value(const detail::mp_exp<detail::terminal, A1, A2, A3, A4>& exp) BOOST_NOEXCEPT { return exp.value(); }
 template <class A2, class A3, class A4>
- static BOOST_CONSTEXPR const Backend& function_arg_value(const detail::mp_exp<detail::terminal, mp_number<Backend>, A2, A3, A4>& exp) BOOST_NOEXCEPT { return exp.value().backend(); }
+ static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& function_arg_value(const detail::mp_exp<detail::terminal, mp_number<Backend>, A2, A3, A4>& exp) BOOST_NOEXCEPT { return exp.value().backend(); }
 Backend m_backend;
};

+/*
namespace detail
{

template <class Backend, bool ExpressionTemplates>
-inline int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+BOOST_FORCEINLINE int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
{
 return a.compare(b);
}

template <class Backend, bool ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
-inline int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const mp_exp<tag, A1, A2, A3, A4>& b)
+BOOST_FORCEINLINE int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const mp_exp<tag, A1, A2, A3, A4>& b)
{
 return a.compare(mp_number<Backend, ExpressionTemplates>(b));
}
@@ -1631,7 +1632,6 @@

}

-/*
template <class Exp1, class Exp2>
inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type
 operator == (const Exp1& a, const Exp2& b)
@@ -1712,7 +1712,7 @@
}

template <class Backend, bool ExpressionTemplates>
-inline void swap(mp_number<Backend, ExpressionTemplates>& a, mp_number<Backend, ExpressionTemplates>& b)
+BOOST_FORCEINLINE void swap(mp_number<Backend, ExpressionTemplates>& a, mp_number<Backend, ExpressionTemplates>& b)
{
 a.swap(b);
}

Modified: sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp 2012-08-03 14:24:53 EDT (Fri, 03 Aug 2012)
@@ -129,12 +129,13 @@
}

template <class R, class T>
-__forceinline void mul_2n(R& r, const T& a, const T& b)
+BOOST_FORCEINLINE void mul_2n(R& r, const T& a, const T& b)
{
- r = R(a) * b;
+ r = a;
+ r *= b;
}

-__forceinline void mul_2n(int128_t& r, const boost::int64_t& a, const boost::int64_t& b)
+BOOST_FORCEINLINE void mul_2n(int128_t& r, const boost::int64_t& a, const boost::int64_t& b)
{
r = mult_64x64_to_128(a, b);
}

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r79860 - sandbox/type_erasure/boost/type_erasure"
Previous message: steven_at_[hidden]: "[Boost-commit] svn:boost r79858 - in sandbox/type_erasure: boost/type_erasure libs/type_erasure/test"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk