Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r79932 - in sandbox/big_number: boost/multiprecision boost/multiprecision/concepts boost/multiprecision/depricated boost/multiprecision/detail boost/multiprecision/detail/functions libs/multiprecision/doc libs/multiprecision/example libs/multiprecision/performance libs/multiprecision/test libs/multiprecision/test/concepts libs/multiprecision/test/include_test libs/multiprecision/test/math libs/multiprecision/test/ublas_interop
From: john_at_[hidden]
Date: 2012-08-08 14:15:02

Author: johnmaddock
Date: 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
New Revision: 79932
URL: http://svn.boost.org/trac/boost/changeset/79932

Log:
Big search and replace rename, removing mp_ prefix.
Added:
   sandbox/big_number/boost/multiprecision/detail/number_base.hpp
      - copied, changed from r79925, /sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp
   sandbox/big_number/boost/multiprecision/detail/number_compare.hpp
      - copied, changed from r79925, /sandbox/big_number/boost/multiprecision/detail/mp_number_compare.hpp
   sandbox/big_number/boost/multiprecision/number.hpp
      - copied, changed from r79926, /sandbox/big_number/boost/multiprecision/mp_number.hpp
   sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp
      - copied, changed from r79925, /sandbox/big_number/libs/multiprecision/test/concepts/mp_number_concept_check.cpp
Removed:
   sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp
   sandbox/big_number/boost/multiprecision/detail/mp_number_compare.hpp
   sandbox/big_number/boost/multiprecision/mp_number.hpp
   sandbox/big_number/libs/multiprecision/test/concepts/mp_number_concept_check.cpp
Text files modified:
   sandbox/big_number/boost/multiprecision/concepts/mp_number_archetypes.hpp | 8
   sandbox/big_number/boost/multiprecision/cpp_dec_float.hpp | 78 ++--
   sandbox/big_number/boost/multiprecision/cpp_int.hpp | 170 ++++----
   sandbox/big_number/boost/multiprecision/depricated/arithmetic_backend.hpp | 6
   sandbox/big_number/boost/multiprecision/depricated/fixed_int.hpp | 28
   sandbox/big_number/boost/multiprecision/detail/big_lanczos.hpp | 4
   sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp | 12
   sandbox/big_number/boost/multiprecision/detail/default_ops.hpp | 376 ++++++++++----------
   sandbox/big_number/boost/multiprecision/detail/functions/constants.hpp | 6
   sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp | 22
   sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp | 24
   sandbox/big_number/boost/multiprecision/detail/generic_interconvert.hpp | 18
   sandbox/big_number/boost/multiprecision/detail/integer_ops.hpp | 64 +-
   sandbox/big_number/boost/multiprecision/detail/no_et_ops.hpp | 334 +++++++++---------
   sandbox/big_number/boost/multiprecision/detail/number_base.hpp | 710 ++++++++++++++++++++--------------------
   sandbox/big_number/boost/multiprecision/detail/number_compare.hpp | 272 +++++++-------
   sandbox/big_number/boost/multiprecision/gmp.hpp | 186 +++++-----
   sandbox/big_number/boost/multiprecision/miller_rabin.hpp | 16
   sandbox/big_number/boost/multiprecision/mpfr.hpp | 126 +++---
   sandbox/big_number/boost/multiprecision/number.hpp | 198 +++++-----
   sandbox/big_number/boost/multiprecision/random.hpp | 34
   sandbox/big_number/boost/multiprecision/rational_adapter.hpp | 22
   sandbox/big_number/boost/multiprecision/tommath.hpp | 54 +-
   sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk | 562 +++++++++++++++---------------
   sandbox/big_number/libs/multiprecision/example/cpp_int_snips.cpp | 2
   sandbox/big_number/libs/multiprecision/example/floating_point_examples.cpp | 4
   sandbox/big_number/libs/multiprecision/example/integer_examples.cpp | 2
   sandbox/big_number/libs/multiprecision/performance/arithmetic_backend.hpp | 6
   sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp | 12
   sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp | 8
   sandbox/big_number/libs/multiprecision/performance/miller_rabin_performance.cpp | 16
   sandbox/big_number/libs/multiprecision/performance/performance_test.cpp | 14
   sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp | 24
   sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp | 18
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_basic.cpp | 10
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_bessel.cpp | 10
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_elliptic.cpp | 10
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_gamma.cpp | 10
   sandbox/big_number/libs/multiprecision/test/concepts/sf_concept_check_poly.cpp | 10
   sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp | 10
   sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp | 20
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp | 18
   sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp | 20
   sandbox/big_number/libs/multiprecision/test/test_acos.cpp | 18
   sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp | 26
   sandbox/big_number/libs/multiprecision/test/test_asin.cpp | 22
   sandbox/big_number/libs/multiprecision/test/test_atan.cpp | 24
   sandbox/big_number/libs/multiprecision/test/test_constants.cpp | 8
   sandbox/big_number/libs/multiprecision/test/test_constexpr.cpp | 8
   sandbox/big_number/libs/multiprecision/test/test_cos.cpp | 18
   sandbox/big_number/libs/multiprecision/test/test_cosh.cpp | 18
   sandbox/big_number/libs/multiprecision/test/test_cpp_int.cpp | 2
   sandbox/big_number/libs/multiprecision/test/test_exp.cpp | 22
   sandbox/big_number/libs/multiprecision/test/test_fixed_int.cpp | 2
   sandbox/big_number/libs/multiprecision/test/test_float_io.cpp | 14
   sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp | 2
   sandbox/big_number/libs/multiprecision/test/test_generic_conv.cpp | 6
   sandbox/big_number/libs/multiprecision/test/test_int_io.cpp | 6
   sandbox/big_number/libs/multiprecision/test/test_log.cpp | 22
   sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp | 10
   sandbox/big_number/libs/multiprecision/test/test_pow.cpp | 22
   sandbox/big_number/libs/multiprecision/test/test_rational_io.cpp | 4
   sandbox/big_number/libs/multiprecision/test/test_round.cpp | 18
   sandbox/big_number/libs/multiprecision/test/test_sin.cpp | 22
   sandbox/big_number/libs/multiprecision/test/test_sinh.cpp | 22
   sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp | 26
   sandbox/big_number/libs/multiprecision/test/test_tanh.cpp | 18
   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
   101 files changed, 2217 insertions(+), 2213 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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -12,7 +12,7 @@
#include <cmath>
#include <boost/cstdint.hpp>
#include <boost/lexical_cast.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/mpl/list.hpp>

@@ -195,17 +195,17 @@
 return (boost::math::fpclassify)(arg.m_value);
}

-typedef boost::multiprecision::mp_number<mp_number_backend_float_architype> mp_number_float_architype;
+typedef boost::multiprecision::number<mp_number_backend_float_architype> mp_number_float_architype;

}}} // namespaces

namespace std{

template <bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype, ExpressionTemplates> > : public std::numeric_limits<long double>
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype, ExpressionTemplates> > : public std::numeric_limits<long double>
{
 typedef std::numeric_limits<long double> base_type;
- typedef boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype, ExpressionTemplates> number_type;
public:
 static number_type (min)() BOOST_NOEXCEPT { return (base_type::min)(); }
 static number_type (max)() BOOST_NOEXCEPT { return (base_type::max)(); }

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -14,7 +14,7 @@

#include <boost/cstdint.hpp>
#include <boost/array.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/big_lanczos.hpp>

//
@@ -1342,9 +1342,9 @@
 else if(exp != v.exp)
 {
 // The signs are the same and the exponents are different.
- const int val_cmp_exp = ((exp < v.exp) ? 1 : -1);
+ const int val_cexpression = ((exp < v.exp) ? 1 : -1);

- return (neg ? val_cmp_exp : -val_cmp_exp);
+ return (neg ? val_cexpression : -val_cexpression);
 }
 else
 {
@@ -2730,7 +2730,7 @@
{
 if(!x.isfinite())
 {
- result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, mp_number<cpp_dec_float<Digits10> >(x), 0, boost::math::policies::policy<>()).backend();
+ result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, number<cpp_dec_float<Digits10> >(x), 0, boost::math::policies::policy<>()).backend();
 return;
 }
 else if(x.isint())
@@ -2842,15 +2842,15 @@
using boost::multiprecision::backends::cpp_dec_float;

-typedef mp_number<cpp_dec_float<50> > cpp_dec_float_50;
-typedef mp_number<cpp_dec_float<100> > cpp_dec_float_100;
+typedef number<cpp_dec_float<50> > cpp_dec_float_50;
+typedef number<cpp_dec_float<100> > cpp_dec_float_100;

}}

