Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r80418 - in sandbox/big_number: boost/multiprecision boost/multiprecision/concepts boost/multiprecision/depricated boost/multiprecision/detail libs/multiprecision/doc libs/multiprecision/performance libs/multiprecision/test libs/multiprecision/test/compile_fail libs/multiprecision/test/concepts libs/multiprecision/test/include_test libs/multiprecision/test/math libs/multiprecision/test/ublas_interop
From: john_at_[hidden]
Date: 2012-09-06 05:50:52

Author: johnmaddock
Date: 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
New Revision: 80418
URL: http://svn.boost.org/trac/boost/changeset/80418

Log:
Big search and replace change of name for the ExpressionTemplates template parameter to class number.
Text files modified:
   sandbox/big_number/boost/multiprecision/concepts/mp_number_archetypes.hpp | 2
   sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp | 48 ++--
   sandbox/big_number/boost/multiprecision/cpp_int.hpp | 158 +++++++-------
   sandbox/big_number/boost/multiprecision/depricated/arithmetic_backend.hpp | 2
   sandbox/big_number/boost/multiprecision/depricated/fixed_int.hpp | 4
   sandbox/big_number/boost/multiprecision/detail/big_lanczos.hpp | 2
   sandbox/big_number/boost/multiprecision/detail/default_ops.hpp | 118 +++++-----
   sandbox/big_number/boost/multiprecision/detail/et_ops.hpp | 428 ++++++++++++++++++++--------------------
   sandbox/big_number/boost/multiprecision/detail/integer_ops.hpp | 20
   sandbox/big_number/boost/multiprecision/detail/no_et_ops.hpp | 392 ++++++++++++++++++------------------
   sandbox/big_number/boost/multiprecision/detail/number_base.hpp | 32 +-
   sandbox/big_number/boost/multiprecision/detail/number_compare.hpp | 88 ++++----
   sandbox/big_number/boost/multiprecision/gmp.hpp | 142 ++++++------
   sandbox/big_number/boost/multiprecision/miller_rabin.hpp | 6
   sandbox/big_number/boost/multiprecision/mpfr.hpp | 96 ++++----
   sandbox/big_number/boost/multiprecision/number.hpp | 38 +-
   sandbox/big_number/boost/multiprecision/random.hpp | 14
   sandbox/big_number/boost/multiprecision/rational_adapter.hpp | 6
   sandbox/big_number/boost/multiprecision/tommath.hpp | 46 ++--
   sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk | 68 +++---
   sandbox/big_number/libs/multiprecision/performance/arithmetic_backend.hpp | 2
   sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp | 8
   sandbox/big_number/libs/multiprecision/performance/miller_rabin_performance.cpp | 6
   sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp | 20
   sandbox/big_number/libs/multiprecision/test/compile_fail/operator_fail_01.cpp | 4
   sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp | 2
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_basic.cpp | 2
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_bessel.cpp | 2
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_elliptic.cpp | 2
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_gamma.cpp | 2
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_poly.cpp | 2
   sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp | 8
   sandbox/big_number/libs/multiprecision/test/math/table_type.hpp | 2
   sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_constexpr.cpp | 8
   sandbox/big_number/libs/multiprecision/test/test_cpp_int_conv.cpp | 8
   sandbox/big_number/libs/multiprecision/test/test_float_io.cpp | 6
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp | 2
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp | 2
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp | 2
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp | 2
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp | 2
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp | 2
   43 files changed, 911 insertions(+), 905 deletions(-)

Modified: sandbox/big_number/boost/multiprecision/concepts/mp_number_archetypes.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/concepts/mp_number_archetypes.hpp (original)
+++ sandbox/big_number/boost/multiprecision/concepts/mp_number_archetypes.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -206,7 +206,7 @@

namespace std{

-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype, ExpressionTemplates> > : public std::numeric_limits<long double>
{
typedef std::numeric_limits<long double> base_type;

Modified: sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp (original)
+++ sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -2881,7 +2881,7 @@

namespace std
{
- template <unsigned Digits10, bool ExpressionTemplates>
+ template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
 class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >
 {
 public:
@@ -2922,49 +2922,49 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::digits;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::digits10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::max_digits10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::is_signed;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::is_integer;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::is_exact;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::radix;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST boost::int64_t numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::min_exponent;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST boost::int64_t numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::min_exponent10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST boost::int64_t numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::max_exponent;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST boost::int64_t numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::max_exponent10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::has_infinity;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::has_quiet_NaN;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::has_signaling_NaN;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::has_denorm;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::has_denorm_loss;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::is_iec559;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::is_bounded;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::is_modulo;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::traps;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::tinyness_before;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >::round_style;

#endif
@@ -2974,7 +2974,7 @@

namespace policies{

-template <unsigned Digits10, class Policy, bool ExpressionTemplates>
+template <unsigned Digits10, class Policy, boost::multiprecision::expression_template_option ExpressionTemplates>
struct precision< boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates>, Policy>
{
 // Define a local copy of cpp_dec_float_digits10 because it might differ

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-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -3069,16 +3069,16 @@
typedef number<cpp_rational_backend> cpp_rational;

// Fixed precision unsigned types:
-typedef number<cpp_int_backend<128, false, void>, false> uint128_t;
-typedef number<cpp_int_backend<256, false, void>, false> uint256_t;
-typedef number<cpp_int_backend<512, false, void>, false> uint512_t;
-typedef number<cpp_int_backend<1024, false, void>, false> uint1024_t;
+typedef number<cpp_int_backend<128, false, void>, et_off> uint128_t;
+typedef number<cpp_int_backend<256, false, void>, et_off> uint256_t;
+typedef number<cpp_int_backend<512, false, void>, et_off> uint512_t;
+typedef number<cpp_int_backend<1024, false, void>, et_off> uint1024_t;

// Fixed precision signed types:
-typedef number<cpp_int_backend<128, true, void>, false> int128_t;
-typedef number<cpp_int_backend<256, true, void>, false> int256_t;
-typedef number<cpp_int_backend<512, true, void>, false> int512_t;
-typedef number<cpp_int_backend<1024, true, void>, false> int1024_t;
+typedef number<cpp_int_backend<128, true, void>, et_off> int128_t;
+typedef number<cpp_int_backend<256, true, void>, et_off> int256_t;
+typedef number<cpp_int_backend<512, true, void>, et_off> int512_t;
+typedef number<cpp_int_backend<1024, true, void>, et_off> int1024_t;

#ifdef BOOST_MSVC
#pragma warning(pop)
@@ -3102,7 +3102,7 @@

namespace std{

-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> number_type;
@@ -3154,54 +3154,54 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::digits;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::digits10;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::max_digits10;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_signed;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_integer;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_exact;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::radix;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::min_exponent;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::min_exponent10;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::max_exponent;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::max_exponent10;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_infinity;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_quiet_NaN;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_signaling_NaN;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_denorm;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_denorm_loss;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_iec559;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_bounded;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_modulo;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::traps;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::tinyness_before;
-template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
+template <unsigned MinBits, bool Signed, class Allocator, bool trivial, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::round_style;

#endif

-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> number_type;
@@ -3273,59 +3273,59 @@
 BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
};

-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::inititializer numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::init;

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::digits;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::digits10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::max_digits10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_signed;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_integer;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_exact;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::radix;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::min_exponent;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::min_exponent10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::max_exponent;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::max_exponent10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_infinity;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_quiet_NaN;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_signaling_NaN;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_denorm;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_denorm_loss;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_iec559;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_bounded;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_modulo;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::traps;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::tinyness_before;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::round_style;

#endif

-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> number_type;
@@ -3401,54 +3401,54 @@
 BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
};

-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::inititializer numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::init;

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::digits;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::digits10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::max_digits10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_signed;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_integer;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_exact;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::radix;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::min_exponent;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::min_exponent10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::max_exponent;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::max_exponent10;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_infinity;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_quiet_NaN;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_signaling_NaN;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_denorm;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_denorm_loss;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_iec559;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_bounded;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_modulo;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::traps;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::tinyness_before;
-template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
+template <unsigned MinBits, boost::multiprecision::expression_template_option ExpressionTemplates, bool trivial>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::round_style;

#endif

Modified: sandbox/big_number/boost/multiprecision/depricated/arithmetic_backend.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/depricated/arithmetic_backend.hpp (original)
+++ sandbox/big_number/boost/multiprecision/depricated/arithmetic_backend.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -127,7 +127,7 @@

namespace std{

-template <class Arithmetic, bool ExpressionTemplates>
+template <class Arithmetic, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates > > : public std::numeric_limits<Arithmetic>
{
typedef std::numeric_limits<Arithmetic> base_type;

Modified: sandbox/big_number/boost/multiprecision/depricated/fixed_int.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/depricated/fixed_int.hpp (original)
+++ sandbox/big_number/boost/multiprecision/depricated/fixed_int.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -1517,7 +1517,7 @@

namespace std{

-template <unsigned Bits, bool Signed, bool ExpressionTemplates>
+template <unsigned Bits, bool Signed, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> number_type;
@@ -1591,7 +1591,7 @@
 BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
};

-template <unsigned Bits, bool Signed, bool ExpressionTemplates>
+template <unsigned Bits, bool Signed, boost::multiprecision::expression_template_option ExpressionTemplates>
typename numeric_limits<boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >::initializer const
 numeric_limits<boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >::init;
}

Modified: sandbox/big_number/boost/multiprecision/detail/big_lanczos.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/big_lanczos.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/big_lanczos.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -16,7 +16,7 @@
template <class T, class Policy>
struct lanczos;

-template<class Backend, bool ExpressionTemplates, class Policy>
+template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
struct lanczos<multiprecision::number<Backend, ExpressionTemplates>, Policy>
{
typedef typename boost::math::policies::precision<multiprecision::number<Backend, ExpressionTemplates>, Policy>::type precision_type;

Modified: sandbox/big_number/boost/multiprecision/detail/default_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/default_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/default_ops.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -945,7 +945,7 @@
//
// Default versions of floating point classification routines:
//
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 using multiprecision::default_ops::eval_fpclassify;
@@ -957,7 +957,7 @@
 typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return fpclassify(value_type(arg));
}
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 int v = fpclassify(arg);
@@ -969,7 +969,7 @@
 typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isfinite(value_type(arg));
}
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 return fpclassify(arg) == FP_NAN;
@@ -980,7 +980,7 @@
 typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isnan(value_type(arg));
}
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 return fpclassify(arg) == FP_INFINITE;
@@ -991,7 +991,7 @@
 typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isinf(value_type(arg));
}
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 return fpclassify(arg) == FP_NORMAL;
@@ -1013,7 +1013,7 @@
 return BOOST_MP_MOVE(trunc(number_type(v), pol));
}

-template <class Backend, bool ExpressionTemplates, class Policy>
+template <class Backend, expression_template_option ExpressionTemplates, class Policy>
inline number<Backend, ExpressionTemplates> trunc(const number<Backend, ExpressionTemplates>& v, const Policy&)
{
 using default_ops::eval_trunc;
@@ -1036,7 +1036,7 @@
{
 return itrunc(v, boost::math::policies::policy<>());
}
-template <class Backend, bool ExpressionTemplates, class Policy>
+template <class Backend, expression_template_option ExpressionTemplates, class Policy>
inline int itrunc(const number<Backend, ExpressionTemplates>& v, const Policy& pol)
{
 number<Backend, ExpressionTemplates> r = trunc(v, pol);
@@ -1044,7 +1044,7 @@
 return boost::math::policies::raise_rounding_error("boost::multiprecision::itrunc<%1%>(%1%)", 0, v, 0, pol).template convert_to<int>();
 return r.template convert_to<int>();
}
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline int itrunc(const number<Backend, ExpressionTemplates>& v)
{
 return itrunc(v, boost::math::policies::policy<>());
@@ -1063,7 +1063,7 @@
{
 return ltrunc(v, boost::math::policies::policy<>());
}
-template <class T, bool ExpressionTemplates, class Policy>
+template <class T, expression_template_option ExpressionTemplates, class Policy>
inline long ltrunc(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
 number<T, ExpressionTemplates> r = trunc(v, pol);
@@ -1071,7 +1071,7 @@
 return boost::math::policies::raise_rounding_error("boost::multiprecision::ltrunc<%1%>(%1%)", 0, v, 0L, pol).template convert_to<long>();
 return r.template convert_to<long>();
}
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
inline long ltrunc(const number<T, ExpressionTemplates>& v)
{
 return ltrunc(v, boost::math::policies::policy<>());
@@ -1091,7 +1091,7 @@
{
 return lltrunc(v, boost::math::policies::policy<>());
}
-template <class T, bool ExpressionTemplates, class Policy>
+template <class T, expression_template_option ExpressionTemplates, class Policy>
inline long long lltrunc(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
 number<T, ExpressionTemplates> r = trunc(v, pol);
@@ -1099,7 +1099,7 @@
 return boost::math::policies::raise_rounding_error("boost::multiprecision::lltrunc<%1%>(%1%)", 0, v, 0LL, pol).template convert_to<long long>();
 return r.template convert_to<long long>();
}
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
inline long long lltrunc(const number<T, ExpressionTemplates>& v)
{
 return lltrunc(v, boost::math::policies::policy<>());
@@ -1111,7 +1111,7 @@
 typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 return BOOST_MP_MOVE(round(static_cast<number_type>(v), pol));
}
-template <class T, bool ExpressionTemplates, class Policy>
+template <class T, expression_template_option ExpressionTemplates, class Policy>
inline number<T, ExpressionTemplates> round(const number<T, ExpressionTemplates>& v, const Policy&)
{
 using default_ops::eval_round;
@@ -1134,7 +1134,7 @@
{
 return iround(v, boost::math::policies::policy<>());
}
-template <class T, bool ExpressionTemplates, class Policy>
+template <class T, expression_template_option ExpressionTemplates, class Policy>
inline int iround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
 number<T, ExpressionTemplates> r = round(v, pol);
@@ -1142,7 +1142,7 @@
 return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", 0, v, 0, pol).template convert_to<int>();
 return r.template convert_to<int>();
}
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
inline int iround(const number<T, ExpressionTemplates>& v)
{
 return iround(v, boost::math::policies::policy<>());
@@ -1161,7 +1161,7 @@
{
 return lround(v, boost::math::policies::policy<>());
}
-template <class T, bool ExpressionTemplates, class Policy>
+template <class T, expression_template_option ExpressionTemplates, class Policy>
inline long lround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
 number<T, ExpressionTemplates> r = round(v, pol);
@@ -1169,7 +1169,7 @@
 return boost::math::policies::raise_rounding_error("boost::multiprecision::lround<%1%>(%1%)", 0, v, 0L, pol).template convert_to<long>();
 return r.template convert_to<long>();
}
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
inline long lround(const number<T, ExpressionTemplates>& v)
{
 return lround(v, boost::math::policies::policy<>());
@@ -1189,7 +1189,7 @@
{
 return llround(v, boost::math::policies::policy<>());
}
-template <class T, bool ExpressionTemplates, class Policy>
+template <class T, expression_template_option ExpressionTemplates, class Policy>
inline long long llround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
 number<T, ExpressionTemplates> r = round(v, pol);
@@ -1197,7 +1197,7 @@
 return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", 0, v, 0LL, pol).template convert_to<long long>();
 return r.template convert_to<long long>();
}
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
inline long long llround(const number<T, ExpressionTemplates>& v)
{
 return llround(v, boost::math::policies::policy<>());
@@ -1241,9 +1241,9 @@
 detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , number<Backend, true> > \
+ , number<Backend, et_on> > \
>::type \
-func(const number<Backend, true>& arg)\
+func(const number<Backend, et_on>& arg)\
{\
 return detail::expression<\
 detail::function\
@@ -1257,10 +1257,10 @@
template <class Backend> \
inline typename boost::enable_if_c<\
 boost::multiprecision::number_category<Backend>::value == category,\
- number<Backend, false> >::type \
-func(const number<Backend, false>& arg)\
+ number<Backend, et_off> >::type \
+func(const number<Backend, et_off>& arg)\
{\
- number<Backend, false> result;\
+ number<Backend, et_off> result;\
 using default_ops::BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend());\
 return BOOST_MP_MOVE(result);\
@@ -1296,10 +1296,10 @@
 detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , number<Backend, true> \
- , number<Backend, true> > \
+ , number<Backend, et_on> \
+ , number<Backend, et_on> > \
>::type \
-func(const number<Backend, true>& arg, const number<Backend, true>& a)\
+func(const number<Backend, et_on>& arg, const number<Backend, et_on>& a)\
{\
 return detail::expression<\
 detail::function\
@@ -1318,10 +1318,10 @@
 detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , number<Backend, true> \
+ , number<Backend, et_on> \
 , detail::expression<tag, A1, A2, A3, A4> > \
>::type \
-func(const number<Backend, true>& arg, const detail::expression<tag, A1, A2, A3, A4>& a)\
+func(const number<Backend, et_on>& arg, const detail::expression<tag, A1, A2, A3, A4>& a)\
{\
 return detail::expression<\
 detail::function\
@@ -1341,9 +1341,9 @@
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
 , detail::expression<tag, A1, A2, A3, A4> \
- , number<Backend, true> > \
+ , number<Backend, et_on> > \
>::type \
-func(const detail::expression<tag, A1, A2, A3, A4>& arg, const number<Backend, true>& a)\
+func(const detail::expression<tag, A1, A2, A3, A4>& arg, const number<Backend, et_on>& a)\
{\
 return detail::expression<\
 detail::function\
@@ -1384,11 +1384,11 @@
 detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , number<Backend, true> \
+ , number<Backend, et_on> \
 , Arithmetic\
> \
>::type \
-func(const number<Backend, true>& arg, const Arithmetic& a)\
+func(const number<Backend, et_on>& arg, const Arithmetic& a)\
{\
 return detail::expression<\
 detail::function\
@@ -1431,10 +1431,10 @@
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
 , Arithmetic \
- , number<Backend, true> \
+ , number<Backend, et_on> \
> \
>::type \
-func(const Arithmetic& arg, const number<Backend, true>& a)\
+func(const Arithmetic& arg, const number<Backend, et_on>& a)\
{\
 return detail::expression<\
 detail::function\
@@ -1472,10 +1472,10 @@
}\
template <class Backend> \
inline typename enable_if_c<(number_category<Backend>::value == category),\
- number<Backend, false> >::type \
-func(const number<Backend, false>& arg, const number<Backend, false>& a)\
+ number<Backend, et_off> >::type \
+func(const number<Backend, et_off>& arg, const number<Backend, et_off>& a)\
{\
- number<Backend, false> result;\
+ number<Backend, et_off> result;\
 using default_ops:: BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend(), a.backend());\
 return BOOST_MP_MOVE(result);\
@@ -1483,12 +1483,12 @@
template <class Backend, class Arithmetic> \
inline typename enable_if_c<\
 is_arithmetic<Arithmetic>::value && (number_category<Backend>::value == category),\
- number<Backend, false> \
+ number<Backend, et_off> \
>::type \
-func(const number<Backend, false>& arg, const Arithmetic& a)\
+func(const number<Backend, et_off>& arg, const Arithmetic& a)\
{\
 typedef typename detail::canonical<Arithmetic, Backend>::type canonical_type;\
- number<Backend, false> result;\
+ number<Backend, et_off> result;\
 using default_ops:: BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend(), static_cast<canonical_type>(a));\
 return BOOST_MP_MOVE(result);\
@@ -1496,12 +1496,12 @@
template <class Backend, class Arithmetic> \
inline typename enable_if_c<\
 is_arithmetic<Arithmetic>::value && (number_category<Backend>::value == category),\
- number<Backend, false> \
+ number<Backend, et_off> \
>::type \
-func(const Arithmetic& a, const number<Backend, false>& arg)\
+func(const Arithmetic& a, const number<Backend, et_off>& arg)\
{\
 typedef typename detail::canonical<Arithmetic, Backend>::type canonical_type;\
- number<Backend, false> result;\
+ number<Backend, et_off> result;\
 using default_ops:: BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), static_cast<canonical_type>(a), arg.backend());\
 return BOOST_MP_MOVE(result);\
@@ -1536,10 +1536,10 @@
 detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , number<Backend, true> \
+ , number<Backend, et_on> \
 , Arg2> \
>::type \
-func(const number<Backend, true>& arg, Arg2 const& a)\
+func(const number<Backend, et_on>& arg, Arg2 const& a)\
{\
 return detail::expression<\
 detail::function\
@@ -1555,10 +1555,10 @@
template <class Backend> \
inline typename enable_if_c<\
 (number_category<Backend>::value == category),\
- number<Backend, false> >::type \
-func(const number<Backend, false>& arg, Arg2 const& a)\
+ number<Backend, et_off> >::type \
+func(const number<Backend, et_off>& arg, Arg2 const& a)\
{\
- number<Backend, false> result;\
+ number<Backend, et_off> result;\
 using default_ops:: BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend(), a);\
 return BOOST_MP_MOVE(result);\
@@ -1614,23 +1614,23 @@
inline detail::expression<
 detail::function
 , detail::abs_funct<Backend>
- , number<Backend, true> >
-abs(const number<Backend, true>& arg)
+ , number<Backend, et_on> >
+abs(const number<Backend, et_on>& arg)
{
 return detail::expression<
 detail::function
 , detail::abs_funct<Backend>
- , number<Backend, true>
+ , number<Backend, et_on>
>(
 detail::abs_funct<Backend>()
 , arg
 );
}
template <class Backend>
-inline number<Backend, false>
-abs(const number<Backend, false>& arg)
+inline number<Backend, et_off>
+abs(const number<Backend, et_off>& arg)
{
- number<Backend, false> result;
+ number<Backend, et_off> result;
 using default_ops::eval_abs;
 eval_abs(result.backend(), arg.backend());
 return BOOST_MP_MOVE(result);
@@ -1685,25 +1685,25 @@
 template <class T> T sinc_pi_imp(T);
 template <class T> T sinhc_pi_imp(T);
}
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline multiprecision::number<Backend, ExpressionTemplates> sinc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x)
{
 return BOOST_MP_MOVE(detail::sinc_pi_imp(x));
}

-template <class Backend, bool ExpressionTemplates, class Policy>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline multiprecision::number<Backend, ExpressionTemplates> sinc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x, const Policy&)
{
 return BOOST_MP_MOVE(detail::sinc_pi_imp(x));
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline multiprecision::number<Backend, ExpressionTemplates> sinhc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x)
{
 return BOOST_MP_MOVE(detail::sinhc_pi_imp(x));
}

-template <class Backend, bool ExpressionTemplates, class Policy>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline multiprecision::number<Backend, ExpressionTemplates> sinhc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x, const Policy&)
{
 return BOOST_MP_MOVE(boost::math::sinhc_pi(x));

Modified: sandbox/big_number/boost/multiprecision/detail/et_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/et_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/et_ops.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -13,46 +13,46 @@
//
// Unary operators first:
//
-template <class B, bool ExpressionTemplates>
+template <class B, expression_template_option ExpressionTemplates>
inline const number<B, ExpressionTemplates>& operator + (const number<B, ExpressionTemplates>& v) { return v; }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& operator + (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return v; }
template <class B>
-inline detail::expression<detail::negate, number<B, true> > operator - (const number<B, true>& v) { return detail::expression<detail::negate, number<B, true> >(v); }
+inline detail::expression<detail::negate, number<B, et_on> > operator - (const number<B, et_on>& v) { return detail::expression<detail::negate, number<B, et_on> >(v); }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > operator - (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
template <class B>
-inline detail::expression<detail::complement_immediates, number<B, true> > operator ~ (const number<B, true>& v) { return detail::expression<detail::complement_immediates, number<B, true> >(v); }
+inline detail::expression<detail::complement_immediates, number<B, et_on> > operator ~ (const number<B, et_on>& v) { return detail::expression<detail::complement_immediates, number<B, et_on> >(v); }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > operator ~ (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
//
// Then addition:
//
template <class B>
-inline detail::expression<detail::add_immediates, number<B, true>, number<B, true> >
- operator + (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
+ operator + (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::add_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::add_immediates, number<B, true>, V > >::type
- operator + (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::add_immediates, number<B, et_on>, V > >::type
+ operator + (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::add_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::add_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::add_immediates, V, number<B, true> > >::type
- operator + (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
+ operator + (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::add_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b);
}
-template <class B, bool ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
 operator + (const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
 operator + (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -79,82 +79,82 @@
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
-template <class B, bool ET, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::minus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
 operator + (const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref());
}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::minus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
 operator + (const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::minus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref());
}
template <class B>
-inline detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >
- operator + (const number<B, true>& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
+ operator + (const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}
template <class B>
-inline detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >
- operator + (const detail::expression<detail::negate, number<B, true> >& a, const number<B, true>& b)
+inline detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
+ operator + (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
- return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(b, a.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref());
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::subtract_immediates, V, number<B, true> > >::type
- operator + (const detail::expression<detail::negate, number<B, true> >& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
+ operator + (const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
- return detail::expression<detail::subtract_immediates, V, number<B, true> >(b, a.left_ref());
+ return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(b, a.left_ref());
}
-template <class B, class B2, bool ET>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, true> > >::type
- operator + (const detail::expression<detail::negate, number<B, true> >& a, const number<B2, ET>& b)
+template <class B, class B2, expression_template_option ET>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
+ operator + (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
- return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, true> >(b, a.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
}
-template <class B2, bool ET, class B>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, true> > >::type
- operator + (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, true> >& b)
+template <class B2, expression_template_option ET, class B>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
+ operator + (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}
template <class B>
-inline detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, number<B, true> > >
- operator + (const detail::expression<detail::negate, number<B, true> >& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
+ operator + (const detail::expression<detail::negate, number<B, et_on> >& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, number<B, true> > >(detail::expression<detail::add_immediates, number<B, true>, number<B, true> >(a.left_ref(), b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b.left_ref()));
}
//
// Subtraction:
//
template <class B>
-inline detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >
- operator - (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
+ operator - (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::subtract_immediates, number<B, true>, V > >::type
- operator - (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::subtract_immediates, number<B, et_on>, V > >::type
+ operator - (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::subtract_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::subtract_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::subtract_immediates, V, number<B, true> > >::type
- operator - (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
+ operator - (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::subtract_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(a, b);
}
-template <class B, bool ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
 operator - (const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
 operator - (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -181,13 +181,13 @@
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
-template <class B, bool ET, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::plus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
 operator - (const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref());
}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
 operator - (const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -195,70 +195,70 @@
 detail::expression<detail::plus, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
}
template <class B>
-inline detail::expression<detail::add_immediates, number<B, true>, number<B, true> >
- operator - (const number<B, true>& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
+ operator - (const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::add_immediates, number<B, true>, number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}
template <class B>
-inline detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, number<B, true> > >
- operator - (const detail::expression<detail::negate, number<B, true> >& a, const number<B, true>& b)
+inline detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
+ operator - (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
- return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, number<B, true> > >(
- detail::expression<detail::add_immediates, number<B, true>, number<B, true> >(b, a.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
+ detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, V > > >::type
- operator - (const detail::expression<detail::negate, number<B, true> >& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V > > >::type
+ operator - (const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
- return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, V > >(detail::expression<detail::add_immediates, number<B, true>, V >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V > >(detail::expression<detail::add_immediates, number<B, et_on>, V >(a.left_ref(), b));
}
-template <class B, class B2, bool ET>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, number<B2, ET> > > >::type
- operator - (const detail::expression<detail::negate, number<B, true> >& a, const number<B2, ET>& b)
+template <class B, class B2, expression_template_option ET>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > > >::type
+ operator - (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
- return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, true>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, true>, number<B2, ET> >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::add_immediates, V, number<B, true> > >::type
- operator - (const V& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
+ operator - (const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::add_immediates, V, number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b.left_ref());
}
-template <class B2, bool ET, class B>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::add_immediates, number<B2, ET>, number<B, true> > >::type
- operator - (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, true> >& b)
+template <class B2, expression_template_option ET, class B>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> > >::type
+ operator - (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::add_immediates, number<B2, ET>, number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}
//
// Multiplication:
//
template <class B>
-inline detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> >
- operator * (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >
+ operator * (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::multiply_immediates, number<B, true>, V > >::type
- operator * (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::multiply_immediates, number<B, et_on>, V > >::type
+ operator * (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::multiply_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::multiply_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::multiply_immediates, V, number<B, true> > >::type
- operator * (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::multiply_immediates, V, number<B, et_on> > >::type
+ operator * (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::multiply_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::multiply_immediates, V, number<B, et_on> >(a, b);
}
-template <class B, bool ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
 operator * (const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
 operator * (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -285,14 +285,14 @@
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
-template <class B, bool ET, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
 operator * (const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
 detail::expression<detail::multiplies, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > (a, b.left_ref()));
}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
 operator * (const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -300,75 +300,75 @@
 detail::expression<detail::multiplies, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
}
template <class B>
-inline detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> > >
- operator * (const number<B, true>& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
+ operator * (const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> > >(
- detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> >(a, b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
+ detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
template <class B>
-inline detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> > >
- operator * (const detail::expression<detail::negate, number<B, true> >& a, const number<B, true>& b)
+inline detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
+ operator * (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
- return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> > >(
- detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> >(b, a.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
+ detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, V > > >::type
- operator * (const detail::expression<detail::negate, number<B, true> >& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V > > >::type
+ operator * (const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
- return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, V > > (
- detail::expression<detail::multiply_immediates, number<B, true>, V >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V > > (
+ detail::expression<detail::multiply_immediates, number<B, et_on>, V >(a.left_ref(), b));
}
-template <class B, class B2, bool ET>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B2, ET> > > >::type
- operator * (const detail::expression<detail::negate, number<B, true> >& a, const number<B2, ET>& b)
+template <class B, class B2, expression_template_option ET>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
+ operator * (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
- return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B2, ET> > > (
- detail::expression<detail::multiply_immediates, number<B, true>, number<B2, ET> >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > (
+ detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, V > > >::type
- operator * (const V& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V > > >::type
+ operator * (const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, V > >(
- detail::expression<detail::multiply_immediates, number<B, true>, V >(b.left_ref(), a));
+ return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V > >(
+ detail::expression<detail::multiply_immediates, number<B, et_on>, V >(b.left_ref(), a));
}
-template <class B2, bool ET, class B>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B2, ET> > > >::type
- operator * (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, true> >& b)
+template <class B2, expression_template_option ET, class B>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
+ operator * (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, true>, number<B2, ET> > >(
- detail::expression<detail::multiply_immediates, number<B, true>, number<B2, ET> >(b.left_ref(), a));
+ return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
+ detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
}
//
// Division:
//
template <class B>
-inline detail::expression<detail::divide_immediates, number<B, true>, number<B, true> >
- operator / (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >
+ operator / (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::divide_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::divide_immediates, number<B, true>, V > >::type
- operator / (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::divide_immediates, number<B, et_on>, V > >::type
+ operator / (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::divide_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::divide_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::divide_immediates, V, number<B, true> > >::type
- operator / (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::divide_immediates, V, number<B, et_on> > >::type
+ operator / (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::divide_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
}
-template <class B, bool ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
 operator / (const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
 operator / (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -395,14 +395,14 @@
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
-template <class B, bool ET, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
 operator / (const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
 detail::expression<detail::divides, number<B, ET>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref()));
}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline detail::expression<detail::negate, detail::expression<detail::divides, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, number<B, ET> > >
 operator / (const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
@@ -410,79 +410,79 @@
 detail::expression<detail::divides, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, number<B, ET> >(a.left_ref(), b));
}
template <class B>
-inline detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, number<B, true> > >
- operator / (const number<B, true>& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
+ operator / (const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, number<B, true> > >(
- detail::expression<detail::divide_immediates, number<B, true>, number<B, true> >(a, b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
+ detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
template <class B>
-inline detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, number<B, true> > >
- operator / (const detail::expression<detail::negate, number<B, true> >& a, const number<B, true>& b)
+inline detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
+ operator / (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
- return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, number<B, true> > >(
- detail::expression<detail::divide_immediates, number<B, true>, number<B, true> >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
+ detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, V > > >::type
- operator / (const detail::expression<detail::negate, number<B, true> >& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V > > >::type
+ operator / (const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
- return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, V > >(
- detail::expression<detail::divide_immediates, number<B, true>, V>(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V > >(
+ detail::expression<detail::divide_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
-template <class B, class B2, bool ET>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, number<B2, ET> > > >::type
- operator / (const detail::expression<detail::negate, number<B, true> >& a, const number<B2, ET>& b)
+template <class B, class B2, expression_template_option ET>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > > >::type
+ operator / (const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
- return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, true>, number<B2, ET> > >(
- detail::expression<detail::divide_immediates, number<B, true>, number<B2, ET> >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
+ detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, true> > > >::type
- operator / (const V& a, const detail::expression<detail::negate, number<B, true> >& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > > >::type
+ operator / (const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, true> > >(
- detail::expression<detail::divide_immediates, V, number<B, true> >(a, b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > >(
+ detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b.left_ref()));
}
-template <class B2, bool ET, class B>
-inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, true> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, true> > > >::type
- operator / (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, true> >& b)
+template <class B2, expression_template_option ET, class B>
+inline typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > > >::type
+ operator / (const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
- return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, true> > >(
- detail::expression<detail::divide_immediates, number<B2, ET>, number<B, true> >(a, b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
+ detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
}
//
// Modulus:
//
template <class B>
-inline detail::expression<detail::modulus_immediates, number<B, true>, number<B, true> >
- operator % (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >
+ operator % (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::modulus_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::modulus_immediates, number<B, true>, V > >::type
- operator % (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::modulus_immediates, number<B, et_on>, V > >::type
+ operator % (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::modulus_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::modulus_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::modulus_immediates, V, number<B, true> > >::type
- operator % (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::modulus_immediates, V, number<B, et_on> > >::type
+ operator % (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::modulus_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::expression<detail::modulus, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
- operator % (const number<B, true>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
+ operator % (const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::expression<detail::modulus, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >
- operator % (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, true>& b)
+inline detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >
+ operator % (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(a, b);
+ return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
@@ -506,10 +506,10 @@
// Left shift:
//
template <class B, class I>
-inline typename enable_if<is_integral, detail::expression<detail::shift_left, number<B, true>, I > >::type
- operator << (const number<B, true>& a, const I& b)
+inline typename enable_if<is_integral, detail::expression<detail::shift_left, number<B, et_on>, I > >::type
+ operator << (const number<B, et_on>& a, const I& b)
{
- return detail::expression<detail::shift_left, number<B, true>, I>(a, b);
+ return detail::expression<detail::shift_left, number<B, et_on>, I>(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
inline typename enable_if<is_integral, detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
@@ -521,10 +521,10 @@
// Right shift:
//
template <class B, class I>
-inline typename enable_if<is_integral, detail::expression<detail::shift_right, number<B, true>, I > >::type
- operator >> (const number<B, true>& a, const I& b)
+inline typename enable_if<is_integral, detail::expression<detail::shift_right, number<B, et_on>, I > >::type
+ operator >> (const number<B, et_on>& a, const I& b)
{
- return detail::expression<detail::shift_right, number<B, true>, I>(a, b);
+ return detail::expression<detail::shift_right, number<B, et_on>, I>(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
inline typename enable_if<is_integral, detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
@@ -536,34 +536,34 @@
// Bitwise AND:
//
template <class B>
-inline detail::expression<detail::bitwise_and_immediates, number<B, true>, number<B, true> >
- operator & (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >
+ operator & (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_and_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::bitwise_and_immediates, number<B, true>, V > >::type
- operator & (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V > >::type
+ operator & (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::bitwise_and_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::bitwise_and_immediates, V, number<B, true> > >::type
- operator & (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> > >::type
+ operator & (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_and_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::expression<detail::bitwise_and, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
- operator & (const number<B, true>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
+ operator & (const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::expression<detail::bitwise_and, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >
- operator & (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, true>& b)
+inline detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >
+ operator & (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
@@ -587,34 +587,34 @@
// Bitwise OR:
//
template <class B>
-inline detail::expression<detail::bitwise_or_immediates, number<B, true>, number<B, true> >
- operator| (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >
+ operator| (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_or_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::bitwise_or_immediates, number<B, true>, V > >::type
- operator| (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V > >::type
+ operator| (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::bitwise_or_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::bitwise_or_immediates, V, number<B, true> > >::type
- operator| (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> > >::type
+ operator| (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_or_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::expression<detail::bitwise_or, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
- operator| (const number<B, true>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
+ operator| (const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::expression<detail::bitwise_or, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >
- operator| (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, true>& b)
+inline detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >
+ operator| (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
@@ -638,34 +638,34 @@
// Bitwise XOR:
//
template <class B>
-inline detail::expression<detail::bitwise_xor_immediates, number<B, true>, number<B, true> >
- operator^ (const number<B, true>& a, const number<B, true>& b)
+inline detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >
+ operator^ (const number<B, et_on>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_xor_immediates, number<B, true>, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::bitwise_xor_immediates, number<B, true>, V > >::type
- operator^ (const number<B, true>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V > >::type
+ operator^ (const number<B, et_on>& a, const V& b)
{
- return detail::expression<detail::bitwise_xor_immediates, number<B, true>, V >(a, b);
+ return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, true> >, detail::expression<detail::bitwise_xor_immediates, V, number<B, true> > >::type
- operator^ (const V& a, const number<B, true>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> > >::type
+ operator^ (const V& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_xor_immediates, V, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::expression<detail::bitwise_xor, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
- operator^ (const number<B, true>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
+ operator^ (const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::expression<detail::bitwise_xor, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >
- operator^ (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, true>& b)
+inline detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >
+ operator^ (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
- return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >

Modified: sandbox/big_number/boost/multiprecision/detail/integer_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/integer_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/integer_ops.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -131,7 +131,7 @@

}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer>::type
 divide_qr(const number<Backend, ExpressionTemplates>& x, const number<Backend, ExpressionTemplates>& y,
 number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
@@ -140,7 +140,7 @@
 eval_qr(x.backend(), y.backend(), q.backend(), r.backend());
}

-template <class Backend, bool ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer>::type
 divide_qr(const number<Backend, ExpressionTemplates>& x, const multiprecision::detail::expression<tag, A1, A2, A3, A4>& y,
 number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
@@ -148,7 +148,7 @@
 divide_qr(x, number<Backend, ExpressionTemplates>(y), q, r);
}

-template <class tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer>::type
 divide_qr(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, const number<Backend, ExpressionTemplates>& y,
 number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
@@ -156,7 +156,7 @@
 divide_qr(number<Backend, ExpressionTemplates>(x), y, q, r);
}

-template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b, class Backend, bool ExpressionTemplates>
+template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer>::type
 divide_qr(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, const multiprecision::detail::expression<tagb, A1b, A2b, A3b, A4b>& y,
 number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
@@ -164,7 +164,7 @@
 divide_qr(number<Backend, ExpressionTemplates>(x), number<Backend, ExpressionTemplates>(y), q, r);
}

-template <class Backend, bool ExpressionTemplates, class Integer>
+template <class Backend, expression_template_option ExpressionTemplates, class Integer>
inline typename enable_if<mpl::and_<is_integral<Integer>, mpl::bool_<number_category<Backend>::value == number_kind_integer> >, Integer>::type
 integer_modulus(const number<Backend, ExpressionTemplates>& x, Integer val)
{
@@ -180,7 +180,7 @@
 return integer_modulus(result_type(x), val);
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, unsigned>::type
 lsb(const number<Backend, ExpressionTemplates>& x)
{
@@ -198,7 +198,7 @@
 return eval_lsb(n.backend());
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, bool>::type
 bit_test(const number<Backend, ExpressionTemplates>& x, unsigned index)
{
@@ -216,7 +216,7 @@
 return eval_bit_test(n.backend(), index);
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
 bit_set(number<Backend, ExpressionTemplates>& x, unsigned index)
{
@@ -225,7 +225,7 @@
 return x;
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
 bit_unset(number<Backend, ExpressionTemplates>& x, unsigned index)
{
@@ -234,7 +234,7 @@
 return x;
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
 bit_flip(number<Backend, ExpressionTemplates>& x, unsigned index)
{

Modified: sandbox/big_number/boost/multiprecision/detail/no_et_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/no_et_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/no_et_ops.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -15,16 +15,16 @@
// NOTE: these operators have to be defined after the methods in default_ops.hpp.
//
template <class B>
-inline number<B, false> operator - (const number<B, false>& v)
+inline number<B, et_off> operator - (const number<B, et_off>& v)
{
- number<B, false> result(v);
+ number<B, et_off> result(v);
 result.backend().negate();
 return BOOST_MP_MOVE(result);
}
template <class B>
-inline number<B, false> operator ~ (const number<B, false>& v)
+inline number<B, et_off> operator ~ (const number<B, et_off>& v)
{
- number<B, false> result;
+ number<B, et_off> result;
 eval_complement(result.backend(), v.backend());
 return BOOST_MP_MOVE(result);
}
@@ -32,252 +32,252 @@
// Addition:
//
template <class B>
-inline number<B, false> operator + (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator + (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_add;
 eval_add(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator + (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator + (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_add;
- eval_add(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_add(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator + (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator + (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_add;
- eval_add(result.backend(), b.backend(), number<B, false>::canonical_value(a));
+ eval_add(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
 return BOOST_MP_MOVE(result);
}
//
// Subtraction:
//
template <class B>
-inline number<B, false> operator - (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator - (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_subtract;
 eval_subtract(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator - (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator - (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_subtract;
- eval_subtract(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_subtract(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator - (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator - (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_subtract;
- eval_subtract(result.backend(), number<B, false>::canonical_value(a), b.backend());
+ eval_subtract(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
 return BOOST_MP_MOVE(result);
}
//
// Multiply:
//
template <class B>
-inline number<B, false> operator * (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator * (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_multiply;
 eval_multiply(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator * (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator * (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_multiply;
- eval_multiply(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_multiply(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator * (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator * (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_multiply;
- eval_multiply(result.backend(), b.backend(), number<B, false>::canonical_value(a));
+ eval_multiply(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
 return BOOST_MP_MOVE(result);
}
//
// divide:
//
template <class B>
-inline number<B, false> operator / (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator / (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_divide;
 eval_divide(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator / (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator / (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_divide;
- eval_divide(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_divide(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator / (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator / (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_divide;
- eval_divide(result.backend(), number<B, false>::canonical_value(a), b.backend());
+ eval_divide(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
 return BOOST_MP_MOVE(result);
}
//
// modulus:
//
template <class B>
-inline number<B, false> operator % (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator % (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_modulus;
 eval_modulus(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator % (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator % (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_modulus;
- eval_modulus(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_modulus(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator % (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator % (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_modulus;
- eval_modulus(result.backend(), number<B, false>::canonical_value(a), b.backend());
+ eval_modulus(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
 return BOOST_MP_MOVE(result);
}
//
// Bitwise or:
//
template <class B>
-inline number<B, false> operator | (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator | (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator | (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator | (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_or;
- eval_bitwise_or(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_bitwise_or(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator | (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator | (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_or;
- eval_bitwise_or(result.backend(), b.backend(), number<B, false>::canonical_value(a));
+ eval_bitwise_or(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
 return BOOST_MP_MOVE(result);
}
//
// Bitwise xor:
//
template <class B>
-inline number<B, false> operator ^ (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator ^ (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator ^ (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator ^ (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_bitwise_xor(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator ^ (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator ^ (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(result.backend(), b.backend(), number<B, false>::canonical_value(a));
+ eval_bitwise_xor(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
 return BOOST_MP_MOVE(result);
}
//
// Bitwise and:
//
template <class B>
-inline number<B, false> operator & (const number<B, false>& a, const number<B, false>& b)
+inline number<B, et_off> operator & (const number<B, et_off>& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(result.backend(), a.backend(), b.backend());
 return BOOST_MP_MOVE(result);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator & (const number<B, false>& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator & (const number<B, et_off>& a, const V& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_and;
- eval_bitwise_and(result.backend(), a.backend(), number<B, false>::canonical_value(b));
+ eval_bitwise_and(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator & (const V& a, const number<B, false>& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator & (const V& a, const number<B, et_off>& b)
{
- number<B, false> result;
+ number<B, et_off> result;
 using default_ops::eval_bitwise_and;
- eval_bitwise_and(result.backend(), b.backend(), number<B, false>::canonical_value(a));
+ eval_bitwise_and(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
 return BOOST_MP_MOVE(result);
}
//
// shifts:
//
template <class B, class I>
-inline typename enable_if<is_integral, number<B, false> >::type
- operator << (const number<B, false>& a, const I& b)
+inline typename enable_if<is_integral, number<B, et_off> >::type
+ operator << (const number<B, et_off>& a, const I& b)
{
- number<B, false> result(a);
+ number<B, et_off> result(a);
 using default_ops::eval_left_shift;
 detail::check_shift_range(b, mpl::bool_<(sizeof(I) > sizeof(std::size_t))>(), is_signed());
 eval_left_shift(result.backend(), b);
 return BOOST_MP_MOVE(result);
}
template <class B, class I>
-inline typename enable_if<is_integral, number<B, false> >::type
- operator >> (const number<B, false>& a, const I& b)
+inline typename enable_if<is_integral, number<B, et_off> >::type
+ operator >> (const number<B, et_off>& a, const I& b)
{
- number<B, false> result(a);
+ number<B, et_off> result(a);
 using default_ops::eval_right_shift;
 detail::check_shift_range(b, mpl::bool_<(sizeof(I) > sizeof(std::size_t))>(), is_signed());
 eval_right_shift(result.backend(), b);
@@ -297,313 +297,313 @@
// semantics help a great deal in return by value, so performance is still pretty good...
//
template <class B>
-inline number<B, false> operator - (number<B, false>&& v)
+inline number<B, et_off> operator - (number<B, et_off>&& v)
{
 v.backend().negate();
- return static_cast<number<B, false>&&>(v);
+ return static_cast<number<B, et_off>&&>(v);
}
template <class B>
-inline number<B, false> operator ~ (number<B, false>&& v)
+inline number<B, et_off> operator ~ (number<B, et_off>&& v)
{
 eval_complement(v.backend(), v.backend());
- return static_cast<number<B, false>&&>(v);
+ return static_cast<number<B, et_off>&&>(v);
}
//
// Addition:
//
template <class B>
-inline number<B, false> operator + (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator + (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_add;
 eval_add(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B>
-inline number<B, false> operator + (const number<B, false>& a, number<B, false>&& b)
+inline number<B, et_off> operator + (const number<B, et_off>& a, number<B, et_off>&& b)
{
 using default_ops::eval_add;
 eval_add(b.backend(), a.backend());
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
template <class B>
-inline number<B, false> operator + (number<B, false>&& a, number<B, false>&& b)
+inline number<B, et_off> operator + (number<B, et_off>&& a, number<B, et_off>&& b)
{
 using default_ops::eval_add;
 eval_add(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator + (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator + (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_add;
- eval_add(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_add(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator + (const V& a, number<B, false>&& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator + (const V& a, number<B, et_off>&& b)
{
 using default_ops::eval_add;
- eval_add(b.backend(), number<B, false>::canonical_value(a));
- return static_cast<number<B, false>&&>(b);
+ eval_add(b.backend(), number<B, et_off>::canonical_value(a));
+ return static_cast<number<B, et_off>&&>(b);
}
//
// Subtraction:
//
template <class B>
-inline number<B, false> operator - (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator - (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_subtract;
 eval_subtract(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B>
-inline number<B, false> operator - (const number<B, false>& a, number<B, false>&& b)
+inline number<B, et_off> operator - (const number<B, et_off>& a, number<B, et_off>&& b)
{
 using default_ops::eval_subtract;
 eval_subtract(b.backend(), a.backend());
 b.backend().negate();
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
template <class B>
-inline number<B, false> operator - (number<B, false>&& a, number<B, false>&& b)
+inline number<B, et_off> operator - (number<B, et_off>&& a, number<B, et_off>&& b)
{
 using default_ops::eval_subtract;
 eval_subtract(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator - (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator - (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_subtract;
- eval_subtract(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_subtract(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator - (const V& a, number<B, false>&& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator - (const V& a, number<B, et_off>&& b)
{
 using default_ops::eval_subtract;
- eval_subtract(b.backend(), number<B, false>::canonical_value(a));
+ eval_subtract(b.backend(), number<B, et_off>::canonical_value(a));
 b.backend().negate();
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
//
// Multiply:
//
template <class B>
-inline number<B, false> operator * (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator * (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_multiply;
 eval_multiply(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B>
-inline number<B, false> operator * (const number<B, false>& a, number<B, false>&& b)
+inline number<B, et_off> operator * (const number<B, et_off>& a, number<B, et_off>&& b)
{
 using default_ops::eval_multiply;
 eval_multiply(b.backend(), a.backend());
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
template <class B>
-inline number<B, false> operator * (number<B, false>&& a, number<B, false>&& b)
+inline number<B, et_off> operator * (number<B, et_off>&& a, number<B, et_off>&& b)
{
 using default_ops::eval_multiply;
 eval_multiply(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator * (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator * (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_multiply;
- eval_multiply(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_multiply(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator * (const V& a, number<B, false>&& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator * (const V& a, number<B, et_off>&& b)
{
 using default_ops::eval_multiply;
- eval_multiply(b.backend(), number<B, false>::canonical_value(a));
- return static_cast<number<B, false>&&>(b);
+ eval_multiply(b.backend(), number<B, et_off>::canonical_value(a));
+ return static_cast<number<B, et_off>&&>(b);
}
//
// divide:
//
template <class B>
-inline number<B, false> operator / (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator / (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_divide;
 eval_divide(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator / (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator / (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_divide;
- eval_divide(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_divide(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
//
// modulus:
//
template <class B>
-inline number<B, false> operator % (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator % (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_modulus;
 eval_modulus(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator % (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator % (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_modulus;
- eval_modulus(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_modulus(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
//
// Bitwise or:
//
template <class B>
-inline number<B, false> operator | (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator | (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B>
-inline number<B, false> operator | (const number<B, false>& a, number<B, false>&& b)
+inline number<B, et_off> operator | (const number<B, et_off>& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(b.backend(), a.backend());
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
template <class B>
-inline number<B, false> operator | (number<B, false>&& a, number<B, false>&& b)
+inline number<B, et_off> operator | (number<B, et_off>&& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator | (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator | (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_bitwise_or;
- eval_bitwise_or(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_bitwise_or(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator | (const V& a, number<B, false>&& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator | (const V& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_or;
- eval_bitwise_or(b.backend(), number<B, false>::canonical_value(a));
- return static_cast<number<B, false>&&>(b);
+ eval_bitwise_or(b.backend(), number<B, et_off>::canonical_value(a));
+ return static_cast<number<B, et_off>&&>(b);
}
//
// Bitwise xor:
//
template <class B>
-inline number<B, false> operator ^ (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator ^ (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B>
-inline number<B, false> operator ^ (const number<B, false>& a, number<B, false>&& b)
+inline number<B, et_off> operator ^ (const number<B, et_off>& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(b.backend(), a.backend());
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
template <class B>
-inline number<B, false> operator ^ (number<B, false>&& a, number<B, false>&& b)
+inline number<B, et_off> operator ^ (number<B, et_off>&& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator ^ (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator ^ (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_bitwise_xor(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator ^ (const V& a, number<B, false>&& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator ^ (const V& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(b.backend(), number<B, false>::canonical_value(a));
- return static_cast<number<B, false>&&>(b);
+ eval_bitwise_xor(b.backend(), number<B, et_off>::canonical_value(a));
+ return static_cast<number<B, et_off>&&>(b);
}
//
// Bitwise and:
//
template <class B>
-inline number<B, false> operator & (number<B, false>&& a, const number<B, false>& b)
+inline number<B, et_off> operator & (number<B, et_off>&& a, const number<B, et_off>& b)
{
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B>
-inline number<B, false> operator & (const number<B, false>& a, number<B, false>&& b)
+inline number<B, et_off> operator & (const number<B, et_off>& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(b.backend(), a.backend());
- return static_cast<number<B, false>&&>(b);
+ return static_cast<number<B, et_off>&&>(b);
}
template <class B>
-inline number<B, false> operator & (number<B, false>&& a, number<B, false>&& b)
+inline number<B, et_off> operator & (number<B, et_off>&& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(a.backend(), b.backend());
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator & (number<B, false>&& a, const V& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator & (number<B, et_off>&& a, const V& b)
{
 using default_ops::eval_bitwise_and;
- eval_bitwise_and(a.backend(), number<B, false>::canonical_value(b));
- return static_cast<number<B, false>&&>(a);
+ eval_bitwise_and(a.backend(), number<B, et_off>::canonical_value(b));
+ return static_cast<number<B, et_off>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_compatible_arithmetic_type<V, number<B, false> >, number<B, false> >::type
- operator & (const V& a, number<B, false>&& b)
+inline typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
+ operator & (const V& a, number<B, et_off>&& b)
{
 using default_ops::eval_bitwise_and;
- eval_bitwise_and(b.backend(), number<B, false>::canonical_value(a));
- return static_cast<number<B, false>&&>(b);
+ eval_bitwise_and(b.backend(), number<B, et_off>::canonical_value(a));
+ return static_cast<number<B, et_off>&&>(b);
}
//
// shifts:
//
template <class B, class I>
-inline typename enable_if<is_integral, number<B, false> >::type
- operator << (number<B, false>&& a, const I& b)
+inline typename enable_if<is_integral, number<B, et_off> >::type
+ operator << (number<B, et_off>&& a, const I& b)
{
 using default_ops::eval_left_shift;
 eval_left_shift(a.backend(), b);
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}
template <class B, class I>
-inline typename enable_if<is_integral, number<B, false> >::type
- operator >> (number<B, false>&& a, const I& b)
+inline typename enable_if<is_integral, number<B, et_off> >::type
+ operator >> (number<B, et_off>&& a, const I& b)
{
 using default_ops::eval_right_shift;
 eval_right_shift(a.backend(), b);
- return static_cast<number<B, false>&&>(a);
+ return static_cast<number<B, et_off>&&>(a);
}

#endif

Modified: sandbox/big_number/boost/multiprecision/detail/number_base.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/number_base.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/number_base.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -14,13 +14,19 @@

namespace boost{ namespace multiprecision{

-template <class Backend, bool ExpressionTemplates = true>
+enum expression_template_option
+{
+ et_off = 0,
+ et_on = 1
+};
+
+template <class Backend, expression_template_option ExpressionTemplates = et_on>
class number;

template <class T>
struct is_number : public mpl::false_ {};

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
struct is_number<number<Backend, ExpressionTemplates> > : public mpl::true_ {};

namespace detail{
@@ -79,12 +85,12 @@
 typedef typename remove_cv<typename decay<const Val>::type>::type type;
};
template <class B, class Backend, class Tag>
-struct canonical_imp<number<B, true>, Backend, Tag>
+struct canonical_imp<number<B, et_on>, Backend, Tag>
{
 typedef B type;
};
template <class B, class Backend, class Tag>
-struct canonical_imp<number<B, false>, Backend, Tag>
+struct canonical_imp<number<B, et_off>, Backend, Tag>
{
 typedef B type;
};
@@ -178,7 +184,7 @@
template <class T>
struct backend_type;

-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
struct backend_type<number<T, ExpressionTemplates> >
{
 typedef T type;
@@ -193,7 +199,7 @@

template <class T>
struct is_number : public mpl::false_{};
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
struct is_number<boost::multiprecision::number<T, ExpressionTemplates> > : public mpl::true_{};
template <class T>
struct is_mp_number_exp : public mpl::false_{};
@@ -203,25 +209,25 @@
template <class T1, class T2>
struct combine_expression;

-template <class T1, bool ExpressionTemplates, class T2>
+template <class T1, expression_template_option ExpressionTemplates, class T2>
struct combine_expression<number<T1, ExpressionTemplates>, T2>
{
 typedef number<T1, ExpressionTemplates> type;
};

-template <class T1, class T2, bool ExpressionTemplates>
+template <class T1, class T2, expression_template_option ExpressionTemplates>
struct combine_expression<T1, number<T2, ExpressionTemplates> >
{
 typedef number<T2, ExpressionTemplates> type;
};

-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
struct combine_expression<number<T, ExpressionTemplates>, number<T, ExpressionTemplates> >
{
 typedef number<T, ExpressionTemplates> type;
};

-template <class T1, bool ExpressionTemplates1, class T2, bool ExpressionTemplates2>
+template <class T1, expression_template_option ExpressionTemplates1, class T2, expression_template_option ExpressionTemplates2>
struct combine_expression<number<T1, ExpressionTemplates1>, number<T2, ExpressionTemplates2> >
{
 typedef typename mpl::if_c<
@@ -643,14 +649,14 @@

template <class Num>
struct number_category : public mpl::int_<std::numeric_limits<Num>::is_integer ? number_kind_integer : (std::numeric_limits<Num>::max_exponent ? number_kind_floating_point : number_kind_unknown)> {};
-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
struct number_category<number<Backend, ExpressionTemplates> > : public number_category<Backend>{};
template <class tag, class A1, class A2, class A3, class A4>
struct number_category<detail::expression<tag, A1, A2, A3, A4> > : public number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>{};

template <class T>
struct component_type;
-template <class T, bool ExpressionTemplates>
+template <class T, expression_template_option ExpressionTemplates>
struct component_type<number<T, ExpressionTemplates> > : public component_type<T>{};
template <class tag, class A1, class A2, class A3, class A4>
struct component_type<detail::expression<tag, A1, A2, A3, A4> > : public component_type<typename detail::expression<tag, A1, A2, A3, A4>::result_type>{};
@@ -668,7 +674,7 @@
 typedef typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type type;
};

-template <class R, class B, bool ET>
+template <class R, class B, boost::multiprecision::expression_template_option ET>
inline R real_cast(const boost::multiprecision::number<B, ET>& val)
{
 return val.template convert_to<R>();

Modified: sandbox/big_number/boost/multiprecision/detail/number_compare.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/number_compare.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/number_compare.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -31,9 +31,9 @@
inline bool eval_eq(const B& a, const A& b)
{
 typedef typename mpl::if_c<
- is_convertible<A, number<B, true> >::value,
- number<B, true>,
- number<B, false> >::type mp_type;
+ is_convertible<A, number<B, et_on> >::value,
+ number<B, et_on>,
+ number<B, et_off> >::type mp_type;
 mp_type t(b);
 return eval_eq(a, t.backend());
}
@@ -47,9 +47,9 @@
inline bool eval_lt(const B& a, const A& b)
{
 typedef typename mpl::if_c<
- is_convertible<A, number<B, true> >::value,
- number<B, true>,
- number<B, false> >::type mp_type;
+ is_convertible<A, number<B, et_on> >::value,
+ number<B, et_on>,
+ number<B, et_off> >::type mp_type;
 mp_type t(b);
 return eval_lt(a, t.backend());
}
@@ -63,9 +63,9 @@
inline bool eval_gt(const B& a, const A& b)
{
 typedef typename mpl::if_c<
- is_convertible<A, number<B, true> >::value,
- number<B, true>,
- number<B, false> >::type mp_type;
+ is_convertible<A, number<B, et_on> >::value,
+ number<B, et_on>,
+ number<B, et_off> >::type mp_type;
 mp_type t(b);
 return eval_gt(a, t.backend());
}
@@ -77,32 +77,32 @@
template <class Num, class Val>
struct is_valid_mixed_compare : public mpl::false_ {};

-template <class B, bool ET, class Val>
+template <class B, expression_template_option ET, class Val>
struct is_valid_mixed_compare<number<B, ET>, Val> : public is_convertible<Val, number<B, ET>> {};
/*
-template <class Val, class B, bool ET>
+template <class Val, class B, expression_template_option ET>
struct is_valid_mixed_compare<Val, number<B, ET> > : public is_convertible<Val, number<B, ET>> {};
*/
-template <class B, bool ET>
+template <class B, expression_template_option ET>
struct is_valid_mixed_compare<number<B, ET>, number<B, ET> > : public mpl::false_ {};

-template <class B, bool ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct is_valid_mixed_compare<number<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> >
 : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};

-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, bool ET>
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
struct is_valid_mixed_compare<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
 : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};

}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline bool operator == (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
{
 using default_ops::eval_eq;
 return eval_eq(a.backend(), b.backend());
}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator == (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
@@ -110,7 +110,7 @@
 return eval_eq(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
/*
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator == (const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
@@ -119,7 +119,7 @@
 return eval_eq(a.backend(), t.backend());
}
*/
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator == (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -136,7 +136,7 @@
 return eval_eq(t.backend(), result_type::canonical_value(a));
}
/*
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -163,13 +163,13 @@
 return eval_eq(t.backend(), t2.backend());
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline bool operator != (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
{
 using default_ops::eval_eq;
 return !eval_eq(a.backend(), b.backend());
}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator != (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
@@ -177,7 +177,7 @@
 return !eval_eq(a.backend(), number<Backend>::canonical_value(b));
}
/*
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator != (const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
@@ -186,7 +186,7 @@
 return !eval_eq(a.backend(), t.backend());
}
*/
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator != (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -203,7 +203,7 @@
 return !eval_eq(t.backend(), result_type::canonical_value(a));
}
/*
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -230,13 +230,13 @@
 return !eval_eq(t.backend(), t2.backend());
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline bool operator < (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
{
 using default_ops::eval_lt;
 return eval_lt(a.backend(), b.backend());
}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator < (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
@@ -244,7 +244,7 @@
 return eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
/*
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator < (const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
@@ -253,7 +253,7 @@
 return eval_lt(a.backend(), t.backend());
}
*/
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator < (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -270,7 +270,7 @@
 return eval_gt(t.backend(), result_type::canonical_value(a));
}
/*
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -298,13 +298,13 @@
 return eval_lt(t.backend(), t2.backend());
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline bool operator > (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
{
 using default_ops::eval_gt;
 return eval_gt(a.backend(), b.backend());
}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator > (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
@@ -312,7 +312,7 @@
 return eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
/*
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator > (const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
@@ -321,7 +321,7 @@
 return eval_gt(a.backend(), t.backend());
}
*/
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator > (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -338,7 +338,7 @@
 return eval_lt(t.backend(), result_type::canonical_value(a));
}
/*
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -366,13 +366,13 @@
 return eval_gt(t.backend(), t2.backend());
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline bool operator <= (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
{
 using default_ops::eval_gt;
 return !eval_gt(a.backend(), b.backend());
}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator <= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
@@ -380,7 +380,7 @@
 return !eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
/*
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator <= (const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
@@ -389,7 +389,7 @@
 return !eval_gt(a.backend(), t.backend());
}
*/
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator <= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -406,7 +406,7 @@
 return !eval_lt(t.backend(), result_type::canonical_value(a));
}
/*
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -434,13 +434,13 @@
 return !eval_gt(t.backend(), t2.backend());
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline bool operator >= (const number<Backend, ExpressionTemplates>& a, const number<Backend, ExpressionTemplates>& b)
{
 using default_ops::eval_lt;
 return !eval_lt(a.backend(), b.backend());
}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
+template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator >= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
@@ -448,7 +448,7 @@
 return !eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
/*
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
+template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator >= (const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
@@ -457,7 +457,7 @@
 return !eval_lt(a.backend(), t.backend());
}
*/
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
+template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
 operator >= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
@@ -474,7 +474,7 @@
 return !eval_gt(t.backend(), result_type::canonical_value(a));
}
/*
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
+template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline typename enable_if<is_same<number<Backend, ExpressionTemplates>, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>, bool>::type
 operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{

Modified: sandbox/big_number/boost/multiprecision/gmp.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/gmp.hpp (original)
+++ sandbox/big_number/boost/multiprecision/gmp.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -2151,7 +2151,7 @@
//
// numeric_limits [partial] specializations for the types declared in this header:
//
-template<unsigned Digits10, bool ExpressionTemplates>
+template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> number_type;
@@ -2259,10 +2259,10 @@
 static const data_initializer initializer;
};

-template<unsigned Digits10, bool ExpressionTemplates>
+template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::initializer;

-template<bool ExpressionTemplates>
+template<boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> number_type;
@@ -2303,54 +2303,54 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::digits;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_signed;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_integer;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_exact;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::radix;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::min_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::min_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_infinity;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_quiet_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_signaling_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_denorm;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_denorm_loss;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_iec559;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_bounded;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_modulo;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::traps;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::tinyness_before;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::round_style;

#endif

-template<bool ExpressionTemplates>
+template<boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> number_type;
@@ -2401,54 +2401,54 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::digits;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_signed;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_integer;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_exact;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::radix;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::min_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::min_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_infinity;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_quiet_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_signaling_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_denorm;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_denorm_loss;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_iec559;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_bounded;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_modulo;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::traps;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::tinyness_before;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::round_style;

#endif

-template<bool ExpressionTemplates>
+template<boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> number_type;
@@ -2500,49 +2500,49 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_signed;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_integer;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_exact;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::radix;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_infinity;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_quiet_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_signaling_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm_loss;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_iec559;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_bounded;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_modulo;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::traps;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::tinyness_before;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::round_style;

#endif

Modified: sandbox/big_number/boost/multiprecision/miller_rabin.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/miller_rabin.hpp (original)
+++ sandbox/big_number/boost/multiprecision/miller_rabin.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -11,7 +11,7 @@
namespace boost{
namespace multiprecision{

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
bool check_small_factors(const number<Backend, ExpressionTemplates>& n)
{
 static const boost::uint32_t small_factors1[] = {
@@ -117,7 +117,7 @@
 return false;
}

-template <class Backend, bool ExpressionTemplates, class Engine>
+template <class Backend, expression_template_option ExpressionTemplates, class Engine>
typename enable_if_c<number_category<Backend>::value == number_kind_integer, bool>::type
 miller_rabin_test(const number<Backend, ExpressionTemplates>& n, unsigned trials, Engine& gen)
{
@@ -178,7 +178,7 @@
#endif
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
bool miller_rabin_test(const number<Backend, ExpressionTemplates>& x, unsigned trials)
{
 static mt19937 gen;

Modified: sandbox/big_number/boost/multiprecision/mpfr.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mpfr.hpp (original)
+++ sandbox/big_number/boost/multiprecision/mpfr.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -1103,7 +1103,7 @@
 return boost::multiprecision::backends::detail::get_default_precision();
}
template <>
-inline int digits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, false> >() BOOST_NOEXCEPT
+inline int digits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >() BOOST_NOEXCEPT
{
 return boost::multiprecision::backends::detail::get_default_precision();
}
@@ -1117,7 +1117,7 @@
//
// numeric_limits [partial] specializations for the types declared in this header:
//
-template<unsigned Digits10, bool ExpressionTemplates>
+template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> number_type;
@@ -1249,60 +1249,60 @@
 static const data_initializer initializer;
};

-template<unsigned Digits10, bool ExpressionTemplates>
+template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::initializer;

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::digits;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::digits10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_digits10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_signed;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_integer;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_exact;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::radix;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::min_exponent;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::min_exponent10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_exponent;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_exponent10;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_infinity;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_quiet_NaN;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_signaling_NaN;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_denorm;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_denorm_loss;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_iec559;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_bounded;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_modulo;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::traps;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::tinyness_before;
-template <unsigned Digits10, bool ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::round_style;

#endif

-template<bool ExpressionTemplates>
+template<boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >
{
 typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> number_type;
@@ -1343,49 +1343,49 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::digits;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::max_digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_signed;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_integer;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_exact;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::radix;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::min_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::min_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::max_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::max_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_infinity;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_quiet_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_signaling_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_denorm;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_denorm_loss;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_iec559;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_bounded;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_modulo;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::traps;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::tinyness_before;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::round_style;

#endif

Modified: sandbox/big_number/boost/multiprecision/number.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/number.hpp (original)
+++ sandbox/big_number/boost/multiprecision/number.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -34,7 +34,7 @@
#pragma warning(disable:4127 4714)
#endif

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
class number
{
 typedef number<Backend, ExpressionTemplates> self_type;
@@ -87,16 +87,16 @@
 m_backend = canonical_value(v);
 }
 */
- template<bool ET>
+ template<expression_template_option ET>
 BOOST_FORCEINLINE BOOST_CONSTEXPR number(const 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>
+ template <class Other, expression_template_option ET>
 BOOST_FORCEINLINE number(const number<Other, ET>& val,
 typename enable_if_c<(boost::is_convertible<Other, Backend>::value && !detail::is_restricted_conversion<Other, Backend>::value)>::type* = 0)
 BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<Other>()))
 : m_backend(val.backend()) {}

- template <class Other, bool ET>
+ template <class Other, expression_template_option ET>
 explicit number(const number<Other, ET>& val, typename enable_if_c<
 (!detail::is_explicitly_convertible<Other, Backend>::value)
>::type* = 0)
@@ -106,7 +106,7 @@
 //
 detail::generic_interconvert(backend(), val.backend(), number_category<Backend>(), number_category<Other>());
 }
- template <class Other, bool ET>
+ template <class Other, expression_template_option ET>
 explicit BOOST_FORCEINLINE number(const number<Other, ET>& val, typename enable_if_c<
 (detail::is_explicitly_convertible<Other, Backend>::value
 && (detail::is_restricted_conversion<Other, Backend>::value || !boost::is_convertible<Other, Backend>::value))
@@ -119,7 +119,7 @@
 using default_ops::assign_components;
 assign_components(m_backend, canonical_value(v1), canonical_value(v2));
 }
- template <class Other, bool ET>
+ template <class Other, expression_template_option ET>
 BOOST_FORCEINLINE number(const number<Other, ET>& v1, const number<Other, ET>& v2, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0)
 {
 using default_ops::assign_components;
@@ -547,7 +547,7 @@
 using default_ops::eval_convert_to;
 eval_convert_to(result, m_backend);
 }
- template <class B2, bool ET>
+ template <class B2, expression_template_option ET>
 void convert_to_imp(number<B2, ET>* result)const
 {
 result->assign(*this);
@@ -1584,7 +1584,7 @@
 // the non-member operators way easier if they are:
 //
 static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& canonical_value(const self_type& v) BOOST_NOEXCEPT { return v.m_backend; }
- template <class B2, bool ET>
+ template <class B2, expression_template_option ET>
 static BOOST_FORCEINLINE BOOST_CONSTEXPR const B2& canonical_value(const number<B2, ET>& v) BOOST_NOEXCEPT { return v.backend(); }
 template <class V>
 static BOOST_FORCEINLINE BOOST_CONSTEXPR typename disable_if<is_same<typename detail::canonical<V, Backend>::type, V>, typename detail::canonical<V, Backend>::type>::type
@@ -1596,7 +1596,7 @@

};

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline std::ostream& operator << (std::ostream& os, const number<Backend, ExpressionTemplates>& r)
{
 std::streamsize d = os.precision();
@@ -1625,7 +1625,7 @@

} // namespace detail

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
inline std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r)
{
 std::string s;
@@ -1634,7 +1634,7 @@
 return is;
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
BOOST_FORCEINLINE void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b)
{
 a.swap(b);
@@ -1645,7 +1645,7 @@
template <class T>
class rational;

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline std::istream& operator >> (std::istream& is, rational<multiprecision::number<Backend, ExpressionTemplates> >& r)
{
 std::string s1;
@@ -1680,37 +1680,37 @@
 return is;
}

-template <class T, bool ExpressionTemplates, class Arithmetic>
+template <class T, multiprecision::expression_template_option ExpressionTemplates, class Arithmetic>
typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator == (const rational<multiprecision::number<T, ExpressionTemplates> >& a, const Arithmetic& b)
{
 return a == multiprecision::number<T, ExpressionTemplates>(b);
}

-template <class T, bool ExpressionTemplates, class Arithmetic>
+template <class T, multiprecision::expression_template_option ExpressionTemplates, class Arithmetic>
typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator == (const Arithmetic& b, const rational<multiprecision::number<T, ExpressionTemplates> >& a)
{
 return a == multiprecision::number<T, ExpressionTemplates>(b);
}

-template <class T, bool ExpressionTemplates, class Arithmetic>
+template <class T, multiprecision::expression_template_option ExpressionTemplates, class Arithmetic>
typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator != (const rational<multiprecision::number<T, ExpressionTemplates> >& a, const Arithmetic& b)
{
 return a != multiprecision::number<T, ExpressionTemplates>(b);
}

-template <class T, bool ExpressionTemplates, class Arithmetic>
+template <class T, multiprecision::expression_template_option ExpressionTemplates, class Arithmetic>
typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator != (const Arithmetic& b, const rational<multiprecision::number<T, ExpressionTemplates> >& a)
{
 return a != multiprecision::number<T, ExpressionTemplates>(b);
}

-template <class T, bool ExpressionTemplates>
+template <class T, multiprecision::expression_template_option ExpressionTemplates>
inline multiprecision::number<T, ExpressionTemplates> numerator(const rational<multiprecision::number<T, ExpressionTemplates> >& a)
{
 return a.numerator();
}

-template <class T, bool ExpressionTemplates>
+template <class T, multiprecision::expression_template_option ExpressionTemplates>
inline multiprecision::number<T, ExpressionTemplates> denominator(const rational<multiprecision::number<T, ExpressionTemplates> >& a)
{
 return a.denominator();
@@ -1723,7 +1723,7 @@
template<class V>
class sparse_vector_element;

-template <class V, class Backend, bool ExpressionTemplates>
+template <class V, class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline bool operator == (const sparse_vector_element<V>& a, const ::boost::multiprecision::number<Backend, ExpressionTemplates>& b)
{
typedef typename sparse_vector_element<V>::const_reference ref_type;

Modified: sandbox/big_number/boost/multiprecision/random.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/random.hpp (original)
+++ sandbox/big_number/boost/multiprecision/random.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -17,7 +17,7 @@
// Need to find a better solution, like make Boost.Random safe to use with
// UDT's and depricate/remove this header altogether.
//
-template<class Engine, class Backend, bool ExpressionTemplates>
+template<class Engine, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
boost::multiprecision::number<Backend, ExpressionTemplates>
 generate_uniform_int(Engine& eng, const boost::multiprecision::number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::number<Backend, ExpressionTemplates>& max_value);

@@ -30,7 +30,7 @@
namespace random{
namespace detail{

-template<class Backend, bool ExpressionTemplates>
+template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct subtract<boost::multiprecision::number<Backend, ExpressionTemplates>, true>
{
 typedef boost::multiprecision::number<Backend, ExpressionTemplates> result_type;
@@ -39,7 +39,7 @@

}

-template<class Engine, std::size_t w, class Backend, bool ExpressionTemplates>
+template<class Engine, std::size_t w, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
class independent_bits_engine<Engine, w, boost::multiprecision::number<Backend, ExpressionTemplates> >
{
public:
@@ -198,7 +198,7 @@
 Engine _base;
};

-template<class Backend, bool ExpressionTemplates>
+template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
class uniform_smallint<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
public:
@@ -381,7 +381,7 @@

namespace detail{

-template<class Backend, bool ExpressionTemplates>
+template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct select_uniform_01<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
 template<class RealType>
@@ -391,7 +391,7 @@
 };
};

-template<class Engine, class Backend, bool ExpressionTemplates>
+template<class Engine, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
boost::multiprecision::number<Backend, ExpressionTemplates>
 generate_uniform_int(
 Engine& eng, const boost::multiprecision::number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::number<Backend, ExpressionTemplates>& max_value,
@@ -557,7 +557,7 @@
 }
}

-template<class Engine, class Backend, bool ExpressionTemplates>
+template<class Engine, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<Backend, ExpressionTemplates>
 generate_uniform_int(Engine& eng, const boost::multiprecision::number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::number<Backend, ExpressionTemplates>& max_value)
{

Modified: sandbox/big_number/boost/multiprecision/rational_adapter.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/rational_adapter.hpp (original)
+++ sandbox/big_number/boost/multiprecision/rational_adapter.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -259,7 +259,7 @@

namespace std{

-template <class IntBackend, bool ExpressionTemplates>
+template <class IntBackend, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> > : public std::numeric_limits<boost::multiprecision::number<IntBackend, ExpressionTemplates> >
{
typedef std::numeric_limits<boost::multiprecision::number<IntBackend> > base_type;
@@ -280,9 +280,9 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <class IntBackend, bool ExpressionTemplates>
+template <class IntBackend, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> >::is_integer;
-template <class IntBackend, bool ExpressionTemplates>
+template <class IntBackend, boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> >::is_exact;

#endif

Modified: sandbox/big_number/boost/multiprecision/tommath.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/tommath.hpp (original)
+++ sandbox/big_number/boost/multiprecision/tommath.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -629,7 +629,7 @@

namespace std{

-template<bool ExpressionTemplates>
+template<boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >
{
typedef boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> number_type;
@@ -680,49 +680,49 @@

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_digits10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_signed;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_integer;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_exact;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::radix;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent10;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_infinity;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_quiet_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_signaling_NaN;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm_loss;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_iec559;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_bounded;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_modulo;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::traps;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::tinyness_before;
-template <bool ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::round_style;

#endif

Modified: sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk (original)
+++ sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -95,7 +95,7 @@

 namespace mp = boost::multiprecision; // Reduce the typing a bit later...

- typedef mp::number<mp::mpfr_float_backend<300>, false> my_float;
+ typedef mp::number<mp::mpfr_float_backend<300>, et_off> my_float;

 my_float a, b, c; // These variables have 300 decimal digits precision

@@ -123,8 +123,8 @@

Mixed arithmetic will fail if the conversion is either ambiguous or explicit:

- number<cpp_int_backend<>, false> a(2);
- number<cpp_int_backend<>, true> b(3);
+ number<cpp_int_backend<>, et_off> a(2);
+ number<cpp_int_backend<>, et_on> b(3);

 b = a * b; // Error, implicit conversion could go either way.
 b = a * 3.14; // Error, no operator overload if the conversion would be explicit.
@@ -137,7 +137,7 @@
that look something like:

 template <class B>
- number<B, false> operator + (number&& a, const number& b)
+ number<B, et_off> operator + (number&& a, const number& b)
 {
 return std::move(a += b);
 }
@@ -336,16 +336,16 @@
 typedef number<cpp_rational_backend> cpp_rational; // arbitrary precision rational number

 // Fixed precision unsigned types:
- typedef number<cpp_int_backend<128, false, void>, false> uint128_t;
- typedef number<cpp_int_backend<256, false, void>, false> uint256_t;
- typedef number<cpp_int_backend<512, false, void>, false> uint512_t;
- typedef number<cpp_int_backend<1024, false, void>, false> uint1024_t;
+ typedef number<cpp_int_backend<128, false, void>, et_off> uint128_t;
+ typedef number<cpp_int_backend<256, false, void>, et_off> uint256_t;
+ typedef number<cpp_int_backend<512, false, void>, et_off> uint512_t;
+ typedef number<cpp_int_backend<1024, false, void>, et_off> uint1024_t;

 // Fixed precision signed types:
- typedef number<cpp_int_backend<128, true, void>, false> int128_t;
- typedef number<cpp_int_backend<256, true, void>, false> int256_t;
- typedef number<cpp_int_backend<512, true, void>, false> int512_t;
- typedef number<cpp_int_backend<1024, true, void>, false> int1024_t;
+ typedef number<cpp_int_backend<128, true, void>, et_off> int128_t;
+ typedef number<cpp_int_backend<256, true, void>, et_off> int256_t;
+ typedef number<cpp_int_backend<512, true, void>, et_off> int512_t;
+ typedef number<cpp_int_backend<1024, true, void>, et_off> int1024_t;

 }} // namespaces

@@ -1043,10 +1043,10 @@

 #include <boost/multiprecision/miller_rabin.hpp>

- template <class Backend, bool ExpressionTemplates, class Engine>
+ template <class Backend, expression_template_option ExpressionTemplates, class Engine>
 bool miller_rabin_test(const number<Backend, ExpressionTemplates>& n, unsigned trials, Engine& gen);

- template <class Backend, bool ExpressionTemplates, class Engine>
+ template <class Backend, expression_template_option ExpressionTemplates, class Engine>
 bool miller_rabin_test(const number<Backend, ExpressionTemplates>& n, unsigned trials);

These functions perform a Miller-Rabin test for primality, if the result is `false` then /n/ is definitely composite,
@@ -1076,7 +1076,7 @@

 namespace boost{ namespace multiprecision{

- template <class Backend, bool ExpressionTemplates = true>
+ template <class Backend, expression_template_option ExpressionTemplates = true>
 class number
 {
 number();
@@ -1153,14 +1153,14 @@
 bool operator>=(const ``['see-below]``&, const ``['see-below]``&);

 // Swap:
- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b);

 // iostream support:
- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 std::ostream& operator << (std::ostream& os, const number<Backend, ExpressionTemplates>& r);
 std::ostream& operator << (std::ostream& os, const ``['unmentionable-expression-template-type]``& r);
- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r);

 // Non-member function standard library support:
@@ -1209,7 +1209,7 @@
 // Integer specific functions:
 ``['unmentionable-expression-template-type]`` pow(const ``['number-or-expression-template-type]``&, unsigned);
 ``['unmentionable-expression-template-type]`` powm(const ``['number-or-expression-template-type]``& b, const ``['number-or-expression-template-type]``& p, const ``['number-or-expression-template-type]``& m);
- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 void divide_qr(const ``['number-or-expression-template-type]``& x, const ``['number-or-expression-template-type]``& y,
 number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r);
 template <class Integer>
@@ -1247,7 +1247,7 @@
 // numeric_limits support:
 namespace std{

- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 struct numeric_limits<boost::multiprecision<Backend, ExpressionTemplates> >
 {
 /* Usual members here */
@@ -1257,7 +1257,7 @@

[h4 Description]

- template <class Backend, bool ExpressionTemplates = true>
+ template <class Backend, expression_template_option ExpressionTemplates = true>
 class number;

Class `number` has two template arguments:
@@ -1433,7 +1433,7 @@
The return type of these operators is either:

* An ['unmentionable-type] expression template type when `ExpressionTemplates` is `true`.
-* Type `number<Backend, false>` when `ExpressionTemplates` is `false`.
+* Type `number<Backend, et_off>` when `ExpressionTemplates` is `false`.
* Type `bool` if the operator is a comparison operator.

Finally note that the second argument to the left and right shift operations must be a builtin integer type,
@@ -1448,11 +1448,11 @@

[h4 Iostream Support]

- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 std::ostream& operator << (std::ostream& os, const number<Backend, ExpressionTemplates>& r);
 template <class Unspecified...>
 std::ostream& operator << (std::ostream& os, const unmentionable-expression-template& r);
- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 inline std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r)

These operators provided formatted input-output operations on `number` types, and expression templates derived from them.
@@ -1495,7 +1495,7 @@
 ``['unmentionable-expression-template-type]`` atan2 (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

These functions all behave exactly as their standard library counterparts do: their argument is either an instance of `number` or
-an expression template derived from it; If the argument is of type `number<Backend, false>` then that is also the return type,
+an expression template derived from it; If the argument is of type `number<Backend, et_off>` then that is also the return type,
otherwise the return type is an expression template.

These functions are normally implemented by the Backend type. However, default versions are provided for Backend types that
@@ -1545,7 +1545,7 @@

Returns ['b[super p] mod m] as an expression template.

- template <class Backend, bool ExpressionTemplates>
+ template <class Backend, expression_template_option ExpressionTemplates>
 bool divide_qr(const ``['number-or-expression-template-type]``& x, const ``['number-or-expression-template-type]``& y,
 number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r);

@@ -1643,16 +1643,16 @@
 typedef number<cpp_rational_backend> cpp_rational; // arbitrary precision rational number

 // Fixed precision unsigned types:
- typedef number<cpp_int_backend<128, false, void>, false> uint128_t;
- typedef number<cpp_int_backend<256, false, void>, false> uint256_t;
- typedef number<cpp_int_backend<512, false, void>, false> uint512_t;
- typedef number<cpp_int_backend<1024, false, void>, false> uint1024_t;
+ typedef number<cpp_int_backend<128, false, void>, et_off> uint128_t;
+ typedef number<cpp_int_backend<256, false, void>, et_off> uint256_t;
+ typedef number<cpp_int_backend<512, false, void>, et_off> uint512_t;
+ typedef number<cpp_int_backend<1024, false, void>, et_off> uint1024_t;

 // Fixed precision signed types:
- typedef number<cpp_int_backend<128, true, void>, false> int128_t;
- typedef number<cpp_int_backend<256, true, void>, false> int256_t;
- typedef number<cpp_int_backend<512, true, void>, false> int512_t;
- typedef number<cpp_int_backend<1024, true, void>, false> int1024_t;
+ typedef number<cpp_int_backend<128, true, void>, et_off> int128_t;
+ typedef number<cpp_int_backend<256, true, void>, et_off> int256_t;
+ typedef number<cpp_int_backend<512, true, void>, et_off> int512_t;
+ typedef number<cpp_int_backend<1024, true, void>, et_off> int1024_t;

 }} // namespaces

Modified: sandbox/big_number/libs/multiprecision/performance/arithmetic_backend.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/arithmetic_backend.hpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/arithmetic_backend.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -522,7 +522,7 @@

namespace std{

-template <class Arithmetic, bool ExpressionTemplates>
+template <class Arithmetic, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates > > : public std::numeric_limits<Arithmetic>
{
typedef std::numeric_limits<Arithmetic> base_type;

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-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -270,14 +270,14 @@
 std::cout << "calculating...\n";

 do_calc<test_traits<boost::int64_t, boost::int64_t> >("int64_t, int64_t");
- do_calc<test_traits<number<arithmetic_backend<boost::int64_t>, false>, number<arithmetic_backend<boost::int64_t>, false> > >("arithmetic_backend<int64_t>");
+ do_calc<test_traits<number<arithmetic_backend<boost::int64_t>, et_off>, number<arithmetic_backend<boost::int64_t>, et_off> > >("arithmetic_backend<int64_t>");
 do_calc<test_traits<boost::int64_t, int128_t> >("int64_t, int128_t");
 do_calc<test_traits<boost::int64_t, int128_t> >("int64_t, int128_t");
- do_calc<test_traits<boost::int64_t, number<cpp_int_backend<128, true, void>, true> > >("int64_t, int128_t (ET)");
+ do_calc<test_traits<boost::int64_t, number<cpp_int_backend<128, true, void>, et_on> > >("int64_t, int128_t (ET)");
 do_calc<test_traits<boost::int64_t, cpp_int> >("int64_t, cpp_int");
- do_calc<test_traits<boost::int64_t, number<cpp_int_backend<>, false> > >("int64_t, cpp_int (no ET's)");
+ do_calc<test_traits<boost::int64_t, number<cpp_int_backend<>, et_off> > >("int64_t, cpp_int (no ET's)");
 do_calc<test_traits<boost::int64_t, number<cpp_int_backend<128> > > >("int64_t, cpp_int(128-bit cache)");
- do_calc<test_traits<boost::int64_t, number<cpp_int_backend<128>, false> > >("int64_t, cpp_int (128-bit Cache no ET's)");
+ do_calc<test_traits<boost::int64_t, number<cpp_int_backend<128>, et_off> > >("int64_t, cpp_int (128-bit Cache no ET's)");

 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/performance/miller_rabin_performance.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/miller_rabin_performance.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/miller_rabin_performance.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -136,7 +136,7 @@
{
 using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
- test_miller_rabin<number<cpp_int_backend<>, false> >("cpp_int (no Expression templates)");
+ test_miller_rabin<number<cpp_int_backend<>, et_off> >("cpp_int (no Expression templates)");
 test_miller_rabin<cpp_int>("cpp_int");
 test_miller_rabin<number<cpp_int_backend<128> > >("cpp_int (128-bit cache)");
 test_miller_rabin<number<cpp_int_backend<256> > >("cpp_int (256-bit cache)");
@@ -145,12 +145,12 @@
 test_miller_rabin<int1024_t>("int1024_t");
#endif
#ifdef TEST_MPZ
- test_miller_rabin<number<gmp_int, false> >("mpz_int (no Expression templates)");
+ test_miller_rabin<number<gmp_int, et_off> >("mpz_int (no Expression templates)");
 test_miller_rabin<mpz_int>("mpz_int");
 std::cout << "Time for mpz_int (native Miller Rabin Test) = " << test_miller_rabin_gmp() << std::endl;
#endif
#ifdef TEST_TOMMATH
- test_miller_rabin<number<boost::multiprecision::tommath_int, false> >("tom_int (no Expression templates)");
+ test_miller_rabin<number<boost::multiprecision::tommath_int, et_off> >("tom_int (no Expression templates)");
 test_miller_rabin<boost::multiprecision::tom_int>("tom_int");
#endif
 mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);

Modified: sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -233,7 +233,7 @@
 std::cout << "Allocation Counts for Horner Evaluation:\n";
#ifdef TEST_MPFR
 basic_allocation_test("mpfr_float_50", mpfr_float_50(2));
- basic_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, false>(2));
+ basic_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, et_off>(2));
#endif
#ifdef TEST_MPFR_CLASS
 basic_allocation_test("mpfr_class", mpfr_class(2));
@@ -245,7 +245,7 @@
 std::cout << "Allocation Counts for boost::math::tools::evaluate_polynomial:\n";
#ifdef TEST_MPFR
 poly_allocation_test("mpfr_float_50", mpfr_float_50(2));
- poly_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, false>(2));
+ poly_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, et_off>(2));
#endif
#ifdef TEST_MPFR_CLASS
 poly_allocation_test("mpfr_class", mpfr_class(2));
@@ -261,12 +261,12 @@
 time_proc("Bessel Functions - double", test_bessel<double>);
 time_proc("Bessel Functions - real_concept", test_bessel<boost::math::concepts::real_concept>);
 time_proc("Bessel Functions - arithmetic_backend<double>", test_bessel<number<arithmetic_backend<double> > >);
- time_proc("Bessel Functions - arithmetic_backend<double> - no expression templates", test_bessel<number<arithmetic_backend<double>, false> >);
+ time_proc("Bessel Functions - arithmetic_backend<double> - no expression templates", test_bessel<number<arithmetic_backend<double>, et_off> >);

 time_proc("Non-central T - double", test_nct<double>);
 time_proc("Non-central T - real_concept", test_nct<boost::math::concepts::real_concept>);
 time_proc("Non-central T - arithmetic_backend<double>", test_nct<number<arithmetic_backend<double> > >);
- time_proc("Non-central T - arithmetic_backend<double> - no expression templates", test_nct<number<arithmetic_backend<double>, false> >);
+ time_proc("Non-central T - arithmetic_backend<double> - no expression templates", test_nct<number<arithmetic_backend<double>, et_off> >);
#endif

 //
@@ -288,7 +288,7 @@
#endif
#ifdef TEST_MPF
 time_proc("mpf_float_50", test_bessel<mpf_float_50>, 3);
- time_proc("mpf_float_50 (no expression templates", test_bessel<number<gmp_float<50>, false> >, 3);
+ time_proc("mpf_float_50 (no expression templates", test_bessel<number<gmp_float<50>, et_off> >, 3);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_50", test_bessel<cpp_dec_float_50>, 3);
@@ -314,7 +314,7 @@
#endif
#ifdef TEST_MPF
 time_proc("mpf_float_100", test_bessel<mpf_float_100>);
- time_proc("mpf_float_100 (no expression templates", test_bessel<number<gmp_float<100>, false> >);
+ time_proc("mpf_float_100 (no expression templates", test_bessel<number<gmp_float<100>, et_off> >);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_100", test_bessel<cpp_dec_float_100>);
@@ -341,7 +341,7 @@
#endif
#ifdef TEST_MPF
 time_proc("mpf_float_50", test_polynomial<mpf_float_50>);
- time_proc("mpf_float_50 (no expression templates", test_polynomial<number<gmp_float<50>, false> >);
+ time_proc("mpf_float_50 (no expression templates", test_polynomial<number<gmp_float<50>, et_off> >);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_50", test_polynomial<cpp_dec_float_50>);
@@ -367,7 +367,7 @@
#endif
#ifdef TEST_MPF
 time_proc("mpf_float_100", test_polynomial<mpf_float_100>);
- time_proc("mpf_float_100 (no expression templates", test_polynomial<number<gmp_float<100>, false> >);
+ time_proc("mpf_float_100 (no expression templates", test_polynomial<number<gmp_float<100>, et_off> >);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_100", test_polynomial<cpp_dec_float_100>);
@@ -393,7 +393,7 @@
#endif
#ifdef TEST_MPF
 time_proc("mpf_float_50", test_nct<mpf_float_50>);
- time_proc("mpf_float_50 (no expression templates", test_nct<number<gmp_float<50>, false> >);
+ time_proc("mpf_float_50 (no expression templates", test_nct<number<gmp_float<50>, et_off> >);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_50", test_nct<cpp_dec_float_50>);
@@ -419,7 +419,7 @@
#endif
#ifdef TEST_MPF
 time_proc("mpf_float_100", test_nct<mpf_float_100>);
- time_proc("mpf_float_100 (no expression templates", test_nct<number<gmp_float<100>, false> >);
+ time_proc("mpf_float_100 (no expression templates", test_nct<number<gmp_float<100>, et_off> >);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_100", test_nct<cpp_dec_float_100>);

Modified: sandbox/big_number/libs/multiprecision/test/compile_fail/operator_fail_01.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/compile_fail/operator_fail_01.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/compile_fail/operator_fail_01.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -9,8 +9,8 @@

int main()
{
- number<cpp_dec_float<50>, true> a(2);
- number<cpp_dec_float<50>, false> b(2);
+ number<cpp_dec_float<50>, et_on> a(2);
+ number<cpp_dec_float<50>, et_off> b(2);

a = a + b;
}

Modified: sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -186,7 +186,7 @@
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

Modified: sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_basic.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_basic.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_basic.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -139,7 +139,7 @@
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

Modified: sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_bessel.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_bessel.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_bessel.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -104,7 +104,7 @@
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

Modified: sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_elliptic.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_elliptic.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_elliptic.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -110,7 +110,7 @@
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

Modified: sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_gamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_gamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_gamma.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -126,7 +126,7 @@
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

Modified: sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_poly.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_poly.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_poly.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -101,7 +101,7 @@
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

Modified: sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -8,9 +8,9 @@
using namespace boost::multiprecision;

number<cpp_int_backend<> > a;
-number<cpp_int_backend<>, false> b;
-number<cpp_int_backend<64, true, void>, false> c;
-number<cpp_int_backend<128, false, void>, false> d;
-number<cpp_int_backend<500, true, void>, false> e;
+number<cpp_int_backend<>, et_off> b;
+number<cpp_int_backend<64, true, void>, et_off> c;
+number<cpp_int_backend<128, false, void>, et_off> d;
+number<cpp_int_backend<500, true, void>, et_off> e;

Modified: sandbox/big_number/libs/multiprecision/test/math/table_type.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/table_type.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/table_type.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -27,7 +27,7 @@
return os << static_cast<const char*>(what);
}

-template <class Backend, bool ExpressionTemplates>
+template <class Backend, expression_template_option ExpressionTemplates>
struct table_type<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
typedef string_table_entry type;

Modified: sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -203,7 +203,7 @@
{
 typedef boost::multiprecision::int256_t type;
};
-template <unsigned D, bool S, bool ET>
+template <unsigned D, bool S, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<D, S, void>, ET> >
{
 typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<D/2, S, void>, ET> type;
@@ -1654,7 +1654,7 @@
#endif
#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_dec_float_50>();
- test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false> >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFR
 test<boost::multiprecision::mpfr_float>();
@@ -1679,13 +1679,13 @@
#endif
#ifdef TEST_CPP_INT_2
 test<boost::multiprecision::cpp_rational>();
- test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>, false> >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>, boost::multiprecision::et_off> >();
 test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<500, true, void> > >();
#endif
#ifdef TEST_CPP_INT_3
 // Again with "trivial" backends:
- test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, true, void>, false > >();
- test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, false, void>, false > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, true, void>, boost::multiprecision::et_off > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, false, void>, boost::multiprecision::et_off > >();
#endif
#ifdef TEST_CPP_INT_BR
 test<boost::rational<boost::multiprecision::cpp_int> >();

Modified: sandbox/big_number/libs/multiprecision/test/test_constexpr.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_constexpr.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_constexpr.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -31,9 +31,9 @@

using namespace boost::multiprecision;

-template void test1<number<backends::cpp_int_backend<64, false, void, true>, false> >();
-template void test1<number<backends::cpp_int_backend<64, true, void, true>, false> >();
-template void test3<number<backends::cpp_int_backend<2048, false, void>, false> >();
-template void test2<number<backends::cpp_int_backend<2048, true, void>, false> >();
+template void test1<number<backends::cpp_int_backend<64, false, void, true>, et_off> >();
+template void test1<number<backends::cpp_int_backend<64, true, void, true>, et_off> >();
+template void test3<number<backends::cpp_int_backend<2048, false, void>, et_off> >();
+template void test2<number<backends::cpp_int_backend<2048, true, void>, et_off> >();

#endif
\ No newline at end of file

Modified: sandbox/big_number/libs/multiprecision/test/test_cpp_int_conv.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_cpp_int_conv.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_cpp_int_conv.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -48,7 +48,7 @@
 int128_t i6(i4);
 BOOST_TEST(i6 == -5677334);

- number<cpp_int_backend<32, true, void>, false> i7(i3);
+ number<cpp_int_backend<32, true, void>, et_off> i7(i3);
 BOOST_TEST(i7 == -1234567);

 int256_t i8(i6);
@@ -57,13 +57,13 @@
 i7.assign(4.0);
 BOOST_TEST(i7 == 4);

- number<cpp_int_backend<30, true, void>, false> i9(-5677334);
+ number<cpp_int_backend<30, true, void>, et_off> i9(-5677334);
 i7 = i9;
 BOOST_TEST(i7 == -5677334);
- i7 = number<cpp_int_backend<32, true, void>, false>(i9);
+ i7 = number<cpp_int_backend<32, true, void>, et_off>(i9);
 BOOST_TEST(i7 == -5677334);

- i9 = static_cast<number<cpp_int_backend<30, true, void>, false> >(i7);
+ i9 = static_cast<number<cpp_int_backend<30, true, void>, et_off> >(i7);
 BOOST_TEST(i9 == -5677334);

 ++i9;

Modified: sandbox/big_number/libs/multiprecision/test/test_float_io.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_float_io.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_float_io.cpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -214,21 +214,21 @@
 static const unsigned value = std::numeric_limits<T>::digits10 + 5;
};
#ifdef TEST_CPP_DEC_FLOAT
-template <unsigned D, bool ET>
+template <unsigned D, boost::multiprecision::expression_template_option ET>
struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >
{
 static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >::max_digits10;
};
#endif
#ifdef TEST_MPF_50
-template <unsigned D, bool ET>
+template <unsigned D, boost::multiprecision::expression_template_option ET>
struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >
{
 static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >::max_digits10;
};
#endif
#ifdef TEST_MPFR_50
-template <unsigned D, bool ET>
+template <unsigned D, boost::multiprecision::expression_template_option ET>
struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >
{
 static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >::max_digits10;

Modified: sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
//typedef double mp_test_type;

#define USE_RANGE

Modified: sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -18,7 +18,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
//typedef double mp_test_type;

#define USE_RANGE

Modified: sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
//typedef double mp_test_type;

#define USE_RANGE

Modified: sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
//typedef double mp_test_type;

#define USE_RANGE

Modified: sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
//typedef double mp_test_type;

#define USE_RANGE

Modified: sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp (original)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp 2012-09-06 05:50:47 EDT (Thu, 06 Sep 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
//typedef double mp_test_type;

#define USE_RANGE

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