namespace std
{
 template <unsigned Digits10, bool ExpressionTemplates>
- class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >
+ class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> >
 {
 public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
@@ -2877,63 +2877,63 @@
 BOOST_STATIC_CONSTEXPR bool traps = false;
 BOOST_STATIC_CONSTEXPR bool tinyness_before = false;

- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> (min) (void) { return (boost::multiprecision::cpp_dec_float<Digits10>::min)(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> (max) (void) { return (boost::multiprecision::cpp_dec_float<Digits10>::max)(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> lowest (void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> epsilon (void) { return boost::multiprecision::cpp_dec_float<Digits10>::eps(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> round_error (void) { return 0.5L; }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> infinity (void) { return boost::multiprecision::cpp_dec_float<Digits10>::inf(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> quiet_NaN (void) { return boost::multiprecision::cpp_dec_float<Digits10>::nan(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> signaling_NaN(void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
- BOOST_STATIC_CONSTEXPR boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> denorm_min (void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> (min) (void) { return (boost::multiprecision::cpp_dec_float<Digits10>::min)(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> (max) (void) { return (boost::multiprecision::cpp_dec_float<Digits10>::max)(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> lowest (void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> epsilon (void) { return boost::multiprecision::cpp_dec_float<Digits10>::eps(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> round_error (void) { return 0.5L; }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> infinity (void) { return boost::multiprecision::cpp_dec_float<Digits10>::inf(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> quiet_NaN (void) { return boost::multiprecision::cpp_dec_float<Digits10>::nan(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> signaling_NaN(void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
+ BOOST_STATIC_CONSTEXPR boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates> denorm_min (void) { return boost::multiprecision::cpp_dec_float<Digits10>::zero(); }
 };

#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

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

#endif
}
@@ -2943,7 +2943,7 @@
namespace policies{

template <unsigned Digits10, class Policy, bool ExpressionTemplates>
-struct precision< boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<Digits10>, ExpressionTemplates>, Policy>
+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
 // from the template parameter Digits10 for small or large digit counts.

Modified: sandbox/big_number/boost/multiprecision/cpp_int.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/cpp_int.hpp (original)
+++ sandbox/big_number/boost/multiprecision/cpp_int.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -9,7 +9,7 @@
#include <iostream>
#include <iomanip>
#include <boost/cstdint.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>
#include <boost/array.hpp>
#include <boost/type_traits/is_integral.hpp>
@@ -2940,21 +2940,21 @@
template <unsigned MinBits, bool Signed, class Allocator, bool trivial>
struct number_category<cpp_int_backend<MinBits, Signed, Allocator, trivial> > : public mpl::int_<number_kind_integer>{};

-typedef mp_number<cpp_int_backend<> > cpp_int;
+typedef number<cpp_int_backend<> > cpp_int;
typedef rational_adapter<cpp_int_backend<> > cpp_rational_backend;
-typedef mp_number<cpp_rational_backend> cpp_rational;
+typedef number<cpp_rational_backend> cpp_rational;

// Fixed precision unsigned types:
-typedef mp_number<cpp_int_backend<128, false, void>, false> mp_uint128_t;
-typedef mp_number<cpp_int_backend<256, false, void>, false> mp_uint256_t;
-typedef mp_number<cpp_int_backend<512, false, void>, false> mp_uint512_t;
-typedef mp_number<cpp_int_backend<1024, false, void>, false> mp_uint1024_t;
+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;

// Fixed precision signed types:
-typedef mp_number<cpp_int_backend<128, true, void>, false> mp_int128_t;
-typedef mp_number<cpp_int_backend<256, true, void>, false> mp_int256_t;
-typedef mp_number<cpp_int_backend<512, true, void>, false> mp_int512_t;
-typedef mp_number<cpp_int_backend<1024, true, void>, false> mp_int1024_t;
+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;

#ifdef BOOST_MSVC
#pragma warning(pop)
@@ -2968,9 +2968,9 @@
namespace std{

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

public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
@@ -3020,56 +3020,56 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

template <unsigned MinBits, bool Signed, class Allocator, bool trivial, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::digits;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::digits10;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::max_digits10;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_signed;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_integer;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_exact;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::radix;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::min_exponent;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::min_exponent10;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::max_exponent;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::max_exponent10;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_infinity;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_quiet_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_signaling_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_denorm;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::has_denorm_loss;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_iec559;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_bounded;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::is_modulo;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::traps;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::tinyness_before;
+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>
-BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, Signed, Allocator, trivial>, ExpressionTemplates> >::round_style;
+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>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> number_type;

 struct inititializer
 {
@@ -3144,61 +3144,61 @@
};

template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
-const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::inititializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::init;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::digits;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::digits10;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::max_digits10;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_signed;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_integer;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_exact;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::radix;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::min_exponent;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::min_exponent10;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::max_exponent;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::max_exponent10;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_infinity;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_quiet_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_signaling_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_denorm;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::has_denorm_loss;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_iec559;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_bounded;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::is_modulo;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::traps;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::tinyness_before;
+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>
-BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, true, void, trivial>, ExpressionTemplates> >::round_style;
+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>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> number_type;

 struct inititializer
 {
@@ -3272,54 +3272,54 @@
};

template <unsigned MinBits, bool ExpressionTemplates, bool trivial>
-const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::inititializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::init;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::digits;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::digits10;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::max_digits10;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_signed;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_integer;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_exact;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::radix;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::min_exponent;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::min_exponent10;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::max_exponent;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::max_exponent10;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_infinity;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_quiet_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_signaling_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_denorm;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::has_denorm_loss;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_iec559;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_bounded;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::is_modulo;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::traps;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::tinyness_before;
+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>
-BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<MinBits, false, void, trivial>, ExpressionTemplates> >::round_style;
+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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -11,7 +11,7 @@
#include <sstream>
#include <boost/cstdint.hpp>
#include <boost/lexical_cast.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>

namespace boost{
namespace multiprecision{
@@ -128,10 +128,10 @@
namespace std{

template <class Arithmetic, bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates > > : public std::numeric_limits<Arithmetic>
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates > > : public std::numeric_limits<Arithmetic>
{
 typedef std::numeric_limits<Arithmetic> base_type;
- typedef boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR number_type (min)() BOOST_NOEXCEPT { return (base_type::min)(); }
 BOOST_STATIC_CONSTEXPR number_type (max)() BOOST_NOEXCEPT { return (base_type::max)(); }

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -9,7 +9,7 @@
#include <iostream>
#include <iomanip>
#include <boost/cstdint.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/cpp_int_core.hpp>
#include <boost/array.hpp>
#include <boost/type_traits/is_integral.hpp>
@@ -1504,13 +1504,13 @@
template <unsigned Bits, bool Signed>
struct number_category<fixed_int<Bits, Signed> > : public mpl::int_<number_kind_integer>{};

-typedef mp_number<fixed_int<128, false> > mp_uint128_t;
-typedef mp_number<fixed_int<256, false> > mp_uint256_t;
-typedef mp_number<fixed_int<512, false> > mp_uint512_t;
-
-typedef mp_number<fixed_int<128, true> > mp_int128_t;
-typedef mp_number<fixed_int<256, true> > mp_int256_t;
-typedef mp_number<fixed_int<512, true> > mp_int512_t;
+typedef number<fixed_int<128, false> > uint128_t;
+typedef number<fixed_int<256, false> > uint256_t;
+typedef number<fixed_int<512, false> > uint512_t;
+
+typedef number<fixed_int<128, true> > int128_t;
+typedef number<fixed_int<256, true> > int256_t;
+typedef number<fixed_int<512, true> > int512_t;

}} // namespaces

@@ -1518,16 +1518,16 @@
namespace std{

template <unsigned Bits, bool Signed, bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> number_type;

 struct initializer
 {
 initializer()
 {
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<Bits, Signed> > >::min)();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<Bits, Signed> > >::max)();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed> > >::min)();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::fixed_int<Bits, Signed> > >::max)();
 }
 void do_nothing()const{}
 };
@@ -1592,8 +1592,8 @@
};

template <unsigned Bits, bool Signed, bool ExpressionTemplates>
-typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >::initializer const
- numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::fixed_int<Bits, Signed>, ExpressionTemplates> >::init;
+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;
}

#endif

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -17,9 +17,9 @@
struct lanczos;

template<class Backend, bool ExpressionTemplates, class Policy>
-struct lanczos<multiprecision::mp_number<Backend, ExpressionTemplates>, Policy>
+struct lanczos<multiprecision::number<Backend, ExpressionTemplates>, Policy>
{
- typedef typename boost::math::policies::precision<multiprecision::mp_number<Backend, ExpressionTemplates>, Policy>::type precision_type;
+ typedef typename boost::math::policies::precision<multiprecision::number<Backend, ExpressionTemplates>, Policy>::type precision_type;
 typedef typename mpl::if_c<
 precision_type::value <= 73,
 lanczos13UDT,

Modified: sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/cpp_int_trivial_ops.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -10,6 +10,14 @@

namespace boost{ namespace multiprecision{ namespace backends{

+#ifdef BOOST_MSVC
+#pragma warning(push)
+ // C4389: signed/unsigned mismatch
+ // C4127: conditional expression is constant
+ // C4018: signed/unsigned mismatch
+#pragma warning(disable:4127 4018 4389)
+#endif
+
template <unsigned MinBits>
BOOST_FORCEINLINE bool eval_eq(const cpp_int_backend<MinBits, true, void, true>& a, const cpp_int_backend<MinBits, true, void, true>& b) BOOST_NOEXCEPT
{
@@ -357,10 +365,6 @@
*result.limbs() = boost::math::lcm(*a.limbs(), *b.limbs());
}

-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127 4018)
-#endif
template <class R, unsigned MinBits>
inline void eval_convert_to(R* result, const cpp_int_backend<MinBits, true, void, true>& val)
{

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -7,7 +7,7 @@
#define BOOST_MATH_BIG_NUM_DEF_OPS

#include <boost/math/policies/error_handling.hpp>
-#include <boost/multiprecision/detail/mp_number_base.hpp>
+#include <boost/multiprecision/detail/number_base.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/utility/enable_if.hpp>
@@ -693,7 +693,7 @@
 int c = eval_fpclassify(a);
 if(c == FP_NAN || c == FP_INFINITE)
 {
- result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, mp_number<T>(a), 0, boost::math::policies::policy<>()).backend();
+ result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, number<T>(a), 0, boost::math::policies::policy<>()).backend();
 return;
 }
 if(eval_get_sign(a) < 0)
@@ -710,7 +710,7 @@
 int c = eval_fpclassify(a);
 if(c == FP_NAN || c == FP_INFINITE)
 {
- result = boost::math::policies::raise_rounding_error("boost::multiprecision::round<%1%>(%1%)", 0, mp_number<T>(a), 0, boost::math::policies::policy<>()).backend();
+ result = boost::math::policies::raise_rounding_error("boost::multiprecision::round<%1%>(%1%)", 0, number<T>(a), 0, boost::math::policies::policy<>()).backend();
 return;
 }
 if(eval_get_sign(a) < 0)
@@ -844,60 +844,60 @@
// Default versions of floating point classification routines:
//
template <class Backend, bool ExpressionTemplates>
-inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::mp_number<Backend, ExpressionTemplates>& arg)
+inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 using multiprecision::default_ops::eval_fpclassify;
 return eval_fpclassify(arg.backend());
}
template <class tag, class A1, class A2, class A3, class A4>
-inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& arg)
+inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return fpclassify(value_type(arg));
}
template <class Backend, bool ExpressionTemplates>
-inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::mp_number<Backend, ExpressionTemplates>& arg)
+inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 int v = fpclassify(arg);
 return (v != FP_INFINITE) && (v != FP_NAN);
}
template <class tag, class A1, class A2, class A3, class A4>
-inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& arg)
+inline bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isfinite(value_type(arg));
}
template <class Backend, bool ExpressionTemplates>
-inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::mp_number<Backend, ExpressionTemplates>& arg)
+inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 return fpclassify(arg) == FP_NAN;
}
template <class tag, class A1, class A2, class A3, class A4>
-inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& arg)
+inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isnan(value_type(arg));
}
template <class Backend, bool ExpressionTemplates>
-inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::mp_number<Backend, ExpressionTemplates>& arg)
+inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 return fpclassify(arg) == FP_INFINITE;
}
template <class tag, class A1, class A2, class A3, class A4>
-inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& arg)
+inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isinf(value_type(arg));
}
template <class Backend, bool ExpressionTemplates>
-inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::mp_number<Backend, ExpressionTemplates>& arg)
+inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
 return fpclassify(arg) == FP_NORMAL;
}
template <class tag, class A1, class A2, class A3, class A4>
-inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& arg)
+inline bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type value_type;
 return isnormal(value_type(arg));
}

@@ -905,198 +905,198 @@
namespace multiprecision{

template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type trunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline typename detail::expression<tag, A1, A2, A3, A4>::result_type trunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 return BOOST_MP_MOVE(trunc(number_type(v), pol));
}

template <class Backend, bool ExpressionTemplates, class Policy>
-inline mp_number<Backend, ExpressionTemplates> trunc(const mp_number<Backend, ExpressionTemplates>& v, const Policy&)
+inline number<Backend, ExpressionTemplates> trunc(const number<Backend, ExpressionTemplates>& v, const Policy&)
{
 using default_ops::eval_trunc;
- mp_number<Backend, ExpressionTemplates> result;
+ number<Backend, ExpressionTemplates> result;
 eval_trunc(result.backend(), v.backend());
 return BOOST_MP_MOVE(result);
}

template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline int itrunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline int itrunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type r = trunc(v, pol);
 if((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !boost::math::isfinite(v))
 return boost::math::policies::raise_rounding_error("boost::multiprecision::itrunc<%1%>(%1%)", 0, number_type(v), 0, pol).template convert_to<int>();
 return r.template convert_to<int>();
}
template <class tag, class A1, class A2, class A3, class A4>
-inline int itrunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v)
+inline int itrunc(const detail::expression<tag, A1, A2, A3, A4>& v)
{
 return itrunc(v, boost::math::policies::policy<>());
}
template <class Backend, bool ExpressionTemplates, class Policy>
-inline int itrunc(const mp_number<Backend, ExpressionTemplates>& v, const Policy& pol)
+inline int itrunc(const number<Backend, ExpressionTemplates>& v, const Policy& pol)
{
- mp_number<Backend, ExpressionTemplates> r = trunc(v, pol);
+ number<Backend, ExpressionTemplates> r = trunc(v, pol);
 if((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !boost::math::isfinite(v))
 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>
-inline int itrunc(const mp_number<Backend, ExpressionTemplates>& v)
+inline int itrunc(const number<Backend, ExpressionTemplates>& v)
{
 return itrunc(v, boost::math::policies::policy<>());
}
template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline long ltrunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline long ltrunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type r = trunc(v, pol);
 if((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !boost::math::isfinite(v))
 return boost::math::policies::raise_rounding_error("boost::multiprecision::ltrunc<%1%>(%1%)", 0, number_type(v), 0L, pol).template convert_to<long>();
 return r.template convert_to<long>();
}
template <class tag, class A1, class A2, class A3, class A4>
-inline long ltrunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v)
+inline long ltrunc(const detail::expression<tag, A1, A2, A3, A4>& v)
{
 return ltrunc(v, boost::math::policies::policy<>());
}
template <class T, bool ExpressionTemplates, class Policy>
-inline long ltrunc(const mp_number<T, ExpressionTemplates>& v, const Policy& pol)
+inline long ltrunc(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
- mp_number<T, ExpressionTemplates> r = trunc(v, pol);
+ number<T, ExpressionTemplates> r = trunc(v, pol);
 if((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !boost::math::isfinite(v))
 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>
-inline long ltrunc(const mp_number<T, ExpressionTemplates>& v)
+inline long ltrunc(const number<T, ExpressionTemplates>& v)
{
 return ltrunc(v, boost::math::policies::policy<>());
}
#ifndef BOOST_NO_LONG_LONG
template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline long long lltrunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline long long lltrunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type r = trunc(v, pol);
 if((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !boost::math::isfinite(v))
 return boost::math::policies::raise_rounding_error("boost::multiprecision::lltrunc<%1%>(%1%)", 0, number_type(v), 0LL, pol).template convert_to<long long>();
 return r.template convert_to<long long>();
}
template <class tag, class A1, class A2, class A3, class A4>
-inline long long lltrunc(const detail::mp_exp<tag, A1, A2, A3, A4>& v)
+inline long long lltrunc(const detail::expression<tag, A1, A2, A3, A4>& v)
{
 return lltrunc(v, boost::math::policies::policy<>());
}
template <class T, bool ExpressionTemplates, class Policy>
-inline long long lltrunc(const mp_number<T, ExpressionTemplates>& v, const Policy& pol)
+inline long long lltrunc(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
- mp_number<T, ExpressionTemplates> r = trunc(v, pol);
+ number<T, ExpressionTemplates> r = trunc(v, pol);
 if((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !boost::math::isfinite(v))
 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>
-inline long long lltrunc(const mp_number<T, ExpressionTemplates>& v)
+inline long long lltrunc(const number<T, ExpressionTemplates>& v)
{
 return lltrunc(v, boost::math::policies::policy<>());
}
#endif
template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type round(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline typename detail::expression<tag, A1, A2, A3, A4>::result_type round(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ 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>
-inline mp_number<T, ExpressionTemplates> round(const mp_number<T, ExpressionTemplates>& v, const Policy&)
+inline number<T, ExpressionTemplates> round(const number<T, ExpressionTemplates>& v, const Policy&)
{
 using default_ops::eval_round;
- mp_number<T, ExpressionTemplates> result;
+ number<T, ExpressionTemplates> result;
 eval_round(result.backend(), v.backend());
 return BOOST_MP_MOVE(result);
}

template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline int iround(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline int iround(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type r = round(v, pol);
 if((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !boost::math::isfinite(v))
 return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", 0, number_type(v), 0, pol).template convert_to<int>();
 return r.template convert_to<int>();
}
template <class tag, class A1, class A2, class A3, class A4>
-inline int iround(const detail::mp_exp<tag, A1, A2, A3, A4>& v)
+inline int iround(const detail::expression<tag, A1, A2, A3, A4>& v)
{
 return iround(v, boost::math::policies::policy<>());
}
template <class T, bool ExpressionTemplates, class Policy>
-inline int iround(const mp_number<T, ExpressionTemplates>& v, const Policy& pol)
+inline int iround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
- mp_number<T, ExpressionTemplates> r = round(v, pol);
+ number<T, ExpressionTemplates> r = round(v, pol);
 if((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !boost::math::isfinite(v))
 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>
-inline int iround(const mp_number<T, ExpressionTemplates>& v)
+inline int iround(const number<T, ExpressionTemplates>& v)
{
 return iround(v, boost::math::policies::policy<>());
}
template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline long lround(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline long lround(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type r = round(v, pol);
 if((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !boost::math::isfinite(v))
 return boost::math::policies::raise_rounding_error("boost::multiprecision::lround<%1%>(%1%)", 0, number_type(v), 0L, pol).template convert_to<long>();
 return r.template convert_to<long>();
}
template <class tag, class A1, class A2, class A3, class A4>
-inline long lround(const detail::mp_exp<tag, A1, A2, A3, A4>& v)
+inline long lround(const detail::expression<tag, A1, A2, A3, A4>& v)
{
 return lround(v, boost::math::policies::policy<>());
}
template <class T, bool ExpressionTemplates, class Policy>
-inline long lround(const mp_number<T, ExpressionTemplates>& v, const Policy& pol)
+inline long lround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
- mp_number<T, ExpressionTemplates> r = round(v, pol);
+ number<T, ExpressionTemplates> r = round(v, pol);
 if((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !boost::math::isfinite(v))
 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>
-inline long lround(const mp_number<T, ExpressionTemplates>& v)
+inline long lround(const number<T, ExpressionTemplates>& v)
{
 return lround(v, boost::math::policies::policy<>());
}
#ifndef BOOST_NO_LONG_LONG
template <class tag, class A1, class A2, class A3, class A4, class Policy>
-inline long long llround(const detail::mp_exp<tag, A1, A2, A3, A4>& v, const Policy& pol)
+inline long long llround(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
- typedef typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type r = round(v, pol);
 if((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !boost::math::isfinite(v))
 return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", 0, number_type(v), 0LL, pol).template convert_to<long long>();
 return r.template convert_to<long long>();
}
template <class tag, class A1, class A2, class A3, class A4>
-inline long long llround(const detail::mp_exp<tag, A1, A2, A3, A4>& v)
+inline long long llround(const detail::expression<tag, A1, A2, A3, A4>& v)
{
 return llround(v, boost::math::policies::policy<>());
}
template <class T, bool ExpressionTemplates, class Policy>
-inline long long llround(const mp_number<T, ExpressionTemplates>& v, const Policy& pol)
+inline long long llround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
- mp_number<T, ExpressionTemplates> r = round(v, pol);
+ number<T, ExpressionTemplates> r = round(v, pol);
 if((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !boost::math::isfinite(v))
 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>
-inline long long llround(const mp_number<T, ExpressionTemplates>& v)
+inline long long llround(const number<T, ExpressionTemplates>& v)
{
 return llround(v, boost::math::policies::policy<>());
}
@@ -1117,36 +1117,36 @@
}\
\
template <class tag, class A1, class A2, class A3, class A4> \
-inline typename enable_if_c<number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category,\
- detail::mp_exp<\
+inline typename enable_if_c<number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category,\
+ detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> > \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> > \
>::type \
-func(const detail::mp_exp<tag, A1, A2, A3, A4>& arg)\
+func(const detail::expression<tag, A1, A2, A3, A4>& arg)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
> (\
- detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>() \
+ detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>() \
 , arg \
 );\
}\
template <class Backend> \
inline typename enable_if_c<number_category<Backend>::value == category,\
- detail::mp_exp<\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend, true> > \
+ , number<Backend, true> > \
>::type \
-func(const mp_number<Backend, true>& arg)\
+func(const number<Backend, true>& arg)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend> \
+ , number<Backend> \
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
 , arg \
@@ -1155,10 +1155,10 @@
template <class Backend> \
inline typename boost::enable_if_c<\
 boost::multiprecision::number_category<Backend>::value == category,\
- mp_number<Backend, false> >::type \
-func(const mp_number<Backend, false>& arg)\
+ number<Backend, false> >::type \
+func(const number<Backend, false>& arg)\
{\
- mp_number<Backend, false> result;\
+ number<Backend, false> result;\
 using default_ops::BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend());\
 return BOOST_MP_MOVE(result);\
@@ -1191,19 +1191,19 @@
}\
template <class Backend> \
inline typename enable_if_c<number_category<Backend>::value == category,\
- detail::mp_exp<\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend, true> \
- , mp_number<Backend, true> > \
+ , number<Backend, true> \
+ , number<Backend, true> > \
>::type \
-func(const mp_number<Backend, true>& arg, const mp_number<Backend, true>& a)\
+func(const number<Backend, true>& arg, const number<Backend, true>& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend> \
- , mp_number<Backend> \
+ , number<Backend> \
+ , number<Backend> \
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
 , arg,\
@@ -1212,20 +1212,20 @@
}\
template <class Backend, class tag, class A1, class A2, class A3, class A4> \
inline typename enable_if_c<\
- (number_category<Backend>::value == category) && (number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category),\
- detail::mp_exp<\
+ (number_category<Backend>::value == category) && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend, true> \
- , detail::mp_exp<tag, A1, A2, A3, A4> > \
+ , number<Backend, true> \
+ , detail::expression<tag, A1, A2, A3, A4> > \
>::type \
-func(const mp_number<Backend, true>& arg, const detail::mp_exp<tag, A1, A2, A3, A4>& a)\
+func(const number<Backend, true>& arg, const detail::expression<tag, A1, A2, A3, A4>& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , number<Backend> \
+ , detail::expression<tag, A1, A2, A3, A4> \
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
 , arg,\
@@ -1234,20 +1234,20 @@
}\
template <class tag, class A1, class A2, class A3, class A4, class Backend> \
inline typename enable_if_c<\
- (number_category<Backend>::value == category) && (number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category),\
- detail::mp_exp<\
+ (number_category<Backend>::value == category) && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
- , mp_number<Backend, true> > \
+ , detail::expression<tag, A1, A2, A3, A4> \
+ , number<Backend, true> > \
>::type \
-func(const detail::mp_exp<tag, A1, A2, A3, A4>& arg, const mp_number<Backend, true>& a)\
+func(const detail::expression<tag, A1, A2, A3, A4>& arg, const number<Backend, true>& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
- , mp_number<Backend> \
+ , detail::expression<tag, A1, A2, A3, A4> \
+ , number<Backend> \
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
 , arg,\
@@ -1256,22 +1256,22 @@
}\
template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b> \
inline typename enable_if_c<\
- (number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category) && (number_category<detail::mp_exp<tagb, A1b, A2b, A3b, A4b> >::value == category),\
- detail::mp_exp<\
+ (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category) && (number_category<detail::expression<tagb, A1b, A2b, A3b, A4b> >::value == category),\
+ detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
- , detail::mp_exp<tagb, A1b, A2b, A3b, A4b> > \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
+ , detail::expression<tagb, A1b, A2b, A3b, A4b> > \
>::type \
-func(const detail::mp_exp<tag, A1, A2, A3, A4>& arg, const detail::mp_exp<tagb, A1b, A2b, A3b, A4b>& a)\
+func(const detail::expression<tag, A1, A2, A3, A4>& arg, const detail::expression<tagb, A1b, A2b, A3b, A4b>& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
- , detail::mp_exp<tagb, A1b, A2b, A3b, A4b> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
+ , detail::expression<tagb, A1b, A2b, A3b, A4b> \
>(\
- detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>() \
+ detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>() \
 , arg,\
 a\
 );\
@@ -1279,19 +1279,19 @@
template <class Backend, class Arithmetic> \
inline typename enable_if_c<\
 is_arithmetic<Arithmetic>::value && (number_category<Backend>::value == category),\
- detail::mp_exp<\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend, true> \
+ , number<Backend, true> \
 , Arithmetic\
> \
>::type \
-func(const mp_number<Backend, true>& arg, const Arithmetic& a)\
+func(const number<Backend, true>& arg, const Arithmetic& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend> \
+ , number<Backend> \
 , Arithmetic\
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
@@ -1301,23 +1301,23 @@
}\
template <class tag, class A1, class A2, class A3, class A4, class Arithmetic> \
inline typename enable_if_c<\
- is_arithmetic<Arithmetic>::value && (number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category),\
- detail::mp_exp<\
+ is_arithmetic<Arithmetic>::value && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),\
+ detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
 , Arithmetic\
> \
>::type \
-func(const detail::mp_exp<tag, A1, A2, A3, A4>& arg, const Arithmetic& a)\
+func(const detail::expression<tag, A1, A2, A3, A4>& arg, const Arithmetic& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
 , Arithmetic\
>(\
- detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>() \
+ detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>() \
 , arg,\
 a\
 );\
@@ -1325,20 +1325,20 @@
template <class Backend, class Arithmetic> \
inline typename enable_if_c<\
 is_arithmetic<Arithmetic>::value && (number_category<Backend>::value == category),\
- detail::mp_exp<\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
 , Arithmetic \
- , mp_number<Backend, true> \
+ , number<Backend, true> \
> \
>::type \
-func(const Arithmetic& arg, const mp_number<Backend, true>& a)\
+func(const Arithmetic& arg, const number<Backend, true>& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
 , Arithmetic \
- , mp_number<Backend> \
+ , number<Backend> \
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
 , arg,\
@@ -1347,33 +1347,33 @@
}\
template <class tag, class A1, class A2, class A3, class A4, class Arithmetic> \
inline typename enable_if_c<\
- is_arithmetic<Arithmetic>::value && (number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category),\
- detail::mp_exp<\
+ is_arithmetic<Arithmetic>::value && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),\
+ detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
 , Arithmetic \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::expression<tag, A1, A2, A3, A4> \
> \
>::type \
-func(const Arithmetic& arg, const detail::mp_exp<tag, A1, A2, A3, A4>& a)\
+func(const Arithmetic& arg, const detail::expression<tag, A1, A2, A3, A4>& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
 , Arithmetic \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::expression<tag, A1, A2, A3, A4> \
>(\
- detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>() \
+ detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>() \
 , arg,\
 a\
 );\
}\
template <class Backend> \
inline typename enable_if_c<(number_category<Backend>::value == category),\
- mp_number<Backend, false> >::type \
-func(const mp_number<Backend, false>& arg, const mp_number<Backend, false>& a)\
+ number<Backend, false> >::type \
+func(const number<Backend, false>& arg, const number<Backend, false>& a)\
{\
- mp_number<Backend, false> result;\
+ number<Backend, false> result;\
 using default_ops:: BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend(), a.backend());\
 return BOOST_MP_MOVE(result);\
@@ -1381,12 +1381,12 @@
template <class Backend, class Arithmetic> \
inline typename enable_if_c<\
 is_arithmetic<Arithmetic>::value && (number_category<Backend>::value == category),\
- mp_number<Backend, false> \
+ number<Backend, false> \
>::type \
-func(const mp_number<Backend, false>& arg, const Arithmetic& a)\
+func(const number<Backend, false>& arg, const Arithmetic& a)\
{\
 typedef typename detail::canonical<Arithmetic, Backend>::type canonical_type;\
- mp_number<Backend, false> result;\
+ number<Backend, false> 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);\
@@ -1394,12 +1394,12 @@
template <class Backend, class Arithmetic> \
inline typename enable_if_c<\
 is_arithmetic<Arithmetic>::value && (number_category<Backend>::value == category),\
- mp_number<Backend, false> \
+ number<Backend, false> \
>::type \
-func(const Arithmetic& a, const mp_number<Backend, false>& arg)\
+func(const Arithmetic& a, const number<Backend, false>& arg)\
{\
 typedef typename detail::canonical<Arithmetic, Backend>::type canonical_type;\
- mp_number<Backend, false> result;\
+ number<Backend, false> 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);\
@@ -1409,40 +1409,40 @@
#define HETERO_BINARY_OP_FUNCTOR_B(func, Arg2, category)\
template <class tag, class A1, class A2, class A3, class A4> \
inline typename enable_if_c<\
- (number_category<detail::mp_exp<tag, A1, A2, A3, A4> >::value == category),\
- detail::mp_exp<\
+ (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),\
+ detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
 , Arg2> \
>::type \
-func(const detail::mp_exp<tag, A1, A2, A3, A4>& arg, Arg2 const& a)\
+func(const detail::expression<tag, A1, A2, A3, A4>& arg, Arg2 const& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
- , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type> \
- , detail::mp_exp<tag, A1, A2, A3, A4> \
+ , detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type> \
+ , detail::expression<tag, A1, A2, A3, A4> \
 , Arg2\
>(\
- detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>() \
+ detail::BOOST_JOIN(func, _funct)<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>() \
 , arg, a \
 );\
}\
template <class Backend> \
inline typename enable_if_c<\
 (number_category<Backend>::value == category),\
- detail::mp_exp<\
+ detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend, true> \
+ , number<Backend, true> \
 , Arg2> \
>::type \
-func(const mp_number<Backend, true>& arg, Arg2 const& a)\
+func(const number<Backend, true>& arg, Arg2 const& a)\
{\
- return detail::mp_exp<\
+ return detail::expression<\
 detail::function\
 , detail::BOOST_JOIN(func, _funct)<Backend> \
- , mp_number<Backend> \
+ , number<Backend> \
 , Arg2\
>(\
 detail::BOOST_JOIN(func, _funct)<Backend>() \
@@ -1453,10 +1453,10 @@
template <class Backend> \
inline typename enable_if_c<\
 (number_category<Backend>::value == category),\
- mp_number<Backend, false> >::type \
-func(const mp_number<Backend, false>& arg, Arg2 const& a)\
+ number<Backend, false> >::type \
+func(const number<Backend, false>& arg, Arg2 const& a)\
{\
- mp_number<Backend, false> result;\
+ number<Backend, false> result;\
 using default_ops:: BOOST_JOIN(eval_,func);\
 BOOST_JOIN(eval_,func)(result.backend(), arg.backend(), a);\
 return BOOST_MP_MOVE(result);\
@@ -1493,42 +1493,42 @@
}

template <class tag, class A1, class A2, class A3, class A4>
-inline detail::mp_exp<
+inline detail::expression<
 detail::function
- , detail::abs_funct<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>
- , detail::mp_exp<tag, A1, A2, A3, A4> >
-abs(const detail::mp_exp<tag, A1, A2, A3, A4>& arg)
+ , detail::abs_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>
+ , detail::expression<tag, A1, A2, A3, A4> >
+abs(const detail::expression<tag, A1, A2, A3, A4>& arg)
{
- return detail::mp_exp<
+ return detail::expression<
 detail::function
- , detail::abs_funct<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>
- , detail::mp_exp<tag, A1, A2, A3, A4>
+ , detail::abs_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>
+ , detail::expression<tag, A1, A2, A3, A4>
> (
- detail::abs_funct<typename detail::backend_type<detail::mp_exp<tag, A1, A2, A3, A4> >::type>()
+ detail::abs_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>()
 , arg
 );
}
template <class Backend>
-inline detail::mp_exp<
+inline detail::expression<
 detail::function
 , detail::abs_funct<Backend>
- , mp_number<Backend, true> >
-abs(const mp_number<Backend, true>& arg)
+ , number<Backend, true> >
+abs(const number<Backend, true>& arg)
{
- return detail::mp_exp<
+ return detail::expression<
 detail::function
 , detail::abs_funct<Backend>
- , mp_number<Backend, true>
+ , number<Backend, true>
>(
 detail::abs_funct<Backend>()
 , arg
 );
}
template <class Backend>
-inline mp_number<Backend, false>
-abs(const mp_number<Backend, false>& arg)
+inline number<Backend, false>
+abs(const number<Backend, false>& arg)
{
- mp_number<Backend, false> result;
+ number<Backend, false> result;
 using default_ops::eval_abs;
 eval_abs(result.backend(), arg.backend());
 return BOOST_MP_MOVE(result);
@@ -1577,32 +1577,32 @@

namespace math{
//
-// Overload of Boost.Math functions that find the wrong overload when used with mp_number:
+// Overload of Boost.Math functions that find the wrong overload when used with number:
//
namespace detail{
 template <class T> T sinc_pi_imp(T);
 template <class T> T sinhc_pi_imp(T);
}
template <class Backend, bool ExpressionTemplates>
-inline multiprecision::mp_number<Backend, ExpressionTemplates> sinc_pi(const multiprecision::mp_number<Backend, ExpressionTemplates>& x)
+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>
-inline multiprecision::mp_number<Backend, ExpressionTemplates> sinc_pi(const multiprecision::mp_number<Backend, ExpressionTemplates>& x, const 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>
-inline multiprecision::mp_number<Backend, ExpressionTemplates> sinhc_pi(const multiprecision::mp_number<Backend, ExpressionTemplates>& x)
+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>
-inline multiprecision::mp_number<Backend, ExpressionTemplates> sinhc_pi(const multiprecision::mp_number<Backend, ExpressionTemplates>& x, const 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/functions/constants.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/functions/constants.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/functions/constants.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -246,7 +246,7 @@
 static bool b = false;
 if(!b)
 {
- calc_log2(result, boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ calc_log2(result, boost::multiprecision::detail::digits2<number<T> >::value);
 b = true;
 }

@@ -262,7 +262,7 @@
 static bool b = false;
 if(!b)
 {
- calc_e(result, boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ calc_e(result, boost::multiprecision::detail::digits2<number<T> >::value);
 b = true;
 }

@@ -278,7 +278,7 @@
 static bool b = false;
 if(!b)
 {
- calc_pi(result, boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ calc_pi(result, boost::multiprecision::detail::digits2<number<T> >::value);
 b = true;
 }

Modified: sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/functions/pow.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -90,7 +90,7 @@
 typedef typename mpl::front<typename T::unsigned_types>::type ui_type;

 BOOST_ASSERT(&H0F0 != &x);
- long tol = boost::multiprecision::detail::digits2<mp_number<T> >::value;
+ long tol = boost::multiprecision::detail::digits2<number<T> >::value;
 T t;

 T x_pow_n_div_n_fact(x);
@@ -146,7 +146,7 @@
 eval_multiply(H1F0, pochham_a, x_pow_n_div_n_fact);
 eval_add(H1F0, si_type(1));
 T lim;
- eval_ldexp(lim, H1F0, 1 - boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ eval_ldexp(lim, H1F0, 1 - boost::multiprecision::detail::digits2<number<T> >::value);
 if(eval_get_sign(lim) < 0)
 lim.negate();

@@ -154,7 +154,7 @@
 T term, part;

 // Series expansion of hyperg_1f0(a; ; x).
- for(n = 2; n < boost::multiprecision::detail::digits2<mp_number<T> >::value + 10; n++)
+ for(n = 2; n < boost::multiprecision::detail::digits2<number<T> >::value + 10; n++)
 {
 eval_multiply(x_pow_n_div_n_fact, x);
 eval_divide(x_pow_n_div_n_fact, n);
@@ -167,7 +167,7 @@
 if(lim.compare(term) >= 0)
 break;
 }
- if(n >= boost::multiprecision::detail::digits2<mp_number<T> >::value + 10)
+ if(n >= boost::multiprecision::detail::digits2<number<T> >::value + 10)
 BOOST_THROW_EXCEPTION(std::runtime_error("H1F0 failed to converge"));
}

@@ -193,7 +193,7 @@
 bool isneg = eval_get_sign(x) < 0;
 if(type == FP_NAN)
 {
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 }
 else if(type == FP_INFINITE)
@@ -218,7 +218,7 @@
 xx.negate();

 // Check the range of the argument.
- static const canonical_exp_type maximum_arg_for_exp = std::numeric_limits<mp_number<T> >::max_exponent == 0 ? (std::numeric_limits<long>::max)() : std::numeric_limits<mp_number<T> >::max_exponent;
+ static const canonical_exp_type maximum_arg_for_exp = std::numeric_limits<number<T> >::max_exponent == 0 ? (std::numeric_limits<long>::max)() : std::numeric_limits<number<T> >::max_exponent;

 if(xx.compare(maximum_arg_for_exp) >= 0)
 {
@@ -226,7 +226,7 @@
 if(isneg)
 result = ui_type(0);
 else
- result = std::numeric_limits<mp_number<T> >::has_infinity ? std::numeric_limits<mp_number<T> >::infinity().backend() : (std::numeric_limits<mp_number<T> >::max)().backend();
+ result = std::numeric_limits<number<T> >::has_infinity ? std::numeric_limits<number<T> >::infinity().backend() : (std::numeric_limits<number<T> >::max)().backend();
 return;
 }
 if(xx.compare(si_type(1)) <= 0)
@@ -234,7 +234,7 @@
 //
 // Use series for exp(x) - 1:
 //
- T lim = std::numeric_limits<mp_number<T> >::epsilon().backend();
+ T lim = std::numeric_limits<number<T> >::epsilon().backend();
 unsigned k = 2;
 exp_series = xx;
 result = si_type(1);
@@ -344,7 +344,7 @@
 else
 eval_subtract(result, t);

- eval_multiply(lim, result, std::numeric_limits<mp_number<T> >::epsilon().backend());
+ eval_multiply(lim, result, std::numeric_limits<number<T> >::epsilon().backend());
 if(eval_get_sign(lim) < 0)
 lim.negate();
 INSTRUMENT_BACKEND(lim);
@@ -465,7 +465,7 @@

 if((eval_get_sign(x) < 0) && !bo_a_isint)
 {
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 }

 T t, da;
@@ -564,7 +564,7 @@
 ui_type k = 1;

 T lim(x);
- eval_ldexp(lim, lim, 1 - boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ eval_ldexp(lim, lim, 1 - boost::multiprecision::detail::digits2<number<T> >::value);

 do
 {

Modified: sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/functions/trig.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -36,7 +36,7 @@

 T tol;
 tol = ui_type(1);
- eval_ldexp(tol, tol, 1 - boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ eval_ldexp(tol, tol, 1 - boost::multiprecision::detail::digits2<number<T> >::value);
 eval_multiply(tol, result);
 if(eval_get_sign(tol) < 0)
 tol.negate();
@@ -87,7 +87,7 @@
 {
 case FP_INFINITE:
 case FP_NAN:
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 case FP_ZERO:
 result = ui_type(0);
@@ -233,7 +233,7 @@
 {
 case FP_INFINITE:
 case FP_NAN:
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 case FP_ZERO:
 result = ui_type(1);
@@ -391,7 +391,7 @@
 eval_add(result, ui_type(1));

 T lim;
- eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<number<T> >::value);

 if(eval_get_sign(lim) < 0)
 lim.negate();
@@ -447,7 +447,7 @@
 {
 case FP_NAN:
 case FP_INFINITE:
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 case FP_ZERO:
 result = ui_type(0);
@@ -464,7 +464,7 @@
 int c = xx.compare(ui_type(1));
 if(c > 0)
 {
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 }
 else if(c == 0)
@@ -524,7 +524,7 @@
 eval_subtract(result, s);

 T lim;
- eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<mp_number<T> >::value);
+ eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<number<T> >::value);
 if(eval_get_sign(s) < 0)
 s.negate();
 if(eval_get_sign(lim) < 0)
@@ -546,7 +546,7 @@
 {
 case FP_NAN:
 case FP_INFINITE:
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 case FP_ZERO:
 result = get_constant_pi<T>();
@@ -559,7 +559,7 @@

 if(c > 0)
 {
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 }
 else if(c == 0)
@@ -591,7 +591,7 @@
 switch(eval_fpclassify(x))
 {
 case FP_NAN:
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 return;
 case FP_ZERO:
 result = ui_type(0);
@@ -656,7 +656,7 @@
 static const boost::int32_t double_digits10_minus_a_few = std::numeric_limits<double>::digits10 - 3;

 T s, c, t;
- for(boost::int32_t digits = double_digits10_minus_a_few; digits <= std::numeric_limits<mp_number<T> >::digits10; digits *= 2)
+ for(boost::int32_t digits = double_digits10_minus_a_few; digits <= std::numeric_limits<number<T> >::digits10; digits *= 2)
 {
 eval_sin(s, result);
 eval_cos(c, result);
@@ -710,7 +710,7 @@
 {
 if(eval_fpclassify(x) == FP_INFINITE)
 {
- result = std::numeric_limits<mp_number<T> >::quiet_NaN().backend();
+ result = std::numeric_limits<number<T> >::quiet_NaN().backend();
 }
 else
 {

Modified: sandbox/big_number/boost/multiprecision/detail/generic_interconvert.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/generic_interconvert.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/generic_interconvert.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -116,7 +116,7 @@
 // radixes but it would complicate things.... use a string convertion when the radix is other
 // than 2:
 //
- if(std::numeric_limits<mp_number<From> >::radix != 2)
+ if(std::numeric_limits<number<From> >::radix != 2)
 {
 to = from.str(0, std::ios_base::fmtflags()).c_str();
 return;
@@ -190,10 +190,10 @@
template <class To, class From>
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_rational>& /*to_type*/, const mpl::int_<number_kind_rational>& /*from_type*/)
{
- typedef typename component_type<mp_number<From> >::type from_component_type;
- typedef typename component_type<mp_number<To> >::type to_component_type;
+ typedef typename component_type<number<From> >::type from_component_type;
+ typedef typename component_type<number<To> >::type to_component_type;

- mp_number<From> t(from);
+ number<From> t(from);
 to_component_type n(numerator(t)), d(denominator(t));
 using default_ops::assign_components;
 assign_components(to, n.backend(), d.backend());
@@ -202,9 +202,9 @@
template <class To, class From>
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_rational>& /*to_type*/, const mpl::int_<number_kind_integer>& /*from_type*/)
{
- typedef typename component_type<mp_number<To> >::type to_component_type;
+ typedef typename component_type<number<To> >::type to_component_type;

- mp_number<From> t(from);
+ number<From> t(from);
 to_component_type n(t), d(1);
 using default_ops::assign_components;
 assign_components(to, n.backend(), d.backend());
@@ -213,12 +213,12 @@
template <class To, class From>
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_floating_point>& /*to_type*/, const mpl::int_<number_kind_rational>& /*from_type*/)
{
- typedef typename component_type<mp_number<From> >::type from_component_type;
+ typedef typename component_type<number<From> >::type from_component_type;
 using default_ops::eval_divide;

- mp_number<From> t(from);
+ number<From> t(from);
 from_component_type n(numerator(t)), d(denominator(t));
- mp_number<To> fn(n), fd(d);
+ number<To> fn(n), fd(d);
 eval_divide(to, fn.backend(), fd.backend());
}

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -6,7 +6,7 @@
#ifndef BOOST_MP_INT_FUNC_HPP
#define BOOST_MP_INT_FUNC_HPP

-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>

namespace boost{ namespace multiprecision{

@@ -42,8 +42,8 @@

template <class Backend, bool ExpressionTemplates>
inline typename enable_if_c<number_category<Backend>::value == number_kind_integer>::type
- divide_qr(const mp_number<Backend, ExpressionTemplates>& x, const mp_number<Backend, ExpressionTemplates>& y,
- mp_number<Backend, ExpressionTemplates>& q, mp_number<Backend, ExpressionTemplates>& r)
+ divide_qr(const number<Backend, ExpressionTemplates>& x, const number<Backend, ExpressionTemplates>& y,
+ number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
{
 using default_ops::eval_qr;
 eval_qr(x.backend(), y.backend(), q.backend(), r.backend());
@@ -51,57 +51,57 @@

template <class Backend, bool 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 mp_number<Backend, ExpressionTemplates>& x, const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& y,
- mp_number<Backend, ExpressionTemplates>& q, mp_number<Backend, ExpressionTemplates>& r)
+ 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)
{
- divide_qr(x, mp_number<Backend, ExpressionTemplates>(y), q, r);
+ divide_qr(x, number<Backend, ExpressionTemplates>(y), q, r);
}

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

template <class Backend, bool 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 mp_number<Backend, ExpressionTemplates>& x, Integer val)
+ integer_modulus(const number<Backend, ExpressionTemplates>& x, Integer val)
{
 using default_ops::eval_integer_modulus;
 return eval_integer_modulus(x.backend(), val);
}

template <class tag, class A1, class A2, class A3, class A4, class Integer>
-inline typename enable_if<mpl::and_<is_integral<Integer>, mpl::bool_<number_category<typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer> >, Integer>::type
- integer_modulus(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& x, Integer val)
+inline typename enable_if<mpl::and_<is_integral<Integer>, mpl::bool_<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer> >, Integer>::type
+ integer_modulus(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, Integer val)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type result_type;
 return integer_modulus(result_type(x), val);
}

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

template <class tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<number_category<typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, unsigned>::type
- lsb(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& x)
+inline typename enable_if_c<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, unsigned>::type
+ lsb(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type n(x);
 using default_ops::eval_lsb;
 return eval_lsb(n.backend());
@@ -109,25 +109,25 @@

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

template <class tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<number_category<typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, bool>::type
- bit_test(const multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& x, unsigned index)
+inline typename enable_if_c<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, bool>::type
+ bit_test(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, unsigned index)
{
- typedef typename multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type number_type;
+ typedef typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type number_type;
 number_type n(x);
 using default_ops::eval_bit_test;
 return eval_bit_test(n.backend(), index);
}

template <class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, mp_number<Backend, ExpressionTemplates>&>::type
- bit_set(mp_number<Backend, ExpressionTemplates>& x, unsigned index)
+inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
+ bit_set(number<Backend, ExpressionTemplates>& x, unsigned index)
{
 using default_ops::eval_bit_set;
 eval_bit_set(x.backend(), index);
@@ -135,8 +135,8 @@
}

template <class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, mp_number<Backend, ExpressionTemplates>&>::type
- bit_unset(mp_number<Backend, ExpressionTemplates>& x, unsigned index)
+inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
+ bit_unset(number<Backend, ExpressionTemplates>& x, unsigned index)
{
 using default_ops::eval_bit_unset;
 eval_bit_unset(x.backend(), index);
@@ -144,8 +144,8 @@
}

template <class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, mp_number<Backend, ExpressionTemplates>&>::type
- bit_flip(mp_number<Backend, ExpressionTemplates>& x, unsigned index)
+inline typename enable_if_c<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
+ bit_flip(number<Backend, ExpressionTemplates>& x, unsigned index)
{
 using default_ops::eval_bit_flip;
 eval_bit_flip(x.backend(), index);
@@ -314,10 +314,10 @@
 is_integral<V>
>
>,
- detail::mp_exp<detail::function, detail::powm_func, T, U, V> >::type
+ detail::expression<detail::function, detail::powm_func, T, U, V> >::type
 powm(const T& b, const U& p, const V& mod)
{
- return detail::mp_exp<detail::function, detail::powm_func, T, U, V>(
+ return detail::expression<detail::function, detail::powm_func, T, U, V>(
 detail::powm_func(), b, p, mod);
}

Deleted: sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
+++ (empty file)
@@ -1,1262 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2011 John Maddock. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_BIG_NUM_BASE_HPP
-#define BOOST_MATH_BIG_NUM_BASE_HPP
-
-#include <limits>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/lexical_cast.hpp>
-
-namespace boost{ namespace multiprecision{
-
-template <class Backend, bool ExpressionTemplates = true>
-class mp_number;
-
-template <class T>
-struct is_mp_number : public mpl::false_ {};
-
-template <class Backend, bool ExpressionTemplates>
-struct is_mp_number<mp_number<Backend, ExpressionTemplates> > : public mpl::true_ {};
-
-namespace detail{
-
-// Forward-declare an expression wrapper
-template<class tag, class Arg1 = void, class Arg2 = void, class Arg3 = void, class Arg4 = void>
-struct mp_exp;
-
-} // namespace detail
-
-template <class T>
-struct is_mp_number_expression : public mpl::false_ {};
-
-template<class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct is_mp_number_expression<detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > : public mpl::true_ {};
-
-namespace detail{
-//
-// Workaround for missing abs(long long) on some compilers:
-//
-template <class T>
-typename boost::enable_if<is_arithmetic<T>, T>::type abs(const T& t) BOOST_NOEXCEPT
-{
- return t < 0 ? -t : t;
-}
-
-#define BOOST_MP_USING_ABS using std::abs; using boost::multiprecision::detail::abs;
-
-//
-// Move support:
-//
-#ifndef BOOST_NO_RVALUE_REFERENCES
-# define BOOST_MP_MOVE(x) std::move(x)
-#else
-# define BOOST_MP_MOVE(x) x
-#endif
-
-template <int b>
-struct has_enough_bits
-{
- template <class T>
- struct type : public mpl::bool_<std::numeric_limits<T>::digits >= b>{};
-};
-
-template <class Val, class Backend, class Tag>
-struct canonical_imp
-{
- typedef Val type;
-};
-template <class Val, class Backend>
-struct canonical_imp<Val, Backend, mpl::int_<0> >
-{
- typedef typename has_enough_bits<std::numeric_limits<Val>::digits>::template type<mpl::_> pred_type;
- typedef typename mpl::find_if<
- typename Backend::signed_types,
- pred_type
- >::type iter_type;
- typedef typename mpl::deref<iter_type>::type type;
-};
-template <class Val, class Backend>
-struct canonical_imp<Val, Backend, mpl::int_<1> >
-{
- typedef typename has_enough_bits<std::numeric_limits<Val>::digits>::template type<mpl::_> pred_type;
- typedef typename mpl::find_if<
- typename Backend::unsigned_types,
- pred_type
- >::type iter_type;
- typedef typename mpl::deref<iter_type>::type type;
-};
-template <class Val, class Backend>
-struct canonical_imp<Val, Backend, mpl::int_<2> >
-{
- typedef typename has_enough_bits<std::numeric_limits<Val>::digits>::template type<mpl::_> pred_type;
- typedef typename mpl::find_if<
- typename Backend::float_types,
- pred_type
- >::type iter_type;
- typedef typename mpl::deref<iter_type>::type type;
-};
-template <class Val, class Backend>
-struct canonical_imp<Val, Backend, mpl::int_<3> >
-{
- typedef const char* type;
-};
-
-template <class Val, class Backend>
-struct canonical
-{
- typedef typename mpl::if_<
- is_signed<Val>,
- mpl::int_<0>,
- typename mpl::if_<
- is_unsigned<Val>,
- mpl::int_<1>,
- typename mpl::if_<
- is_floating_point<Val>,
- mpl::int_<2>,
- typename mpl::if_<
- mpl::or_<
- is_convertible<Val, const char*>,
- is_same<Val, std::string>
- >,
- mpl::int_<3>,
- mpl::int_<4>
- >::type
- >::type
- >::type
- >::type tag_type;
-
- typedef typename canonical_imp<Val, Backend, tag_type>::type type;
-};
-
-struct terminal{};
-struct negate{};
-struct plus{};
-struct minus{};
-struct multiplies{};
-struct divides{};
-struct modulus{};
-struct shift_left{};
-struct shift_right{};
-struct bitwise_and{};
-struct bitwise_or{};
-struct bitwise_xor{};
-struct bitwise_complement{};
-struct add_immediates{};
-struct subtract_immediates{};
-struct multiply_immediates{};
-struct divide_immediates{};
-struct modulus_immediates{};
-struct bitwise_and_immediates{};
-struct bitwise_or_immediates{};
-struct bitwise_xor_immediates{};
-struct complement_immediates{};
-struct function{};
-
-template <class T>
-struct backend_type;
-
-template <class T, bool ExpressionTemplates>
-struct backend_type<mp_number<T, ExpressionTemplates> >
-{
- typedef T type;
-};
-
-template <class tag, class A1, class A2, class A3, class A4>
-struct backend_type<mp_exp<tag, A1, A2, A3, A4> >
-{
- typedef typename backend_type<typename mp_exp<tag, A1, A2, A3, A4>::result_type>::type type;
-};
-
-
-template <class T>
-struct is_mp_number : public mpl::false_{};
-template <class T, bool ExpressionTemplates>
-struct is_mp_number<boost::multiprecision::mp_number<T, ExpressionTemplates> > : public mpl::true_{};
-template <class T>
-struct is_mp_number_exp : public mpl::false_{};
-template <class Tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct is_mp_number_exp<boost::multiprecision::detail::mp_exp<Tag, Arg1, Arg2, Arg3, Arg4> > : public mpl::true_{};
-
-template <class T1, class T2>
-struct combine_expression;
-
-template <class T1, bool ExpressionTemplates, class T2>
-struct combine_expression<mp_number<T1, ExpressionTemplates>, T2>
-{
- typedef mp_number<T1, ExpressionTemplates> type;
-};
-
-template <class T1, class T2, bool ExpressionTemplates>
-struct combine_expression<T1, mp_number<T2, ExpressionTemplates> >
-{
- typedef mp_number<T2, ExpressionTemplates> type;
-};
-
-template <class T, bool ExpressionTemplates>
-struct combine_expression<mp_number<T, ExpressionTemplates>, mp_number<T, ExpressionTemplates> >
-{
- typedef mp_number<T, ExpressionTemplates> type;
-};
-
-template <class T>
-struct arg_type
-{
- typedef mp_exp<terminal, T> type;
-};
-
-template <class Tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct arg_type<mp_exp<Tag, Arg1, Arg2, Arg3, Arg4> >
-{
- typedef mp_exp<Tag, Arg1, Arg2, Arg3, Arg4> type;
-};
-
-template <class T>
-struct unmentionable
-{
- static void proc(){}
-};
-
-typedef void (*unmentionable_type)();
-
-template <class T>
-struct mp_exp_storage
-{
- typedef const T& type;
-};
-
-template <class T>
-struct mp_exp_storage<T*>
-{
- typedef T* type;
-};
-
-template <class T>
-struct mp_exp_storage<const T*>
-{
- typedef const T* type;
-};
-
-template <class tag, class A1, class A2, class A3, class A4>
-struct mp_exp_storage<mp_exp<tag, A1, A2, A3, A4> >
-{
- typedef mp_exp<tag, A1, A2, A3, A4> type;
-};
-
-template<class tag, class Arg1>
-struct mp_exp<tag, Arg1, void, void, void>
-{
- typedef mpl::int_<1> arity;
- typedef typename arg_type<Arg1>::type left_type;
- typedef typename left_type::result_type result_type;
- typedef tag tag_type;
-
- explicit mp_exp(const Arg1& a) : arg(a) {}
-
- left_type left()const { return left_type(arg); }
-
- const Arg1& left_ref()const BOOST_NOEXCEPT { return arg; }
-
- static const unsigned depth = left_type::depth + 1;
-
- operator unmentionable_type()const
- {
- result_type r(*this);
- return r ? &unmentionable<void>::proc : 0;
- }
-
-private:
- typename mp_exp_storage<Arg1>::type arg;
- mp_exp& operator=(const mp_exp&);
-};
-
-template<class Arg1>
-struct mp_exp<terminal, Arg1, void, void, void>
-{
- typedef mpl::int_<0> arity;
- typedef Arg1 result_type;
- typedef terminal tag_type;
-
- explicit mp_exp(const Arg1& a) : arg(a) {}
-
- const Arg1& value()const BOOST_NOEXCEPT { return arg; }
-
- static const unsigned depth = 0;
-
- operator unmentionable_type()const
- {
- return arg ? &unmentionable<void>::proc : 0;
- }
-
-private:
- typename mp_exp_storage<Arg1>::type arg;
- mp_exp& operator=(const mp_exp&);
-};
-
-template <class tag, class Arg1, class Arg2>
-struct mp_exp<tag, Arg1, Arg2, void, void>
-{
- typedef mpl::int_<2> arity;
- typedef typename arg_type<Arg1>::type left_type;
- typedef typename arg_type<Arg2>::type right_type;
- typedef typename left_type::result_type left_result_type;
- typedef typename right_type::result_type right_result_type;
- typedef typename combine_expression<left_result_type, right_result_type>::type result_type;
- typedef tag tag_type;
-
- mp_exp(const Arg1& a1, const Arg2& a2) : arg1(a1), arg2(a2) {}
-
- left_type left()const { return left_type(arg1); }
- right_type right()const { return right_type(arg2); }
- const Arg1& left_ref()const BOOST_NOEXCEPT { return arg1; }
- const Arg2& right_ref()const BOOST_NOEXCEPT { return arg2; }
-
- operator unmentionable_type()const
- {
- result_type r(*this);
- return r ? &unmentionable<void>::proc : 0;
- }
-
- static const unsigned left_depth = left_type::depth + 1;
- static const unsigned right_depth = right_type::depth + 1;
- static const unsigned depth = left_depth > right_depth ? left_depth : right_depth;
-private:
- typename mp_exp_storage<Arg1>::type arg1;
- typename mp_exp_storage<Arg2>::type arg2;
- mp_exp& operator=(const mp_exp&);
-};
-
-template <class tag, class Arg1, class Arg2, class Arg3>
-struct mp_exp<tag, Arg1, Arg2, Arg3, void>
-{
- typedef mpl::int_<3> arity;
- typedef typename arg_type<Arg1>::type left_type;
- typedef typename arg_type<Arg2>::type middle_type;
- typedef typename arg_type<Arg3>::type right_type;
- typedef typename left_type::result_type left_result_type;
- typedef typename middle_type::result_type middle_result_type;
- typedef typename right_type::result_type right_result_type;
- typedef typename combine_expression<
- left_result_type,
- typename combine_expression<right_result_type, middle_result_type>::type
- >::type result_type;
- typedef tag tag_type;
-
- mp_exp(const Arg1& a1, const Arg2& a2, const Arg3& a3) : arg1(a1), arg2(a2), arg3(a3) {}
-
- left_type left()const { return left_type(arg1); }
- middle_type middle()const { return middle_type(arg2); }
- right_type right()const { return right_type(arg3); }
- const Arg1& left_ref()const BOOST_NOEXCEPT { return arg1; }
- const Arg2& middle_ref()const BOOST_NOEXCEPT { return arg2; }
- const Arg3& right_ref()const BOOST_NOEXCEPT { return arg3; }
-
- operator unmentionable_type()const
- {
- result_type r(*this);
- return r ? &unmentionable<void>::proc : 0;
- }
-
- static const unsigned left_depth = left_type::depth + 1;
- static const unsigned middle_depth = middle_type::depth + 1;
- static const unsigned right_depth = right_type::depth + 1;
- static const unsigned depth = left_depth > right_depth ? (left_depth > middle_depth ? left_depth : middle_depth) : (right_depth > middle_depth ? right_depth : middle_depth);
-private:
- typename mp_exp_storage<Arg1>::type arg1;
- typename mp_exp_storage<Arg2>::type arg2;
- typename mp_exp_storage<Arg3>::type arg3;
- mp_exp& operator=(const mp_exp&);
-};
-
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct mp_exp
-{
- typedef mpl::int_<4> arity;
- typedef typename arg_type<Arg1>::type left_type;
- typedef typename arg_type<Arg2>::type left_middle_type;
- typedef typename arg_type<Arg3>::type right_middle_type;
- typedef typename arg_type<Arg4>::type right_type;
- typedef typename left_type::result_type left_result_type;
- typedef typename left_middle_type::result_type left_middle_result_type;
- typedef typename right_middle_type::result_type right_middle_result_type;
- typedef typename right_type::result_type right_result_type;
- typedef typename combine_expression<
- typename combine_expression<
- typename combine_expression<left_result_type, left_middle_result_type>::type,
- right_middle_result_type
- >::type,
- right_result_type
- >::type result_type;
- typedef tag tag_type;
-
- mp_exp(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) : arg1(a1), arg2(a2), arg3(a3), arg4(a4) {}
-
- left_type left()const { return left_type(arg1); }
- left_middle_type left_middle()const { return left_middle_type(arg2); }
- right_middle_type right_middle()const { return right_middle_type(arg3); }
- right_type right()const { return right_type(arg4); }
- const Arg1& left_ref()const BOOST_NOEXCEPT { return arg1; }
- const Arg2& left_middle_ref()const BOOST_NOEXCEPT { return arg2; }
- const Arg3& right_middle_ref()const BOOST_NOEXCEPT { return arg3; }
- const Arg4& right_ref()const BOOST_NOEXCEPT { return arg4; }
-
- operator unmentionable_type()const
- {
- result_type r(*this);
- return r ? &unmentionable<void>::proc : 0;
- }
-
- static const unsigned left_depth = left_type::depth + 1;
- static const unsigned left_middle_depth = left_middle_type::depth + 1;
- static const unsigned right_middle_depth = right_middle_type::depth + 1;
- static const unsigned right_depth = right_type::depth + 1;
-
- static const unsigned left_max_depth = left_depth > left_middle_depth ? left_depth : left_middle_depth;
- static const unsigned right_max_depth = right_depth > right_middle_depth ? right_depth : right_middle_depth;
-
- static const unsigned depth = left_max_depth > right_max_depth ? left_max_depth : right_max_depth;
-private:
- typename mp_exp_storage<Arg1>::type arg1;
- typename mp_exp_storage<Arg2>::type arg2;
- typename mp_exp_storage<Arg3>::type arg3;
- typename mp_exp_storage<Arg4>::type arg4;
- mp_exp& operator=(const mp_exp&);
-};
-
-template <class T>
-struct digits2
-{
- BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
- BOOST_STATIC_ASSERT((std::numeric_limits<T>::radix == 2) || (std::numeric_limits<T>::radix == 10));
- // If we really have so many digits that this fails, then we're probably going to hit other problems anyway:
- BOOST_STATIC_ASSERT(LONG_MAX / 1000 > (std::numeric_limits<T>::digits + 1));
- static const long value = std::numeric_limits<T>::radix == 10 ? (((std::numeric_limits<T>::digits + 1) * 1000L) / 301L) : std::numeric_limits<T>::digits;
-};
-
-#ifndef BOOST_MP_MIN_EXPONENT_DIGITS
-#ifdef _MSC_VER
-# define BOOST_MP_MIN_EXPONENT_DIGITS 2
-#else
-# define BOOST_MP_MIN_EXPONENT_DIGITS 2
-#endif
-#endif
-
-template <class S>
-void format_float_string(S& str, boost::intmax_t my_exp, boost::intmax_t digits, std::ios_base::fmtflags f, bool iszero)
-{
- typedef typename S::size_type size_type;
- bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
- bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed;
- bool showpoint = (f & std::ios_base::showpoint) == std::ios_base::showpoint;
- bool showpos = (f & std::ios_base::showpos) == std::ios_base::showpos;
-
- bool neg = str.size() && (str[0] == '-');
-
- if(neg)
- str.erase(0, 1);
-
- if(digits == 0)
- {
- digits = (std::max)(str.size(), size_type(16));
- }
-
- if(iszero || str.empty() || (str.find_first_not_of('0') == S::npos))
- {
- // We will be printing zero, even though the value might not
- // actually be zero (it just may have been rounded to zero).
- str = "0";
- if(scientific || fixed)
- {
- str.append(1, '.');
- str.append(size_type(digits), '0');
- if(scientific)
- str.append("e+00");
- }
- else
- {
- if(showpoint)
- {
- str.append(1, '.');
- if(digits > 1)
- str.append(size_type(digits - 1), '0');
- }
- }
- if(neg)
- str.insert(0, 1, '-');
- else if(showpos)
- str.insert(0, 1, '+');
- return;
- }
-
- if(!fixed && !scientific && !showpoint)
- {
- //
- // Suppress trailing zeros:
- //
- std::string::iterator pos = str.end();
- while(pos != str.begin() && *--pos == '0'){}
- if(pos != str.end())
- ++pos;
- str.erase(pos, str.end());
- if(str.empty())
- str = '0';
- }
- else if(!fixed || (my_exp >= 0))
- {
- //
- // Pad out the end with zero's if we need to:
- //
- boost::intmax_t chars = str.size();
- chars = digits - chars;
- if(scientific)
- ++chars;
- if(chars > 0)
- {
- str.append(static_cast<std::string::size_type>(chars), '0');
- }
- }
-
- if(fixed || (!scientific && (my_exp >= -4) && (my_exp < digits)))
- {
- if(1 + my_exp > static_cast<boost::intmax_t>(str.size()))
- {
- // Just pad out the end with zeros:
- str.append(static_cast<std::string::size_type>(1 + my_exp - str.size()), '0');
- if(showpoint || fixed)
- str.append(".");
- }
- else if(my_exp + 1 < static_cast<boost::intmax_t>(str.size()))
- {
- if(my_exp < 0)
- {
- str.insert(0, static_cast<std::string::size_type>(-1 - my_exp), '0');
- str.insert(0, "0.");
- }
- else
- {
- // Insert the decimal point:
- str.insert(static_cast<std::string::size_type>(my_exp + 1), 1, '.');
- }
- }
- else if(showpoint || fixed) // we have exactly the digits we require to left of the point
- str += ".";
-
- if(fixed)
- {
- // We may need to add trailing zeros:
- boost::intmax_t l = str.find('.') + 1;
- l = digits - (str.size() - l);
- if(l > 0)
- str.append(size_type(l), '0');
- }
- }
- else
- {
- BOOST_MP_USING_ABS
- // Scientific format:
- if(showpoint || (str.size() > 1))
- str.insert(1, 1, '.');
- str.append(1, 'e');
- S e = boost::lexical_cast<S>(abs(my_exp));
- if(e.size() < BOOST_MP_MIN_EXPONENT_DIGITS)
- e.insert(0, BOOST_MP_MIN_EXPONENT_DIGITS-e.size(), '0');
- if(my_exp < 0)
- e.insert(0, 1, '-');
- else
- e.insert(0, 1, '+');
- str.append(e);
- }
- if(neg)
- str.insert(0, 1, '-');
- else if(showpos)
- str.insert(0, 1, '+');
-}
-
-} // namespace detail
-
-//
-// Non-member operators for mp_number:
-//
-// Unary operators first:
-//
-template <class B, bool ExpressionTemplates>
-inline const mp_number<B, ExpressionTemplates>& operator + (const mp_number<B, ExpressionTemplates>& v) { return v; }
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& v) { return v; }
-template <class B>
-inline detail::mp_exp<detail::negate, mp_number<B, true> > operator - (const mp_number<B, true>& v) { return detail::mp_exp<detail::negate, mp_number<B, true> >(v); }
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::negate, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::mp_exp<detail::negate, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
-template <class B>
-inline detail::mp_exp<detail::complement_immediates, mp_number<B, true> > operator ~ (const mp_number<B, true>& v) { return detail::mp_exp<detail::complement_immediates, mp_number<B, true> >(v); }
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_complement, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > operator ~ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::mp_exp<detail::bitwise_complement, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
-//
-// Then addition:
-//
-template <class B>
-inline detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >
- operator + (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::add_immediates, mp_number<B, true>, V > >::type
- operator + (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::add_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::add_immediates, V, mp_number<B, true> > >::type
- operator + (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::add_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::plus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator + (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::plus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::plus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator + (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::plus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
-//
-template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
- operator + (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref());
-}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
- operator + (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref());
-}
-template <class B>
-inline detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >
- operator + (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref());
-}
-template <class B>
-inline detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >
- operator + (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(b, a.left_ref());
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> > >::type
- operator + (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
-{
- return detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> >(b, a.left_ref());
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> > >::type
- operator + (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref());
-}
-//
-// Subtraction:
-//
-template <class B>
-inline detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >
- operator - (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, V > >::type
- operator - (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> > >::type
- operator - (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::minus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator - (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::minus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::minus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator - (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::minus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
-//
-template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
- operator - (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref());
-}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator - (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
-}
-template <class B>
-inline detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >
- operator - (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref());
-}
-template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator - (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >(b, a.left_ref()));
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, V > > >::type
- operator - (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, V > >(detail::mp_exp<detail::add_immediates, mp_number<B, true>, V >(a.left_ref(), b));
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::add_immediates, V, mp_number<B, true> > >::type
- operator - (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::add_immediates, V, mp_number<B, true> >(a, b.left_ref());
-}
-//
-// Multiplication:
-//
-template <class B>
-inline detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >
- operator * (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > >::type
- operator * (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiply_immediates, V, mp_number<B, true> > >::type
- operator * (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::multiply_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::multiplies, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator * (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::multiplies, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator * (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator * (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator * (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiplies, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator * (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::multiplies, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
-//
-template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator * (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > (a, b.left_ref()));
-}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator * (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
-}
-template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator * (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref()));
-}
-template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator * (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >(b, a.left_ref()));
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > > >::type
- operator * (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > > (
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V >(a.left_ref(), b));
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > > >::type
- operator * (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > >(
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V >(b.left_ref(), a));
-}
-//
-// Division:
-//
-template <class B>
-inline detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >
- operator / (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V > >::type
- operator / (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> > >::type
- operator / (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::divides, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator / (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::divides, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator / (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator / (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator / (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divides, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator / (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::divides, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
-//
-template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator / (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::divides, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref()));
-}
-template <class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, mp_number<B, true> > >
- operator / (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, mp_number<B, true> > >(
- detail::mp_exp<detail::divides, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, mp_number<B, true> >(a.left_ref(), b));
-}
-template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator / (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref()));
-}
-template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator / (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >(a.left_ref(), b));
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V > > >::type
- operator / (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V > >(
- detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V>(a.left_ref(), b));
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> > > >::type
- operator / (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
-{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> > >(
- detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> >(a, b.left_ref()));
-}
-//
-// Modulus:
-//
-template <class B>
-inline detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, mp_number<B, true> >
- operator % (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, V > >::type
- operator % (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus_immediates, V, mp_number<B, true> > >::type
- operator % (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::modulus_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::modulus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator % (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::modulus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator % (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator % (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator % (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator % (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::modulus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Left shift:
-//
-template <class B, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_left, mp_number<B, true>, I > >::type
- operator << (const mp_number<B, true>& a, const I& b)
-{
- return detail::mp_exp<detail::shift_left, mp_number<B, true>, I>(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_left, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
- operator << (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
-{
- return detail::mp_exp<detail::shift_left, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
-}
-//
-// Right shift:
-//
-template <class B, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_right, mp_number<B, true>, I > >::type
- operator >> (const mp_number<B, true>& a, const I& b)
-{
- return detail::mp_exp<detail::shift_right, mp_number<B, true>, I>(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_right, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
- operator >> (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
-{
- return detail::mp_exp<detail::shift_right, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
-}
-//
-// Bitwise AND:
-//
-template <class B>
-inline detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, mp_number<B, true> >
- operator & (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, V > >::type
- operator & (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and_immediates, V, mp_number<B, true> > >::type
- operator & (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_and_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_and, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator & (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::bitwise_and, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator & (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator & (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator & (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator & (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::bitwise_and, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Bitwise OR:
-//
-template <class B>
-inline detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, mp_number<B, true> >
- operator| (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, V > >::type
- operator| (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or_immediates, V, mp_number<B, true> > >::type
- operator| (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_or_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_or, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator| (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::bitwise_or, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator| (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator| (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator| (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator| (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::bitwise_or, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-//
-// Bitwise XOR:
-//
-template <class B>
-inline detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, mp_number<B, true> >
- operator^ (const mp_number<B, true>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
-}
-template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, V > >::type
- operator^ (const mp_number<B, true>& a, const V& b)
-{
- return detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, V >(a, b);
-}
-template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor_immediates, V, mp_number<B, true> > >::type
- operator^ (const V& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_xor_immediates, V, mp_number<B, true> >(a, b);
-}
-template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_xor, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator^ (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::bitwise_xor, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator^ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
-{
- return detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(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::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator^ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
-{
- return detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
-}
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator^ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
-{
- return detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
-}
-template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator^ (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
-{
- return detail::mp_exp<detail::bitwise_xor, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
-}
-
-//
-// Traits class, lets us know what kind of number we have, defaults to a floating point type:
-//
-enum number_category_type
-{
- number_kind_integer = 0,
- number_kind_floating_point = 1,
- number_kind_rational = 2,
- number_kind_fixed_point = 3
-};
-
-template <class Num>
-struct number_category : public mpl::int_<number_kind_floating_point> {};
-template <class Backend, bool ExpressionTemplates>
-struct number_category<mp_number<Backend, ExpressionTemplates> > : public number_category<Backend>{};
-template <class tag, class A1, class A2, class A3, class A4>
-struct number_category<detail::mp_exp<tag, A1, A2, A3, A4> > : public number_category<typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type>{};
-
-template <class T>
-struct component_type;
-template <class T, bool ExpressionTemplates>
-struct component_type<mp_number<T, ExpressionTemplates> > : public component_type<T>{};
-template <class tag, class A1, class A2, class A3, class A4>
-struct component_type<detail::mp_exp<tag, A1, A2, A3, A4> > : public component_type<typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type>{};
-
-}} // namespaces
-
-namespace boost{ namespace math{ namespace tools{
-
-template <class T>
-struct promote_arg;
-
-template <class tag, class A1, class A2, class A3, class A4>
-struct promote_arg<boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4> >
-{
- typedef typename boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type type;
-};
-
-template <class R, class B, bool ET>
-inline R real_cast(const boost::multiprecision::mp_number<B, ET>& val)
-{
- return val.template convert_to<R>();
-}
-
-template <class R, class tag, class A1, class A2, class A3, class A4>
-inline R real_cast(const boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& val)
-{
- typedef typename boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type val_type;
- return val_type(val).template convert_to<R>();
-}
-
-
-}}}
-
-#endif // BOOST_MATH_BIG_NUM_BASE_HPP
-
-

Deleted: sandbox/big_number/boost/multiprecision/detail/mp_number_compare.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/detail/mp_number_compare.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
+++ (empty file)
@@ -1,482 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2012 John Maddock. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MP_COMPARE_HPP
-#define BOOST_MP_COMPARE_HPP
-
-//
-// Comparison operators for mp_number.
-//
-
-namespace boost{ namespace multiprecision{
-
-namespace default_ops{
-
-template <class B>
-inline bool eval_eq(const B& a, const B& b)
-{
- return a.compare(b) == 0;
-}
-template <class B, class A>
-inline bool eval_eq(const B& a, const A& b)
-{
- typedef typename mpl::if_<
- is_convertible<A, mp_number<B, false> >,
- mp_number<B, false>,
- mp_number<B, true>
- >::type mp_type;
- mp_type t(b);
- return eval_eq(a, t.backend());
-}
-
-template <class B>
-inline bool eval_lt(const B& a, const B& b)
-{
- return a.compare(b) < 0;
-}
-template <class B, class A>
-inline bool eval_lt(const B& a, const A& b)
-{
- typedef typename mpl::if_<
- is_convertible<A, mp_number<B, false> >,
- mp_number<B, false>,
- mp_number<B, true>
- >::type mp_type;
- mp_type t(b);
- return eval_lt(a, t.backend());
-}
-
-template <class B>
-inline bool eval_gt(const B& a, const B& b)
-{
- return a.compare(b) > 0;
-}
-template <class B, class A>
-inline bool eval_gt(const B& a, const A& b)
-{
- typedef typename mpl::if_<
- is_convertible<A, mp_number<B, false> >,
- mp_number<B, false>,
- mp_number<B, true>
- >::type mp_type;
- mp_type t(b);
- return eval_gt(a, t.backend());
-}
-
-}
-
-template <class Backend, bool ExpressionTemplates>
-inline bool operator == (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_eq;
- return eval_eq(a.backend(), b.backend());
-}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_eq;
- return eval_eq(a.backend(), ct(b));
-}
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator == (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
- return eval_eq(a.backend(), t.backend());
-}
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_eq;
- return eval_eq(b.backend(), ct(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_eq;
- result_type t(b);
- return eval_eq(t.backend(), ct(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator == (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- return eval_eq(t.backend(), b.backend());
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_eq;
- result_type t(a);
- return eval_eq(t.backend(), ct(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator == (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- return eval_eq(t.backend(), t2.backend());
-}
-
-template <class Backend, bool ExpressionTemplates>
-inline bool operator != (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_eq;
- return !eval_eq(a.backend(), b.backend());
-}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_eq;
- return !eval_eq(a.backend(), ct(b));
-}
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator != (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
- return !eval_eq(a.backend(), t.backend());
-}
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_eq;
- return !eval_eq(b.backend(), ct(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_eq;
- result_type t(b);
- return !eval_eq(t.backend(), ct(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator != (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- return !eval_eq(t.backend(), b.backend());
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_eq;
- result_type t(a);
- return !eval_eq(t.backend(), ct(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator != (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- return !eval_eq(t.backend(), t2.backend());
-}
-
-template <class Backend, bool ExpressionTemplates>
-inline bool operator < (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_lt;
- return eval_lt(a.backend(), b.backend());
-}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_lt;
- return eval_lt(a.backend(), ct(b));
-}
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator < (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
- return eval_lt(a.backend(), t.backend());
-}
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_gt;
- return eval_gt(b.backend(), ct(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_gt;
- result_type t(b);
- return eval_gt(t.backend(), ct(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator < (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- return eval_lt(t.backend(), b.backend());
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_lt;
- result_type t(a);
- return eval_lt(t.backend(), ct(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator < (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- return eval_lt(t.backend(), t2.backend());
-}
-
-template <class Backend, bool ExpressionTemplates>
-inline bool operator > (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_gt;
- return eval_gt(a.backend(), b.backend());
-}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_gt;
- return eval_gt(a.backend(), ct(b));
-}
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator > (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
- return eval_gt(a.backend(), t.backend());
-}
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_lt;
- return eval_lt(b.backend(), ct(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_lt;
- result_type t(b);
- return eval_lt(t.backend(), ct(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator > (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- return eval_gt(t.backend(), b.backend());
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_gt;
- result_type t(a);
- return eval_gt(t.backend(), ct(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator > (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- return eval_gt(t.backend(), t2.backend());
-}
-
-template <class Backend, bool ExpressionTemplates>
-inline bool operator <= (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_gt;
- return !eval_gt(a.backend(), b.backend());
-}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_gt;
- return !eval_gt(a.backend(), ct(b));
-}
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator <= (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
- return !eval_gt(a.backend(), t.backend());
-}
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_lt;
- return !eval_lt(b.backend(), ct(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_lt;
- result_type t(b);
- return !eval_lt(t.backend(), ct(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator <= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- return !eval_gt(t.backend(), b.backend());
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_gt;
- result_type t(a);
- return !eval_gt(t.backend(), ct(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator <= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- return !eval_gt(t.backend(), t2.backend());
-}
-
-template <class Backend, bool ExpressionTemplates>
-inline bool operator >= (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_lt;
- return !eval_lt(a.backend(), b.backend());
-}
-template <class Backend, bool ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_lt;
- return !eval_lt(a.backend(), ct(b));
-}
-template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator >= (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
- return !eval_lt(a.backend(), t.backend());
-}
-template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- typedef typename detail::canonical<Arithmetic, Backend>::type ct;
- using default_ops::eval_gt;
- return !eval_gt(b.backend(), ct(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_gt;
- result_type t(b);
- return !eval_gt(t.backend(), ct(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator >= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- return !eval_lt(t.backend(), b.backend());
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
- typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
- using default_ops::eval_lt;
- result_type t(a);
- return !eval_lt(t.backend(), ct(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator >= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- return !eval_lt(t.backend(), t2.backend());
-}
-
-
-}} // namespaces
-
-#endif // BOOST_MP_COMPARE_HPP
-

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -10,21 +10,21 @@
namespace multiprecision{

//
-// Operators for non-expression template enabled mp_number.
+// Operators for non-expression template enabled number.
// NOTE: this is not a complete header - really just a suffix to default_ops.hpp.
// NOTE: these operators have to be defined after the methods in default_ops.hpp.
//
template <class B>
-inline mp_number<B, false> operator - (const mp_number<B, false>& v)
+inline number<B, false> operator - (const number<B, false>& v)
{
- mp_number<B, false> result(v);
+ number<B, false> result(v);
 result.backend().negate();
 return BOOST_MP_MOVE(result);
}
template <class B>
-inline mp_number<B, false> operator ~ (const mp_number<B, false>& v)
+inline number<B, false> operator ~ (const number<B, false>& v)
{
- mp_number<B, false> result;
+ number<B, false> result;
 eval_complement(result.backend(), v.backend());
 return BOOST_MP_MOVE(result);
}
@@ -32,29 +32,29 @@
// Addition:
//
template <class B>
-inline mp_number<B, false> operator + (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator + (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator + (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator + (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_add;
 eval_add(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator + (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator + (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_add;
 eval_add(result.backend(), b.backend(), static_cast<canonical_type>(a));
 return BOOST_MP_MOVE(result);
@@ -63,29 +63,29 @@
// Subtraction:
//
template <class B>
-inline mp_number<B, false> operator - (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator - (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator - (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator - (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_subtract;
 eval_subtract(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator - (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator - (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_subtract;
 eval_subtract(result.backend(), static_cast<canonical_type>(a), b.backend());
 return BOOST_MP_MOVE(result);
@@ -94,29 +94,29 @@
// Multiply:
//
template <class B>
-inline mp_number<B, false> operator * (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator * (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator * (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator * (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_multiply;
 eval_multiply(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator * (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator * (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_multiply;
 eval_multiply(result.backend(), b.backend(), static_cast<canonical_type>(a));
 return BOOST_MP_MOVE(result);
@@ -125,29 +125,29 @@
// divide:
//
template <class B>
-inline mp_number<B, false> operator / (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator / (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator / (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator / (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_divide;
 eval_divide(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator / (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator / (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_divide;
 eval_divide(result.backend(), static_cast<canonical_type>(a), b.backend());
 return BOOST_MP_MOVE(result);
@@ -156,29 +156,29 @@
// modulus:
//
template <class B>
-inline mp_number<B, false> operator % (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator % (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator % (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator % (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_modulus;
 eval_modulus(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator % (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator % (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_modulus;
 eval_modulus(result.backend(), static_cast<canonical_type>(a), b.backend());
 return BOOST_MP_MOVE(result);
@@ -187,29 +187,29 @@
// Bitwise or:
//
template <class B>
-inline mp_number<B, false> operator | (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator | (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator | (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator | (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator | (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator | (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(result.backend(), b.backend(), static_cast<canonical_type>(a));
 return BOOST_MP_MOVE(result);
@@ -218,29 +218,29 @@
// Bitwise xor:
//
template <class B>
-inline mp_number<B, false> operator ^ (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator ^ (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator ^ (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator ^ (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator ^ (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator ^ (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(result.backend(), b.backend(), static_cast<canonical_type>(a));
 return BOOST_MP_MOVE(result);
@@ -249,29 +249,29 @@
// Bitwise and:
//
template <class B>
-inline mp_number<B, false> operator & (const mp_number<B, false>& a, const mp_number<B, false>& b)
+inline number<B, false> operator & (const number<B, false>& a, const number<B, false>& b)
{
- mp_number<B, false> result;
+ number<B, false> 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_arithmetic<V>, mp_number<B, false> >::type
- operator & (const mp_number<B, false>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator & (const number<B, false>& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(result.backend(), a.backend(), static_cast<canonical_type>(b));
 return BOOST_MP_MOVE(result);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator & (const V& a, const mp_number<B, false>& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator & (const V& a, const number<B, false>& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
- mp_number<B, false> result;
+ number<B, false> result;
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(result.backend(), b.backend(), static_cast<canonical_type>(a));
 return BOOST_MP_MOVE(result);
@@ -280,19 +280,19 @@
// shifts:
//
template <class B, class I>
-inline typename enable_if<is_integral, mp_number<B, false> >::type
- operator << (const mp_number<B, false>& a, const I& b)
+inline typename enable_if<is_integral, number<B, false> >::type
+ operator << (const number<B, false>& a, const I& b)
{
- mp_number<B, false> result(a);
+ number<B, false> result(a);
 using default_ops::eval_left_shift;
 eval_left_shift(result.backend(), b);
 return BOOST_MP_MOVE(result);
}
template <class B, class I>
-inline typename enable_if<is_integral, mp_number<B, false> >::type
- operator >> (const mp_number<B, false>& a, const I& b)
+inline typename enable_if<is_integral, number<B, false> >::type
+ operator >> (const number<B, false>& a, const I& b)
{
- mp_number<B, false> result(a);
+ number<B, false> result(a);
 using default_ops::eval_right_shift;
 eval_right_shift(result.backend(), b);
 return BOOST_MP_MOVE(result);
@@ -311,327 +311,327 @@
// semantics help a great deal in return by value, so performance is still pretty good...
//
template <class B>
-inline mp_number<B, false> operator - (mp_number<B, false>&& v)
+inline number<B, false> operator - (number<B, false>&& v)
{
 v.backend().negate();
- return static_cast<mp_number<B, false>&&>(v);
+ return static_cast<number<B, false>&&>(v);
}
template <class B>
-inline mp_number<B, false> operator ~ (mp_number<B, false>&& v)
+inline number<B, false> operator ~ (number<B, false>&& v)
{
 eval_complement(v.backend(), v.backend());
- return static_cast<mp_number<B, false>&&>(v);
+ return static_cast<number<B, false>&&>(v);
}
//
// Addition:
//
template <class B>
-inline mp_number<B, false> operator + (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator + (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_add;
 eval_add(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B>
-inline mp_number<B, false> operator + (const mp_number<B, false>& a, mp_number<B, false>&& b)
+inline number<B, false> operator + (const number<B, false>& a, number<B, false>&& b)
{
 using default_ops::eval_add;
 eval_add(b.backend(), a.backend());
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
template <class B>
-inline mp_number<B, false> operator + (mp_number<B, false>&& a, mp_number<B, false>&& b)
+inline number<B, false> operator + (number<B, false>&& a, number<B, false>&& b)
{
 using default_ops::eval_add;
 eval_add(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator + (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator + (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_add;
 eval_add(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator + (const V& a, mp_number<B, false>&& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator + (const V& a, number<B, false>&& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_add;
 eval_add(b.backend(), static_cast<canonical_type>(a));
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
//
// Subtraction:
//
template <class B>
-inline mp_number<B, false> operator - (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator - (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_subtract;
 eval_subtract(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B>
-inline mp_number<B, false> operator - (const mp_number<B, false>& a, mp_number<B, false>&& b)
+inline number<B, false> operator - (const number<B, false>& a, number<B, false>&& b)
{
 using default_ops::eval_subtract;
 eval_subtract(b.backend(), a.backend());
 b.backend().negate();
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
template <class B>
-inline mp_number<B, false> operator - (mp_number<B, false>&& a, mp_number<B, false>&& b)
+inline number<B, false> operator - (number<B, false>&& a, number<B, false>&& b)
{
 using default_ops::eval_subtract;
 eval_subtract(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator - (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator - (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_subtract;
 eval_subtract(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator - (const V& a, mp_number<B, false>&& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator - (const V& a, number<B, false>&& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_subtract;
 eval_subtract(b.backend(), static_cast<canonical_type>(a));
 b.backend().negate();
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
//
// Multiply:
//
template <class B>
-inline mp_number<B, false> operator * (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator * (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_multiply;
 eval_multiply(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B>
-inline mp_number<B, false> operator * (const mp_number<B, false>& a, mp_number<B, false>&& b)
+inline number<B, false> operator * (const number<B, false>& a, number<B, false>&& b)
{
 using default_ops::eval_multiply;
 eval_multiply(b.backend(), a.backend());
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
template <class B>
-inline mp_number<B, false> operator * (mp_number<B, false>&& a, mp_number<B, false>&& b)
+inline number<B, false> operator * (number<B, false>&& a, number<B, false>&& b)
{
 using default_ops::eval_multiply;
 eval_multiply(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator * (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator * (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_multiply;
 eval_multiply(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator * (const V& a, mp_number<B, false>&& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator * (const V& a, number<B, false>&& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_multiply;
 eval_multiply(b.backend(), static_cast<canonical_type>(a));
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
//
// divide:
//
template <class B>
-inline mp_number<B, false> operator / (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator / (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_divide;
 eval_divide(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator / (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator / (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_divide;
 eval_divide(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
//
// modulus:
//
template <class B>
-inline mp_number<B, false> operator % (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator % (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_modulus;
 eval_modulus(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator % (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator % (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_modulus;
 eval_modulus(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
//
// Bitwise or:
//
template <class B>
-inline mp_number<B, false> operator | (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator | (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B>
-inline mp_number<B, false> operator | (const mp_number<B, false>& a, mp_number<B, false>&& b)
+inline number<B, false> operator | (const number<B, false>& a, number<B, false>&& b)
{
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(b.backend(), a.backend());
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
template <class B>
-inline mp_number<B, false> operator | (mp_number<B, false>&& a, mp_number<B, false>&& b)
+inline number<B, false> operator | (number<B, false>&& a, number<B, false>&& b)
{
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator | (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator | (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator | (const V& a, mp_number<B, false>&& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator | (const V& a, number<B, false>&& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_bitwise_or;
 eval_bitwise_or(b.backend(), static_cast<canonical_type>(a));
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
//
// Bitwise xor:
//
template <class B>
-inline mp_number<B, false> operator ^ (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator ^ (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B>
-inline mp_number<B, false> operator ^ (const mp_number<B, false>& a, mp_number<B, false>&& b)
+inline number<B, false> operator ^ (const number<B, false>& a, number<B, false>&& b)
{
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(b.backend(), a.backend());
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
template <class B>
-inline mp_number<B, false> operator ^ (mp_number<B, false>&& a, mp_number<B, false>&& b)
+inline number<B, false> operator ^ (number<B, false>&& a, number<B, false>&& b)
{
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator ^ (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator ^ (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator ^ (const V& a, mp_number<B, false>&& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator ^ (const V& a, number<B, false>&& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_bitwise_xor;
 eval_bitwise_xor(b.backend(), static_cast<canonical_type>(a));
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
//
// Bitwise and:
//
template <class B>
-inline mp_number<B, false> operator & (mp_number<B, false>&& a, const mp_number<B, false>& b)
+inline number<B, false> operator & (number<B, false>&& a, const number<B, false>& b)
{
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B>
-inline mp_number<B, false> operator & (const mp_number<B, false>& a, mp_number<B, false>&& b)
+inline number<B, false> operator & (const number<B, false>& a, number<B, false>&& b)
{
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(b.backend(), a.backend());
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
template <class B>
-inline mp_number<B, false> operator & (mp_number<B, false>&& a, mp_number<B, false>&& b)
+inline number<B, false> operator & (number<B, false>&& a, number<B, false>&& b)
{
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(a.backend(), b.backend());
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator & (mp_number<B, false>&& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator & (number<B, false>&& a, const V& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(a.backend(), static_cast<canonical_type>(b));
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, mp_number<B, false> >::type
- operator & (const V& a, mp_number<B, false>&& b)
+inline typename enable_if<is_arithmetic<V>, number<B, false> >::type
+ operator & (const V& a, number<B, false>&& b)
{
 typedef typename detail::canonical<V, B>::type canonical_type;
 using default_ops::eval_bitwise_and;
 eval_bitwise_and(b.backend(), static_cast<canonical_type>(a));
- return static_cast<mp_number<B, false>&&>(b);
+ return static_cast<number<B, false>&&>(b);
}
//
// shifts:
//
template <class B, class I>
-inline typename enable_if<is_integral, mp_number<B, false> >::type
- operator << (mp_number<B, false>&& a, const I& b)
+inline typename enable_if<is_integral, number<B, false> >::type
+ operator << (number<B, false>&& a, const I& b)
{
 using default_ops::eval_left_shift;
 eval_left_shift(a.backend(), b);
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}
template <class B, class I>
-inline typename enable_if<is_integral, mp_number<B, false> >::type
- operator >> (mp_number<B, false>&& a, const I& b)
+inline typename enable_if<is_integral, number<B, false> >::type
+ operator >> (number<B, false>&& a, const I& b)
{
 using default_ops::eval_right_shift;
 eval_right_shift(a.backend(), b);
- return static_cast<mp_number<B, false>&&>(a);
+ return static_cast<number<B, false>&&>(a);
}

#endif

Copied: sandbox/big_number/boost/multiprecision/detail/number_base.hpp (from r79925, /sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp)
==============================================================================
--- /sandbox/big_number/boost/multiprecision/detail/mp_number_base.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/number_base.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -14,19 +14,19 @@
namespace boost{ namespace multiprecision{

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

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

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

namespace detail{

// Forward-declare an expression wrapper
template<class tag, class Arg1 = void, class Arg2 = void, class Arg3 = void, class Arg4 = void>
-struct mp_exp;
+struct expression;

} // namespace detail

@@ -34,7 +34,7 @@
struct is_mp_number_expression : public mpl::false_ {};

template<class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct is_mp_number_expression<detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > : public mpl::true_ {};
+struct is_mp_number_expression<detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > : public mpl::true_ {};

namespace detail{
//
@@ -160,58 +160,58 @@
struct backend_type;

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

template <class tag, class A1, class A2, class A3, class A4>
-struct backend_type<mp_exp<tag, A1, A2, A3, A4> >
+struct backend_type<expression<tag, A1, A2, A3, A4> >
{
- typedef typename backend_type<typename mp_exp<tag, A1, A2, A3, A4>::result_type>::type type;
+ typedef typename backend_type<typename expression<tag, A1, A2, A3, A4>::result_type>::type type;
};

template <class T>
struct is_mp_number : public mpl::false_{};
template <class T, bool ExpressionTemplates>
-struct is_mp_number<boost::multiprecision::mp_number<T, ExpressionTemplates> > : public mpl::true_{};
+struct is_mp_number<boost::multiprecision::number<T, ExpressionTemplates> > : public mpl::true_{};
template <class T>
struct is_mp_number_exp : public mpl::false_{};
template <class Tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct is_mp_number_exp<boost::multiprecision::detail::mp_exp<Tag, Arg1, Arg2, Arg3, Arg4> > : public mpl::true_{};
+struct is_mp_number_exp<boost::multiprecision::detail::expression<Tag, Arg1, Arg2, Arg3, Arg4> > : public mpl::true_{};

template <class T1, class T2>
struct combine_expression;

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

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

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

template <class T>
struct arg_type
{
- typedef mp_exp<terminal, T> type;
+ typedef expression<terminal, T> type;
};

template <class Tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct arg_type<mp_exp<Tag, Arg1, Arg2, Arg3, Arg4> >
+struct arg_type<expression<Tag, Arg1, Arg2, Arg3, Arg4> >
{
- typedef mp_exp<Tag, Arg1, Arg2, Arg3, Arg4> type;
+ typedef expression<Tag, Arg1, Arg2, Arg3, Arg4> type;
};

template <class T>
@@ -223,38 +223,38 @@
typedef void (*unmentionable_type)();

template <class T>
-struct mp_exp_storage
+struct expression_storage
{
 typedef const T& type;
};

template <class T>
-struct mp_exp_storage<T*>
+struct expression_storage<T*>
{
 typedef T* type;
};

template <class T>
-struct mp_exp_storage<const T*>
+struct expression_storage<const T*>
{
 typedef const T* type;
};

template <class tag, class A1, class A2, class A3, class A4>
-struct mp_exp_storage<mp_exp<tag, A1, A2, A3, A4> >
+struct expression_storage<expression<tag, A1, A2, A3, A4> >
{
- typedef mp_exp<tag, A1, A2, A3, A4> type;
+ typedef expression<tag, A1, A2, A3, A4> type;
};

template<class tag, class Arg1>
-struct mp_exp<tag, Arg1, void, void, void>
+struct expression<tag, Arg1, void, void, void>
{
 typedef mpl::int_<1> arity;
 typedef typename arg_type<Arg1>::type left_type;
 typedef typename left_type::result_type result_type;
 typedef tag tag_type;

- explicit mp_exp(const Arg1& a) : arg(a) {}
+ explicit expression(const Arg1& a) : arg(a) {}

 left_type left()const { return left_type(arg); }

@@ -269,18 +269,18 @@
 }

private:
- typename mp_exp_storage<Arg1>::type arg;
- mp_exp& operator=(const mp_exp&);
+ typename expression_storage<Arg1>::type arg;
+ expression& operator=(const expression&);
};

template<class Arg1>
-struct mp_exp<terminal, Arg1, void, void, void>
+struct expression<terminal, Arg1, void, void, void>
{
 typedef mpl::int_<0> arity;
 typedef Arg1 result_type;
 typedef terminal tag_type;

- explicit mp_exp(const Arg1& a) : arg(a) {}
+ explicit expression(const Arg1& a) : arg(a) {}

 const Arg1& value()const BOOST_NOEXCEPT { return arg; }

@@ -292,12 +292,12 @@
 }

private:
- typename mp_exp_storage<Arg1>::type arg;
- mp_exp& operator=(const mp_exp&);
+ typename expression_storage<Arg1>::type arg;
+ expression& operator=(const expression&);
};

template <class tag, class Arg1, class Arg2>
-struct mp_exp<tag, Arg1, Arg2, void, void>
+struct expression<tag, Arg1, Arg2, void, void>
{
 typedef mpl::int_<2> arity;
 typedef typename arg_type<Arg1>::type left_type;
@@ -307,7 +307,7 @@
 typedef typename combine_expression<left_result_type, right_result_type>::type result_type;
 typedef tag tag_type;

- mp_exp(const Arg1& a1, const Arg2& a2) : arg1(a1), arg2(a2) {}
+ expression(const Arg1& a1, const Arg2& a2) : arg1(a1), arg2(a2) {}

 left_type left()const { return left_type(arg1); }
 right_type right()const { return right_type(arg2); }
@@ -324,13 +324,13 @@
 static const unsigned right_depth = right_type::depth + 1;
 static const unsigned depth = left_depth > right_depth ? left_depth : right_depth;
private:
- typename mp_exp_storage<Arg1>::type arg1;
- typename mp_exp_storage<Arg2>::type arg2;
- mp_exp& operator=(const mp_exp&);
+ typename expression_storage<Arg1>::type arg1;
+ typename expression_storage<Arg2>::type arg2;
+ expression& operator=(const expression&);
};

template <class tag, class Arg1, class Arg2, class Arg3>
-struct mp_exp<tag, Arg1, Arg2, Arg3, void>
+struct expression<tag, Arg1, Arg2, Arg3, void>
{
 typedef mpl::int_<3> arity;
 typedef typename arg_type<Arg1>::type left_type;
@@ -345,7 +345,7 @@
>::type result_type;
 typedef tag tag_type;

- mp_exp(const Arg1& a1, const Arg2& a2, const Arg3& a3) : arg1(a1), arg2(a2), arg3(a3) {}
+ expression(const Arg1& a1, const Arg2& a2, const Arg3& a3) : arg1(a1), arg2(a2), arg3(a3) {}

 left_type left()const { return left_type(arg1); }
 middle_type middle()const { return middle_type(arg2); }
@@ -365,14 +365,14 @@
 static const unsigned right_depth = right_type::depth + 1;
 static const unsigned depth = left_depth > right_depth ? (left_depth > middle_depth ? left_depth : middle_depth) : (right_depth > middle_depth ? right_depth : middle_depth);
private:
- typename mp_exp_storage<Arg1>::type arg1;
- typename mp_exp_storage<Arg2>::type arg2;
- typename mp_exp_storage<Arg3>::type arg3;
- mp_exp& operator=(const mp_exp&);
+ typename expression_storage<Arg1>::type arg1;
+ typename expression_storage<Arg2>::type arg2;
+ typename expression_storage<Arg3>::type arg3;
+ expression& operator=(const expression&);
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct mp_exp
+struct expression
{
 typedef mpl::int_<4> arity;
 typedef typename arg_type<Arg1>::type left_type;
@@ -392,7 +392,7 @@
>::type result_type;
 typedef tag tag_type;

- mp_exp(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) : arg1(a1), arg2(a2), arg3(a3), arg4(a4) {}
+ expression(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) : arg1(a1), arg2(a2), arg3(a3), arg4(a4) {}

 left_type left()const { return left_type(arg1); }
 left_middle_type left_middle()const { return left_middle_type(arg2); }
@@ -419,11 +419,11 @@

 static const unsigned depth = left_max_depth > right_max_depth ? left_max_depth : right_max_depth;
private:
- typename mp_exp_storage<Arg1>::type arg1;
- typename mp_exp_storage<Arg2>::type arg2;
- typename mp_exp_storage<Arg3>::type arg3;
- typename mp_exp_storage<Arg4>::type arg4;
- mp_exp& operator=(const mp_exp&);
+ typename expression_storage<Arg1>::type arg1;
+ typename expression_storage<Arg2>::type arg2;
+ typename expression_storage<Arg3>::type arg3;
+ typename expression_storage<Arg4>::type arg4;
+ expression& operator=(const expression&);
};

template <class T>
@@ -578,629 +578,629 @@
} // namespace detail

//
-// Non-member operators for mp_number:
+// Non-member operators for number:
//
// Unary operators first:
//
template <class B, bool ExpressionTemplates>
-inline const mp_number<B, ExpressionTemplates>& operator + (const mp_number<B, ExpressionTemplates>& v) { return v; }
+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::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& v) { return v; }
+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::mp_exp<detail::negate, mp_number<B, true> > operator - (const mp_number<B, true>& v) { return detail::mp_exp<detail::negate, mp_number<B, true> >(v); }
+inline detail::expression<detail::negate, number<B, true> > operator - (const number<B, true>& v) { return detail::expression<detail::negate, number<B, true> >(v); }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::negate, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::mp_exp<detail::negate, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
+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::mp_exp<detail::complement_immediates, mp_number<B, true> > operator ~ (const mp_number<B, true>& v) { return detail::mp_exp<detail::complement_immediates, mp_number<B, true> >(v); }
+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); }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_complement, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > operator ~ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::mp_exp<detail::bitwise_complement, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
+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::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >
- operator + (const mp_number<B, true>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::add_immediates, number<B, true>, number<B, true> >
+ operator + (const number<B, true>& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::add_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::add_immediates, mp_number<B, true>, V > >::type
- operator + (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::add_immediates, number<B, true>, V > >::type
+ operator + (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::add_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::add_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::add_immediates, V, mp_number<B, true> > >::type
- operator + (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::add_immediates, V, number<B, true> > >::type
+ operator + (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::add_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::add_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::plus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator + (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::plus, 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)
{
- return detail::mp_exp<detail::plus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::plus, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::plus, 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)
{
- return detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator + (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator + (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator + (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::plus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::plus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator + (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator + (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::plus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
- operator + (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::minus, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
+ operator + (const number<B, true>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref());
+ return detail::expression<detail::minus, number<B, true>, 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>
-inline detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
- operator + (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::minus, number<B, true>, 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, true>& b)
{
- return detail::mp_exp<detail::minus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref());
+ return detail::expression<detail::minus, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref());
}
template <class B>
-inline detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >
- operator + (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& 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)
{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(a, b.left_ref());
}
template <class B>
-inline detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >
- operator + (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(b, a.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(b, a.left_ref());
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> > >::type
- operator + (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::subtract_immediates, V, number<B, true> > >::type
+ operator + (const detail::expression<detail::negate, number<B, true> >& a, const V& b)
{
- return detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> >(b, a.left_ref());
+ return detail::expression<detail::subtract_immediates, V, number<B, true> >(b, a.left_ref());
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> > >::type
- operator + (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::subtract_immediates, V, number<B, true> > >::type
+ operator + (const V& a, const detail::expression<detail::negate, number<B, true> >& b)
{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(a, b.left_ref());
}
//
// Subtraction:
//
template <class B>
-inline detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >
- operator - (const mp_number<B, true>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >
+ operator - (const number<B, true>& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::subtract_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, V > >::type
- operator - (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::subtract_immediates, number<B, true>, V > >::type
+ operator - (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::subtract_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::subtract_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> > >::type
- operator - (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::subtract_immediates, V, number<B, true> > >::type
+ operator - (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::subtract_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::subtract_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::minus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator - (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::minus, 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)
{
- return detail::mp_exp<detail::minus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::minus, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::minus, 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)
{
- return detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator - (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator - (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator - (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::minus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::minus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator - (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator - (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::minus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
- operator - (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::plus, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >
+ operator - (const number<B, true>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref());
+ return detail::expression<detail::plus, number<B, true>, 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>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator - (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::negate, detail::expression<detail::plus, number<B, true>, 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, true>& b)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::plus, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::plus, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
+ detail::expression<detail::plus, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
}
template <class B>
-inline detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >
- operator - (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& 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)
{
- return detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::add_immediates, number<B, true>, number<B, true> >(a, b.left_ref());
}
template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator - (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::add_immediates, mp_number<B, true>, mp_number<B, true> >(b, a.left_ref()));
+ 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()));
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, V > > >::type
- operator - (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::add_immediates, mp_number<B, true>, V > >(detail::mp_exp<detail::add_immediates, mp_number<B, true>, V >(a.left_ref(), 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));
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::add_immediates, V, mp_number<B, true> > >::type
- operator - (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::add_immediates, V, number<B, true> > >::type
+ operator - (const V& a, const detail::expression<detail::negate, number<B, true> >& b)
{
- return detail::mp_exp<detail::add_immediates, V, mp_number<B, true> >(a, b.left_ref());
+ return detail::expression<detail::add_immediates, V, number<B, true> >(a, b.left_ref());
}
//
// Multiplication:
//
template <class B>
-inline detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >
- operator * (const mp_number<B, true>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> >
+ operator * (const number<B, true>& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::multiply_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > >::type
- operator * (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::multiply_immediates, number<B, true>, V > >::type
+ operator * (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::multiply_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiply_immediates, V, mp_number<B, true> > >::type
- operator * (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::multiply_immediates, V, number<B, true> > >::type
+ operator * (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::multiply_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::multiply_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::multiplies, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator * (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::multiplies, 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)
{
- return detail::mp_exp<detail::multiplies, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::multiplies, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator * (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::multiplies, 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)
{
- return detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator * (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator * (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator * (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator * (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::multiplies, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::multiplies, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator * (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator * (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::multiplies, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator * (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
+ operator * (const number<B, true>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > (a, b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
+ detail::expression<detail::multiplies, number<B, true>, 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>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator * (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, true>, 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, true>& b)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::multiplies, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
+ detail::expression<detail::multiplies, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(b, a.left_ref()));
}
template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator * (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref()));
+ 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()));
}
template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator * (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, mp_number<B, true> >(b, a.left_ref()));
+ 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()));
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > > >::type
- operator * (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > > (
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V >(a.left_ref(), 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));
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > > >::type
- operator * (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
+inline typename enable_if<is_arithmetic<V>, 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V > >(
- detail::mp_exp<detail::multiply_immediates, mp_number<B, true>, V >(b.left_ref(), a));
+ 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));
}
//
// Division:
//
template <class B>
-inline detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >
- operator / (const mp_number<B, true>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::divide_immediates, number<B, true>, number<B, true> >
+ operator / (const number<B, true>& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::divide_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V > >::type
- operator / (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::divide_immediates, number<B, true>, V > >::type
+ operator / (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::divide_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> > >::type
- operator / (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::divide_immediates, V, number<B, true> > >::type
+ operator / (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::divide_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::divides, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator / (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::divides, 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)
{
- return detail::mp_exp<detail::divides, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::divides, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator / (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::divides, 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)
{
- return detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator / (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator / (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator / (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator / (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::divides, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::divides, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator / (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator / (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::divides, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
- operator / (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
+inline detail::expression<detail::negate, detail::expression<detail::divides, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >
+ operator / (const number<B, true>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
- detail::mp_exp<detail::divides, mp_number<B, true>, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type >(a, b.left_ref()));
+ return detail::expression<detail::negate, detail::expression<detail::divides, number<B, true>, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type > >(
+ detail::expression<detail::divides, number<B, true>, 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>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, mp_number<B, true> > >
- operator / (const detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::negate, detail::expression<detail::divides, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, number<B, true> > >
+ operator / (const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divides, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, mp_number<B, true> > >(
- detail::mp_exp<detail::divides, typename detail::mp_exp<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, mp_number<B, true> >(a.left_ref(), b));
+ return detail::expression<detail::negate, detail::expression<detail::divides, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, number<B, true> > >(
+ detail::expression<detail::divides, typename detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>::left_type, number<B, true> >(a.left_ref(), b));
}
template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator / (const mp_number<B, true>& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >(a, b.left_ref()));
+ 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()));
}
template <class B>
-inline detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >
- operator / (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> > >(
- detail::mp_exp<detail::divide_immediates, mp_number<B, true>, mp_number<B, true> >(a.left_ref(), 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));
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V > > >::type
- operator / (const detail::mp_exp<detail::negate, mp_number<B, true> >& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V > >(
- detail::mp_exp<detail::divide_immediates, mp_number<B, true>, V>(a.left_ref(), 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));
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> > > >::type
- operator / (const V& a, const detail::mp_exp<detail::negate, mp_number<B, true> >& b)
+inline typename enable_if<is_arithmetic<V>, 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)
{
- return detail::mp_exp<detail::negate, detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> > >(
- detail::mp_exp<detail::divide_immediates, V, mp_number<B, true> >(a, b.left_ref()));
+ 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()));
}
//
// Modulus:
//
template <class B>
-inline detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, mp_number<B, true> >
- operator % (const mp_number<B, true>& a, const mp_number<B, true>& b)
+inline detail::expression<detail::modulus_immediates, number<B, true>, number<B, true> >
+ operator % (const number<B, true>& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::modulus_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, V > >::type
- operator % (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::modulus_immediates, number<B, true>, V > >::type
+ operator % (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::modulus_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::modulus_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus_immediates, V, mp_number<B, true> > >::type
- operator % (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::modulus_immediates, V, number<B, true> > >::type
+ operator % (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::modulus_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::modulus_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::modulus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator % (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+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)
{
- return detail::mp_exp<detail::modulus, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::modulus, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator % (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator % (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator % (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator % (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator % (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::modulus, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::modulus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator % (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator % (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::modulus, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Left shift:
//
template <class B, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_left, mp_number<B, true>, I > >::type
- operator << (const mp_number<B, true>& a, const I& b)
+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)
{
- return detail::mp_exp<detail::shift_left, mp_number<B, true>, I>(a, b);
+ return detail::expression<detail::shift_left, number<B, true>, I>(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_left, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
- operator << (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
+inline typename enable_if<is_integral, detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
+ operator << (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
{
- return detail::mp_exp<detail::shift_left, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
+ return detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
}
//
// Right shift:
//
template <class B, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_right, mp_number<B, true>, I > >::type
- operator >> (const mp_number<B, true>& a, const I& b)
+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)
{
- return detail::mp_exp<detail::shift_right, mp_number<B, true>, I>(a, b);
+ return detail::expression<detail::shift_right, number<B, true>, I>(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
-inline typename enable_if<is_integral, detail::mp_exp<detail::shift_right, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
- operator >> (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
+inline typename enable_if<is_integral, detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
+ operator >> (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
{
- return detail::mp_exp<detail::shift_right, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
+ return detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
}
//
// Bitwise AND:
//
template <class B>
-inline detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, mp_number<B, true> >
- operator & (const mp_number<B, true>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_and_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, V > >::type
- operator & (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_and_immediates, number<B, true>, V > >::type
+ operator & (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::bitwise_and_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::bitwise_and_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and_immediates, V, mp_number<B, true> > >::type
- operator & (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_and_immediates, V, number<B, true> > >::type
+ operator & (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::bitwise_and_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_and_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_and, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator & (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+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)
{
- return detail::mp_exp<detail::bitwise_and, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_and, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator & (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator & (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator & (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator & (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator & (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::bitwise_and, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_and, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator & (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator & (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::bitwise_and, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Bitwise OR:
//
template <class B>
-inline detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, mp_number<B, true> >
- operator| (const mp_number<B, true>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_or_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, V > >::type
- operator| (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_or_immediates, number<B, true>, V > >::type
+ operator| (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::bitwise_or_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::bitwise_or_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or_immediates, V, mp_number<B, true> > >::type
- operator| (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_or_immediates, V, number<B, true> > >::type
+ operator| (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::bitwise_or_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_or_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_or, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator| (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+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)
{
- return detail::mp_exp<detail::bitwise_or, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_or, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator| (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator| (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator| (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator| (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator| (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::bitwise_or, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_or, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator| (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator| (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::bitwise_or, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Bitwise XOR:
//
template <class B>
-inline detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, mp_number<B, true> >
- operator^ (const mp_number<B, true>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_xor_immediates, number<B, true>, number<B, true> >(a, b);
}
template <class B, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, V > >::type
- operator^ (const mp_number<B, true>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_xor_immediates, number<B, true>, V > >::type
+ operator^ (const number<B, true>& a, const V& b)
{
- return detail::mp_exp<detail::bitwise_xor_immediates, mp_number<B, true>, V >(a, b);
+ return detail::expression<detail::bitwise_xor_immediates, number<B, true>, V >(a, b);
}
template <class V, class B>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor_immediates, V, mp_number<B, true> > >::type
- operator^ (const V& a, const mp_number<B, true>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_xor_immediates, V, number<B, true> > >::type
+ operator^ (const V& a, const number<B, true>& b)
{
- return detail::mp_exp<detail::bitwise_xor_immediates, V, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_xor_immediates, V, number<B, true> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline detail::mp_exp<detail::bitwise_xor, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >
- operator^ (const mp_number<B, true>& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+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)
{
- return detail::mp_exp<detail::bitwise_xor, mp_number<B, true>, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_xor, number<B, true>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
-inline detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >
- operator^ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const mp_number<B, true>& 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)
{
- return detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, mp_number<B, true> >(a, b);
+ return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, true> >(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::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
- operator^ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
+inline detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
+ operator^ (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
- return detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, detail::mp_exp<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
+ return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
- operator^ (const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V > >::type
+ operator^ (const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
- return detail::mp_exp<detail::bitwise_xor, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
+ return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V >(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-inline typename enable_if<is_arithmetic<V>, detail::mp_exp<detail::bitwise_xor, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> > >::type
- operator^ (const V& a, const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& b)
+inline typename enable_if<is_arithmetic<V>, detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
+ operator^ (const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
- return detail::mp_exp<detail::bitwise_xor, V, detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
+ return detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

//
@@ -1217,16 +1217,16 @@
template <class Num>
struct number_category : public mpl::int_<number_kind_floating_point> {};
template <class Backend, bool ExpressionTemplates>
-struct number_category<mp_number<Backend, ExpressionTemplates> > : public number_category<Backend>{};
+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::mp_exp<tag, A1, A2, A3, A4> > : public number_category<typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type>{};
+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>
-struct component_type<mp_number<T, ExpressionTemplates> > : public component_type<T>{};
+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::mp_exp<tag, A1, A2, A3, A4> > : public component_type<typename detail::mp_exp<tag, A1, A2, A3, A4>::result_type>{};
+struct component_type<detail::expression<tag, A1, A2, A3, A4> > : public component_type<typename detail::expression<tag, A1, A2, A3, A4>::result_type>{};

}} // namespaces

@@ -1236,21 +1236,21 @@
struct promote_arg;

template <class tag, class A1, class A2, class A3, class A4>
-struct promote_arg<boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4> >
+struct promote_arg<boost::multiprecision::detail::expression<tag, A1, A2, A3, A4> >
{
- typedef typename boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type type;
+ typedef typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type type;
};

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

template <class R, class tag, class A1, class A2, class A3, class A4>
-inline R real_cast(const boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>& val)
+inline R real_cast(const boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>& val)
{
- typedef typename boost::multiprecision::detail::mp_exp<tag, A1, A2, A3, A4>::result_type val_type;
+ typedef typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type val_type;
 return val_type(val).template convert_to<R>();
}

Copied: sandbox/big_number/boost/multiprecision/detail/number_compare.hpp (from r79925, /sandbox/big_number/boost/multiprecision/detail/mp_number_compare.hpp)
==============================================================================
--- /sandbox/big_number/boost/multiprecision/detail/mp_number_compare.hpp (original)
+++ sandbox/big_number/boost/multiprecision/detail/number_compare.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -7,7 +7,7 @@
#define BOOST_MP_COMPARE_HPP

//
-// Comparison operators for mp_number.
+// Comparison operators for number.
//

namespace boost{ namespace multiprecision{
@@ -23,9 +23,9 @@
inline bool eval_eq(const B& a, const A& b)
{
 typedef typename mpl::if_<
- is_convertible<A, mp_number<B, false> >,
- mp_number<B, false>,
- mp_number<B, true>
+ is_convertible<A, number<B, false> >,
+ number<B, false>,
+ number<B, true>
>::type mp_type;
 mp_type t(b);
 return eval_eq(a, t.backend());
@@ -40,9 +40,9 @@
inline bool eval_lt(const B& a, const A& b)
{
 typedef typename mpl::if_<
- is_convertible<A, mp_number<B, false> >,
- mp_number<B, false>,
- mp_number<B, true>
+ is_convertible<A, number<B, false> >,
+ number<B, false>,
+ number<B, true>
>::type mp_type;
 mp_type t(b);
 return eval_lt(a, t.backend());
@@ -57,9 +57,9 @@
inline bool eval_gt(const B& a, const A& b)
{
 typedef typename mpl::if_<
- is_convertible<A, mp_number<B, false> >,
- mp_number<B, false>,
- mp_number<B, true>
+ is_convertible<A, number<B, false> >,
+ number<B, false>,
+ number<B, true>
>::type mp_type;
 mp_type t(b);
 return eval_gt(a, t.backend());
@@ -68,410 +68,410 @@
}

template <class Backend, bool ExpressionTemplates>
-inline bool operator == (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator == (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_eq;
 return eval_eq(a.backend(), ct(b));
}
template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator == (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+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)
{
 using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(b);
 return eval_eq(a.backend(), t.backend());
}
template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator == (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_eq;
 return eval_eq(b.backend(), ct(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator == (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_eq;
 result_type t(b);
 return eval_eq(t.backend(), ct(a));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator == (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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)
{
 using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
 return eval_eq(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator == (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_eq;
 result_type t(a);
 return eval_eq(t.backend(), ct(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator == (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
+inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
+ operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
 using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
 return eval_eq(t.backend(), t2.backend());
}

template <class Backend, bool ExpressionTemplates>
-inline bool operator != (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator != (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_eq;
 return !eval_eq(a.backend(), ct(b));
}
template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator != (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+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)
{
 using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(b);
 return !eval_eq(a.backend(), t.backend());
}
template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator != (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_eq;
 return !eval_eq(b.backend(), ct(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator != (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_eq;
 result_type t(b);
 return !eval_eq(t.backend(), ct(a));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator != (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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)
{
 using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
 return !eval_eq(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator != (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_eq;
 result_type t(a);
 return !eval_eq(t.backend(), ct(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator != (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
+inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
+ operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
 using default_ops::eval_eq;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
 return !eval_eq(t.backend(), t2.backend());
}

template <class Backend, bool ExpressionTemplates>
-inline bool operator < (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator < (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_lt;
 return eval_lt(a.backend(), ct(b));
}
template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator < (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+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)
{
 using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(b);
 return eval_lt(a.backend(), t.backend());
}
template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator < (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_gt;
 return eval_gt(b.backend(), ct(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator < (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_gt;
 result_type t(b);
 return eval_gt(t.backend(), ct(a));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator < (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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)
{
 using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
 return eval_lt(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator < (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_lt;
 result_type t(a);
 return eval_lt(t.backend(), ct(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator < (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
+inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
+ operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
 using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
 return eval_lt(t.backend(), t2.backend());
}

template <class Backend, bool ExpressionTemplates>
-inline bool operator > (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator > (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_gt;
 return eval_gt(a.backend(), ct(b));
}
template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator > (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+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)
{
 using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(b);
 return eval_gt(a.backend(), t.backend());
}
template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator > (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_lt;
 return eval_lt(b.backend(), ct(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator > (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_lt;
 result_type t(b);
 return eval_lt(t.backend(), ct(a));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator > (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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)
{
 using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
 return eval_gt(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator > (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_gt;
 result_type t(a);
 return eval_gt(t.backend(), ct(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator > (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
+inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
+ operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
 using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
 return eval_gt(t.backend(), t2.backend());
}

template <class Backend, bool ExpressionTemplates>
-inline bool operator <= (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator <= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_gt;
 return !eval_gt(a.backend(), ct(b));
}
template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator <= (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+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)
{
 using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(b);
 return !eval_gt(a.backend(), t.backend());
}
template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator <= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_lt;
 return !eval_lt(b.backend(), ct(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator <= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_lt;
 result_type t(b);
 return !eval_lt(t.backend(), ct(a));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator <= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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)
{
 using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
 return !eval_gt(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator <= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_gt;
 result_type t(a);
 return !eval_gt(t.backend(), ct(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator <= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
+inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
+ operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
 using default_ops::eval_gt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
 return !eval_gt(t.backend(), t2.backend());
}

template <class Backend, bool ExpressionTemplates>
-inline bool operator >= (const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const mp_number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator >= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_lt;
 return !eval_lt(a.backend(), ct(b));
}
template <class Backend, bool ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator >= (const mp_number<Backend, ExpressionTemplates>& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+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)
{
 using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(b);
 return !eval_lt(a.backend(), t.backend());
}
template <class Arithmetic, class Backend, bool ExpressionTemplates>
-inline typename enable_if_c<(is_convertible<Arithmetic, mp_number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const Arithmetic& a, const mp_number<Backend, ExpressionTemplates>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, number<Backend, ExpressionTemplates> >::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator >= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
 typedef typename detail::canonical<Arithmetic, Backend>::type ct;
 using default_ops::eval_gt;
 return !eval_gt(b.backend(), ct(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const Arithmetic& a, const detail::mp_exp<Tag, A1, A2, A3, A4>& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator >= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_gt;
 result_type t(b);
 return !eval_gt(t.backend(), ct(a));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline typename enable_if<is_same<mp_number<Backend, ExpressionTemplates>, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>, bool>::type
- operator >= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
+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)
{
 using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
 return !eval_lt(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
- operator >= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
+inline typename enable_if_c<(is_convertible<Arithmetic, typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value && !is_mp_number_expression<Arithmetic>::value && !is_mp_number<Arithmetic>::value), bool>::type
+ operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
- typedef typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type result_type;
+ typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
 typedef typename detail::canonical<Arithmetic, typename result_type::backend_type>::type ct;
 using default_ops::eval_lt;
 result_type t(a);
 return !eval_lt(t.backend(), ct(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type, typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator >= (const detail::mp_exp<Tag, A1, A2, A3, A4>& a, const detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>& b)
+inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
+ operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
 using default_ops::eval_lt;
- typename detail::mp_exp<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::mp_exp<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
+ typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
+ typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
 return !eval_lt(t.backend(), t2.backend());
}

Modified: sandbox/big_number/boost/multiprecision/gmp.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/gmp.hpp (original)
+++ sandbox/big_number/boost/multiprecision/gmp.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -6,7 +6,7 @@
#ifndef BOOST_MATH_ER_GMP_BACKEND_HPP
#define BOOST_MATH_ER_GMP_BACKEND_HPP

-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>
#include <boost/multiprecision/detail/big_lanczos.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
@@ -1870,15 +1870,15 @@
{
 return mpq_sgn(val.data()) == 0;
}
-inline mp_number<gmp_int> numerator(const mp_number<gmp_rational>& val)
+inline number<gmp_int> numerator(const number<gmp_rational>& val)
{
- mp_number<gmp_int> result;
+ number<gmp_int> result;
 mpz_set(result.backend().data(), (mpq_numref(val.backend().data())));
 return result;
}
-inline mp_number<gmp_int> denominator(const mp_number<gmp_rational>& val)
+inline number<gmp_int> denominator(const number<gmp_rational>& val)
{
- mp_number<gmp_int> result;
+ number<gmp_int> result;
 mpz_set(result.backend().data(), (mpq_denref(val.backend().data())));
 return result;
}
@@ -2072,9 +2072,9 @@
using boost::multiprecision::backends::gmp_float;

template <>
-struct component_type<mp_number<gmp_rational> >
+struct component_type<number<gmp_rational> >
{
- typedef mp_number<gmp_int> type;
+ typedef number<gmp_int> type;
};

template<>
@@ -2082,13 +2082,13 @@
template<>
struct number_category<gmp_rational> : public mpl::int_<number_kind_rational>{};

-typedef mp_number<gmp_float<50> > mpf_float_50;
-typedef mp_number<gmp_float<100> > mpf_float_100;
-typedef mp_number<gmp_float<500> > mpf_float_500;
-typedef mp_number<gmp_float<1000> > mpf_float_1000;
-typedef mp_number<gmp_float<0> > mpf_float;
-typedef mp_number<gmp_int > mpz_int;
-typedef mp_number<gmp_rational > mpq_rational;
+typedef number<gmp_float<50> > mpf_float_50;
+typedef number<gmp_float<100> > mpf_float_100;
+typedef number<gmp_float<500> > mpf_float_500;
+typedef number<gmp_float<1000> > mpf_float_1000;
+typedef number<gmp_float<0> > mpf_float;
+typedef number<gmp_int > mpz_int;
+typedef number<gmp_rational > mpq_rational;

}} // namespaces

@@ -2098,9 +2098,9 @@
// numeric_limits [partial] specializations for the types declared in this header:
//
template<unsigned Digits10, bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
 //
@@ -2195,10 +2195,10 @@
 {
 data_initializer()
 {
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<digits10> > >::epsilon();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<digits10> > >::round_error();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<digits10> > >::min)();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<digits10> > >::max)();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<digits10> > >::epsilon();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<digits10> > >::round_error();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<digits10> > >::min)();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<digits10> > >::max)();
 }
 void do_nothing()const{}
 };
@@ -2206,12 +2206,12 @@
};

template<unsigned Digits10, bool ExpressionTemplates>
-const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::initializer;
+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>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = false;
 static number_type (min)() BOOST_NOEXCEPT { return number_type(); }
@@ -2250,56 +2250,56 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

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

#endif

template<bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_int, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_int, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
 //
@@ -2348,56 +2348,56 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

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

#endif

template<bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
 //
@@ -2447,49 +2447,49 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_digits10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_digits10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_signed;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_signed;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_integer;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_integer;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_exact;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_exact;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::radix;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::radix;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_infinity;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_infinity;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_quiet_NaN;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_quiet_NaN;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_signaling_NaN;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_signaling_NaN;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm;
+BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm_loss;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm_loss;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_iec559;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_iec559;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_bounded;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_bounded;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_modulo;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_modulo;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::traps;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::traps;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::tinyness_before;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::tinyness_before;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::round_style;
+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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -12,7 +12,7 @@
namespace multiprecision{

template <class Backend, bool ExpressionTemplates>
-bool check_small_factors(const mp_number<Backend, ExpressionTemplates>& n)
+bool check_small_factors(const number<Backend, ExpressionTemplates>& n)
{
 static const boost::uint32_t small_factors1[] = {
 3u, 5u, 7u, 11u, 13u, 17u, 19u, 23u };
@@ -119,13 +119,13 @@

template <class Backend, bool ExpressionTemplates, class Engine>
typename enable_if_c<number_category<Backend>::value == number_kind_integer, bool>::type
- miller_rabin_test(const mp_number<Backend, ExpressionTemplates>& n, unsigned trials, Engine& gen)
+ miller_rabin_test(const number<Backend, ExpressionTemplates>& n, unsigned trials, Engine& gen)
{
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4127)
#endif
- typedef mp_number<Backend, ExpressionTemplates> number_type;
+ typedef number<Backend, ExpressionTemplates> number_type;

 if(n <= 227)
 return is_small_prime(n.template convert_to<unsigned>());
@@ -179,23 +179,23 @@
}

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

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Engine>
-bool miller_rabin_test(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> & n, unsigned trials, Engine& gen)
+bool miller_rabin_test(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4> & n, unsigned trials, Engine& gen)
{
- typedef typename detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>::result_type number_type;
+ typedef typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type number_type;
 return miller_rabin_test(number_type(n), trials, gen);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-bool miller_rabin_test(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4> & n, unsigned trials)
+bool miller_rabin_test(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4> & n, unsigned trials)
{
- typedef typename detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>::result_type number_type;
+ typedef typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type number_type;
 return miller_rabin_test(number_type(n), trials);
}

Deleted: sandbox/big_number/boost/multiprecision/mp_number.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mp_number.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
+++ (empty file)
@@ -1,1694 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2011 John Maddock. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_EXTENDED_REAL_HPP
-#define BOOST_MATH_EXTENDED_REAL_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/mpl/max.hpp>
-#include <boost/mpl/plus.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/find_if.hpp>
-#include <boost/assert.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/multiprecision/detail/generic_interconvert.hpp>
-#include <boost/multiprecision/detail/mp_number_compare.hpp>
-#include <istream> // stream operators
-#include <cstdio> // EOF
-
-namespace boost{ namespace multiprecision{
-
-#ifdef BOOST_MSVC
-// warning C4127: conditional expression is constant
-// warning C4714: function marked as __forceinline not inlined
-#pragma warning(push)
-#pragma warning(disable:4127 4714)
-#endif
-
-template <class Backend, bool ExpressionTemplates>
-class mp_number
-{
- typedef mp_number<Backend, ExpressionTemplates> self_type;
-public:
- typedef Backend backend_type;
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number() BOOST_NOEXCEPT_IF(noexcept(Backend())) {}
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(e.m_backend){}
- template <class V>
- BOOST_FORCEINLINE mp_number(V v, typename enable_if_c<
- (boost::is_arithmetic<V>::value || is_same<std::string, V>::value || is_convertible<V, const char*>::value)
- && !is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value >::type* = 0)
- {
- m_backend = canonical_value(v);
- }
- template <class V>
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(V v, typename enable_if_c<
- (boost::is_arithmetic<V>::value || is_same<std::string, V>::value || is_convertible<V, const char*>::value)
- && is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value >::type* = 0)
- : m_backend(canonical_value(v)) {}
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number& e, unsigned digits10)
- : m_backend(e.m_backend, digits10){}
- /*
- //
- // This conflicts with component based initialization (for rational and complex types)
- // which is arguably more useful. Disabled for now.
- //
- template <class V>
- mp_number(V v, unsigned digits10, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* dummy1 = 0)
- {
- m_backend.precision(digits10);
- m_backend = canonical_value(v);
- }
- */
- template<bool ET>
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number<Backend, ET>& val) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(val.m_backend) {}
-
- template <class Other, bool ET>
- BOOST_FORCEINLINE mp_number(const mp_number<Other, ET>& val, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<Other>()))
- {
- m_backend = val.backend();
- }
- template <class Other, bool ET>
- mp_number(const mp_number<Other, ET>& val, typename disable_if<boost::is_convertible<Other, Backend> >::type* = 0)
- {
- //
- // Attempt a generic interconvertion:
- //
- detail::generic_interconvert(backend(), val.backend(), number_category<Backend>(), number_category<Other>());
- }
- template <class V>
- BOOST_FORCEINLINE mp_number(V v1, V v2, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* = 0)
- {
- using default_ops::assign_components;
- assign_components(m_backend, canonical_value(v1), canonical_value(v2));
- }
- template <class Other, bool ET>
- BOOST_FORCEINLINE mp_number(const mp_number<Other, ET>& v1, const mp_number<Other, ET>& v2, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0)
- {
- using default_ops::assign_components;
- assign_components(m_backend, v1.backend(), v2.backend());
- }
-
- template <class V>
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(V v, typename enable_if<mpl::and_<is_convertible<V, Backend>, mpl::not_<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > > > >::type* = 0)
- BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const V&>(std::declval<V>()))))
- : m_backend(v){}
-
- template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- mp_number& operator=(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e)
- {
- typedef typename is_same<mp_number, typename detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::type tag_type;
- do_assign(e, tag_type());
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number& operator=(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Backend&>(std::declval<Backend>())))
- {
- m_backend = e.m_backend;
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> >, mp_number<Backend, ExpressionTemplates>& >::type
- operator=(const V& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<typename boost::multiprecision::detail::canonical<V, Backend>::type>()))
- {
- m_backend = canonical_value(v);
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<mpl::and_<is_convertible<V, Backend>, mpl::not_<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > > >, mp_number<Backend, ExpressionTemplates>& >::type
- operator=(const V& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const V&>(std::declval<V>())))
- {
- m_backend = v;
- return *this;
- }
-
- template <bool ET>
- BOOST_FORCEINLINE mp_number& operator=(const mp_number<Backend, ET>& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Backend&>(std::declval<Backend>())))
- {
- m_backend = v.backend();
- return *this;
- }
-
- template <class Other>
- BOOST_FORCEINLINE typename enable_if<is_convertible<Other, Backend>, mp_number<Backend, ExpressionTemplates>& >::type
- operator=(const mp_number<Other>& v) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = static_cast<const Other&>(std::declval<Other>())))
- {
- m_backend = v.backend();
- return *this;
- }
-
- template <class Other>
- typename disable_if<is_convertible<Other, Backend>, mp_number<Backend, ExpressionTemplates>& >::type
- operator=(const mp_number<Other>& v)
- {
- //
- // Attempt a generic interconvertion:
- //
- detail::generic_interconvert(backend(), v.backend(), number_category<Backend>(), number_category<Other>());
- return *this;
- }
-
- template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- mp_number(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e)
- {
- *this = e;
- }
-
-#ifndef BOOST_NO_RVALUE_REFERENCES
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(mp_number&& r) BOOST_NOEXCEPT : m_backend(static_cast<Backend&&>(r.m_backend)){}
- BOOST_FORCEINLINE mp_number& operator=(mp_number&& r) BOOST_NOEXCEPT
- {
- m_backend = static_cast<Backend&&>(r.m_backend);
- return *this;
- }
-#endif
-
- mp_number& operator+=(const self_type& val)
- {
- do_add(detail::mp_exp<detail::terminal, self_type>(val), detail::terminal());
- return *this;
- }
-
- template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- mp_number& operator+=(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e)
- {
- // Create a copy if e contains this, but not if we're just doing a
- // x += x
- if(contains_self(e) && !is_self(e))
- {
- self_type temp(e);
- do_add(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
- }
- else
- {
- do_add(e, tag());
- }
- return *this;
- }
-
- template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator+=(const V& v)
- {
- using default_ops::eval_add;
- eval_add(m_backend, canonical_value(v));
- return *this;
- }
-
- mp_number& operator-=(const self_type& val)
- {
- do_subtract(detail::mp_exp<detail::terminal, self_type>(val), detail::terminal());
- return *this;
- }
-
- template <class Exp>
- mp_number& operator-=(const detail::mp_exp<Exp>& e)
- {
- // Create a copy if e contains this:
- if(contains_self(e))
- {
- self_type temp(e);
- do_subtract(temp, detail::terminal());
- }
- else
- {
- do_subtract(e, typename Exp::tag_type());
- }
- return *this;
- }
-
- template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator-=(const V& v)
- {
- using default_ops::eval_subtract;
- eval_subtract(m_backend, canonical_value(v));
- return *this;
- }
-
-
- mp_number& operator *= (const self_type& e)
- {
- do_multiplies(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
- return *this;
- }
-
- template <class Exp>
- mp_number& operator*=(const detail::mp_exp<Exp>& e)
- {
- // Create a temporary if the RHS references *this, but not
- // if we're just doing an x *= x;
- if(contains_self(e) && !is_self(e))
- {
- self_type temp(e);
- do_multiplies(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
- }
- else
- {
- do_multiplies(e, typename Exp::tag_type());
- }
- return *this;
- }
-
- template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator*=(const V& v)
- {
- using default_ops::eval_multiply;
- eval_multiply(m_backend, canonical_value(v));
- return *this;
- }
-
- mp_number& operator%=(const self_type& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- do_modulus(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
- return *this;
- }
- template <class Exp>
- mp_number& operator%=(const detail::mp_exp<Exp>& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- // Create a temporary if the RHS references *this:
- if(contains_self(e))
- {
- self_type temp(e);
- do_modulus(temp, detail::terminal());
- }
- else
- {
- do_modulus(e, typename Exp::tag_type());
- }
- return *this;
- }
- template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator%=(const V& v)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- using default_ops::eval_modulus;
- eval_modulus(m_backend, canonical_value(v));
- return *this;
- }
-
- //
- // These operators are *not* proto-ized.
- // The issue is that the increment/decrement must happen
- // even if the result of the operator *is never used*.
- // Possibly we could modify our expression wrapper to
- // execute the increment/decrement on destruction, but
- // correct implemetation will be tricky, so defered for now...
- //
- BOOST_FORCEINLINE mp_number& operator++()
- {
- using default_ops::eval_increment;
- eval_increment(m_backend);
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number& operator--()
- {
- using default_ops::eval_decrement;
- eval_decrement(m_backend);
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number operator++(int)
- {
- using default_ops::eval_increment;
- self_type temp(*this);
- eval_increment(m_backend);
- return BOOST_MP_MOVE(temp);
- }
-
- BOOST_FORCEINLINE mp_number operator--(int)
- {
- using default_ops::eval_decrement;
- self_type temp(*this);
- eval_decrement(m_backend);
- return BOOST_MP_MOVE(temp);
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<is_integral<V>, mp_number&>::type operator <<= (V val)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The left-shift operation is only valid for integer types");
- check_shift_range(val, mpl::bool_<(sizeof(V) > sizeof(std::size_t))>(), is_signed<V>());
- eval_left_shift(m_backend, canonical_value(val));
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<is_integral<V>, mp_number&>::type operator >>= (V val)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The right-shift operation is only valid for integer types");
- check_shift_range(val, mpl::bool_<(sizeof(V) > sizeof(std::size_t))>(), is_signed<V>());
- eval_right_shift(m_backend, canonical_value(val));
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number& operator /= (const self_type& e)
- {
- do_divide(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
- return *this;
- }
-
- template <class Exp>
- mp_number& operator/=(const detail::mp_exp<Exp>& e)
- {
- // Create a temporary if the RHS references *this:
- if(contains_self(e))
- {
- self_type temp(e);
- do_divide(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
- }
- else
- {
- do_divide(e, typename Exp::tag_type());
- }
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator/=(const V& v)
- {
- using default_ops::eval_divide;
- eval_divide(m_backend, canonical_value(v));
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number& operator&=(const self_type& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
- do_bitwise_and(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
- return *this;
- }
-
- template <class Exp>
- mp_number& operator&=(const detail::mp_exp<Exp>& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
- // Create a temporary if the RHS references *this, but not
- // if we're just doing an x &= x;
- if(contains_self(e) && !is_self(e))
- {
- self_type temp(e);
- do_bitwise_and(temp, detail::terminal());
- }
- else
- {
- do_bitwise_and(e, typename Exp::tag_type());
- }
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator&=(const V& v)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
- using default_ops::eval_bitwise_and;
- eval_bitwise_and(m_backend, canonical_value(v));
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number& operator|=(const self_type& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
- do_bitwise_or(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
- return *this;
- }
-
- template <class Exp>
- mp_number& operator|=(const detail::mp_exp<Exp>& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
- // Create a temporary if the RHS references *this, but not
- // if we're just doing an x |= x;
- if(contains_self(e) && !is_self(e))
- {
- self_type temp(e);
- do_bitwise_or(temp, detail::terminal());
- }
- else
- {
- do_bitwise_or(e, typename Exp::tag_type());
- }
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator|=(const V& v)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
- using default_ops::eval_bitwise_or;
- eval_bitwise_or(m_backend, canonical_value(v));
- return *this;
- }
-
- BOOST_FORCEINLINE mp_number& operator^=(const self_type& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
- do_bitwise_xor(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
- return *this;
- }
-
- template <class Exp>
- mp_number& operator^=(const detail::mp_exp<Exp>& e)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
- if(contains_self(e))
- {
- self_type temp(e);
- do_bitwise_xor(temp, detail::terminal());
- }
- else
- {
- do_bitwise_xor(e, typename Exp::tag_type());
- }
- return *this;
- }
-
- template <class V>
- BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
- operator^=(const V& v)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
- using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(m_backend, canonical_value(v));
- return *this;
- }
- //
- // Use in boolean context:
- //
- typedef bool (self_type::*unmentionable_type)()const;
-
- BOOST_FORCEINLINE operator unmentionable_type()const
- {
- return is_zero() ? 0 : &self_type::is_zero;
- }
-
- //
- // swap:
- //
- BOOST_FORCEINLINE void swap(self_type& other) BOOST_NOEXCEPT
- {
- m_backend.swap(other.backend());
- }
- //
- // Zero and sign:
- //
- BOOST_FORCEINLINE bool is_zero()const
- {
- using default_ops::eval_is_zero;
- return eval_is_zero(m_backend);
- }
- BOOST_FORCEINLINE int sign()const
- {
- using default_ops::eval_get_sign;
- return eval_get_sign(m_backend);
- }
- //
- // String conversion functions:
- //
- std::string str(std::streamsize digits = 0, std::ios_base::fmtflags f = std::ios_base::fmtflags(0))const
- {
- return m_backend.str(digits, f);
- }
- template <class T>
- T convert_to()const
- {
- using default_ops::eval_convert_to;
- T result;
- eval_convert_to(&result, m_backend);
- return result;
- }
-#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-template <class T>
-explicit operator T()const
-{
- return this->template convert_to<T>();
-}
-#endif
- //
- // Default precision:
- //
- static unsigned default_precision() BOOST_NOEXCEPT
- {
- return Backend::default_precision();
- }
- static void default_precision(unsigned digits10)
- {
- Backend::default_precision(digits10);
- }
- unsigned precision()const BOOST_NOEXCEPT
- {
- return m_backend.precision();
- }
- void precision(unsigned digits10)
- {
- m_backend.precision(digits10);
- }
- //
- // Comparison:
- //
- BOOST_FORCEINLINE int compare(const mp_number<Backend, ExpressionTemplates>& o)const
- BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>().compare(std::declval<Backend>())))
- {
- return m_backend.compare(o.m_backend);
- }
- template <class V>
- BOOST_FORCEINLINE typename enable_if<is_arithmetic<V>, int>::type compare(const V& o)const
- {
- using default_ops::eval_get_sign;
- if(o == 0)
- return eval_get_sign(m_backend);
- return m_backend.compare(canonical_value(o));
- }
- BOOST_FORCEINLINE Backend& backend() BOOST_NOEXCEPT
- {
- return m_backend;
- }
- BOOST_FORCEINLINE const Backend& backend()const BOOST_NOEXCEPT
- {
- return m_backend;
- }
-private:
- template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- void do_assign(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e, const mpl::true_&)
- {
- do_assign(e, tag());
- }
- template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- void do_assign(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e, const mpl::false_&)
- {
- // The result of the expression isn't the same type as this -
- // create a temporary result and assign it to *this:
- typedef typename detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>::result_type temp_type;
- temp_type t(e);
- *this = t;
- }
-
-
- template <class V>
- void check_shift_range(V val, const mpl::true_&, const mpl::true_&)
- {
- if(val > (std::numeric_limits<std::size_t>::max)())
- BOOST_THROW_EXCEPTION(std::out_of_range("Can not shift by a value greater than std::numeric_limits<std::size_t>::max()."));
- if(val < 0)
- BOOST_THROW_EXCEPTION(std::out_of_range("Can not shift by a negative value."));
- }
- template <class V>
- void check_shift_range(V val, const mpl::false_&, const mpl::true_&)
- {
- if(val < 0)
- BOOST_THROW_EXCEPTION(std::out_of_range("Can not shift by a negative value."));
- }
- template <class V>
- void check_shift_range(V val, const mpl::true_&, const mpl::false_&)
- {
- if(val > (std::numeric_limits<std::size_t>::max)())
- BOOST_THROW_EXCEPTION(std::out_of_range("Can not shift by a value greater than std::numeric_limits<std::size_t>::max()."));
- }
- template <class V>
- void check_shift_range(V, const mpl::false_&, const mpl::false_&) BOOST_NOEXCEPT{}
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::add_immediates&)
- {
- using default_ops::eval_add;
- eval_add(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::subtract_immediates&)
- {
- using default_ops::eval_subtract;
- eval_subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::multiply_immediates&)
- {
- using default_ops::eval_multiply;
- eval_multiply(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::divide_immediates&)
- {
- using default_ops::eval_divide;
- eval_divide(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::negate&)
- {
- typedef typename Exp::left_type left_type;
- do_assign(e.left(), typename left_type::tag_type());
- m_backend.negate();
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::plus&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- static int const left_depth = left_type::depth;
- static int const right_depth = right_type::depth;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_add(e.right(), typename right_type::tag_type());
- }
- else if(br && is_self(e.right()))
- {
- // Ignore the right node, it's *this, just add the left:
- do_add(e.left(), typename left_type::tag_type());
- }
- else if(bl || br)
- {
- self_type temp(e);
- temp.m_backend.swap(this->m_backend);
- }
- else if(left_depth >= right_depth)
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_add(e.right(), typename right_type::tag_type());
- }
- else
- {
- do_assign(e.right(), typename right_type::tag_type());
- do_add(e.left(), typename left_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::minus&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- static int const left_depth = left_type::depth;
- static int const right_depth = right_type::depth;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just subtract the right:
- do_subtract(e.right(), typename right_type::tag_type());
- }
- else if(br && is_self(e.right()))
- {
- // Ignore the right node, it's *this, just subtract the left and negate the result:
- do_subtract(e.left(), typename left_type::tag_type());
- m_backend.negate();
- }
- else if(bl || br)
- {
- self_type temp(e);
- temp.m_backend.swap(this->m_backend);
- }
- else if(left_depth >= right_depth)
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_subtract(e.right(), typename right_type::tag_type());
- }
- else
- {
- do_assign(e.right(), typename right_type::tag_type());
- do_subtract(e.left(), typename left_type::tag_type());
- m_backend.negate();
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::multiplies&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- static int const left_depth = left_type::depth;
- static int const right_depth = right_type::depth;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_multiplies(e.right(), typename right_type::tag_type());
- }
- else if(br && is_self(e.right()))
- {
- // Ignore the right node, it's *this, just add the left:
- do_multiplies(e.left(), typename left_type::tag_type());
- }
- else if(bl || br)
- {
- self_type temp(e);
- temp.m_backend.swap(this->m_backend);
- }
- else if(left_depth >= right_depth)
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_multiplies(e.right(), typename right_type::tag_type());
- }
- else
- {
- do_assign(e.right(), typename right_type::tag_type());
- do_multiplies(e.left(), typename left_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::divides&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_divide(e.right(), typename right_type::tag_type());
- }
- else if(bl || br)
- {
- self_type temp(e);
- temp.m_backend.swap(this->m_backend);
- }
- else
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_divide(e.right(), typename right_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::modulus&)
- {
- //
- // This operation is only valid for integer backends:
- //
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
-
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_modulus(e.right(), typename right_type::tag_type());
- }
- else if(bl || br)
- {
- self_type temp(e);
- temp.m_backend.swap(this->m_backend);
- }
- else
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_modulus(e.right(), typename right_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::modulus_immediates&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- using default_ops::eval_modulus;
- eval_modulus(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_and&)
- {
- //
- // This operation is only valid for integer backends:
- //
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
-
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- static int const left_depth = left_type::depth;
- static int const right_depth = right_type::depth;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_bitwise_and(e.right(), typename right_type::tag_type());
- }
- else if(br && is_self(e.right()))
- {
- do_bitwise_and(e.left(), typename left_type::tag_type());
- }
- else if(left_depth >= right_depth)
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_bitwise_and(e.right(), typename right_type::tag_type());
- }
- else
- {
- do_assign(e.right(), typename right_type::tag_type());
- do_bitwise_and(e.left(), typename left_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_and_immediates&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
- using default_ops::eval_bitwise_and;
- eval_bitwise_and(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_or&)
- {
- //
- // This operation is only valid for integer backends:
- //
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
-
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- static int const left_depth = left_type::depth;
- static int const right_depth = right_type::depth;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_bitwise_or(e.right(), typename right_type::tag_type());
- }
- else if(br && is_self(e.right()))
- {
- do_bitwise_or(e.left(), typename left_type::tag_type());
- }
- else if(left_depth >= right_depth)
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_bitwise_or(e.right(), typename right_type::tag_type());
- }
- else
- {
- do_assign(e.right(), typename right_type::tag_type());
- do_bitwise_or(e.left(), typename left_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_or_immediates&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
- using default_ops::eval_bitwise_or;
- eval_bitwise_or(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_xor&)
- {
- //
- // This operation is only valid for integer backends:
- //
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
-
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
-
- static int const left_depth = left_type::depth;
- static int const right_depth = right_type::depth;
-
- bool bl = contains_self(e.left());
- bool br = contains_self(e.right());
-
- if(bl && is_self(e.left()))
- {
- // Ignore the left node, it's *this, just add the right:
- do_bitwise_xor(e.right(), typename right_type::tag_type());
- }
- else if(br && is_self(e.right()))
- {
- do_bitwise_xor(e.left(), typename left_type::tag_type());
- }
- else if(left_depth >= right_depth)
- {
- do_assign(e.left(), typename left_type::tag_type());
- do_bitwise_xor(e.right(), typename right_type::tag_type());
- }
- else
- {
- do_assign(e.right(), typename right_type::tag_type());
- do_bitwise_xor(e.left(), typename left_type::tag_type());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_xor_immediates&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
- using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::terminal&)
- {
- if(!is_self(e))
- {
- m_backend = canonical_value(e.value());
- }
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::function&)
- {
- typedef typename Exp::arity tag_type;
- do_assign_function(e, tag_type());
- }
- template <class Exp>
- void do_assign(const Exp& e, const detail::shift_left&)
- {
- // We can only shift by an integer value, not an arbitrary expression:
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- typedef typename right_type::arity right_arity;
- BOOST_STATIC_ASSERT_MSG(right_arity::value == 0, "The left shift operator requires an integer value for the shift operand.");
- typedef typename right_type::result_type right_value_type;
- BOOST_STATIC_ASSERT_MSG(is_integral<right_value_type>::value, "The left shift operator requires an integer value for the shift operand.");
- typedef typename left_type::tag_type tag_type;
- do_assign_left_shift(e.left(), canonical_value(e.right().value()), tag_type());
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::shift_right&)
- {
- // We can only shift by an integer value, not an arbitrary expression:
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- typedef typename right_type::arity right_arity;
- BOOST_STATIC_ASSERT_MSG(right_arity::value == 0, "The left shift operator requires an integer value for the shift operand.");
- typedef typename right_type::result_type right_value_type;
- BOOST_STATIC_ASSERT_MSG(is_integral<right_value_type>::value, "The left shift operator requires an integer value for the shift operand.");
- typedef typename left_type::tag_type tag_type;
- do_assign_right_shift(e.left(), canonical_value(e.right().value()), tag_type());
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::bitwise_complement&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ~ operation is only valid for integer types");
- using default_ops::eval_complement;
- self_type temp(e.left());
- eval_complement(m_backend, temp.backend());
- }
-
- template <class Exp>
- void do_assign(const Exp& e, const detail::complement_immediates&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ~ operation is only valid for integer types");
- using default_ops::eval_complement;
- eval_complement(m_backend, canonical_value(e.left().value()));
- }
-
- template <class Exp, class Val>
- void do_assign_right_shift(const Exp& e, const Val& val, const detail::terminal&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The right shift operation is only valid for integer types");
- using default_ops::eval_right_shift;
- eval_right_shift(m_backend, canonical_value(e.value()), val);
- }
-
- template <class Exp, class Val>
- void do_assign_left_shift(const Exp& e, const Val& val, const detail::terminal&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The left shift operation is only valid for integer types");
- using default_ops::eval_left_shift;
- eval_left_shift(m_backend, canonical_value(e.value()), val);
- }
-
- template <class Exp, class Val, class Tag>
- void do_assign_right_shift(const Exp& e, const Val& val, const Tag&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The right shift operation is only valid for integer types");
- using default_ops::eval_right_shift;
- self_type temp(e);
- eval_right_shift(m_backend, temp.backend(), val);
- }
-
- template <class Exp, class Val, class Tag>
- void do_assign_left_shift(const Exp& e, const Val& val, const Tag&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The left shift operation is only valid for integer types");
- using default_ops::eval_left_shift;
- self_type temp(e);
- eval_left_shift(m_backend, temp.backend(), val);
- }
-
- template <class Exp>
- void do_assign_function(const Exp& e, const mpl::int_<1>&)
- {
- e.left().value()(&m_backend);
- }
- template <class Exp>
- void do_assign_function(const Exp& e, const mpl::int_<2>&)
- {
- typedef typename Exp::right_type right_type;
- typedef typename right_type::tag_type tag_type;
- do_assign_function_1(e.left().value(), e.right_ref(), tag_type());
- }
- template <class F, class Exp>
- void do_assign_function_1(const F& f, const Exp& val, const detail::terminal&)
- {
- f(m_backend, function_arg_value(val));
- }
- template <class F, class Exp, class Tag>
- void do_assign_function_1(const F& f, const Exp& val, const Tag&)
- {
- mp_number t(val);
- f(m_backend, t.backend());
- }
- template <class Exp>
- void do_assign_function(const Exp& e, const mpl::int_<3>&)
- {
- typedef typename Exp::middle_type middle_type;
- typedef typename middle_type::tag_type tag_type;
- typedef typename Exp::right_type end_type;
- typedef typename end_type::tag_type end_tag;
- do_assign_function_2(e.left().value(), e.middle_ref(), e.right_ref(), tag_type(), end_tag());
- }
- template <class F, class Exp1, class Exp2>
- void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const detail::terminal&, const detail::terminal&)
- {
- f(m_backend, function_arg_value(val1), function_arg_value(val2));
- }
- template <class F, class Exp1, class Exp2, class Tag1>
- void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const Tag1&, const detail::terminal&)
- {
- self_type temp1(val1);
- f(m_backend, BOOST_MP_MOVE(temp1.backend()), function_arg_value(val2));
- }
- template <class F, class Exp1, class Exp2, class Tag2>
- void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const detail::terminal&, const Tag2&)
- {
- self_type temp2(val2);
- f(m_backend, function_arg_value(val1), BOOST_MP_MOVE(temp2.backend()));
- }
- template <class F, class Exp1, class Exp2, class Tag1, class Tag2>
- void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const Tag1&, const Tag2&)
- {
- self_type temp1(val1);
- self_type temp2(val2);
- f(m_backend, BOOST_MP_MOVE(temp1.backend()), BOOST_MP_MOVE(temp2.backend()));
- }
-
- template <class Exp>
- void do_assign_function(const Exp& e, const mpl::int_<4>&)
- {
- typedef typename Exp::left_middle_type left_type;
- typedef typename left_type::tag_type left_tag_type;
- typedef typename Exp::right_middle_type middle_type;
- typedef typename middle_type::tag_type middle_tag_type;
- typedef typename Exp::right_type right_type;
- typedef typename right_type::tag_type right_tag_type;
- do_assign_function_3a(e.left().value(), e.left_middle_ref(), e.right_middle_ref(), e.right_ref(), left_tag_type(), middle_tag_type(), right_tag_type());
- }
- template <class F, class Exp1, class Exp2, class Exp3, class Tag2, class Tag3>
- void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&, const Tag2& t2, const Tag3& t3)
- {
- do_assign_function_3b(f, val1, val2, val3, t2, t3);
- }
- template <class F, class Exp1, class Exp2, class Exp3, class Tag1, class Tag2, class Tag3>
- void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag1&, const Tag2& t2, const Tag3& t3)
- {
- mp_number t(val1);
- do_assign_function_3b(f, BOOST_MP_MOVE(t), val2, val3, t2, t3);
- }
- template <class F, class Exp1, class Exp2, class Exp3, class Tag3>
- void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&, const Tag3& t3)
- {
- do_assign_function_3c(f, val1, val2, val3, t3);
- }
- template <class F, class Exp1, class Exp2, class Exp3, class Tag2, class Tag3>
- void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag2& /*t2*/, const Tag3& t3)
- {
- mp_number t(val2);
- do_assign_function_3c(f, val1, BOOST_MP_MOVE(t), val3, t3);
- }
- template <class F, class Exp1, class Exp2, class Exp3>
- void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&)
- {
- f(m_backend, function_arg_value(val1), function_arg_value(val2), function_arg_value(val3));
- }
- template <class F, class Exp1, class Exp2, class Exp3, class Tag3>
- void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag3& /*t3*/)
- {
- mp_number t(val3);
- do_assign_function_3c(f, val1, val2, BOOST_MP_MOVE(t), detail::terminal());
- }
-
- template <class Exp>
- void do_add(const Exp& e, const detail::terminal&)
- {
- using default_ops::eval_add;
- eval_add(m_backend, canonical_value(e.value()));
- }
-
- template <class Exp>
- void do_add(const Exp& e, const detail::negate&)
- {
- typedef typename Exp::left_type left_type;
- do_subtract(e.left(), typename left_type::tag_type());
- }
-
- template <class Exp>
- void do_add(const Exp& e, const detail::plus&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_add(e.left(), typename left_type::tag_type());
- do_add(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp>
- void do_add(const Exp& e, const detail::minus&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_add(e.left(), typename left_type::tag_type());
- do_subtract(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp, class unknown>
- void do_add(const Exp& e, const unknown&)
- {
- self_type temp(e);
- do_add(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
- }
-
- template <class Exp>
- void do_add(const Exp& e, const detail::add_immediates&)
- {
- using default_ops::eval_add;
- eval_add(m_backend, canonical_value(e.left().value()));
- eval_add(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_add(const Exp& e, const detail::subtract_immediates&)
- {
- using default_ops::eval_add;
- using default_ops::eval_subtract;
- eval_add(m_backend, canonical_value(e.left().value()));
- eval_subtract(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_subtract(const Exp& e, const detail::terminal&)
- {
- using default_ops::eval_subtract;
- eval_subtract(m_backend, canonical_value(e.value()));
- }
-
- template <class Exp>
- void do_subtract(const Exp& e, const detail::negate&)
- {
- typedef typename Exp::left_type left_type;
- do_add(e.left(), typename left_type::tag_type());
- }
-
- template <class Exp>
- void do_subtract(const Exp& e, const detail::plus&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_subtract(e.left(), typename left_type::tag_type());
- do_subtract(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp>
- void do_subtract(const Exp& e, const detail::minus&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_subtract(e.left(), typename left_type::tag_type());
- do_add(e.right(), typename right_type::tag_type());
- }
- template <class Exp>
- void do_subtract(const Exp& e, const detail::add_immediates&)
- {
- using default_ops::eval_subtract;
- eval_subtract(m_backend, canonical_value(e.left().value()));
- eval_subtract(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_subtract(const Exp& e, const detail::subtract_immediates&)
- {
- using default_ops::eval_add;
- using default_ops::eval_subtract;
- eval_subtract(m_backend, canonical_value(e.left().value()));
- eval_add(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp, class unknown>
- void do_subtract(const Exp& e, const unknown&)
- {
- self_type temp(e);
- do_subtract(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
- }
-
- template <class Exp>
- void do_multiplies(const Exp& e, const detail::terminal&)
- {
- using default_ops::eval_multiply;
- eval_multiply(m_backend, canonical_value(e.value()));
- }
-
- template <class Exp>
- void do_multiplies(const Exp& e, const detail::negate&)
- {
- typedef typename Exp::left_type left_type;
- do_multiplies(e.left(), typename left_type::tag_type());
- m_backend.negate();
- }
-
- template <class Exp>
- void do_multiplies(const Exp& e, const detail::multiplies&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_multiplies(e.left(), typename left_type::tag_type());
- do_multiplies(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp>
- void do_multiplies(const Exp& e, const detail::divides&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_multiplies(e.left(), typename left_type::tag_type());
- do_divide(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp>
- void do_multiplies(const Exp& e, const detail::multiply_immediates&)
- {
- using default_ops::eval_multiply;
- eval_multiply(m_backend, canonical_value(e.left().value()));
- eval_multiply(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_multiplies(const Exp& e, const detail::divide_immediates&)
- {
- using default_ops::eval_multiply;
- using default_ops::eval_divide;
- eval_multiply(m_backend, canonical_value(e.left().value()));
- eval_divide(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp, class unknown>
- void do_multiplies(const Exp& e, const unknown&)
- {
- using default_ops::eval_multiply;
- self_type temp(e);
- eval_multiply(m_backend, temp.m_backend);
- }
-
- template <class Exp>
- void do_divide(const Exp& e, const detail::terminal&)
- {
- using default_ops::eval_divide;
- eval_divide(m_backend, canonical_value(e.value()));
- }
-
- template <class Exp>
- void do_divide(const Exp& e, const detail::negate&)
- {
- typedef typename Exp::left_type left_type;
- do_divide(e.left(), typename left_type::tag_type());
- m_backend.negate();
- }
-
- template <class Exp>
- void do_divide(const Exp& e, const detail::multiplies&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_divide(e.left(), typename left_type::tag_type());
- do_divide(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp>
- void do_divide(const Exp& e, const detail::divides&)
- {
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_divide(e.left(), typename left_type::tag_type());
- do_multiplies(e.right(), typename right_type::tag_type());
- }
-
- template <class Exp>
- void do_divides(const Exp& e, const detail::multiply_immediates&)
- {
- using default_ops::eval_divide;
- eval_divide(m_backend, canonical_value(e.left().value()));
- eval_divide(m_backend, canonical_value(e.right().value()));
- }
- template <class Exp>
- void do_divides(const Exp& e, const detail::divide_immediates&)
- {
- using default_ops::eval_multiply;
- using default_ops::eval_divide;
- eval_divide(m_backend, canonical_value(e.left().value()));
- mutiply(m_backend, canonical_value(e.right().value()));
- }
-
- template <class Exp, class unknown>
- void do_divide(const Exp& e, const unknown&)
- {
- using default_ops::eval_multiply;
- self_type temp(e);
- eval_divide(m_backend, temp.m_backend);
- }
-
- template <class Exp>
- void do_modulus(const Exp& e, const detail::terminal&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- using default_ops::eval_modulus;
- eval_modulus(m_backend, canonical_value(e.value()));
- }
-
- template <class Exp, class Unknown>
- void do_modulus(const Exp& e, const Unknown&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- using default_ops::eval_modulus;
- self_type temp(e);
- eval_modulus(m_backend, canonical_value(temp));
- }
-
- template <class Exp>
- void do_bitwise_and(const Exp& e, const detail::terminal&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
- using default_ops::eval_bitwise_and;
- eval_bitwise_and(m_backend, canonical_value(e.value()));
- }
- template <class Exp>
- void do_bitwise_and(const Exp& e, const detail::bitwise_and&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_bitwise_and(e.left(), typename left_type::tag_type());
- do_bitwise_and(e.right(), typename right_type::tag_type());
- }
- template <class Exp, class unknown>
- void do_bitwise_and(const Exp& e, const unknown&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
- using default_ops::eval_bitwise_and;
- self_type temp(e);
- eval_bitwise_and(m_backend, temp.m_backend);
- }
-
- template <class Exp>
- void do_bitwise_or(const Exp& e, const detail::terminal&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
- using default_ops::eval_bitwise_or;
- eval_bitwise_or(m_backend, canonical_value(e.value()));
- }
- template <class Exp>
- void do_bitwise_or(const Exp& e, const detail::bitwise_or&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_bitwise_or(e.left(), typename left_type::tag_type());
- do_bitwise_or(e.right(), typename right_type::tag_type());
- }
- template <class Exp, class unknown>
- void do_bitwise_or(const Exp& e, const unknown&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
- using default_ops::eval_bitwise_or;
- self_type temp(e);
- eval_bitwise_or(m_backend, temp.m_backend);
- }
-
- template <class Exp>
- void do_bitwise_xor(const Exp& e, const detail::terminal&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
- using default_ops::eval_bitwise_xor;
- eval_bitwise_xor(m_backend, canonical_value(e.value()));
- }
- template <class Exp>
- void do_bitwise_xor(const Exp& e, const detail::bitwise_xor&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
- typedef typename Exp::left_type left_type;
- typedef typename Exp::right_type right_type;
- do_bitwise_xor(e.left(), typename left_type::tag_type());
- do_bitwise_xor(e.right(), typename right_type::tag_type());
- }
- template <class Exp, class unknown>
- void do_bitwise_xor(const Exp& e, const unknown&)
- {
- BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
- using default_ops::eval_bitwise_xor;
- self_type temp(e);
- eval_bitwise_xor(m_backend, temp.m_backend);
- }
-
- // Tests if the expression contains a reference to *this:
- template <class Exp>
- BOOST_FORCEINLINE bool contains_self(const Exp& e)const BOOST_NOEXCEPT
- {
- return contains_self(e, typename Exp::arity());
- }
- template <class Exp>
- BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<0> const&)const BOOST_NOEXCEPT
- {
- return is_realy_self(e.value());
- }
- template <class Exp>
- BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<1> const&)const BOOST_NOEXCEPT
- {
- typedef typename Exp::left_type child_type;
- return contains_self(e.left(), typename child_type::arity());
- }
- template <class Exp>
- BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<2> const&)const BOOST_NOEXCEPT
- {
- typedef typename Exp::left_type child0_type;
- typedef typename Exp::right_type child1_type;
- return contains_self(e.left(), typename child0_type::arity())
- || contains_self(e.right(), typename child1_type::arity());
- }
- template <class Exp>
- BOOST_FORCEINLINE bool contains_self(const Exp& e, mpl::int_<3> const&)const BOOST_NOEXCEPT
- {
- typedef typename Exp::left_type child0_type;
- typedef typename Exp::middle_type child1_type;
- typedef typename Exp::right_type child2_type;
- return contains_self(e.left(), typename child0_type::arity())
- || contains_self(e.middle(), typename child1_type::arity())
- || contains_self(e.right(), typename child2_type::arity());
- }
-
- // Test if the expression is a reference to *this:
- template <class Exp>
- BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_self(const Exp& e)const BOOST_NOEXCEPT
- {
- return is_self(e, typename Exp::arity());
- }
- template <class Exp>
- BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_self(const Exp& e, mpl::int_<0> const&)const BOOST_NOEXCEPT
- {
- return is_realy_self(e.value());
- }
- template <class Exp, int v>
- BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_self(const Exp&, mpl::int_<v> const&)const BOOST_NOEXCEPT
- {
- return false;
- }
-
- template <class Val>
- BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_realy_self(const Val&)const BOOST_NOEXCEPT{ return false; }
- BOOST_FORCEINLINE BOOST_CONSTEXPR bool is_realy_self(const self_type& v)const BOOST_NOEXCEPT{ return &v == this; }
-
- static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& canonical_value(const self_type& v) BOOST_NOEXCEPT { return v.m_backend; }
- template <class V>
- static BOOST_FORCEINLINE BOOST_CONSTEXPR typename detail::canonical<V, Backend>::type canonical_value(const V& v) BOOST_NOEXCEPT { return static_cast<typename detail::canonical<V, Backend>::type>(v); }
- static BOOST_FORCEINLINE typename detail::canonical<std::string, Backend>::type canonical_value(const std::string& v) BOOST_NOEXCEPT { return v.c_str(); }
-
- static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& function_arg_value(const self_type& v) BOOST_NOEXCEPT { return v.backend(); }
- template <class V>
- static BOOST_FORCEINLINE BOOST_CONSTEXPR const V& function_arg_value(const V& v) BOOST_NOEXCEPT { return v; }
- template <class A1, class A2, class A3, class A4>
- static BOOST_FORCEINLINE const A1& function_arg_value(const detail::mp_exp<detail::terminal, A1, A2, A3, A4>& exp) BOOST_NOEXCEPT { return exp.value(); }
- template <class A2, class A3, class A4>
- static BOOST_FORCEINLINE BOOST_CONSTEXPR const Backend& function_arg_value(const detail::mp_exp<detail::terminal, mp_number<Backend>, A2, A3, A4>& exp) BOOST_NOEXCEPT { return exp.value().backend(); }
- Backend m_backend;
-};
-
-template <class Backend, bool ExpressionTemplates>
-inline std::ostream& operator << (std::ostream& os, const mp_number<Backend, ExpressionTemplates>& r)
-{
- std::streamsize d = os.precision();
- std::string s = r.str(d, os.flags());
- std::streamsize ss = os.width();
- if(ss > static_cast<std::streamsize>(s.size()))
- {
- char fill = os.fill();
- if((os.flags() & std::ios_base::left) == std::ios_base::left)
- s.append(static_cast<std::string::size_type>(ss - s.size()), fill);
- else
- s.insert(0, static_cast<std::string::size_type>(ss - s.size()), fill);
- }
- return os << s;
-}
-
-namespace detail{
-
-template <class tag, class A1, class A2, class A3, class A4>
-inline std::ostream& operator << (std::ostream& os, const mp_exp<tag, A1, A2, A3, A4>& r)
-{
- typedef typename mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
- value_type temp(r);
- return os << temp;
-}
-
-} // namespace detail
-
-template <class Backend, bool ExpressionTemplates>
-inline std::istream& operator >> (std::istream& is, mp_number<Backend, ExpressionTemplates>& r)
-{
- std::string s;
- is >> s;
- r = s;
- return is;
-}
-
-template <class Backend, bool ExpressionTemplates>
-BOOST_FORCEINLINE void swap(mp_number<Backend, ExpressionTemplates>& a, mp_number<Backend, ExpressionTemplates>& b)
-{
- a.swap(b);
-}
-
-} // namespace multipreciion
-
-template <class T>
-class rational;
-
-template <class Backend, bool ExpressionTemplates>
-inline std::istream& operator >> (std::istream& is, rational<multiprecision::mp_number<Backend, ExpressionTemplates> >& r)
-{
- std::string s1;
- multiprecision::mp_number<Backend, ExpressionTemplates> v1, v2;
- char c;
- bool have_hex = false;
-
- while((EOF != (c = static_cast<char>(is.peek()))) && (c == 'x' || c == 'X' || c == '-' || c == '+' || (c >= '0' && c <= '9') || (have_hex && (c >= 'a' && c <= 'f')) || (have_hex && (c >= 'A' && c <= 'F'))))
- {
- if(c == 'x' || c == 'X')
- have_hex = true;
- s1.append(1, c);
- is.get();
- }
- v1 = s1;
- s1.erase();
- if(c == '/')
- {
- is.get();
- while((EOF != (c = static_cast<char>(is.peek()))) && (c == 'x' || c == 'X' || c == '-' || c == '+' || (c >= '0' && c <= '9') || (have_hex && (c >= 'a' && c <= 'f')) || (have_hex && (c >= 'A' && c <= 'F'))))
- {
- if(c == 'x' || c == 'X')
- have_hex = true;
- s1.append(1, c);
- is.get();
- }
- v2 = s1;
- }
- else
- v2 = 1;
- r.assign(v1, v2);
- return is;
-}
-
-template <class T, bool ExpressionTemplates, class Arithmetic>
-typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator == (const rational<multiprecision::mp_number<T, ExpressionTemplates> >& a, const Arithmetic& b)
-{
- return a == multiprecision::mp_number<T, ExpressionTemplates>(b);
-}
-
-template <class T, bool ExpressionTemplates, class Arithmetic>
-typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator == (const Arithmetic& b, const rational<multiprecision::mp_number<T, ExpressionTemplates> >& a)
-{
- return a == multiprecision::mp_number<T, ExpressionTemplates>(b);
-}
-
-template <class T, bool ExpressionTemplates, class Arithmetic>
-typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator != (const rational<multiprecision::mp_number<T, ExpressionTemplates> >& a, const Arithmetic& b)
-{
- return a != multiprecision::mp_number<T, ExpressionTemplates>(b);
-}
-
-template <class T, bool ExpressionTemplates, class Arithmetic>
-typename enable_if<boost::is_arithmetic<Arithmetic>, bool>::type operator != (const Arithmetic& b, const rational<multiprecision::mp_number<T, ExpressionTemplates> >& a)
-{
- return a != multiprecision::mp_number<T, ExpressionTemplates>(b);
-}
-
-template <class T, bool ExpressionTemplates>
-inline multiprecision::mp_number<T, ExpressionTemplates> numerator(const rational<multiprecision::mp_number<T, ExpressionTemplates> >& a)
-{
- return a.numerator();
-}
-
-template <class T, bool ExpressionTemplates>
-inline multiprecision::mp_number<T, ExpressionTemplates> denominator(const rational<multiprecision::mp_number<T, ExpressionTemplates> >& a)
-{
- return a.denominator();
-}
-
-namespace numeric { namespace ublas {
-//
-// uBlas interoperability:
-//
-template<class V>
-class sparse_vector_element;
-
-template <class V, class Backend, bool ExpressionTemplates>
-inline bool operator == (const sparse_vector_element<V>& a, const ::boost::multiprecision::mp_number<Backend, ExpressionTemplates>& b)
-{
-typedef typename sparse_vector_element<V>::const_reference ref_type;
- return static_cast<ref_type>(a) == b;
-}
-
-}} // namespaces
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-} // namespaces
-
-#endif

Modified: sandbox/big_number/boost/multiprecision/mpfr.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mpfr.hpp (original)
+++ sandbox/big_number/boost/multiprecision/mpfr.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -6,7 +6,7 @@
#ifndef BOOST_MATH_BN_MPFR_HPP
#define BOOST_MATH_BN_MPFR_HPP

-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/gmp.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/cstdint.hpp>
@@ -897,7 +897,7 @@
{
 if(0 == mpfr_number_p(val.data()))
 {
- result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, mp_number<mpfr_float_backend<Digits10> >(val), 0, boost::math::policies::policy<>()).backend();
+ result = boost::math::policies::raise_rounding_error("boost::multiprecision::trunc<%1%>(%1%)", 0, number<mpfr_float_backend<Digits10> >(val), 0, boost::math::policies::policy<>()).backend();
 return;
 }
 mpfr_trunc(result.data(), val.data());
@@ -1046,11 +1046,11 @@

using boost::multiprecision::backends::mpfr_float_backend;

-typedef mp_number<mpfr_float_backend<50> > mpfr_float_50;
-typedef mp_number<mpfr_float_backend<100> > mpfr_float_100;
-typedef mp_number<mpfr_float_backend<500> > mpfr_float_500;
-typedef mp_number<mpfr_float_backend<1000> > mpfr_float_1000;
-typedef mp_number<mpfr_float_backend<0> > mpfr_float;
+typedef number<mpfr_float_backend<50> > mpfr_float_50;
+typedef number<mpfr_float_backend<100> > mpfr_float_100;
+typedef number<mpfr_float_backend<500> > mpfr_float_500;
+typedef number<mpfr_float_backend<1000> > mpfr_float_1000;
+typedef number<mpfr_float_backend<0> > mpfr_float;

} // namespace multiprecision

@@ -1064,7 +1064,7 @@
 return boost::multiprecision::backends::detail::get_default_precision();
}
template <>
-inline int digits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<0>, false> >() BOOST_NOEXCEPT
+inline int digits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, false> >() BOOST_NOEXCEPT
{
 return boost::multiprecision::backends::detail::get_default_precision();
}
@@ -1079,9 +1079,9 @@
// numeric_limits [partial] specializations for the types declared in this header:
//
template<unsigned Digits10, bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = true;
 BOOST_STATIC_CONSTEXPR number_type (min)() BOOST_NOEXCEPT
@@ -1198,12 +1198,12 @@
 {
 data_initializer()
 {
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<digits10> > >::epsilon();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<digits10> > >::round_error();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<digits10> > >::min)();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<digits10> > >::max)();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<digits10> > >::infinity();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<digits10> > >::quiet_NaN();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<digits10> > >::epsilon();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<digits10> > >::round_error();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<digits10> > >::min)();
+ (std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<digits10> > >::max)();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<digits10> > >::infinity();
+ std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<digits10> > >::quiet_NaN();
 }
 void do_nothing()const{}
 };
@@ -1211,62 +1211,62 @@
};

template<unsigned Digits10, bool ExpressionTemplates>
-const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::initializer;
+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>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::digits;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::digits;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::digits10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::digits10;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_digits10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_digits10;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_signed;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_signed;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_integer;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_integer;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_exact;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_exact;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::radix;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::radix;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::min_exponent;
+BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::min_exponent;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::min_exponent10;
+BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::min_exponent10;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_exponent;
+BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_exponent;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_exponent10;
+BOOST_CONSTEXPR_OR_CONST long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::max_exponent10;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_infinity;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_infinity;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_quiet_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_signaling_NaN;
+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>
-BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_denorm;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::has_denorm_loss;
+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>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_iec559;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_iec559;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_bounded;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_bounded;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_modulo;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::is_modulo;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::traps;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::traps;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::tinyness_before;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::tinyness_before;
template <unsigned Digits10, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10>, ExpressionTemplates> >::round_style;
+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>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_specialized = false;
 static number_type (min)() BOOST_NOEXCEPT { return number_type(0); }
@@ -1305,49 +1305,49 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

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

#endif
} // namespace std

Copied: sandbox/big_number/boost/multiprecision/number.hpp (from r79926, /sandbox/big_number/boost/multiprecision/mp_number.hpp)
==============================================================================
--- /sandbox/big_number/boost/multiprecision/mp_number.hpp (original)
+++ sandbox/big_number/boost/multiprecision/number.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -20,7 +20,7 @@
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/throw_exception.hpp>
#include <boost/multiprecision/detail/generic_interconvert.hpp>
-#include <boost/multiprecision/detail/mp_number_compare.hpp>
+#include <boost/multiprecision/detail/number_compare.hpp>
#include <istream> // stream operators
#include <cstdio> // EOF

@@ -34,26 +34,26 @@
#endif

template <class Backend, bool ExpressionTemplates>
-class mp_number
+class number
{
- typedef mp_number<Backend, ExpressionTemplates> self_type;
+ typedef number<Backend, ExpressionTemplates> self_type;
public:
 typedef Backend backend_type;
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number() BOOST_NOEXCEPT_IF(noexcept(Backend())) {}
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number& e) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(e.m_backend){}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR number() BOOST_NOEXCEPT_IF(noexcept(Backend())) {}
+ BOOST_FORCEINLINE BOOST_CONSTEXPR number(const number& e) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(e.m_backend){}
 template <class V>
- BOOST_FORCEINLINE mp_number(V v, typename enable_if_c<
+ BOOST_FORCEINLINE number(V v, typename enable_if_c<
 (boost::is_arithmetic<V>::value || is_same<std::string, V>::value || is_convertible<V, const char*>::value)
 && !is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value >::type* = 0)
 {
 m_backend = canonical_value(v);
 }
 template <class V>
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(V v, typename enable_if_c<
+ BOOST_FORCEINLINE BOOST_CONSTEXPR number(V v, typename enable_if_c<
 (boost::is_arithmetic<V>::value || is_same<std::string, V>::value || is_convertible<V, const char*>::value)
 && is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value >::type* = 0)
 : m_backend(canonical_value(v)) {}
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number& e, unsigned digits10)
+ BOOST_FORCEINLINE BOOST_CONSTEXPR number(const number& e, unsigned digits10)
 : m_backend(e.m_backend, digits10){}
 /*
 //
@@ -61,22 +61,22 @@
 // which is arguably more useful. Disabled for now.
 //
 template <class V>
- mp_number(V v, unsigned digits10, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* dummy1 = 0)
+ number(V v, unsigned digits10, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* dummy1 = 0)
 {
 m_backend.precision(digits10);
 m_backend = canonical_value(v);
 }
 */
 template<bool ET>
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(const mp_number<Backend, ET>& val) BOOST_NOEXCEPT_IF(noexcept(Backend(static_cast<const Backend&>(std::declval<Backend>())))) : m_backend(val.m_backend) {}
+ 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>
- BOOST_FORCEINLINE mp_number(const mp_number<Other, ET>& val, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<Other>()))
+ BOOST_FORCEINLINE number(const number<Other, ET>& val, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0) BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>() = std::declval<Other>()))
 {
 m_backend = val.backend();
 }
 template <class Other, bool ET>
- mp_number(const mp_number<Other, ET>& val, typename disable_if<boost::is_convertible<Other, Backend> >::type* = 0)
+ number(const number<Other, ET>& val, typename disable_if<boost::is_convertible<Other, Backend> >::type* = 0)
 {
 //
 // Attempt a generic interconvertion:
@@ -84,39 +84,39 @@
 detail::generic_interconvert(backend(), val.backend(), number_category<Backend>(), number_category<Other>());
 }
 template <class V>
- BOOST_FORCEINLINE mp_number(V v1, V v2, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* = 0)
+ BOOST_FORCEINLINE number(V v1, V v2, typename enable_if<mpl::or_<boost::is_arithmetic<V>, is_same<std::string, V>, is_convertible<V, const char*> > >::type* = 0)
 {
 using default_ops::assign_components;
 assign_components(m_backend, canonical_value(v1), canonical_value(v2));
 }
 template <class Other, bool ET>
- BOOST_FORCEINLINE mp_number(const mp_number<Other, ET>& v1, const mp_number<Other, ET>& v2, typename enable_if<boost::is_convertible<Other, Backend> >::type* = 0)
+ 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;
 assign_components(m_backend, v1.backend(), v2.backend());
 }

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

 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- mp_number& operator=(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e)
+ number& operator=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
 {
- typedef typename is_same<mp_number, typename detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::type tag_type;
+ typedef typename is_same<number, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::type tag_type;
 do_assign(e, tag_type());
 return *this;
 }

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

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

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

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

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

 template <class Other>
- typename disable_if<is_convertible<Other, Backend>, mp_number<Backend, ExpressionTemplates>& >::type
- operator=(const mp_number<Other>& v)
+ typename disable_if<is_convertible<Other, Backend>, number<Backend, ExpressionTemplates>& >::type
+ operator=(const number<Other>& v)
 {
 //
 // Attempt a generic interconvertion:
@@ -158,35 +158,35 @@
 }

 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- mp_number(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e)
+ number(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
 {
 *this = e;
 }

#ifndef BOOST_NO_RVALUE_REFERENCES
- BOOST_FORCEINLINE BOOST_CONSTEXPR mp_number(mp_number&& r) BOOST_NOEXCEPT : m_backend(static_cast<Backend&&>(r.m_backend)){}
- BOOST_FORCEINLINE mp_number& operator=(mp_number&& r) BOOST_NOEXCEPT
+ BOOST_FORCEINLINE BOOST_CONSTEXPR number(number&& r) BOOST_NOEXCEPT : m_backend(static_cast<Backend&&>(r.m_backend)){}
+ BOOST_FORCEINLINE number& operator=(number&& r) BOOST_NOEXCEPT
 {
 m_backend = static_cast<Backend&&>(r.m_backend);
 return *this;
 }
#endif

- mp_number& operator+=(const self_type& val)
+ number& operator+=(const self_type& val)
 {
- do_add(detail::mp_exp<detail::terminal, self_type>(val), detail::terminal());
+ do_add(detail::expression<detail::terminal, self_type>(val), detail::terminal());
 return *this;
 }

 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- mp_number& operator+=(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e)
+ number& operator+=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
 {
 // Create a copy if e contains this, but not if we're just doing a
 // x += x
 if(contains_self(e) && !is_self(e))
 {
 self_type temp(e);
- do_add(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
+ do_add(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
 }
 else
 {
@@ -196,7 +196,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ typename enable_if<boost::is_arithmetic<V>, number<Backend, ExpressionTemplates>& >::type
 operator+=(const V& v)
 {
 using default_ops::eval_add;
@@ -204,14 +204,14 @@
 return *this;
 }

- mp_number& operator-=(const self_type& val)
+ number& operator-=(const self_type& val)
 {
- do_subtract(detail::mp_exp<detail::terminal, self_type>(val), detail::terminal());
+ do_subtract(detail::expression<detail::terminal, self_type>(val), detail::terminal());
 return *this;
 }

 template <class Exp>
- mp_number& operator-=(const detail::mp_exp<Exp>& e)
+ number& operator-=(const detail::expression<Exp>& e)
 {
 // Create a copy if e contains this:
 if(contains_self(e))
@@ -227,7 +227,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ typename enable_if<boost::is_arithmetic<V>, number<Backend, ExpressionTemplates>& >::type
 operator-=(const V& v)
 {
 using default_ops::eval_subtract;
@@ -236,21 +236,21 @@
 }

- mp_number& operator *= (const self_type& e)
+ number& operator *= (const self_type& e)
 {
- do_multiplies(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
+ do_multiplies(detail::expression<detail::terminal, self_type>(e), detail::terminal());
 return *this;
 }

 template <class Exp>
- mp_number& operator*=(const detail::mp_exp<Exp>& e)
+ number& operator*=(const detail::expression<Exp>& e)
 {
 // Create a temporary if the RHS references *this, but not
 // if we're just doing an x *= x;
 if(contains_self(e) && !is_self(e))
 {
 self_type temp(e);
- do_multiplies(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
+ do_multiplies(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
 }
 else
 {
@@ -260,7 +260,7 @@
 }

 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ typename enable_if<boost::is_arithmetic<V>, number<Backend, ExpressionTemplates>& >::type
 operator*=(const V& v)
 {
 using default_ops::eval_multiply;
@@ -268,14 +268,14 @@
 return *this;
 }

- mp_number& operator%=(const self_type& e)
+ number& operator%=(const self_type& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
- do_modulus(detail::mp_exp<detail::terminal, self_type>(e), detail::terminal());
+ do_modulus(detail::expression<detail::terminal, self_type>(e), detail::terminal());
 return *this;
 }
 template <class Exp>
- mp_number& operator%=(const detail::mp_exp<Exp>& e)
+ number& operator%=(const detail::expression<Exp>& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
 // Create a temporary if the RHS references *this:
@@ -291,7 +291,7 @@
 return *this;
 }
 template <class V>
- typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ typename enable_if<boost::is_arithmetic<V>, number<Backend, ExpressionTemplates>& >::type
 operator%=(const V& v)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
@@ -308,21 +308,21 @@
 // execute the increment/decrement on destruction, but
 // correct implemetation will be tricky, so defered for now...
 //
- BOOST_FORCEINLINE mp_number& operator++()
+ BOOST_FORCEINLINE number& operator++()
 {
 using default_ops::eval_increment;
 eval_increment(m_backend);
 return *this;
 }

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

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

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

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

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

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

 template <class Exp>
- mp_number& operator/=(const detail::mp_exp<Exp>& e)
+ number& operator/=(const detail::expression<Exp>& e)
 {
 // Create a temporary if the RHS references *this:
 if(contains_self(e))
 {
 self_type temp(e);
- do_divide(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
+ do_divide(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
 }
 else
 {
@@ -379,7 +379,7 @@
 }

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

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

 template <class Exp>
- mp_number& operator&=(const detail::mp_exp<Exp>& e)
+ number& operator&=(const detail::expression<Exp>& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
 // Create a temporary if the RHS references *this, but not
@@ -413,7 +413,7 @@
 }

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

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

 template <class Exp>
- mp_number& operator|=(const detail::mp_exp<Exp>& e)
+ number& operator|=(const detail::expression<Exp>& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
 // Create a temporary if the RHS references *this, but not
@@ -448,7 +448,7 @@
 }

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

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

 template <class Exp>
- mp_number& operator^=(const detail::mp_exp<Exp>& e)
+ number& operator^=(const detail::expression<Exp>& e)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
 if(contains_self(e))
@@ -481,7 +481,7 @@
 }

 template <class V>
- BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, mp_number<Backend, ExpressionTemplates>& >::type
+ BOOST_FORCEINLINE typename enable_if<boost::is_arithmetic<V>, number<Backend, ExpressionTemplates>& >::type
 operator^=(const V& v)
 {
 BOOST_STATIC_ASSERT_MSG(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
@@ -563,7 +563,7 @@
 //
 // Comparison:
 //
- BOOST_FORCEINLINE int compare(const mp_number<Backend, ExpressionTemplates>& o)const
+ BOOST_FORCEINLINE int compare(const number<Backend, ExpressionTemplates>& o)const
 BOOST_NOEXCEPT_IF(noexcept(std::declval<Backend>().compare(std::declval<Backend>())))
 {
 return m_backend.compare(o.m_backend);
@@ -586,16 +586,16 @@
 }
private:
 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- void do_assign(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e, const mpl::true_&)
+ void do_assign(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e, const mpl::true_&)
 {
 do_assign(e, tag());
 }
 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
- void do_assign(const detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>& e, const mpl::false_&)
+ void do_assign(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e, const mpl::false_&)
 {
 // The result of the expression isn't the same type as this -
 // create a temporary result and assign it to *this:
- typedef typename detail::mp_exp<tag, Arg1, Arg2, Arg3, Arg4>::result_type temp_type;
+ typedef typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type temp_type;
 temp_type t(e);
 *this = t;
 }
@@ -1083,7 +1083,7 @@
 template <class F, class Exp, class Tag>
 void do_assign_function_1(const F& f, const Exp& val, const Tag&)
 {
- mp_number t(val);
+ number t(val);
 f(m_backend, t.backend());
 }
 template <class Exp>
@@ -1139,7 +1139,7 @@
 template <class F, class Exp1, class Exp2, class Exp3, class Tag1, class Tag2, class Tag3>
 void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag1&, const Tag2& t2, const Tag3& t3)
 {
- mp_number t(val1);
+ number t(val1);
 do_assign_function_3b(f, BOOST_MP_MOVE(t), val2, val3, t2, t3);
 }
 template <class F, class Exp1, class Exp2, class Exp3, class Tag3>
@@ -1150,7 +1150,7 @@
 template <class F, class Exp1, class Exp2, class Exp3, class Tag2, class Tag3>
 void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag2& /*t2*/, const Tag3& t3)
 {
- mp_number t(val2);
+ number t(val2);
 do_assign_function_3c(f, val1, BOOST_MP_MOVE(t), val3, t3);
 }
 template <class F, class Exp1, class Exp2, class Exp3>
@@ -1161,7 +1161,7 @@
 template <class F, class Exp1, class Exp2, class Exp3, class Tag3>
 void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag3& /*t3*/)
 {
- mp_number t(val3);
+ number t(val3);
 do_assign_function_3c(f, val1, val2, BOOST_MP_MOVE(t), detail::terminal());
 }

@@ -1201,7 +1201,7 @@
 void do_add(const Exp& e, const unknown&)
 {
 self_type temp(e);
- do_add(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
+ do_add(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
 }

 template <class Exp>
@@ -1269,7 +1269,7 @@
 void do_subtract(const Exp& e, const unknown&)
 {
 self_type temp(e);
- do_subtract(detail::mp_exp<detail::terminal, self_type>(temp), detail::terminal());
+ do_subtract(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
 }

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

template <class Backend, bool ExpressionTemplates>
-inline std::ostream& operator << (std::ostream& os, const mp_number<Backend, ExpressionTemplates>& r)
+inline std::ostream& operator << (std::ostream& os, const number<Backend, ExpressionTemplates>& r)
{
 std::streamsize d = os.precision();
 std::string s = r.str(d, os.flags());
@@ -1569,9 +1569,9 @@
namespace detail{

template <class tag, class A1, class A2, class A3, class A4>
-inline std::ostream& operator << (std::ostream& os, const mp_exp<tag, A1, A2, A3, A4>& r)
+inline std::ostream& operator << (std::ostream& os, const expression<tag, A1, A2, A3, A4>& r)
{
- typedef typename mp_exp<tag, A1, A2, A3, A4>::result_type value_type;
+ typedef typename expression<tag, A1, A2, A3, A4>::result_type value_type;
 value_type temp(r);
 return os << temp;
}
@@ -1579,7 +1579,7 @@
} // namespace detail

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

template <class Backend, bool ExpressionTemplates>
-BOOST_FORCEINLINE void swap(mp_number<Backend, ExpressionTemplates>& a, mp_number<Backend, ExpressionTemplates>& b)
+BOOST_FORCEINLINE void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b)
{
 a.swap(b);
}
@@ -1599,10 +1599,10 @@
class rational;

template <class Backend, bool ExpressionTemplates>
-inline std::istream& operator >> (std::istream& is, rational<multiprecision::mp_number<Backend, ExpressionTemplates> >& r)
+inline std::istream& operator >> (std::istream& is, rational<multiprecision::number<Backend, ExpressionTemplates> >& r)
{
 std::string s1;
- multiprecision::mp_number<Backend, ExpressionTemplates> v1, v2;
+ multiprecision::number<Backend, ExpressionTemplates> v1, v2;
 char c;
 bool have_hex = false;

@@ -1634,37 +1634,37 @@
}

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

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

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

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

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

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

template <class V, class Backend, bool ExpressionTemplates>
-inline bool operator == (const sparse_vector_element<V>& a, const ::boost::multiprecision::mp_number<Backend, ExpressionTemplates>& b)
+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;
 return static_cast<ref_type>(a) == b;

Modified: sandbox/big_number/boost/multiprecision/random.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/random.hpp (original)
+++ sandbox/big_number/boost/multiprecision/random.hpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -8,7 +8,7 @@
#ifndef BOOST_MP_RANDOM_HPP
#define BOOST_MP_RANDOM_HPP

-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>

namespace boost{ namespace random{ namespace detail{
//
@@ -18,8 +18,8 @@
// UDT's and depricate/remove this header altogether.
//
template<class Engine, class Backend, bool ExpressionTemplates>
-boost::multiprecision::mp_number<Backend, ExpressionTemplates>
- generate_uniform_int(Engine& eng, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& max_value);
+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);

}}}

@@ -31,20 +31,20 @@
namespace detail{

template<class Backend, bool ExpressionTemplates>
-struct subtract<boost::multiprecision::mp_number<Backend, ExpressionTemplates>, true>
+struct subtract<boost::multiprecision::number<Backend, ExpressionTemplates>, true>
{
- typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+ typedef boost::multiprecision::number<Backend, ExpressionTemplates> result_type;
 result_type operator()(result_type const& x, result_type const& y) { return x - y; }
};

}

template<class Engine, std::size_t w, class Backend, bool ExpressionTemplates>
-class independent_bits_engine<Engine, w, boost::multiprecision::mp_number<Backend, ExpressionTemplates> >
+class independent_bits_engine<Engine, w, boost::multiprecision::number<Backend, ExpressionTemplates> >
{
public:
 typedef Engine base_type;
- typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+ typedef boost::multiprecision::number<Backend, ExpressionTemplates> result_type;

 static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
 { return 0; }
@@ -199,11 +199,11 @@
};

template<class Backend, bool ExpressionTemplates>
-class uniform_smallint<boost::multiprecision::mp_number<Backend, ExpressionTemplates> >
+class uniform_smallint<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
public:
- typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> input_type;
- typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+ typedef boost::multiprecision::number<Backend, ExpressionTemplates> input_type;
+ typedef boost::multiprecision::number<Backend, ExpressionTemplates> result_type;

 class param_type
 {
@@ -382,22 +382,22 @@
namespace detail{

template<class Backend, bool ExpressionTemplates>
-struct select_uniform_01<boost::multiprecision::mp_number<Backend, ExpressionTemplates> >
+struct select_uniform_01<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
 template<class RealType>
 struct apply
 {
- typedef new_uniform_01<boost::multiprecision::mp_number<Backend, ExpressionTemplates> > type;
+ typedef new_uniform_01<boost::multiprecision::number<Backend, ExpressionTemplates> > type;
 };
};

template<class Engine, class Backend, bool ExpressionTemplates>
-boost::multiprecision::mp_number<Backend, ExpressionTemplates>
+boost::multiprecision::number<Backend, ExpressionTemplates>
 generate_uniform_int(
- Engine& eng, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& max_value,
+ Engine& eng, const boost::multiprecision::number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::number<Backend, ExpressionTemplates>& max_value,
 boost::mpl::true_ /** is_integral<Engine::result_type> */)
{
- typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+ typedef boost::multiprecision::number<Backend, ExpressionTemplates> result_type;
 // Since we're using big-numbers, use the result type for all internal calculations:
 typedef result_type range_type;
 typedef result_type base_result;
@@ -558,8 +558,8 @@
}

template<class Engine, class Backend, bool ExpressionTemplates>
-inline boost::multiprecision::mp_number<Backend, ExpressionTemplates>
- generate_uniform_int(Engine& eng, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& max_value)
+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)
{
 typedef typename Engine::result_type base_result;
 typedef typename mpl::or_<boost::is_integral<base_result>, mpl::bool_<boost::multiprecision::number_category<Backend>::value == boost::multiprecision::number_kind_integer> >::type tag_type;

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -11,7 +11,7 @@
#include <sstream>
#include <boost/cstdint.hpp>
#include <boost/lexical_cast.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/rational.hpp>

namespace boost{
@@ -21,7 +21,7 @@
template <class IntBackend>
struct rational_adapter
{
- typedef mp_number<IntBackend> integer_type;
+ typedef number<IntBackend> integer_type;
 typedef boost::rational<integer_type> rational_type;

 typedef typename IntBackend::signed_types signed_types;
@@ -62,7 +62,7 @@
 rational_adapter& operator = (const char* s)
 {
 std::string s1;
- multiprecision::mp_number<IntBackend> v1, v2;
+ multiprecision::number<IntBackend> v1, v2;
 char c;
 bool have_hex = false;
 const char* p = s; // saved for later
@@ -178,12 +178,12 @@
}

template <class IntBackend>
-inline mp_number<IntBackend> numerator(const mp_number<rational_adapter<IntBackend> >& val)
+inline number<IntBackend> numerator(const number<rational_adapter<IntBackend> >& val)
{
 return val.backend().data().numerator();
}
template <class IntBackend>
-inline mp_number<IntBackend> denominator(const mp_number<rational_adapter<IntBackend> >& val)
+inline number<IntBackend> denominator(const number<rational_adapter<IntBackend> >& val)
{
 return val.backend().data().denominator();
}
@@ -204,7 +204,7 @@
template <class T>
struct component_type<rational_adapter<T> >
{
- typedef mp_number<T> type;
+ typedef number<T> type;
};

}} // namespaces
@@ -213,10 +213,10 @@
namespace std{

template <class IntBackend, bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> > : public std::numeric_limits<boost::multiprecision::mp_number<IntBackend, 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::mp_number<IntBackend> > base_type;
- typedef boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<IntBackend> > number_type;
+ typedef std::numeric_limits<boost::multiprecision::number<IntBackend> > base_type;
+ typedef boost::multiprecision::number<boost::multiprecision::rational_adapter<IntBackend> > number_type;
public:
 BOOST_STATIC_CONSTEXPR bool is_integer = false;
 BOOST_STATIC_CONSTEXPR bool is_exact = true;
@@ -234,9 +234,9 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

template <class IntBackend, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> >::is_integer;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> >::is_integer;
template <class IntBackend, bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<IntBackend>, ExpressionTemplates> >::is_exact;
+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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -6,7 +6,7 @@
#ifndef BOOST_MATH_MP_TOMMATH_BACKEND_HPP
#define BOOST_MATH_MP_TOMMATH_BACKEND_HPP

-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/rational_adapter.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
@@ -603,18 +603,18 @@
template<>
struct number_category<tommath_int> : public mpl::int_<number_kind_integer>{};

-typedef mp_number<tommath_int > tom_int;
+typedef number<tommath_int > tom_int;
typedef rational_adapter<tommath_int> tommath_rational;
-typedef mp_number<tommath_rational> tom_rational;
+typedef number<tommath_rational> tom_rational;

}} // namespaces

namespace std{

template<bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> number_type;
public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
//
@@ -663,49 +663,49 @@
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_digits10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_digits10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_signed;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_signed;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_integer;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_integer;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_exact;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_exact;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::radix;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::radix;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent10;
+BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent10;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_infinity;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_infinity;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_quiet_NaN;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_quiet_NaN;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_signaling_NaN;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_signaling_NaN;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm;
+BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm_loss;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm_loss;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_iec559;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_iec559;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_bounded;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_bounded;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_modulo;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_modulo;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::traps;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::traps;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::tinyness_before;
+BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::tinyness_before;
template <bool ExpressionTemplates>
-BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::tommath_int, ExpressionTemplates> >::round_style;
+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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -59,7 +59,7 @@

The Multiprecision library comes in two distinct parts:

-* An expression-template-enabled front-end `mp_number`
+* An expression-template-enabled front-end `number`
that handles all the operator overloading, expression evaluation optimization, and code reduction.
* A selection of back-ends that implement the actual arithmetic operations, and need conform only to the
reduced interface requirements of the front-end.
@@ -76,7 +76,7 @@

 boost::multiprecision::mpz_int myint; // Arbitrary precision integer type.

-Alternatively, you can compose your own multiprecision type, by combining `mp_number` with one of the
+Alternatively, you can compose your own multiprecision type, by combining `number` with one of the
predefined back-end types. For example, suppose you wanted a 300 decimal digit floating-point type
based on the [mpfr] library. In this case, there's no predefined typedef with that level of precision,
so instead we compose our own:
@@ -85,18 +85,18 @@

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

- typedef mp::mp_number<mp::mpfr_float_backend<300> > my_float;
+ typedef mp::number<mp::mpfr_float_backend<300> > my_float;

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

We can repeat the above example, but with the expression templates disabled (for faster compile times, but slower runtimes)
-by passing a second template argument to `mp_number`:
+by passing a second template argument to `number`:

 #include <boost/multiprecision/mpfr.hpp> // Defines the Backend type that wraps MPFR

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

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

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

@@ -106,8 +106,8 @@

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

- mp::mp_int128_t a(3), b(2);
- mp::mp_int512_t c(50), d;
+ mp::int128_t a(3), b(2);
+ mp::int512_t c(50), d;

 d = c * a; // Compiler error

@@ -115,19 +115,19 @@

 d = a; // OK, widening conversion.
 d = a * b; // OK, can convert from an expression template too.
- d = mp::mp_int512_t(a) * c; // OK, all the types in the expression are the same now.
+ d = mp::int512_t(a) * c; // OK, all the types in the expression are the same now.

[h4 Expression Templates]

TODO: compare to rvalue refs.

-Class `mp_number` is expression-template-enabled: that means that rather than having a multiplication
+Class `number` is expression-template-enabled: that means that rather than having a multiplication
operator that looks like this:

 template <class Backend>
- mp_number<Backend> operator * (const mp_number<Backend>& a, const mp_number<Backend>& b)
+ number<Backend> operator * (const number<Backend>& a, const number<Backend>& b)
 {
- mp_number<Backend> result(a);
+ number<Backend> result(a);
 result *= b;
 return result;
 }
@@ -135,7 +135,7 @@
Instead the operator looks more like this:

 template <class Backend>
- ``['unmentionable-type]`` operator * (const mp_number<Backend>& a, const mp_number<Backend>& b);
+ ``['unmentionable-type]`` operator * (const number<Backend>& a, const number<Backend>& b);

Where the "unmentionable" return type is an implementation detail that, rather than containing the result
of the multiplication, contains instructions on how to compute the result. In effect it's just a pair
@@ -151,7 +151,7 @@
 //....
 y = (((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0];

-If type `T` is an `mp_number`, then this expression is evaluated ['without creating a single temporary value]. In contrast,
+If type `T` is an `number`, then this expression is evaluated ['without creating a single temporary value]. In contrast,
if we were using the [mpfr_class] C++ wrapper for [mpfr] - then this expression would result in no less than 11
temporaries (this is true even though [mpfr_class] does use expression templates to reduce the number of temporaries somewhat). Had
we used an even simpler wrapper around [mpfr] like [mpreal] things would have been even worse and no less that 24 temporaries
@@ -164,7 +164,7 @@
[footnote Marc Glisse suggested pre-review that this could be reduced still further by careful use of rvalue-references
and move semantics in the operator overloads. This will be investigated further at a later date.].

-This library also extends expression template support to standard library functions like `abs` or `sin` with `mp_number`
+This library also extends expression template support to standard library functions like `abs` or `sin` with `number`
arguments. This means that an expression such as:

 y = abs(x);
@@ -185,7 +185,7 @@
sadly though, all tricks like this have their downsides. For one thing, expression template libraries
like this one, tend to be slower to compile than their simpler cousins, they're also harder to debug
(should you actually want to step through our code!), and rely on compiler optimizations being turned
-on to give really good performance. Also, since the return type from expressions involving `mp_number`s
+on to give really good performance. Also, since the return type from expressions involving `number`s
is an "unmentionable implementation detail", you have to be careful to cast the result of an expression
to the actual number type when passing an expression to a template function. For example, given:

@@ -224,7 +224,7 @@

[table Evaluation of Order 6 Polynomial.
[[Library][Relative Time][Relative number of memory allocations]]
-[[mp_number][1.0 (0.00793s)][1.0 (2996 total)]]
+[[number][1.0 (0.00793s)][1.0 (2996 total)]]
[[[mpfr_class]][1.2 (0.00931s)][4.3 (12976 total)]]
[[[mpreal]][1.9 (0.0148s)][9.3 (27947 total)]]
]
@@ -241,7 +241,7 @@
transformation is more efficient than creating the extra temporary variable, just not by as much as
one would hope.

-Finally, note that `mp_number` takes a second template argument, which, when set to `false` disables all
+Finally, note that `number` takes a second template argument, which, when set to `false` disables all
the expression template machinery. The result is much faster to compile, but slower at runtime.

We'll conclude this section by providing some more performance comparisons between these three libraries,
@@ -252,14 +252,14 @@

[table Evaluation of Boost.Math's Bessel function test data
[[Library][Relative Time][Relative Number of Memory Allocations]]
-[[mp_number][1.0 (6.21s)][1.0 (2685469)]]
+[[number][1.0 (6.21s)][1.0 (2685469)]]
[[[mpfr_class]][1.04 (6.45s)][1.47 (3946007)]]
[[[mpreal]][1.53 (9.52s)][4.92 (13222940)]]
]

[table Evaluation of Boost.Math's Non-Central T distribution test data
[[Library][Relative Time][Relative Number of Memory Allocations]]
-[[mp_number][1.0 (269s)][1.0 (139082551)]]
+[[number][1.0 (269s)][1.0 (139082551)]]
[[[mpfr_class]][1.04 (278s)][1.81 (252400791)]]
[[[mpreal]][1.49 (401s)][3.22 (447009280)]]
]
@@ -294,28 +294,28 @@
 template <unsigned MinDigits = 0, bool Signed = true, class Allocator = std::allocator<limb_type> >
 class cpp_int_backend;

- typedef mp_number<cpp_int_backend<> > cpp_int; // arbitrary precision integer
+ typedef number<cpp_int_backend<> > cpp_int; // arbitrary precision integer
 typedef rational_adapter<cpp_int_backend<> > cpp_rational_backend;
- typedef mp_number<cpp_rational_backend> cpp_rational; // arbitrary precision rational number
+ typedef number<cpp_rational_backend> cpp_rational; // arbitrary precision rational number

 // Fixed precision unsigned types:
- typedef mp_number<cpp_int_backend<128, false, void>, false> mp_uint128_t;
- typedef mp_number<cpp_int_backend<256, false, void>, false> mp_uint256_t;
- typedef mp_number<cpp_int_backend<512, false, void>, false> mp_uint512_t;
- typedef mp_number<cpp_int_backend<1024, false, void>, false> mp_uint1024_t;
+ 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;

 // Fixed precision signed types:
- typedef mp_number<cpp_int_backend<128, true, void>, false> mp_int128_t;
- typedef mp_number<cpp_int_backend<256, true, void>, false> mp_int256_t;
- typedef mp_number<cpp_int_backend<512, true, void>, false> mp_int512_t;
- typedef mp_number<cpp_int_backend<1024, true, void>, false> mp_int1024_t;
+ 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;

 }} // namespaces

The `cpp_int_backend` type is used via one of the typedefs `boost::multiprecision::cpp_int`,
-`boost::multiprecision::mp_uint128_t`, `boost::multiprecision::mp_uint256_t`,
-`boost::multiprecision::mp_uint512_t`, `boost::multiprecision::mp_int128_t`, `boost::multiprecision::mp_int256_t`
-or `boost::multiprecision::mp_int512_t`.
+`boost::multiprecision::uint128_t`, `boost::multiprecision::uint256_t`,
+`boost::multiprecision::uint512_t`, `boost::multiprecision::int128_t`, `boost::multiprecision::int256_t`
+or `boost::multiprecision::int512_t`.

This back-end is the "Swiss Army Knife" of integer types as it can represent both fixed and
[@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision]
@@ -343,7 +343,7 @@
* Since the precision of `cpp_int_backend` is necessarily limited when the allocator parameter is void,
care should be taken to avoid numeric overflow when using this type
unless you actually want modulo-arithmetic behavior.
-* The type uses a sign-magnitude representation internally, so type `mp_int128_t` has 128-bits of precision plus an extra sign bit.
+* The type uses a sign-magnitude representation internally, so type `int128_t` has 128-bits of precision plus an extra sign bit.
In this respect the behaviour of these types differs from built-in 2's complement types. In might be tempting to use a
127-bit type instead, and indeed this does work, but behaviour is still slightly different from a 2's complement built-in type
as the min and max values are identical (apart from the sign), where as they differ by one for a true 2's complement type.
@@ -356,9 +356,9 @@
the feature off.
* Unsigned types support subtraction, and unary negation - the result is "as if" a 2's complement operation had been performed
 - in other words they behave pretty much as a built in integer type would in this situation. So for example if we were using
- `mp_uint128_t` then both `mp_uint128_t(1)-4` and `-mp_uint128(3)` would result in the value `0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD`
- of type `mp_uint128_t`.
-* This backend supports rvalue-references and is move-aware, making instantiations of `mp_number` on this backend move aware.
+ `uint128_t` then both `uint128_t(1)-4` and `-uint128(3)` would result in the value `0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD`
+ of type `uint128_t`.
+* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.


[h5 Example:]
@@ -375,7 +375,7 @@

 class gmp_int;

- typedef mp_number<gmp_int > mpz_int;
+ typedef number<gmp_int > mpz_int;

 }} // namespaces

@@ -385,7 +385,7 @@
As well as the usual conversions from arithmetic and string types, type `mpz_int` is copy constructible and assignable from:

* The [gmp] native types: `mpf_t`, `mpz_t`, `mpq_t`.
-* Instances of `mp_number<T>` that are wrappers around those types: `mp_number<gmp_float<N> >`, `mp_number<gmp_rational>`.
+* Instances of `number<T>` that are wrappers around those types: `number<gmp_float<N> >`, `number<gmp_rational>`.

It's also possible to access the underlying `mpz_t` via the `data()` member function of `gmp_int`.

@@ -402,7 +402,7 @@
* Division by zero results in a `std::runtime_error` being thrown.
* Although this type is a wrapper around [gmp] it will work equally well with [mpir]. Indeed use of [mpir]
is recommended on Win32.
-* This backend supports rvalue-references and is move-aware, making instantiations of `mp_number` on this backend move aware.
+* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.

[h5 Example:]

@@ -418,7 +418,7 @@

 class tommath_int;

- typedef mp_number<tommath_int > tom_int;
+ typedef number<tommath_int > tom_int;

 }} // namespaces

@@ -481,15 +481,15 @@
 template <unsigned Digits10>
 class gmp_float;

- typedef mp_number<gmp_float<50> > mpf_float_50;
- typedef mp_number<gmp_float<100> > mpf_float_100;
- typedef mp_number<gmp_float<500> > mpf_float_500;
- typedef mp_number<gmp_float<1000> > mpf_float_1000;
- typedef mp_number<gmp_float<0> > mpf_float;
+ typedef number<gmp_float<50> > mpf_float_50;
+ typedef number<gmp_float<100> > mpf_float_100;
+ typedef number<gmp_float<500> > mpf_float_500;
+ typedef number<gmp_float<1000> > mpf_float_1000;
+ typedef number<gmp_float<0> > mpf_float;

 }} // namespaces

-The `gmp_float` back-end is used in conjunction with `mp_number` : it acts as a thin wrapper around the [gmp] `mpf_t`
+The `gmp_float` back-end is used in conjunction with `number` : it acts as a thin wrapper around the [gmp] `mpf_t`
to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

@@ -497,15 +497,15 @@
at variable precision by setting the template argument to zero. The typedefs mpf_float_50, mpf_float_100,
mpf_float_500, mpf_float_1000 provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
respectively. The typedef mpf_float provides a variable precision type whose precision can be controlled via the
-`mp_number`s member functions.
+`number`s member functions.

[note This type only provides standard library and `numeric_limits` support when the precision is fixed at compile time.]

-As well as the usual conversions from arithmetic and string types, instances of `mp_number<mpf_float<N> >` are
+As well as the usual conversions from arithmetic and string types, instances of `number<mpf_float<N> >` are
copy constructible and assignable from:

* The [gmp] native types `mpf_t`, `mpz_t`, `mpq_t`.
-* The `mp_number` wrappers around those types: `mp_number<mpf_float<M> >`, `mp_number<gmp_int>`, `mp_number<gmp_rational>`.
+* The `number` wrappers around those types: `number<mpf_float<M> >`, `number<gmp_int>`, `number<gmp_rational>`.

It's also possible to access the underlying `mpf_t` via the `data()` member function of `gmp_float`.

@@ -514,7 +514,7 @@
* Default constructed `gmp_float`s have the value zero (this is the [gmp] library's default behavior).
* No changes are made to the [gmp] library's global settings, so this type can be safely mixed with
existing [gmp] code.
-* This backend supports rvalue-references and is move-aware, making instantiations of `mp_number` on this backend move aware.
+* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* It is not possible to round-trip objects of this type to and from a string and get back
exactly the same value. This appears to be a limitation of [gmp].
* Since the underlying [gmp] types have no notion of infinities or NaN's, care should be taken
@@ -543,15 +543,15 @@
 template <unsigned Digits10>
 class mpfr_float_backend;

- typedef mp_number<mpfr_float_backend<50> > mpfr_float_50;
- typedef mp_number<mpfr_float_backend<100> > mpfr_float_100;
- typedef mp_number<mpfr_float_backend<500> > mpfr_float_500;
- typedef mp_number<mpfr_float_backend<1000> > mpfr_float_1000;
- typedef mp_number<mpfr_float_backend<0> > mpfr_float;
+ typedef number<mpfr_float_backend<50> > mpfr_float_50;
+ typedef number<mpfr_float_backend<100> > mpfr_float_100;
+ typedef number<mpfr_float_backend<500> > mpfr_float_500;
+ typedef number<mpfr_float_backend<1000> > mpfr_float_1000;
+ typedef number<mpfr_float_backend<0> > mpfr_float;

 }} // namespaces

-The `mpfr_float_backend` type is used in conjunction with `mp_number`: It acts as a thin wrapper around the [mpfr] `mpfr_t`
+The `mpfr_float_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpfr] `mpfr_t`
to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

@@ -559,16 +559,16 @@
at variable precision by setting the template argument to zero. The typedefs mpfr_float_50, mpfr_float_100,
mpfr_float_500, mpfr_float_1000 provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
respectively. The typedef mpfr_float provides a variable precision type whose precision can be controlled via the
-`mp_number`s member functions.
+`number`s member functions.

[note This type only provides `numeric_limits` support when the precision is fixed at compile time.]

-As well as the usual conversions from arithmetic and string types, instances of `mp_number<mpfr_float_backend<N> >` are
+As well as the usual conversions from arithmetic and string types, instances of `number<mpfr_float_backend<N> >` are
copy constructible and assignable from:

* The [gmp] native types `mpf_t`, `mpz_t`, `mpq_t`.
* The [mpfr] native type `mpfr_t`.
-* The `mp_number` wrappers around those types: `mp_number<mpfr_float_backend<M> >`, `mp_number<mpf_float<M> >`, `mp_number<gmp_int>`, `mp_number<gmp_rational>`.
+* The `number` wrappers around those types: `number<mpfr_float_backend<M> >`, `number<mpf_float<M> >`, `number<gmp_int>`, `number<gmp_rational>`.

It's also possible to access the underlying `mpf_t` via the data() member function of `gmp_float`.

@@ -579,7 +579,7 @@
* No changes are made to [gmp] or [mpfr] global settings, so this type can coexist with existing
[mpfr] or [gmp] code.
* The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
-* This backend supports rvalue-references and is move-aware, making instantiations of `mp_number` on this backend move aware.
+* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating point number.
* Division by zero results in an infinity.
@@ -599,12 +599,12 @@
 template <unsigned Digits10>
 class cpp_dec_float;

- typedef mp_number<cpp_dec_float<50> > cpp_dec_float_50;
- typedef mp_number<cpp_dec_float<100> > cpp_dec_float_100;
+ typedef number<cpp_dec_float<50> > cpp_dec_float_50;
+ typedef number<cpp_dec_float<100> > cpp_dec_float_100;

 }} // namespaces

-The `cpp_dec_float` back-end is used in conjunction with `mp_number`: It acts as an entirely C++ (header only and dependency free)
+The `cpp_dec_float` back-end is used in conjunction with `number`: It acts as an entirely C++ (header only and dependency free)
real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

@@ -625,8 +625,8 @@
* The type supports both infinities and NaN's. An infinity is generated whenever the result would overflow,
and a NaN is generated for any mathematically undefined operation.
* There is a `std::numeric_limits` specialisation for this type.
-* Any `mp_number` instantiated on this type, is convertible to any other `mp_number` instantiated on this type -
-for example you can convert from `mp_number<cpp_dec_float<50> >` to `mp_number<cpp_dec_float<SomeOtherValue> >`.
+* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
+for example you can convert from `number<cpp_dec_float<50> >` to `number<cpp_dec_float<SomeOtherValue> >`.
Narrowing conversions are truncating.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating point number.
@@ -690,7 +690,7 @@
[[`cpp_rational`][boost/multiprecision/cpp_int.hpp][2][None][An all C++ Boost-licensed implementation.][Slower than [gmp].]]
[[`tommath_rational`][boost/multiprecision/tommath.hpp][2][[tommath]][All C/C++ implementation that's Boost Software Licence compatible.][Slower than [gmp].]]
[[`rational_adapter`][boost/multiprecision/rational_adapter.hpp][N/A][none][All C++ adapter that allows any integer back-end type to be used as a rational type.][Requires an underlying integer back-end type.]]
-[[`boost::rational`][boost/rational.hpp][N/A][None][A C++ rational number type that can used with any `mp_number` integer type.][The expression templates used by `mp_number` end up being "hidden" inside `boost::rational`: performance may well suffer as a result.]]
+[[`boost::rational`][boost/rational.hpp][N/A][None][A C++ rational number type that can used with any `number` integer type.][The expression templates used by `number` end up being "hidden" inside `boost::rational`: performance may well suffer as a result.]]
]

[section:gmp_rational gmp_rational]
@@ -701,20 +701,20 @@

 class gmp_rational;

- typedef mp_number<gmp_rational > mpq_rational;
+ typedef number<gmp_rational > mpq_rational;

 }} // namespaces

The `gmp_rational` back-end is used via the typedef `boost::multiprecision::mpq_rational`. It acts as a thin wrapper around the [gmp] `mpq_t`
to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision.

-As well as the usual conversions from arithmetic and string types, instances of `mp_number<gmp_rational>` are copy constructible
+As well as the usual conversions from arithmetic and string types, instances of `number<gmp_rational>` are copy constructible
and assignable from:

* The [gmp] native types: `mpz_t`, `mpq_t`.
-* `mp_number<gmp_int>`.
+* `number<gmp_int>`.

-There is also a two-argument constructor that accepts a numerator and denominator (both of type `mp_number<gmp_int>`).
+There is also a two-argument constructor that accepts a numerator and denominator (both of type `number<gmp_int>`).

There are also non-member functions:

@@ -749,7 +749,7 @@

 typedef rational_adapter<cpp_int_backend<> > cpp_rational_backend;

- typedef mp_number<cpp_rational_backend> cpp_rational;
+ typedef number<cpp_rational_backend> cpp_rational;

 }} // namespaces

@@ -788,7 +788,7 @@
 namespace boost{ namespace multiprecision{

 typedef rational_adpater<tommath_int> tommath_rational;
- typedef mp_number<tommath_rational > tom_rational;
+ typedef number<tommath_rational > tom_rational;

 }} // namespaces

@@ -826,7 +826,7 @@

All of the integer types in this library can be used as template arguments to `boost::rational<IntType>`.

-Note that using the library in this way largely negates the effect of the expression templates in `mp_number`.
+Note that using the library in this way largely negates the effect of the expression templates in `number`.

[endsect]

@@ -839,13 +839,13 @@

 }}

-The class template `rational_adapter` is a back-end for `mp_number` which converts any existing integer back-end
+The class template `rational_adapter` is a back-end for `number` which converts any existing integer back-end
into a rational-number back-end.

So for example, given an integer back-end type `MyIntegerBackend`, the use would be something like:

- typedef mp_number<MyIntegerBackend> MyInt;
- typedef mp_number<rational_adapter<MyIntegerBackend> > MyRational;
+ typedef number<MyIntegerBackend> MyInt;
+ typedef number<rational_adapter<MyIntegerBackend> > MyRational;

 MyRational r = 2;
 r /= 3;
@@ -858,7 +858,7 @@

[section:conversions Constructing and Interconverting Between Number Types]

-All of the number types that are based on `mp_number` have certain conversion rules in common.
+All of the number types that are based on `number` have certain conversion rules in common.
In particular:

* Any number type can be constructed (or assigned) from any builtin arithmetic type:
@@ -921,7 +921,7 @@

More information on what additional types a backend supports conversions from are given in the tutorial for each backend.

-* An `mp_number` can be converted to any built in type, via the `convert_to` member function:
+* An `number` can be converted to any built in type, via the `convert_to` member function:

 mpz_int z(2);
 int i = z.template convert_to<int>(); // sets i to 2
@@ -968,10 +968,10 @@
 #include <boost/multiprecision/miller_rabin.hpp>

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

 template <class Backend, bool ExpressionTemplates, class Engine>
- bool miller_rabin_test(const mp_number<Backend, ExpressionTemplates>& n, unsigned trials);
+ 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,
while if the result is `true` then /n/ is prime with probability ['0.25^trials]. The algorithm used performs some
@@ -994,40 +994,40 @@

[section:ref Reference]

-[section:mp_number mp_number]
+[section:number number]

[h4 Synopsis]

 namespace boost{ namespace multiprecision{

 template <class Backend, bool ExpressionTemplates = true>
- class mp_number
+ class number
 {
- mp_number();
- mp_number(see-below);
- mp_number& operator=(see-below);
+ number();
+ number(see-below);
+ number& operator=(see-below);

 // Member operators
- mp_number& operator+=(const ``['see-below]``&);
- mp_number& operator-=(const ``['see-below]``&);
- mp_number& operator*=(const ``['see-below]``&);
- mp_number& operator/=(const ``['see-below]``&);
- mp_number& operator++();
- mp_number& operator--();
- mp_number operator++(int);
- mp_number operator--(int);
-
- mp_number& operator%=(const ``['see-below]``&);
- mp_number& operator&=(const ``['see-below]``&);
- mp_number& operator|=(const ``['see-below]``&);
- mp_number& operator^=(const ``['see-below]``&);
- mp_number& operator<<=(const ``['integer-type]``&);
- mp_number& operator>>=(const ``['integer-type]``&);
+ number& operator+=(const ``['see-below]``&);
+ number& operator-=(const ``['see-below]``&);
+ number& operator*=(const ``['see-below]``&);
+ number& operator/=(const ``['see-below]``&);
+ number& operator++();
+ number& operator--();
+ number operator++(int);
+ number operator--(int);
+
+ number& operator%=(const ``['see-below]``&);
+ number& operator&=(const ``['see-below]``&);
+ number& operator|=(const ``['see-below]``&);
+ number& operator^=(const ``['see-below]``&);
+ number& operator<<=(const ``['integer-type]``&);
+ number& operator>>=(const ``['integer-type]``&);

 // Use in Boolean context:
 operator ``['convertible-to-bool-type]``()const;
 // swap:
- void swap(mp_number& other);
+ void swap(number& other);
 // Sign:
 bool is_zero()const;
 int sign()const;
@@ -1042,7 +1042,7 @@
 unsigned precision()const;
 void precision(unsigned digits10);
 // Comparison:
- int compare(const mp_number<Backend>& o)const;
+ int compare(const number<Backend>& o)const;
 template <class V>
 typename enable_if<is_arithmetic<V>, int>::type compare(const V& o)const;
 // Access to the underlying implementation:
@@ -1074,47 +1074,47 @@

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

 // iostream support:
 template <class Backend, bool ExpressionTemplates>
- std::ostream& operator << (std::ostream& os, const mp_number<Backend, ExpressionTemplates>& r);
+ 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>
- std::istream& operator >> (std::istream& is, mp_number<Backend, ExpressionTemplates>& r);
+ std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r);

 // Non-member function standard library support:
- ``['unmentionable-expression-template-type]`` abs (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` fabs (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` sqrt (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` floor (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` ceil (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` trunc (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` itrunc (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` ltrunc (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` lltrunc(const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` round (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` iround (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` lround (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` llround(const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` exp (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` log (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` log10 (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` cos (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` sin (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` tan (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` acos (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` asin (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` atan (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` cosh (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` sinh (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` tanh (const ``['mp_number-or-expression-template-type]``&);
-
- ``['unmentionable-expression-template-type]`` ldexp (const ``['mp_number-or-expression-template-type]``&, int);
- ``['unmentionable-expression-template-type]`` frexp (const ``['mp_number-or-expression-template-type]``&, int*);
- ``['unmentionable-expression-template-type]`` pow (const ``['mp_number-or-expression-template-type]``&, const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` fmod (const ``['mp_number-or-expression-template-type]``&, const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` atan2 (const ``['mp_number-or-expression-template-type]``&, const ``['mp_number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` abs (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` fabs (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` sqrt (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` floor (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` ceil (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` trunc (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` itrunc (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` ltrunc (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` lltrunc(const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` round (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` iround (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` lround (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` llround(const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` exp (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` log (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` log10 (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` cos (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` sin (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` tan (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` acos (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` asin (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` atan (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` cosh (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` sinh (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` tanh (const ``['number-or-expression-template-type]``&);
+
+ ``['unmentionable-expression-template-type]`` ldexp (const ``['number-or-expression-template-type]``&, int);
+ ``['unmentionable-expression-template-type]`` frexp (const ``['number-or-expression-template-type]``&, int*);
+ ``['unmentionable-expression-template-type]`` pow (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` fmod (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` atan2 (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

 // Traits support:
 template <class T>
@@ -1123,40 +1123,40 @@
 struct number_category;

 // Integer specific functions:
- ``['unmentionable-expression-template-type]`` pow(const ``['mp_number-or-expression-template-type]``&, unsigned);
- ``['unmentionable-expression-template-type]`` powm(const ``['mp_number-or-expression-template-type]``& b, const ``['mp_number-or-expression-template-type]``& p, const ``['mp_number-or-expression-template-type]``& m);
+ ``['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>
- void divide_qr(const ``['mp_number-or-expression-template-type]``& x, const ``['mp_number-or-expression-template-type]``& y,
- mp_number<Backend, ExpressionTemplates>& q, mp_number<Backend, ExpressionTemplates>& r);
+ 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>
- Integer integer_modulus(const ``['mp_number-or-expression-template-type]``& x, Integer val);
- unsigned lsb(const ``['mp_number-or-expression-template-type]``& x);
+ Integer integer_modulus(const ``['number-or-expression-template-type]``& x, Integer val);
+ unsigned lsb(const ``['number-or-expression-template-type]``& x);
 template <class Backend, class ExpressionTemplates>
- bool bit_test(const mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ bool bit_test(const number<Backend, ExpressionTemplates>& val, unsigned index);
 template <class Backend, class ExpressionTemplates>
- mp_number<Backend, ExpressionTemplates>& bit_set(mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ number<Backend, ExpressionTemplates>& bit_set(number<Backend, ExpressionTemplates>& val, unsigned index);
 template <class Backend, class ExpressionTemplates>
- mp_number<Backend, ExpressionTemplates>& bit_unset(mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ number<Backend, ExpressionTemplates>& bit_unset(number<Backend, ExpressionTemplates>& val, unsigned index);
 template <class Backend, class ExpressionTemplates>
- mp_number<Backend, ExpressionTemplates>& bit_flip(mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ number<Backend, ExpressionTemplates>& bit_flip(number<Backend, ExpressionTemplates>& val, unsigned index);
 template <class Engine>
- bool miller_rabin_test(const ``['mp_number-or-expression-template-type]``& n, unsigned trials, Engine& gen);
- bool miller_rabin_test(const ``['mp_number-or-expression-template-type]``& n, unsigned trials);
+ bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials, Engine& gen);
+ bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials);

 // Rational number support:
- typename component_type<``['mp_number-or-expression-template-type]``>::type numerator (const ``['mp_number-or-expression-template-type]``&);
- typename component_type<``['mp_number-or-expression-template-type]``>::type denominator(const ``['mp_number-or-expression-template-type]``&);
+ typename component_type<``['number-or-expression-template-type]``>::type numerator (const ``['number-or-expression-template-type]``&);
+ typename component_type<``['number-or-expression-template-type]``>::type denominator(const ``['number-or-expression-template-type]``&);

 }} // namespaces

 namespace boost{ namespace math{

 // Boost.Math interoperability functions:
- int fpclassify (const ``['mp_number-or-expression-template-type]``&, int);
- bool isfinite (const ``['mp_number-or-expression-template-type]``&, int);
- bool isnan (const ``['mp_number-or-expression-template-type]``&, int);
- bool isinf (const ``['mp_number-or-expression-template-type]``&, int);
- bool isnormal (const ``['mp_number-or-expression-template-type]``&, int);
+ int fpclassify (const ``['number-or-expression-template-type]``&, int);
+ bool isfinite (const ``['number-or-expression-template-type]``&, int);
+ bool isnan (const ``['number-or-expression-template-type]``&, int);
+ bool isinf (const ``['number-or-expression-template-type]``&, int);
+ bool isnormal (const ``['number-or-expression-template-type]``&, int);

 }} // namespaces

@@ -1174,77 +1174,77 @@
[h4 Description]

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

-Class `mp_number` has two template arguments:
+Class `number` has two template arguments:

[variablelist
[[Backend][The actual arithmetic back-end that does all the work.]]
[[ExpressionTemplates][A Boolean value: when true, then expression templates are enabled, otherwise they are disabled.]]
]

- mp_number();
- mp_number(see-below);
- mp_number& operator=(see-below);
+ number();
+ number(see-below);
+ number& operator=(see-below);

-Type `mp_number` is default constructible, and both copy constructible and assignable from:
+Type `number` is default constructible, and both copy constructible and assignable from:

* Itself.
* An expression template which is the result of one of the arithmetic operators.
* Any builtin arithmetic type.
* A `std::string` or any type which is convertible to `const char*`.
* Any type that the Backend is constructible or assignable from.
-* An rvalue reference to another `mp_number`. Move-semantics are used for construction if the backend also
+* An rvalue reference to another `number`. Move-semantics are used for construction if the backend also
supports rvalue reference construction. In the case of assignment, move semantics are always supported
when the argument is an rvalue reference irrespective of the backend.

In addition, if the type has multiple components (for example rational or complex number types), then there is a
two argument constructor:

- mp_number(arg1, arg2);
+ number(arg1, arg2);

Where the two args must either be arithmetic types, or types that are convertible to the two components of `this`.

- mp_number& operator+=(const ``['see-below]``&);
- mp_number& operator-=(const ``['see-below]``&);
- mp_number& operator*=(const ``['see-below]``&);
- mp_number& operator/=(const ``['see-below]``&);
- mp_number& operator++();
- mp_number& operator--();
- mp_number operator++(int);
- mp_number operator--(int);
+ number& operator+=(const ``['see-below]``&);
+ number& operator-=(const ``['see-below]``&);
+ number& operator*=(const ``['see-below]``&);
+ number& operator/=(const ``['see-below]``&);
+ number& operator++();
+ number& operator--();
+ number operator++(int);
+ number operator--(int);
 // Integer only operations:
- mp_number& operator%=(const ``['see-below]``&);
- mp_number& operator&=(const ``['see-below]``&);
- mp_number& operator|=(const ``['see-below]``&);
- mp_number& operator^=(const ``['see-below]``&);
- mp_number& operator<<=(const ``['integer-type]``&);
- mp_number& operator>>=(const ``['integer-type]``&);
+ number& operator%=(const ``['see-below]``&);
+ number& operator&=(const ``['see-below]``&);
+ number& operator|=(const ``['see-below]``&);
+ number& operator^=(const ``['see-below]``&);
+ number& operator<<=(const ``['integer-type]``&);
+ number& operator>>=(const ``['integer-type]``&);

These operators all take their usual arithmetic meanings.

The arguments to these operators is either:

-* Another `mp_number<Backend, ExpressionTemplates>`.
+* Another `number<Backend, ExpressionTemplates>`.
* A builtin arithmetic type.
-* An expression template derived from `mp_number<Backend>`.
+* An expression template derived from `number<Backend>`.

For the left and right shift operations, the argument must be a builtin
integer type with a positive value (negative values result in a `std::runtime_error` being thrown).

Note that all the types involved in the expression must evaluate to the same type - which is to say
-we cannot mix an `mp_number<B1>` with an `mp_number<B2>` where B1 and B2 are different types.
+we cannot mix an `number<B1>` with an `number<B2>` where B1 and B2 are different types.

 operator ``['convertible-to-bool-type]``()const;

-Returns an ['unmentionable-type] that is usable in Boolean contexts (this allows `mp_number` to be used in any
+Returns an ['unmentionable-type] that is usable in Boolean contexts (this allows `number` to be used in any
Boolean context - if statements, conditional statements, or as an argument to a logical operator - without
-type `mp_number` being convertible to type `bool`.
+type `number` being convertible to type `bool`.

-This operator also enables the use of `mp_number` with any of the following operators:
+This operator also enables the use of `number` with any of the following operators:
`!`, `||`, `&&` and `?:`.

- void swap(mp_number& other);
+ void swap(number& other);

Swaps `*this` with `other`.

@@ -1277,7 +1277,7 @@
These functions are only available if the Backend template parameter supports runtime changes to precision. They get and set
the default precision and the precision of `*this` respectively.

- int compare(const mp_number<Backend, ExpressionTemplates>& o)const;
+ int compare(const number<Backend, ExpressionTemplates>& o)const;
 template <class V>
 typename enable_if<is_arithmetic<V>, int>::type compare(const V& other)const;

@@ -1320,19 +1320,19 @@

The arguments to these functions must contain at least one of the following:

-* An `mp_number`.
-* An expression template type derived from `mp_number`.
+* An `number`.
+* An expression template type derived from `number`.

In addition, one of the two arguments may be a builtin arithmetic type.

The return type of these operators is either:

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

Note that all the types involved in the expression must evaluate to the same type - which is to say
-we cannot mix an `mp_number<B1>` with an `mp_number<B2>` where B1 and B2 are different types.
+we cannot mix an `number<B1>` with an `number<B2>` where B1 and B2 are different types.

Finally note that the second argument to the left and right shift operations must be a builtin integer type,
and that the argument must be positive (negative arguments result in a `std::runtime_error` being thrown).
@@ -1340,60 +1340,60 @@
[h4 swap]

 template <class Backend, ExpressionTemplates>
- void swap(mp_number<Backend, ExpressionTemplates>& a, mp_number<Backend, ExpressionTemplates>& b);
+ void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b);

Swaps `a` and `b`.

[h4 Iostream Support]

 template <class Backend, bool ExpressionTemplates>
- std::ostream& operator << (std::ostream& os, const mp_number<Backend, ExpressionTemplates>& r);
+ 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>
- inline std::istream& operator >> (std::istream& is, mp_number<Backend, ExpressionTemplates>& r)
+ inline std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r)

-These operators provided formatted input-output operations on `mp_number` types, and expression templates derived from them.
+These operators provided formatted input-output operations on `number` types, and expression templates derived from them.

It's down to the back-end type to actually implement string conversion. However, the back-ends provided with
this library support all of the iostream formatting flags, field width and precision settings.

[h4 Non-member standard library function support]

- ``['unmentionable-expression-template-type]`` abs (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` fabs (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` sqrt (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` floor (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` ceil (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` trunc (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` itrunc (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` ltrunc (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` lltrunc(const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` round (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` iround (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` lround (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` llround(const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` exp (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` log (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` log10 (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` cos (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` sin (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` tan (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` acos (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` asin (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` atan (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` cosh (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` sinh (const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` tanh (const ``['mp_number-or-expression-template-type]``&);
-
- ``['unmentionable-expression-template-type]`` ldexp (const ``['mp_number-or-expression-template-type]``&, int);
- ``['unmentionable-expression-template-type]`` frexp (const ``['mp_number-or-expression-template-type]``&, int*);
- ``['unmentionable-expression-template-type]`` pow (const ``['mp_number-or-expression-template-type]``&, const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` fmod (const ``['mp_number-or-expression-template-type]``&, const ``['mp_number-or-expression-template-type]``&);
- ``['unmentionable-expression-template-type]`` atan2 (const ``['mp_number-or-expression-template-type]``&, const ``['mp_number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` abs (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` fabs (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` sqrt (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` floor (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` ceil (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` trunc (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` itrunc (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` ltrunc (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` lltrunc(const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` round (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` iround (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` lround (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` llround(const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` exp (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` log (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` log10 (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` cos (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` sin (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` tan (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` acos (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` asin (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` atan (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` cosh (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` sinh (const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` tanh (const ``['number-or-expression-template-type]``&);
+
+ ``['unmentionable-expression-template-type]`` ldexp (const ``['number-or-expression-template-type]``&, int);
+ ``['unmentionable-expression-template-type]`` frexp (const ``['number-or-expression-template-type]``&, int*);
+ ``['unmentionable-expression-template-type]`` pow (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
+ ``['unmentionable-expression-template-type]`` fmod (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
+ ``['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 `mp_number` or
-an expression template derived from it; If the argument is of type `mp_number<Backend, false>` then that is also the return 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,
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
@@ -1421,53 +1421,53 @@

[h4 Integer functions]

- ``['unmentionable-expression-template-type]`` pow(const ``['mp_number-or-expression-template-type]``& b, unsigned p);
+ ``['unmentionable-expression-template-type]`` pow(const ``['number-or-expression-template-type]``& b, unsigned p);

Returns ['b[super p]] as an expression template. Note that this function should be used with extreme care as the result can grow so
large as to take "effectively forever" to compute, or else simply run the host machine out of memory.

- ``['unmentionable-expression-template-type]`` powm(const ``['mp_number-or-expression-template-type]``& b, const ``['mp_number-or-expression-template-type]``& p, const ``['mp_number-or-expression-template-type]``& m);
+ ``['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);

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

 template <class Backend, bool ExpressionTemplates>
- bool divide_qr(const ``['mp_number-or-expression-template-type]``& x, const ``['mp_number-or-expression-template-type]``& y,
- mp_number<Backend, ExpressionTemplates>& q, mp_number<Backend, ExpressionTemplates>& r);
+ 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);

Divides x by y and returns both the quotient and remainder. After the call `q = x / y` and `r = x % y`.

 template <class Integer>
- Integer integer_modulus(const ``['mp_number-or-expression-template-type]``& x, Integer val);
+ Integer integer_modulus(const ``['number-or-expression-template-type]``& x, Integer val);

Returns the absolute value of `x % val`.

- unsigned lsb(const ``['mp_number-or-expression-template-type]``& x);
+ unsigned lsb(const ``['number-or-expression-template-type]``& x);

Returns the index of the least significant bit that is set to 1.

 template <class Backend, class ExpressionTemplates>
- bool bit_test(const mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ bool bit_test(const number<Backend, ExpressionTemplates>& val, unsigned index);

Returns `true` if the bit at /index/ in /val/ is set.

 template <class Backend, class ExpressionTemplates>
- mp_number<Backend, ExpressionTemplates>& bit_set(mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ number<Backend, ExpressionTemplates>& bit_set(number<Backend, ExpressionTemplates>& val, unsigned index);

Sets the bit at /index/ in /val/, and returns /val/.

 template <class Backend, class ExpressionTemplates>
- mp_number<Backend, ExpressionTemplates>& bit_unset(mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ number<Backend, ExpressionTemplates>& bit_unset(number<Backend, ExpressionTemplates>& val, unsigned index);

Unsets the bit at /index/ in /val/, and returns /val/.

 template <class Backend, class ExpressionTemplates>
- mp_number<Backend, ExpressionTemplates>& bit_flip(mp_number<Backend, ExpressionTemplates>& val, unsigned index);
+ number<Backend, ExpressionTemplates>& bit_flip(number<Backend, ExpressionTemplates>& val, unsigned index);

Flips the bit at /index/ in /val/, and returns /val/.

 template <class Engine>
- bool miller_rabin_test(const ``['mp_number-or-expression-template-type]``& n, unsigned trials, Engine& gen);
- bool miller_rabin_test(const ``['mp_number-or-expression-template-type]``& n, unsigned trials);
+ bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials, Engine& gen);
+ bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials);

Tests to see if the number /n/ is probably prime - the test excludes the vast majority of composite numbers
by excluding small prime factors and performing a single Fermat test. Then performs /trials/ Miller-Rabin
@@ -1476,8 +1476,8 @@

[h4 Rational Number Functions]

- typename component_type<``['mp_number-or-expression-template-type]``>::type numerator (const ``['mp_number-or-expression-template-type]``&);
- typename component_type<``['mp_number-or-expression-template-type]``>::type denominator(const ``['mp_number-or-expression-template-type]``&);
+ typename component_type<``['number-or-expression-template-type]``>::type numerator (const ``['number-or-expression-template-type]``&);
+ typename component_type<``['number-or-expression-template-type]``>::type denominator(const ``['number-or-expression-template-type]``&);

These functions return the numerator and denominator of a rational number respectively.

@@ -1485,11 +1485,11 @@

 namespace boost{ namespace math{

- int fpclassify (const ``['mp_number-or-expression-template-type]``&, int);
- bool isfinite (const ``['mp_number-or-expression-template-type]``&, int);
- bool isnan (const ``['mp_number-or-expression-template-type]``&, int);
- bool isinf (const ``['mp_number-or-expression-template-type]``&, int);
- bool isnormal (const ``['mp_number-or-expression-template-type]``&, int);
+ int fpclassify (const ``['number-or-expression-template-type]``&, int);
+ bool isfinite (const ``['number-or-expression-template-type]``&, int);
+ bool isnan (const ``['number-or-expression-template-type]``&, int);
+ bool isinf (const ``['number-or-expression-template-type]``&, int);
+ bool isnormal (const ``['number-or-expression-template-type]``&, int);

 }} // namespaces

@@ -1510,7 +1510,7 @@

 }

-Class template `std::numeric_limits` is specialized for all instantiations of `mp_number` whose precision is known at compile time, plus those
+Class template `std::numeric_limits` is specialized for all instantiations of `number` whose precision is known at compile time, plus those
types whose precision is unlimited (though it is much less useful in those cases). It is not specialized for types
whose precision can vary at compile time (such as `mpf_float`).

@@ -1523,21 +1523,21 @@
 template <unsigned MinBits = 0, bool Signed = true, class Allocator = std::allocator<limb_type> >
 struct cpp_int_backend;

- typedef mp_number<cpp_int_backend<> > cpp_int; // arbitrary precision integer
+ typedef number<cpp_int_backend<> > cpp_int; // arbitrary precision integer
 typedef rational_adapter<cpp_int_backend<> > cpp_rational_backend;
- typedef mp_number<cpp_rational_backend> cpp_rational; // arbitrary precision rational number
+ typedef number<cpp_rational_backend> cpp_rational; // arbitrary precision rational number

 // Fixed precision unsigned types:
- typedef mp_number<cpp_int_backend<128, false, void>, false> mp_uint128_t;
- typedef mp_number<cpp_int_backend<256, false, void>, false> mp_uint256_t;
- typedef mp_number<cpp_int_backend<512, false, void>, false> mp_uint512_t;
- typedef mp_number<cpp_int_backend<1024, false, void>, false> mp_uint1024_t;
+ 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;

 // Fixed precision signed types:
- typedef mp_number<cpp_int_backend<128, true, void>, false> mp_int128_t;
- typedef mp_number<cpp_int_backend<256, true, void>, false> mp_int256_t;
- typedef mp_number<cpp_int_backend<512, true, void>, false> mp_int512_t;
- typedef mp_number<cpp_int_backend<1024, true, void>, false> mp_int1024_t;
+ 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;

 }} // namespaces

@@ -1572,7 +1572,7 @@

 class gmp_int;

- typedef mp_number<gmp_int > mpz_int;
+ typedef number<gmp_int > mpz_int;

 }} // namespaces

@@ -1592,7 +1592,7 @@

 class tommath_int;

- typedef mp_number<tommath_int > tom_int;
+ typedef number<tommath_int > tom_int;

 }} // namespaces

@@ -1613,11 +1613,11 @@
 template <unsigned Digits10>
 class gmp_float;

- typedef mp_number<gmp_float<50> > mpf_float_50;
- typedef mp_number<gmp_float<100> > mpf_float_100;
- typedef mp_number<gmp_float<500> > mpf_float_500;
- typedef mp_number<gmp_float<1000> > mpf_float_1000;
- typedef mp_number<gmp_float<0> > mpf_float;
+ typedef number<gmp_float<50> > mpf_float_50;
+ typedef number<gmp_float<100> > mpf_float_100;
+ typedef number<gmp_float<500> > mpf_float_500;
+ typedef number<gmp_float<1000> > mpf_float_1000;
+ typedef number<gmp_float<0> > mpf_float;

 }} // namespaces

@@ -1626,8 +1626,8 @@
to change.

The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
-should support. When this parameter is zero, then the precision can be set at runtime via `mp_number::default_precision`
-and `mp_number::precision`. Note that this type does not in any way change the GMP library's global state (for example
+should support. When this parameter is zero, then the precision can be set at runtime via `number::default_precision`
+and `number::precision`. Note that this type does not in any way change the GMP library's global state (for example
it does not change the default precision of the mpf_t data type), therefore you can safely mix this type with existing
code that uses GMP, and also mix `gmp_float`s of differing precision.

@@ -1644,11 +1644,11 @@
 template <unsigned Digits10>
 class mpfr_float_backend;

- typedef mp_number<mpfr_float_backend<50> > mpfr_float_50;
- typedef mp_number<mpfr_float_backend<100> > mpfr_float_100;
- typedef mp_number<mpfr_float_backend<500> > mpfr_float_500;
- typedef mp_number<mpfr_float_backend<1000> > mpfr_float_1000;
- typedef mp_number<mpfr_float_backend<0> > mpfr_float;
+ typedef number<mpfr_float_backend<50> > mpfr_float_50;
+ typedef number<mpfr_float_backend<100> > mpfr_float_100;
+ typedef number<mpfr_float_backend<500> > mpfr_float_500;
+ typedef number<mpfr_float_backend<1000> > mpfr_float_1000;
+ typedef number<mpfr_float_backend<0> > mpfr_float;

 }} // namespaces

@@ -1657,8 +1657,8 @@
to change.

The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
-should support. When this parameter is zero, then the precision can be set at runtime via `mp_number::default_precision`
-and `mp_number::precision`. Note that this type does not in any way change the GMP or MPFR library's global state (for example
+should support. When this parameter is zero, then the precision can be set at runtime via `number::default_precision`
+and `number::precision`. Note that this type does not in any way change the GMP or MPFR library's global state (for example
it does not change the default precision of the mpfr_t data type), therefore you can safely mix this type with existing
code that uses GMP or MPFR, and also mix `mpfr_float_backend`s of differing precision.

@@ -1675,8 +1675,8 @@
 template <unsigned Digits10>
 class cpp_dec_float;

- typedef mp_number<cpp_dec_float<50> > cpp_dec_float_50;
- typedef mp_number<cpp_dec_float<100> > cpp_dec_float_100;
+ typedef number<cpp_dec_float<50> > cpp_dec_float_50;
+ typedef number<cpp_dec_float<100> > cpp_dec_float_100;

 }} // namespaces

@@ -1696,13 +1696,13 @@

[section:backendconc Backend Requirements]

-The requirements on the `Backend` template argument to `mp_number` are split up into
+The requirements on the `Backend` template argument to `number` are split up into
compulsory requirements, and optional requirements that are either to improve performance
or provide optional features.

TODO: Add optional construction support, add throws specification, clarify what compulsory means.

-In the following tables, type B is the `Backend` template arument to `mp_number`, `b` and `b2` are
+In the following tables, type B is the `Backend` template arument to `number`, `b` and `b2` are
a variables of type B, `cb` and `cb2` are constant variables of type B, `a` is a variable of Arithmetic type,
`s` is a variable of type `const char*`, `ui` is a variable of type `unsigned`, `bb` is a variable of type `bool`,
`pa` is a variable of type pointer-to-arithmetic-type, `exp` is a variable of type `B::exp_type`,
@@ -1880,7 +1880,7 @@
[[gmp.hpp][Defines all [gmp] related backends.]]
[[integer_ops.hpp][Integer specific non-member functions.]]
[[miller_rabin.hpp][Miller Rabin primality testing code.]]
-[[mp_number.hpp][Defines the `mp_number` backend, is included by all the backend headers.]]
+[[number.hpp][Defines the `number` backend, is included by all the backend headers.]]
[[mpfr.hpp][Defines the mpfr_float_backend backend.]]
[[random.hpp][Defines code to interoperate with Boost.Random.]]
[[rational_adapter.hpp][Defines the `rational_adapter` backend.]]
@@ -1895,7 +1895,7 @@
[[detail/cpp_int_core.hpp][Platform and peformance tuning for the `cpp_int` backend.]]
[[detail/default_ops.hpp][Default versions of the optional backend non-member functions.]]
[[detail/generic_interconvert.hpp][Generic interconversion routines.]]
-[[detail/mp_number_base.hpp][All the expression template code, metaprogramming, and operator overloads for `mp_number`.]]
+[[detail/number_base.hpp][All the expression template code, metaprogramming, and operator overloads for `number`.]]
[[detail/no_et_ops.hpp][The non-expression template operators.]]
[[defail/functions/constants.hpp][Defines constants used by the floating point functions.]]
[[detail/functions/pow.hpp][Defines default versions of the power and exponential related floating point functions.]]
@@ -1959,8 +1959,8 @@
[[cpp_int (256-bit cache)][1.29367(0.442451s)]]
[[cpp_int (512-bit cache)][1.08821(0.37218s)]]
[[cpp_int (1024-bit cache)][1.07902(0.369037s)]]
-[[mp_int1024_t][1.02616(0.35096s)]]
-[[mp_int1024_t (no Expression templates)][1(0.342011s)]]
+[[int1024_t][1.02616(0.35096s)]]
+[[int1024_t (no Expression templates)][1(0.342011s)]]
[[tom_int][3.74233(1.27992s)]]
[[tom_int (no Expression templates)][3.97646(1.35999s)]]
]
@@ -2292,7 +2292,7 @@

* Can the non-expression template operators be further optimised with rvalue reference support?
* Can any functions - in particular value initialization - be made `constexp`?
-* Can we differentiate between explicit and implicit conversions in the mp_number constructor (may need some new type traits)?
+* Can we differentiate between explicit and implicit conversions in the number constructor (may need some new type traits)?
* Can ring types (exact floating point types) be supported? The answer should be yes, but someone needs to write it.
* Make the exponent type for cpp_dec_float a templare parameter, maybe include support for big-integer exponents.
Open question - what should be the default - int32_t or int64_t?

Modified: sandbox/big_number/libs/multiprecision/example/cpp_int_snips.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/example/cpp_int_snips.cpp (original)
+++ sandbox/big_number/libs/multiprecision/example/cpp_int_snips.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -13,7 +13,7 @@

 using namespace boost::multiprecision;

- mp_int128_t v = 1;
+ int128_t v = 1;

 // Do some fixed precision arithmetic:
 for(unsigned i = 1; i <= 20; ++i)

Modified: sandbox/big_number/libs/multiprecision/example/floating_point_examples.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/example/floating_point_examples.cpp (original)
+++ sandbox/big_number/libs/multiprecision/example/floating_point_examples.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -343,7 +343,7 @@

/*`
In this example we'll look at polynomial evaluation, this is not only an important
-use case, but it's one that `mp_number` performs particularly well at because the
+use case, but it's one that `number` performs particularly well at because the
expression templates ['completely eliminate all temporaries] from a
[@http://en.wikipedia.org/wiki/Horner%27s_method Horner polynomial
evaluation scheme].
@@ -353,7 +353,7 @@
*/

using boost::multiprecision::cpp_dec_float;
-typedef boost::multiprecision::mp_number<cpp_dec_float<64> > mp_type;
+typedef boost::multiprecision::number<cpp_dec_float<64> > mp_type;

mp_type mysin(const mp_type& x)
{

Modified: sandbox/big_number/libs/multiprecision/example/integer_examples.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/example/integer_examples.cpp (original)
+++ sandbox/big_number/libs/multiprecision/example/integer_examples.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -32,7 +32,7 @@
 // large the largest is, we'll be able to "pretty format" the results.
 //
 // Calculate the largest number that will fit inside 128 bits, we could
- // also have used numeric_limits<mp_int128_t>::max() for this value:
+ // also have used numeric_limits<int128_t>::max() for this value:
 cpp_int limit = (cpp_int(1) << 128) - 1;
 //
 // Our table of values:

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -12,7 +12,7 @@
#include <boost/cstdint.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/math/concepts/real_concept.hpp>
-#include <boost/multiprecision/mp_number.hpp>
+#include <boost/multiprecision/number.hpp>
#include <boost/math/common_factor_rt.hpp>

namespace boost{
@@ -523,10 +523,10 @@
namespace std{

template <class Arithmetic, bool ExpressionTemplates>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates > > : public std::numeric_limits<Arithmetic>
+class numeric_limits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates > > : public std::numeric_limits<Arithmetic>
{
 typedef std::numeric_limits<Arithmetic> base_type;
- typedef boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates> number_type;
+ typedef boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates> number_type;
public:
 BOOST_STATIC_CONSTEXPR number_type (min)() BOOST_NOEXCEPT { return (base_type::min)(); }
 BOOST_STATIC_CONSTEXPR number_type (max)() BOOST_NOEXCEPT { return (base_type::max)(); }

Modified: sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/delaunay_test.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 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<mp_number<arithmetic_backend<boost::int64_t>, false>, mp_number<arithmetic_backend<boost::int64_t>, false> > >("arithmetic_backend<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<boost::int64_t, int128_t> >("int64_t, int128_t");
- do_calc<test_traits<boost::int64_t, mp_int128_t> >("int64_t, mp_int128_t");
- do_calc<test_traits<boost::int64_t, mp_number<cpp_int_backend<128, true, void>, true> > >("int64_t, mp_int128_t (ET)");
+ 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, cpp_int> >("int64_t, cpp_int");
- do_calc<test_traits<boost::int64_t, mp_number<cpp_int_backend<>, false> > >("int64_t, cpp_int (no ET's)");
- do_calc<test_traits<boost::int64_t, mp_number<cpp_int_backend<128> > > >("int64_t, cpp_int(128-bit cache)");
- do_calc<test_traits<boost::int64_t, mp_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<>, false> > >("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)");

 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/linpack-benchmark.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -93,9 +93,9 @@
extern "C" int MAIN__()
{
#ifdef TEST_MPF_50
- std::cout << "Testing mp_number<mpf_float<50> >" << std::endl;
+ std::cout << "Testing number<mpf_float<50> >" << std::endl;
#elif defined(TEST_MPFR_50)
- std::cout << "Testing mp_number<mpf_float<50> >" << std::endl;
+ std::cout << "Testing number<mpf_float<50> >" << std::endl;
#elif defined(TEST_GMPXX)
 std::cout << "Testing mpf_class at 50 decimal degits" << std::endl;
 mpf_set_default_prec(((50 + 1) * 1000L) / 301L);
@@ -103,7 +103,7 @@
 std::cout << "Testing mpfr_class at 50 decimal degits" << std::endl;
 mpfr_set_default_prec(((50 + 1) * 1000L) / 301L);
#elif defined(TEST_CPP_DEC_FLOAT)
- std::cout << "Testing mp_number<cpp_dec_float<50> >" << std::endl;
+ std::cout << "Testing number<cpp_dec_float<50> >" << std::endl;
#else
 std::cout << "Testing double" << std::endl;
#endif
@@ -1221,7 +1221,7 @@
266.45 0.798 267.24 2.5021 0.79933 4772.2

-mp_number<gmp_float<100> >:
+number<gmp_float<100> >:
~~~~~~~~~~~~~~~~~~~~~~~~~~~

 norm. resid resid machep x(1) x(n)

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -136,21 +136,21 @@
{
 using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
- test_miller_rabin<mp_number<cpp_int_backend<>, false> >("cpp_int (no Expression templates)");
+ test_miller_rabin<number<cpp_int_backend<>, false> >("cpp_int (no Expression templates)");
 test_miller_rabin<cpp_int>("cpp_int");
- test_miller_rabin<mp_number<cpp_int_backend<128> > >("cpp_int (128-bit cache)");
- test_miller_rabin<mp_number<cpp_int_backend<256> > >("cpp_int (256-bit cache)");
- test_miller_rabin<mp_number<cpp_int_backend<512> > >("cpp_int (512-bit cache)");
- test_miller_rabin<mp_number<cpp_int_backend<1024> > >("cpp_int (1024-bit cache)");
- test_miller_rabin<mp_int1024_t>("mp_int1024_t");
+ 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)");
+ test_miller_rabin<number<cpp_int_backend<512> > >("cpp_int (512-bit cache)");
+ test_miller_rabin<number<cpp_int_backend<1024> > >("cpp_int (1024-bit cache)");
+ test_miller_rabin<int1024_t>("int1024_t");
#endif
#ifdef TEST_MPZ
- test_miller_rabin<mp_number<gmp_int, false> >("mpz_int (no Expression templates)");
+ test_miller_rabin<number<gmp_int, false> >("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<mp_number<boost::multiprecision::tommath_int, false> >("tom_int (no Expression templates)");
+ test_miller_rabin<number<boost::multiprecision::tommath_int, false> >("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/performance_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/performance_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/performance/performance_test.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -786,12 +786,12 @@
 test<boost::multiprecision::mpz_int>("gmp_int", 1024);
#endif
#ifdef TEST_CPP_INT
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<64, false, void>, false > >("cpp_int(unsigned, fixed)", 64);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<64, true, void>, false > >("cpp_int(fixed)", 64);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<128, true, void>, false > >("cpp_int(fixed)", 128);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<256, true, void>, false > >("cpp_int(fixed)", 256);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<512, true, void>, false > >("cpp_int(fixed)", 512);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<1024, true, void>, false > >("cpp_int(fixed)", 1024);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, false, void>, false > >("cpp_int(unsigned, fixed)", 64);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, true, void>, false > >("cpp_int(fixed)", 64);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<128, true, void>, false > >("cpp_int(fixed)", 128);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, true, void>, false > >("cpp_int(fixed)", 256);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, true, void>, false > >("cpp_int(fixed)", 512);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<1024, true, void>, false > >("cpp_int(fixed)", 1024);

 test<boost::multiprecision::cpp_int>("cpp_int", 128);
 test<boost::multiprecision::cpp_int>("cpp_int", 256);
@@ -828,7 +828,7 @@
#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_dec_float_50>("cpp_dec_float", 50);
 test<boost::multiprecision::cpp_dec_float_100>("cpp_dec_float", 100);
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<500> > >("cpp_dec_float", 500);
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<500> > >("cpp_dec_float", 500);
#endif
#ifdef TEST_MPFR
 test<boost::multiprecision::mpfr_float_50>("mpfr_float", 50);

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-08-08 14:14:50 EDT (Wed, 08 Aug 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", mp_number<mpfr_float_backend<50>, false>(2));
+ basic_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, false>(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", mp_number<mpfr_float_backend<50>, false>(2));
+ poly_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, false>(2));
#endif
#ifdef TEST_MPFR_CLASS
 poly_allocation_test("mpfr_class", mpfr_class(2));
@@ -260,13 +260,13 @@
#ifdef TEST_FLOAT
 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<mp_number<arithmetic_backend<double> > >);
- time_proc("Bessel Functions - arithmetic_backend<double> - no expression templates", test_bessel<mp_number<arithmetic_backend<double>, false> >);
+ 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("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<mp_number<arithmetic_backend<double> > >);
- time_proc("Non-central T - arithmetic_backend<double> - no expression templates", test_nct<mp_number<arithmetic_backend<double>, false> >);
+ 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> >);
#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<mp_number<gmp_float<50>, false> >, 3);
+ time_proc("mpf_float_50 (no expression templates", test_bessel<number<gmp_float<50>, false> >, 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<mp_number<gmp_float<100>, false> >);
+ time_proc("mpf_float_100 (no expression templates", test_bessel<number<gmp_float<100>, false> >);
#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<mp_number<gmp_float<50>, false> >);
+ time_proc("mpf_float_50 (no expression templates", test_polynomial<number<gmp_float<50>, false> >);
#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<mp_number<gmp_float<100>, false> >);
+ time_proc("mpf_float_100 (no expression templates", test_polynomial<number<gmp_float<100>, false> >);
#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<mp_number<gmp_float<50>, false> >);
+ time_proc("mpf_float_50 (no expression templates", test_nct<number<gmp_float<50>, false> >);
#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<mp_number<gmp_float<100>, false> >);
+ time_proc("mpf_float_100 (no expression templates", test_nct<number<gmp_float<100>, false> >);
#endif
#ifdef TEST_CPP_DEC_FLOAT
 time_proc("cpp_dec_float_100", test_nct<cpp_dec_float_100>);

Deleted: sandbox/big_number/libs/multiprecision/test/concepts/mp_number_concept_check.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/concepts/mp_number_concept_check.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
+++ (empty file)
@@ -1,223 +0,0 @@
-// Copyright John Maddock 2011.
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//
-// This tests that cpp_dec_float_50 meets our
-// conceptual requirements.
-//
-#ifdef _MSC_VER
-# define _SCL_SECURE_NO_WARNINGS
-# pragma warning(disable:4800)
-# pragma warning(disable:4512)
-# pragma warning(disable:4127)
-# pragma warning(disable:4512)
-# pragma warning(disable:4503) // decorated name length exceeded, name was truncated
-#endif
-
-#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) \
- && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)\
- && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET)
-# define TEST_MPF_50
-# define TEST_BACKEND
-# define TEST_MPZ
-# define TEST_MPFR_50
-# define TEST_MPFR_6
-# define TEST_MPFR_15
-# define TEST_MPFR_17
-# define TEST_MPFR_30
-# define TEST_CPP_DEC_FLOAT
-# define TEST_CPP_DEC_FLOAT_NO_ET
-
-#ifdef _MSC_VER
-#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
-#endif
-#ifdef __GNUC__
-#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
-#endif
-
-#endif
-
-#if defined(TEST_MPF_50) || defined(TEST_MPZ)
-#include <boost/multiprecision/gmp.hpp>
-#endif
-#ifdef TEST_BACKEND
-#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
-#endif
-#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET)
-#include <boost/multiprecision/cpp_dec_float.hpp>
-#endif
-#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
-#include <boost/multiprecision/mpfr.hpp>
-#endif
-
-#include <boost/math/concepts/real_type_concept.hpp>
-
-template <class T>
-void test_extra(T)
-{
- T t = 1;
- t = abs(t);
- t = abs(t*t);
-
- t = fabs(t);
- t = fabs(t*t);
-
- t = sqrt(t);
- t = sqrt(t*t);
-
- t = floor(t);
- t = floor(t*t);
-
- t = ceil(t);
- t = ceil(t*t);
-
- t = trunc(t);
- t = trunc(t*t);
-
- t = round(t);
- t = round(t*t);
-
- t = exp(t);
- t = exp(t*t);
-
- t = log(t);
- t = log(t*t);
-
- t = log10(t);
- t = log10(t*t);
-
- t = cos(t);
- t = cos(t*t);
-
- t = sin(t);
- t = sin(t*t);
-
- t = tan(t);
- t = tan(t*t);
-
- t = asin(t);
- t = asin(t*t);
-
- t = atan(t);
- t = atan(t*t);
-
- t = acos(t);
- t = acos(t*t);
-
- t = cosh(t);
- t = cosh(t*t);
-
- t = sinh(t);
- t = sinh(t*t);
-
- t = tanh(t);
- t = tanh(t*t);
-
- double dval = 2;
- t = pow(t, t);
- t = pow(t, t*t);
- t = pow(t, dval);
- t = pow(t*t, t);
- t = pow(t*t, t*t);
- t = pow(t*t, dval);
- t = pow(dval, t);
- t = pow(dval, t*t);
-
- t = atan2(t, t);
- t = atan2(t, t*t);
- t = atan2(t, dval);
- t = atan2(t*t, t);
- t = atan2(t*t, t*t);
- t = atan2(t*t, dval);
- t = atan2(dval, t);
- t = atan2(dval, t*t);
-
- t = fmod(t, t);
- t = fmod(t, t*t);
- t = fmod(t, dval);
- t = fmod(t*t, t);
- t = fmod(t*t, t*t);
- t = fmod(t*t, dval);
- t = fmod(dval, t);
- t = fmod(dval, t*t);
-
- typedef typename T::backend_type backend_type;
- typedef typename backend_type::exponent_type exp_type;
- exp_type e = 0;
- int i = 0;
-
- t = ldexp(t, i);
- t = ldexp(t*t, i);
- t = ldexp(t, e);
- t = ldexp(t*t, e);
-
- t = frexp(t, &i);
- t = frexp(t*t, &i);
- t = frexp(t, &e);
- t = frexp(t*t, &e);
-}
-
-void foo()
-{
-#ifdef TEST_BACKEND
- test_extra(boost::multiprecision::concepts::mp_number_float_architype());
-#endif
-#ifdef TEST_MPF_50
- test_extra(boost::multiprecision::mpf_float_50());
-#endif
-#ifdef TEST_MPFR_50
- test_extra(boost::multiprecision::mpfr_float_50());
-#endif
-#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
-#endif
-#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
-#endif
-#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
-#endif
-#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
-#endif
-#ifdef TEST_CPP_DEC_FLOAT
- test_extra(boost::multiprecision::cpp_dec_float_50());
-#endif
-#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
-#endif
-}
-
-int main()
-{
-#ifdef TEST_BACKEND
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::concepts::mp_number_float_architype>));
-#endif
-#ifdef TEST_MPF_50
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpf_float_50>));
-#endif
-#ifdef TEST_MPFR_50
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
-#endif
-#ifdef TEST_MPFR_6
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> > >));
-#endif
-#ifdef TEST_MPFR_15
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> > >));
-#endif
-#ifdef TEST_MPFR_17
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> > >));
-#endif
-#ifdef TEST_MPFR_30
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> > >));
-#endif
-#ifdef TEST_MPFR_50
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
-#endif
-#ifdef TEST_CPP_DEC_FLOAT
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::cpp_dec_float_50>));
-#endif
-
-}

Copied: sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp (from r79925, /sandbox/big_number/libs/multiprecision/test/concepts/mp_number_concept_check.cpp)
==============================================================================
--- /sandbox/big_number/libs/multiprecision/test/concepts/mp_number_concept_check.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/concepts/number_concept_check.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -171,22 +171,22 @@
 test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
 test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
#endif
}

@@ -202,16 +202,16 @@
 BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
#endif
#ifdef TEST_MPFR_6
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> > >));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> > >));
#endif
#ifdef TEST_MPFR_15
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> > >));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> > >));
#endif
#ifdef TEST_MPFR_17
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> > >));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> > >));
#endif
#ifdef TEST_MPFR_30
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> > >));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> > >));
#endif
#ifdef TEST_MPFR_50
 BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -124,22 +124,22 @@
test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
#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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -89,22 +89,22 @@
test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
#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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -95,22 +95,22 @@
test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
#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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -111,22 +111,22 @@
test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
#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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -86,22 +86,22 @@
test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<6> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<15> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<17> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<30> >());
+ test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
- test_extra(boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false>());
+ test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false>());
#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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -7,10 +7,10 @@

using namespace boost::multiprecision;

-mp_number<cpp_int_backend<> > a;
-mp_number<cpp_int_backend<>, false> b;
-mp_number<cpp_int_backend<64, true, void>, false> c;
-mp_number<cpp_int_backend<128, false, void>, false> d;
-mp_number<cpp_int_backend<500, true, void>, false> e;
+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;

Modified: sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/log1p_expm1_test.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -128,19 +128,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/powm1_sqrtp1m1_test.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -120,19 +120,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - maybe in std::exp?? Disabled for now.
- //test_powm1_sqrtp1m1(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_powm1_sqrtp1m1(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_powm1_sqrtp1m1(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ //test_powm1_sqrtp1m1(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_powm1_sqrtp1m1(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_powm1_sqrtp1m1(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_powm1_sqrtp1m1(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_powm1_sqrtp1m1(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_powm1_sqrtp1m1(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_powm1_sqrtp1m1(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_powm1_sqrtp1m1(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_powm1_sqrtp1m1(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_powm1_sqrtp1m1(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_powm1_sqrtp1m1(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_powm1_sqrtp1m1(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_powm1_sqrtp1m1(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_powm1_sqrtp1m1(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_powm1_sqrtp1m1(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_i.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -88,20 +88,20 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - maybe in std::exp?? Disabled for now.
- //test_bessel(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_bessel(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_bessel(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ //test_bessel(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_bessel(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_bessel(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_bessel(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_bessel(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_bessel(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_bessel(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_bessel(mp_number<cpp_dec_float<8> >(), "mp_number<cpp_dec_float<8> >");
- test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_bessel(number<cpp_dec_float<8> >(), "number<cpp_dec_float<8> >");
+ test_bessel(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_bessel(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_bessel(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_j.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -130,19 +130,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - maybe in std::exp?? Disabled for now.
- //test_bessel(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_bessel(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_bessel(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ //test_bessel(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_bessel(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_bessel(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_bessel(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_bessel(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_bessel(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_bessel(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_bessel(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_bessel(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_bessel(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_k.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -103,19 +103,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - maybe in std::exp?? Disabled for now.
- test_bessel(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_bessel(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_bessel(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_bessel(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_bessel(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_bessel(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_bessel(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_bessel(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_bessel(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_bessel(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_bessel(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_bessel(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_bessel(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_bessel_y.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -129,19 +129,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - our argument reduction in std::sin isn't accurate enough:
- //test_bessel(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_bessel(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_bessel(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ //test_bessel(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_bessel(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_bessel(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_bessel(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_bessel(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_bessel(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_bessel(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_bessel(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_bessel(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_bessel(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_bessel(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_bessel(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_bessel(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_bessel(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_bessel(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_beta.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -115,19 +115,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - our argument reduction in std::sin isn't accurate enough:
- test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_binomial_coeff.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -94,19 +94,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - our argument reduction in std::sin isn't accurate enough:
- test_binomial(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_binomial(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_binomial(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_binomial(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_binomial(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_binomial(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_binomial(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_binomial(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_binomial(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_binomial(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_binomial(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_binomial(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_binomial(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_binomial(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_binomial(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_binomial(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_binomial(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_binomial(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_carlson.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -86,19 +86,19 @@
 //
#ifdef TEST_MPF_50
 // We have accuracy issues with gmp_float<18> - our argument reduction in std::sin isn't accurate enough:
- test_spots(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_spots(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_spots(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_spots(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_spots(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_spots(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_spots(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_spots(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_spots(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_spots(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_spots(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_spots(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_spots(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_cbrt.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -75,19 +75,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_cbrt(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_cbrt(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_cbrt(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_cbrt(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_cbrt(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_cbrt(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_cbrt(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_cbrt(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_cbrt(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_cbrt(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_cbrt(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_cbrt(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_cbrt(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_cbrt(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_cbrt(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_cbrt(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_cbrt(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_cbrt(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_digamma.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -89,19 +89,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_digamma(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_digamma(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_digamma(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_digamma(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_digamma(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_digamma(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_digamma(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_digamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_digamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_digamma(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_digamma(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_digamma(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_digamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_digamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_digamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_digamma(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_digamma(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_digamma(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ellint_1.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -82,19 +82,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_spots(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_spots(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_spots(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_spots(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_spots(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_spots(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_spots(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_spots(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_spots(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_spots(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_spots(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_spots(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_spots(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ellint_2.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -75,19 +75,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_spots(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_spots(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_spots(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_spots(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_spots(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_spots(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_spots(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_spots(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_spots(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_spots(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_spots(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_spots(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_spots(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ellint_3.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -96,19 +96,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_spots(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_spots(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_spots(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_spots(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_spots(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_spots(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_spots(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_spots(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_spots(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_spots(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_spots(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_spots(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_spots(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_spots(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_spots(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_spots(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_spots(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_spots(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_erf.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -96,19 +96,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_erf(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_erf(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_erf(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_erf(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_erf(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_erf(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_erf(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_erf(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_erf(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_erf(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_erf(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_erf(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_erf(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_erf(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_erf(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_erf(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_erf(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_erf(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_expint.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -96,19 +96,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_expint(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_expint(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_expint(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_expint(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_expint(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_expint(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_expint(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_expint(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_expint(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_expint(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_expint(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_expint(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_expint(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_expint(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_expint(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_expint(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_expint(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_expint(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_gamma.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -110,19 +110,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_gamma(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_gamma(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_gamma(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_gamma(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_gamma(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_gamma(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_gamma(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_gamma(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_gamma(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_gamma(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_gamma(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_gamma(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_gamma(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_hermite.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -75,19 +75,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_hermite(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_hermite(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_hermite(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_hermite(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_hermite(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_hermite(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_hermite(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_hermite(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_hermite(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_hermite(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_hermite(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_hermite(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_hermite(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_hermite(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_hermite(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_hermite(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_hermite(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_hermite(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -106,19 +106,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_2.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -106,19 +106,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_3.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -92,19 +92,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_4.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -99,19 +99,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_1.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -85,19 +85,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- //test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ //test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_ibeta_inv_ab_4.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -78,19 +78,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- //test_beta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_beta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_beta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ //test_beta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_beta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_beta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_beta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_beta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_beta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_beta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_beta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_beta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_beta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_beta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_beta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_beta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_beta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_beta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_igamma.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -82,19 +82,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_gamma(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_gamma(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_gamma(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_gamma(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_gamma(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_gamma(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_gamma(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_gamma(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_gamma(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_gamma(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_gamma(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_gamma(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_gamma(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_igamma_inv.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -97,19 +97,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_gamma(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_gamma(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_gamma(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_gamma(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_gamma(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_gamma(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_gamma(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_gamma(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_gamma(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_gamma(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_gamma(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_gamma(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_gamma(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_igamma_inva.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -76,19 +76,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_gamma(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_gamma(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_gamma(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_gamma(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_gamma(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_gamma(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_gamma(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_gamma(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_gamma(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_gamma(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_gamma(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_gamma(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_gamma(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_gamma(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_gamma(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_gamma(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_gamma(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_gamma(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_laguerre.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -75,19 +75,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_laguerre(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_laguerre(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_laguerre(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_laguerre(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_laguerre(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_laguerre(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_laguerre(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_laguerre(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_laguerre(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_laguerre(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_laguerre(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_laguerre(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_laguerre(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_laguerre(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_laguerre(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_laguerre(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_laguerre(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_laguerre(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_legendre.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -75,19 +75,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_legendre_p(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_legendre_p(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_legendre_p(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_legendre_p(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_legendre_p(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_legendre_p(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_legendre_p(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_legendre_p(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_legendre_p(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_legendre_p(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_legendre_p(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_legendre_p(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_legendre_p(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_legendre_p(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_legendre_p(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_legendre_p(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_legendre_p(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_legendre_p(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_tgamma_ratio.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -89,19 +89,19 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_tgamma_ratio(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_tgamma_ratio(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_tgamma_ratio(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_tgamma_ratio(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_tgamma_ratio(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_tgamma_ratio(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_tgamma_ratio(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_tgamma_ratio(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_tgamma_ratio(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_tgamma_ratio(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_tgamma_ratio(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_tgamma_ratio(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_tgamma_ratio(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_tgamma_ratio(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_tgamma_ratio(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_tgamma_ratio(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_tgamma_ratio(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_tgamma_ratio(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/math/test_zeta.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -83,20 +83,20 @@
 // 35 decimal digits: tests arbitrary precision code
 //
#ifdef TEST_MPF_50
- test_zeta(mp_number<gmp_float<18> >(), "mp_number<gmp_float<18> >");
- test_zeta(mp_number<gmp_float<30> >(), "mp_number<gmp_float<30> >");
- test_zeta(mp_number<gmp_float<35> >(), "mp_number<gmp_float<35> >");
+ test_zeta(number<gmp_float<18> >(), "number<gmp_float<18> >");
+ test_zeta(number<gmp_float<30> >(), "number<gmp_float<30> >");
+ test_zeta(number<gmp_float<35> >(), "number<gmp_float<35> >");
#endif
#ifdef TEST_MPFR_50
- test_zeta(mp_number<mpfr_float_backend<18> >(), "mp_number<mpfr_float_backend<18> >");
- test_zeta(mp_number<mpfr_float_backend<30> >(), "mp_number<mpfr_float_backend<30> >");
- test_zeta(mp_number<mpfr_float_backend<35> >(), "mp_number<mpfr_float_backend<35> >");
+ test_zeta(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");
+ test_zeta(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");
+ test_zeta(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test_zeta(mp_number<cpp_dec_float<9> >(), "mp_number<cpp_dec_float<9> >");
- test_zeta(mp_number<cpp_dec_float<18> >(), "mp_number<cpp_dec_float<18> >");
- test_zeta(mp_number<cpp_dec_float<30> >(), "mp_number<cpp_dec_float<30> >");
- test_zeta(mp_number<cpp_dec_float<35> >(), "mp_number<cpp_dec_float<35> >");
+ test_zeta(number<cpp_dec_float<9> >(), "number<cpp_dec_float<9> >");
+ test_zeta(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >");
+ test_zeta(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >");
+ test_zeta(number<cpp_dec_float<35> >(), "number<cpp_dec_float<35> >");
#endif
 return 0;
}

Modified: sandbox/big_number/libs/multiprecision/test/test_acos.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_acos.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_acos.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -89,7 +89,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -103,14 +103,14 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
#endif
 return boost::report_errors();
}

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -1211,12 +1211,12 @@
int main()
{
#ifdef TEST_ARITHMETIC_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<double> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<int> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::arithmetic_backend<unsigned int> > >();
+ test<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<double> > >();
+ test<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<int> > >();
+ test<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<unsigned int> > >();
#endif
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -1228,14 +1228,14 @@
#endif
#ifdef TEST_MPZ
 test<boost::multiprecision::mpz_int>();
- test<boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<boost::multiprecision::gmp_int> > >();
+ test<boost::multiprecision::number<boost::multiprecision::rational_adapter<boost::multiprecision::gmp_int> > >();
#endif
#ifdef TEST_MPQ
 test<boost::multiprecision::mpq_rational>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
 test<boost::multiprecision::cpp_dec_float_50>();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<100>, false> >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, false> >();
#endif
#ifdef TEST_MPFR
 test<boost::multiprecision::mpfr_float>();
@@ -1245,7 +1245,7 @@
#endif
#ifdef TEST_TOMMATH
 test<boost::multiprecision::tom_int>();
- test<boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<boost::multiprecision::tommath_int> > >();
+ test<boost::multiprecision::number<boost::multiprecision::rational_adapter<boost::multiprecision::tommath_int> > >();
#endif
#ifdef TEST_TOMMATH_BOOST_RATIONAL
 test<boost::rational<boost::multiprecision::tom_int> >();
@@ -1255,15 +1255,15 @@
#endif
#ifdef TEST_CPP_INT
 test<boost::multiprecision::cpp_int>();
- test<boost::multiprecision::mp_int256_t >();
- test<boost::multiprecision::mp_uint512_t >();
+ test<boost::multiprecision::int256_t >();
+ test<boost::multiprecision::uint512_t >();
 test<boost::multiprecision::cpp_rational>();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<>, false> >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<500, true, void> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>, false> >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<500, true, void> > >();

 // Again with "trivial" backends:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<64, true, void>, false > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<64, false, void>, false > >();
+ 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 > >();
#endif
#ifdef TEST_CPP_INT_BR
 test<boost::multiprecision::cpp_rational>();

Modified: sandbox/big_number/libs/multiprecision/test/test_asin.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_asin.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_asin.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -85,7 +85,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -99,17 +99,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_atan.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_atan.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_atan.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -62,7 +62,7 @@

#ifdef TEST_MPFR_50
template <unsigned Digits10>
-struct is_mpfr_type<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10> > > : public boost::mpl::true_{};
+struct is_mpfr_type<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10> > > : public boost::mpl::true_{};
#endif

template <class T>
@@ -231,7 +231,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -245,17 +245,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_constants.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_constants.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_constants.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -160,7 +160,7 @@
}
#if defined(TEST_MPFR_50)
template <unsigned N>
-inline bool is_mpfr(const boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<N> >&)
+inline bool is_mpfr(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<N> >&)
{
return true;
}
@@ -185,13 +185,13 @@
int main()
{
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<2000> > >();
+ test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<2000> > >();
#endif
#ifdef TEST_CPP_DEC_FLOAT
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<2000> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<2000> > >();
#endif
#ifdef TEST_MPF_50
- test<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<2000> > >();
+ test<boost::multiprecision::number<boost::multiprecision::gmp_float<2000> > >();
#endif
return boost::report_errors();
}

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -31,9 +31,9 @@

using namespace boost::multiprecision;

-template void test1<mp_number<backends::cpp_int_backend<64, false, void, true>, false> >();
-template void test1<mp_number<backends::cpp_int_backend<64, true, void, true>, false> >();
-template void test3<mp_number<backends::cpp_int_backend<2048, false, void>, false> >();
-template void test2<mp_number<backends::cpp_int_backend<2048, true, void>, false> >();
+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> >();

#endif
\ No newline at end of file

Modified: sandbox/big_number/libs/multiprecision/test/test_cos.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_cos.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_cos.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -285,7 +285,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -299,14 +299,14 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_cosh.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_cosh.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_cosh.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -127,7 +127,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -141,14 +141,14 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_cpp_int.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_cpp_int.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_cpp_int.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -340,7 +340,7 @@
{
 using namespace boost::multiprecision;
 test<cpp_int>();
- test<mp_number<cpp_int_backend<2048, true, void> > >();
+ test<number<cpp_int_backend<2048, true, void> > >();
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_exp.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_exp.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_exp.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -167,7 +167,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -181,17 +181,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_fixed_int.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_fixed_int.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_fixed_int.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -54,7 +54,7 @@
int main()
{
 using namespace boost::multiprecision;
- typedef mp_number<fixed_int<1024, true> > packed_type;
+ typedef number<fixed_int<1024, true> > packed_type;
 unsigned last_error_count = 0;
 for(int i = 0; i < 1000; ++i)
 {

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -42,7 +42,7 @@

#if defined(TEST_MPF_50)
template <unsigned N>
-bool is_mpf(const boost::multiprecision::mp_number<boost::multiprecision::gmp_float<N> >&)
+bool is_mpf(const boost::multiprecision::number<boost::multiprecision::gmp_float<N> >&)
{ return true; }
#endif
template <class T>
@@ -215,23 +215,23 @@
};
#ifdef TEST_CPP_DEC_FLOAT
template <unsigned D, bool ET>
-struct max_digits10_proxy<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<D>, ET> >
+struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >
{
- static const unsigned value = std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<D>, ET> >::max_digits10;
+ 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>
-struct max_digits10_proxy<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<D>, ET> >
+struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >
{
- static const unsigned value = std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<D>, ET> >::max_digits10;
+ 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>
-struct max_digits10_proxy<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<D>, ET> >
+struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >
{
- static const unsigned value = std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<D>, ET> >::max_digits10;
+ static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >::max_digits10;
};
#endif

Modified: sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_fpclassify.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -314,7 +314,7 @@
test<boost::multiprecision::cpp_dec_float_100>();
#endif
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_generic_conv.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_generic_conv.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_generic_conv.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -58,7 +58,7 @@
 //
 // Now integer to float:
 //
- typedef mp_number<cpp_dec_float<500> > dec_float_500;
+ typedef number<cpp_dec_float<500> > dec_float_500;
 dec_float_500 df(c);
 dec_float_500 df2(c.str());
 BOOST_CHECK_EQUAL(df, df2);
@@ -66,7 +66,7 @@
 df2 = -df2;
 BOOST_CHECK_EQUAL(df, df2);
#ifdef TEST_GMP
- typedef mp_number<gmp_float<500> > mpf_type;
+ typedef number<gmp_float<500> > mpf_type;
 mpf_type mpf(c);
 mpf_type mpf2(c.str());
 BOOST_CHECK_EQUAL(mpf, mpf2);
@@ -75,7 +75,7 @@
 BOOST_CHECK_EQUAL(mpf, mpf2);
#endif
#ifdef TEST_MPFR
- typedef mp_number<mpfr_float_backend<500> > mpfr_type;
+ typedef number<mpfr_float_backend<500> > mpfr_type;
 mpfr_type mpfr(c);
 mpfr_type mpfr2(c.str());
 BOOST_CHECK_EQUAL(mpfr, mpfr2);

Modified: sandbox/big_number/libs/multiprecision/test/test_int_io.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_int_io.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_int_io.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -123,9 +123,9 @@
test_round_trip<boost::multiprecision::tom_int>();
#endif
#ifdef TEST_CPP_INT
- test_round_trip<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<> > >();
- test_round_trip<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<1024, true, void> > >();
- test_round_trip<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<512, false, void> > >();
+ test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<> > >();
+ test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<1024, true, void> > >();
+ test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, false, void> > >();
#endif
return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_log.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_log.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_log.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -195,7 +195,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -209,17 +209,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -201,7 +201,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -237,10 +237,10 @@
#endif
#ifdef TEST_CPP_INT
 test<boost::multiprecision::cpp_int>();
- test<boost::multiprecision::mp_int256_t>();
- test<boost::multiprecision::mp_uint512_t>();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<200, false, void> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_int_backend<70, true, void> > >();
+ test<boost::multiprecision::int256_t>();
+ test<boost::multiprecision::uint512_t>();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<200, false, void> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<70, true, void> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_pow.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_pow.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_pow.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -570,7 +570,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -584,17 +584,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_rational_io.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_rational_io.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_rational_io.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -92,7 +92,7 @@
template <class T>
struct is_mp_number : public boost::mpl::false_{};
template <class T>
-struct is_mp_number<boost::multiprecision::mp_number<T> > : public boost::mpl::true_{};
+struct is_mp_number<boost::multiprecision::number<T> > : public boost::mpl::true_{};

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f)
@@ -127,7 +127,7 @@
#ifdef TEST_MPQ
 test_round_trip<boost::multiprecision::mpq_rational>();
 test_round_trip<boost::rational<boost::multiprecision::mpz_int> >();
- test_round_trip<boost::multiprecision::mp_number<boost::multiprecision::rational_adapter<boost::multiprecision::gmp_int> > >();
+ test_round_trip<boost::multiprecision::number<boost::multiprecision::rational_adapter<boost::multiprecision::gmp_int> > >();
#endif
#ifdef TEST_TOMMATH
 test_round_trip<boost::rational<boost::multiprecision::tom_int> >();

Modified: sandbox/big_number/libs/multiprecision/test/test_round.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_round.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_round.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -390,17 +390,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
#endif
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_sin.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_sin.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_sin.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -279,7 +279,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -293,17 +293,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_sinh.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_sinh.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_sinh.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -203,7 +203,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -217,17 +217,17 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_sqrt.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -173,7 +173,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -187,20 +187,20 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
 // Check low multiprecision digit counts.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<9> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<18> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
 // Check up to 1000 multiprecision digits.
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<500> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<1000> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<500> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000> > >();
#endif
 return boost::report_errors();
}

Modified: sandbox/big_number/libs/multiprecision/test/test_tanh.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/test_tanh.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/test_tanh.cpp 2012-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -122,7 +122,7 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
+ test<boost::multiprecision::number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
 test<boost::multiprecision::mpf_float_50>();
@@ -136,14 +136,14 @@
 test<boost::multiprecision::cpp_dec_float_50>();
 test<boost::multiprecision::cpp_dec_float_100>();
 // Some "peculiar" digit counts which stress our code:
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<65> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<64> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<63> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<62> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<61> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<60> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<59> > >();
- test<boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<58> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59> > >();
+ test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58> > >();
#endif
 return boost::report_errors();
}

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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> 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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -18,7 +18,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> 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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> 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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> 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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> 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-08-08 14:14:50 EDT (Wed, 08 Aug 2012)
@@ -19,7 +19,7 @@

#include <boost/multiprecision/cpp_dec_float.hpp>

-typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, false> 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