|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r75093 - in sandbox/big_number: boost/multiprecision boost/multiprecision/concepts boost/multiprecision/detail libs/multiprecision/test
From: john_at_[hidden]
Date: 2011-10-23 07:23:20
Author: johnmaddock
Date: 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
New Revision: 75093
URL: http://svn.boost.org/trac/boost/changeset/75093
Log:
Big search and replace namespace and class renaming: get rid of last references to "big_number" and "real".
Text files modified:
sandbox/big_number/boost/multiprecision/concepts/mp_number_architypes.hpp | 84 ++++++------
sandbox/big_number/boost/multiprecision/detail/default_ops.hpp | 16 +-
sandbox/big_number/boost/multiprecision/gmp.hpp | 212 +++++++++++++++++-----------------
sandbox/big_number/boost/multiprecision/mp_number.hpp | 124 ++++++++++----------
sandbox/big_number/boost/multiprecision/mpfr.hpp | 242 ++++++++++++++++++++--------------------
sandbox/big_number/libs/multiprecision/test/Jamfile.v2 | 47 +++++-
sandbox/big_number/libs/multiprecision/test/linpack-benchmark.cpp | 10
sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp | 26 ++--
sandbox/big_number/libs/multiprecision/test/test_acos.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_arithmetic.cpp | 30 ++--
sandbox/big_number/libs/multiprecision/test/test_asin.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_atan.cpp | 26 ++-
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_exp.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_log.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_numeric_limits.cpp | 24 +-
sandbox/big_number/libs/multiprecision/test/test_pow.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_sin.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_sinh.cpp | 18 +-
sandbox/big_number/libs/multiprecision/test/test_tanh.cpp | 18 +-
21 files changed, 523 insertions(+), 498 deletions(-)
Modified: sandbox/big_number/boost/multiprecision/concepts/mp_number_architypes.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/concepts/mp_number_architypes.hpp (original)
+++ sandbox/big_number/boost/multiprecision/concepts/mp_number_architypes.hpp 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -23,53 +23,53 @@
#pragma warning(disable:4244)
#endif
-struct mp_number_backend_real_architype
+struct mp_number_backend_float_architype
{
typedef mpl::list<long long> signed_types;
typedef mpl::list<unsigned long long> unsigned_types;
typedef mpl::list<long double> real_types;
typedef int exponent_type;
- mp_number_backend_real_architype()
+ mp_number_backend_float_architype()
{
std::cout << "Default construct" << std::endl;
}
- mp_number_backend_real_architype(const mp_number_backend_real_architype& o)
+ mp_number_backend_float_architype(const mp_number_backend_float_architype& o)
{
std::cout << "Copy construct" << std::endl;
m_value = o.m_value;
}
- mp_number_backend_real_architype& operator = (const mp_number_backend_real_architype& o)
+ mp_number_backend_float_architype& operator = (const mp_number_backend_float_architype& o)
{
m_value = o.m_value;
std::cout << "Assignment (" << m_value << ")" << std::endl;
return *this;
}
- mp_number_backend_real_architype& operator = (boost::uintmax_t i)
+ mp_number_backend_float_architype& operator = (boost::uintmax_t i)
{
m_value = i;
std::cout << "UInt Assignment (" << i << ")" << std::endl;
return *this;
}
- mp_number_backend_real_architype& operator = (boost::intmax_t i)
+ mp_number_backend_float_architype& operator = (boost::intmax_t i)
{
m_value = i;
std::cout << "Int Assignment (" << i << ")" << std::endl;
return *this;
}
- mp_number_backend_real_architype& operator = (long double d)
+ mp_number_backend_float_architype& operator = (long double d)
{
m_value = d;
std::cout << "long double Assignment (" << d << ")" << std::endl;
return *this;
}
- mp_number_backend_real_architype& operator = (const char* s)
+ mp_number_backend_float_architype& operator = (const char* s)
{
m_value = boost::lexical_cast<long double>(s);
std::cout << "const char* Assignment (" << s << ")" << std::endl;
return *this;
}
- void swap(mp_number_backend_real_architype& o)
+ void swap(mp_number_backend_float_architype& o)
{
std::cout << "Swapping (" << m_value << " with " << o.m_value << ")" << std::endl;
std::swap(m_value, o.m_value);
@@ -100,7 +100,7 @@
std::cout << "Negating (" << m_value << ")" << std::endl;
m_value = -m_value;
}
- int compare(const mp_number_backend_real_architype& o)const
+ int compare(const mp_number_backend_float_architype& o)const
{
std::cout << "Comparison" << std::endl;
return m_value > o.m_value ? 1 : (m_value < o.m_value ? -1 : 0);
@@ -123,151 +123,151 @@
long double m_value;
};
-inline void add(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& o)
+inline void add(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& o)
{
std::cout << "Addition (" << result.m_value << " += " << o.m_value << ")" << std::endl;
result.m_value += o.m_value;
}
-inline void subtract(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& o)
+inline void subtract(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& o)
{
std::cout << "Subtraction (" << result.m_value << " -= " << o.m_value << ")" << std::endl;
result.m_value -= o.m_value;
}
-inline void multiply(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& o)
+inline void multiply(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& o)
{
std::cout << "Multiplication (" << result.m_value << " *= " << o.m_value << ")" << std::endl;
result.m_value *= o.m_value;
}
-inline void divide(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& o)
+inline void divide(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& o)
{
std::cout << "Division (" << result.m_value << " /= " << o.m_value << ")" << std::endl;
result.m_value /= o.m_value;
}
-inline void convert_to(boost::uintmax_t* result, const mp_number_backend_real_architype& val)
+inline void convert_to(boost::uintmax_t* result, const mp_number_backend_float_architype& val)
{
*result = static_cast<boost::uintmax_t>(val.m_value);
}
-inline void convert_to(boost::intmax_t* result, const mp_number_backend_real_architype& val)
+inline void convert_to(boost::intmax_t* result, const mp_number_backend_float_architype& val)
{
*result = static_cast<boost::intmax_t>(val.m_value);
}
-inline void convert_to(long double* result, mp_number_backend_real_architype& val)
+inline void convert_to(long double* result, mp_number_backend_float_architype& val)
{
*result = val.m_value;
}
-inline void eval_frexp(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg, int* exp)
+inline void eval_frexp(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg, int* exp)
{
result = std::frexp(arg.m_value, exp);
}
-inline void eval_ldexp(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg, int exp)
+inline void eval_ldexp(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg, int exp)
{
result = std::ldexp(arg.m_value, exp);
}
-inline void eval_floor(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_floor(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::floor(arg.m_value);
}
-inline void eval_ceil(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_ceil(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::ceil(arg.m_value);
}
-inline void eval_trunc(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_trunc(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = boost::math::trunc(arg.m_value);
}
-inline void eval_sqrt(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_sqrt(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::sqrt(arg.m_value);
}
-inline void eval_abs(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_abs(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::abs(arg.m_value);
}
-inline void eval_fabs(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_fabs(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::fabs(arg.m_value);
}
-inline int eval_fpclassify(const mp_number_backend_real_architype& arg)
+inline int eval_fpclassify(const mp_number_backend_float_architype& arg)
{
return boost::math::fpclassify(arg.m_value);
}
-inline void eval_pow(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& b, const mp_number_backend_real_architype& e)
+inline void eval_pow(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& b, const mp_number_backend_float_architype& e)
{
result = std::pow(b.m_value, e.m_value);
}
-inline void eval_pow(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& b, int e)
+inline void eval_pow(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& b, int e)
{
result = std::pow(b.m_value, e);
}
-inline void eval_exp(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_exp(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::exp(arg.m_value);
}
-inline void eval_log(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_log(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::log(arg.m_value);
}
-inline void eval_sin(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_sin(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::sin(arg.m_value);
}
-inline void eval_cos(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_cos(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::cos(arg.m_value);
}
-inline void eval_tan(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_tan(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::tan(arg.m_value);
}
-inline void eval_asin(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_asin(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::asin(arg.m_value);
}
-inline void eval_acos(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_acos(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::acos(arg.m_value);
}
-inline void eval_atan(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_atan(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::atan(arg.m_value);
}
-inline void eval_sinh(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_sinh(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::sinh(arg.m_value);
}
-inline void eval_cosh(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_cosh(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::cosh(arg.m_value);
}
-inline void eval_tanh(mp_number_backend_real_architype& result, const mp_number_backend_real_architype& arg)
+inline void eval_tanh(mp_number_backend_float_architype& result, const mp_number_backend_float_architype& arg)
{
result = std::tanh(arg.m_value);
}
-typedef boost::multiprecision::mp_number<mp_number_backend_real_architype> mp_number_real_architype;
+typedef boost::multiprecision::mp_number<mp_number_backend_float_architype> mp_number_float_architype;
}}} // namespaces
@@ -278,10 +278,10 @@
#endif
template <>
-class numeric_limits<boost::multiprecision::concepts::mp_number_real_architype> : public std::numeric_limits<long double>
+class numeric_limits<boost::multiprecision::concepts::mp_number_float_architype> : public std::numeric_limits<long double>
{
typedef std::numeric_limits<long double> base_type;
- typedef boost::multiprecision::concepts::mp_number_real_architype number_type;
+ typedef boost::multiprecision::concepts::mp_number_float_architype number_type;
public:
BOOST_STATIC_CONSTEXPR number_type (min)() noexcept { return (base_type::min)(); }
BOOST_STATIC_CONSTEXPR number_type (max)() noexcept { return (base_type::max)(); }
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -14,7 +14,7 @@
#include <boost/mpl/front.hpp>
#include <boost/cstdint.hpp>
-namespace boost{ namespace multiprecision{ namespace big_num_default_ops{
+namespace boost{ namespace multiprecision{ namespace default_ops{
//
// Default versions of mixed arithmetic, these just construct a temporary
@@ -467,7 +467,7 @@
template <class Backend>
inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::mp_number<Backend>& arg)
{
- using multiprecision::big_num_default_ops::eval_fpclassify;
+ using multiprecision::default_ops::eval_fpclassify;
return eval_fpclassify(arg.backend());
}
template <class tag, class A1, class A2, class A3>
@@ -535,7 +535,7 @@
template <class Backend, class Policy>
inline mp_number<Backend> trunc(const mp_number<Backend>& v, const Policy& pol)
{
- using big_num_default_ops::eval_trunc;
+ using default_ops::eval_trunc;
mp_number<Backend> result;
eval_trunc(result.backend(), v.backend());
return result;
@@ -603,7 +603,7 @@
template <class T, class Policy>
inline mp_number<T> round(const mp_number<T>& v, const Policy& pol)
{
- using big_num_default_ops::eval_round;
+ using default_ops::eval_round;
mp_number<T> result;
eval_round(result.backend(), v.backend());
return result;
@@ -670,7 +670,7 @@
{\
void operator()(Backend& result, const Backend& arg)const\
{\
- using big_num_default_ops::BOOST_JOIN(eval_,func);\
+ using default_ops::BOOST_JOIN(eval_,func);\
BOOST_JOIN(eval_,func)(result, arg);\
}\
};\
@@ -719,13 +719,13 @@
{\
void operator()(Backend& result, const Backend& arg, const Backend& a)const\
{\
- using big_num_default_ops:: BOOST_JOIN(eval_,func);\
+ using default_ops:: BOOST_JOIN(eval_,func);\
BOOST_JOIN(eval_,func)(result, arg, a);\
}\
template <class Arithmetic> \
void operator()(Backend& result, const Backend& arg, const Arithmetic& a)const\
{\
- using big_num_default_ops:: BOOST_JOIN(eval_,func);\
+ using default_ops:: BOOST_JOIN(eval_,func);\
BOOST_JOIN(eval_,func)(result, arg, a);\
}\
};\
@@ -866,7 +866,7 @@
{\
void operator()(Backend& result, Backend const& arg, Arg2 a)const\
{\
- using big_num_default_ops:: BOOST_JOIN(eval_,func);\
+ using default_ops:: BOOST_JOIN(eval_,func);\
BOOST_JOIN(eval_,func)(result, arg, a);\
}\
};\
Modified: sandbox/big_number/boost/multiprecision/gmp.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/gmp.hpp (original)
+++ sandbox/big_number/boost/multiprecision/gmp.hpp 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -18,21 +18,21 @@
namespace boost{ namespace multiprecision{
template <unsigned digits10>
-struct gmp_real;
+struct gmp_float;
namespace detail{
template <unsigned digits10>
-struct gmp_real_imp
+struct gmp_float_imp
{
typedef mpl::list<long, long long> signed_types;
typedef mpl::list<unsigned long, unsigned long long> unsigned_types;
typedef mpl::list<double, long double> real_types;
typedef long exponent_type;
- gmp_real_imp(){}
+ gmp_float_imp(){}
- gmp_real_imp(const gmp_real_imp& o)
+ gmp_float_imp(const gmp_float_imp& o)
{
//
// We have to do an init followed by a set here, otherwise *this may be at
@@ -44,25 +44,25 @@
mpf_set(m_data, o.m_data);
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- gmp_real_imp(gmp_real_imp&& o)
+ gmp_float_imp(gmp_float_imp&& o)
{
m_data[0] = o.m_data[0];
o.m_data[0]._mp_d = 0;
}
#endif
- gmp_real_imp& operator = (const gmp_real_imp& o)
+ gmp_float_imp& operator = (const gmp_float_imp& o)
{
mpf_set(m_data, o.m_data);
return *this;
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- gmp_real_imp& operator = (gmp_real_imp&& o)
+ gmp_float_imp& operator = (gmp_float_imp&& o)
{
mpf_swap(m_data, o.m_data);
return *this;
}
#endif
- gmp_real_imp& operator = (boost::uintmax_t i)
+ gmp_float_imp& operator = (boost::uintmax_t i)
{
boost::uintmax_t mask = ((1uLL << std::numeric_limits<unsigned>::digits) - 1);
unsigned shift = 0;
@@ -81,7 +81,7 @@
mpf_clear(t);
return *this;
}
- gmp_real_imp& operator = (boost::intmax_t i)
+ gmp_float_imp& operator = (boost::intmax_t i)
{
bool neg = i < 0;
*this = static_cast<boost::uintmax_t>(std::abs(i));
@@ -89,22 +89,22 @@
mpf_neg(m_data, m_data);
return *this;
}
- gmp_real_imp& operator = (unsigned long i)
+ gmp_float_imp& operator = (unsigned long i)
{
mpf_set_ui(m_data, i);
return *this;
}
- gmp_real_imp& operator = (long i)
+ gmp_float_imp& operator = (long i)
{
mpf_set_si(m_data, i);
return *this;
}
- gmp_real_imp& operator = (double d)
+ gmp_float_imp& operator = (double d)
{
mpf_set_d(m_data, d);
return *this;
}
- gmp_real_imp& operator = (long double a)
+ gmp_float_imp& operator = (long double a)
{
using std::frexp;
using std::ldexp;
@@ -150,12 +150,12 @@
mpf_div_2exp(m_data, m_data, -e);
return *this;
}
- gmp_real_imp& operator = (const char* s)
+ gmp_float_imp& operator = (const char* s)
{
mpf_set_str(m_data, s, 10);
return *this;
}
- void swap(gmp_real_imp& o)
+ void swap(gmp_float_imp& o)
{
mpf_swap(m_data, o.m_data);
}
@@ -195,7 +195,7 @@
(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
return result;
}
- ~gmp_real_imp()
+ ~gmp_float_imp()
{
if(m_data[0]._mp_d)
mpf_clear(m_data);
@@ -204,7 +204,7 @@
{
mpf_neg(m_data, m_data);
}
- int compare(const gmp_real<digits10>& o)const
+ int compare(const gmp_float<digits10>& o)const
{
return mpf_cmp(m_data, o.m_data);
}
@@ -219,7 +219,7 @@
template <class V>
int compare(V v)const
{
- gmp_real<digits10> d;
+ gmp_float<digits10> d;
d = v;
return compare(d);
}
@@ -237,73 +237,73 @@
} // namespace detail
template <unsigned digits10>
-struct gmp_real : public detail::gmp_real_imp<digits10>
+struct gmp_float : public detail::gmp_float_imp<digits10>
{
- gmp_real()
+ gmp_float()
{
mpf_init2(this->m_data, ((digits10 + 1) * 1000L) / 301L);
}
- gmp_real(const gmp_real& o) : detail::gmp_real_imp<digits10>(o) {}
+ gmp_float(const gmp_float& o) : detail::gmp_float_imp<digits10>(o) {}
#ifndef BOOST_NO_RVALUE_REFERENCES
- gmp_real(gmp_real&& o) : detail::gmp_real_imp<digits10>(o) {}
+ gmp_float(gmp_float&& o) : detail::gmp_float_imp<digits10>(o) {}
#endif
- gmp_real& operator=(const gmp_real& o)
+ gmp_float& operator=(const gmp_float& o)
{
- *static_cast<detail::gmp_real_imp<digits10>*>(this) = static_cast<detail::gmp_real_imp<digits10> const&>(o);
+ *static_cast<detail::gmp_float_imp<digits10>*>(this) = static_cast<detail::gmp_float_imp<digits10> const&>(o);
return *this;
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- gmp_real& operator=(gmp_real&& o)
+ gmp_float& operator=(gmp_float&& o)
{
- *static_cast<detail::gmp_real_imp<digits10>*>(this) = static_cast<detail::gmp_real_imp<digits10>&&>(o);
+ *static_cast<detail::gmp_float_imp<digits10>*>(this) = static_cast<detail::gmp_float_imp<digits10>&&>(o);
return *this;
}
#endif
template <class V>
- gmp_real& operator=(const V& v)
+ gmp_float& operator=(const V& v)
{
- *static_cast<detail::gmp_real_imp<digits10>*>(this) = v;
+ *static_cast<detail::gmp_float_imp<digits10>*>(this) = v;
return *this;
}
};
template <>
-struct gmp_real<0> : public detail::gmp_real_imp<0>
+struct gmp_float<0> : public detail::gmp_float_imp<0>
{
- gmp_real()
+ gmp_float()
{
mpf_init2(this->m_data, ((get_default_precision() + 1) * 1000L) / 301L);
}
- gmp_real(unsigned digits10)
+ gmp_float(unsigned digits10)
{
mpf_init2(this->m_data, ((digits10 + 1) * 1000L) / 301L);
}
- gmp_real(const gmp_real& o) : detail::gmp_real_imp<0>(o) {}
+ gmp_float(const gmp_float& o) : detail::gmp_float_imp<0>(o) {}
#ifndef BOOST_NO_RVALUE_REFERENCES
- gmp_real(gmp_real&& o) : detail::gmp_real_imp<0>(o) {}
+ gmp_float(gmp_float&& o) : detail::gmp_float_imp<0>(o) {}
#endif
- gmp_real(const gmp_real& o, unsigned digits10)
+ gmp_float(const gmp_float& o, unsigned digits10)
{
mpf_init2(this->m_data, ((digits10 + 1) * 1000L) / 301L);
*this = o;
}
- gmp_real& operator=(const gmp_real& o)
+ gmp_float& operator=(const gmp_float& o)
{
- *static_cast<detail::gmp_real_imp<0>*>(this) = static_cast<detail::gmp_real_imp<0> const&>(o);
+ *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0> const&>(o);
return *this;
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- gmp_real& operator=(gmp_real&& o)
+ gmp_float& operator=(gmp_float&& o)
{
- *static_cast<detail::gmp_real_imp<0>*>(this) = static_cast<detail::gmp_real_imp<0> &&>(o);
+ *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0> &&>(o);
return *this;
}
#endif
template <class V>
- gmp_real& operator=(const V& v)
+ gmp_float& operator=(const V& v)
{
- *static_cast<detail::gmp_real_imp<0>*>(this) = v;
+ *static_cast<detail::gmp_float_imp<0>*>(this) = v;
return *this;
}
static unsigned default_precision()
@@ -325,47 +325,47 @@
};
template <unsigned digits10>
-inline void add(gmp_real<digits10>& result, const gmp_real<digits10>& o)
+inline void add(gmp_float<digits10>& result, const gmp_float<digits10>& o)
{
mpf_add(result.data(), result.data(), o.data());
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& result, const gmp_real<digits10>& o)
+inline void subtract(gmp_float<digits10>& result, const gmp_float<digits10>& o)
{
mpf_sub(result.data(), result.data(), o.data());
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& result, const gmp_real<digits10>& o)
+inline void multiply(gmp_float<digits10>& result, const gmp_float<digits10>& o)
{
mpf_mul(result.data(), result.data(), o.data());
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& result, const gmp_real<digits10>& o)
+inline void divide(gmp_float<digits10>& result, const gmp_float<digits10>& o)
{
mpf_div(result.data(), result.data(), o.data());
}
template <unsigned digits10>
-inline void add(gmp_real<digits10>& result, unsigned long i)
+inline void add(gmp_float<digits10>& result, unsigned long i)
{
mpf_add_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& result, unsigned long i)
+inline void subtract(gmp_float<digits10>& result, unsigned long i)
{
mpf_sub_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& result, unsigned long i)
+inline void multiply(gmp_float<digits10>& result, unsigned long i)
{
mpf_mul_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& result, unsigned long i)
+inline void divide(gmp_float<digits10>& result, unsigned long i)
{
mpf_div_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
-inline void add(gmp_real<digits10>& result, long i)
+inline void add(gmp_float<digits10>& result, long i)
{
if(i > 0)
mpf_add_ui(result.data(), result.data(), i);
@@ -373,7 +373,7 @@
mpf_sub_ui(result.data(), result.data(), std::abs(i));
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& result, long i)
+inline void subtract(gmp_float<digits10>& result, long i)
{
if(i > 0)
mpf_sub_ui(result.data(), result.data(), i);
@@ -381,14 +381,14 @@
mpf_add_ui(result.data(), result.data(), std::abs(i));
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& result, long i)
+inline void multiply(gmp_float<digits10>& result, long i)
{
mpf_mul_ui(result.data(), result.data(), std::abs(i));
if(i < 0)
mpf_neg(result.data(), result.data());
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& result, long i)
+inline void divide(gmp_float<digits10>& result, long i)
{
mpf_div_ui(result.data(), result.data(), std::abs(i));
if(i < 0)
@@ -398,17 +398,17 @@
// Specialised 3 arg versions of the basic operators:
//
template <unsigned digits10>
-inline void add(gmp_real<digits10>& a, const gmp_real<digits10>& x, const gmp_real<digits10>& y)
+inline void add(gmp_float<digits10>& a, const gmp_float<digits10>& x, const gmp_float<digits10>& y)
{
mpf_add(a.data(), x.data(), y.data());
}
template <unsigned digits10>
-inline void add(gmp_real<digits10>& a, const gmp_real<digits10>& x, unsigned long y)
+inline void add(gmp_float<digits10>& a, const gmp_float<digits10>& x, unsigned long y)
{
mpf_add_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void add(gmp_real<digits10>& a, const gmp_real<digits10>& x, long y)
+inline void add(gmp_float<digits10>& a, const gmp_float<digits10>& x, long y)
{
if(y < 0)
mpf_sub_ui(a.data(), x.data(), -y);
@@ -416,12 +416,12 @@
mpf_add_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void add(gmp_real<digits10>& a, unsigned long x, const gmp_real<digits10>& y)
+inline void add(gmp_float<digits10>& a, unsigned long x, const gmp_float<digits10>& y)
{
mpf_add_ui(a.data(), y.data(), x);
}
template <unsigned digits10>
-inline void add(gmp_real<digits10>& a, long x, const gmp_real<digits10>& y)
+inline void add(gmp_float<digits10>& a, long x, const gmp_float<digits10>& y)
{
if(x < 0)
{
@@ -432,17 +432,17 @@
mpf_add_ui(a.data(), y.data(), x);
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& a, const gmp_real<digits10>& x, const gmp_real<digits10>& y)
+inline void subtract(gmp_float<digits10>& a, const gmp_float<digits10>& x, const gmp_float<digits10>& y)
{
mpf_sub(a.data(), x.data(), y.data());
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& a, const gmp_real<digits10>& x, unsigned long y)
+inline void subtract(gmp_float<digits10>& a, const gmp_float<digits10>& x, unsigned long y)
{
mpf_sub_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& a, const gmp_real<digits10>& x, long y)
+inline void subtract(gmp_float<digits10>& a, const gmp_float<digits10>& x, long y)
{
if(y < 0)
mpf_add_ui(a.data(), x.data(), -y);
@@ -450,12 +450,12 @@
mpf_sub_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& a, unsigned long x, const gmp_real<digits10>& y)
+inline void subtract(gmp_float<digits10>& a, unsigned long x, const gmp_float<digits10>& y)
{
mpf_ui_sub(a.data(), x, y.data());
}
template <unsigned digits10>
-inline void subtract(gmp_real<digits10>& a, long x, const gmp_real<digits10>& y)
+inline void subtract(gmp_float<digits10>& a, long x, const gmp_float<digits10>& y)
{
if(x < 0)
{
@@ -467,17 +467,17 @@
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& a, const gmp_real<digits10>& x, const gmp_real<digits10>& y)
+inline void multiply(gmp_float<digits10>& a, const gmp_float<digits10>& x, const gmp_float<digits10>& y)
{
mpf_mul(a.data(), x.data(), y.data());
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& a, const gmp_real<digits10>& x, unsigned long y)
+inline void multiply(gmp_float<digits10>& a, const gmp_float<digits10>& x, unsigned long y)
{
mpf_mul_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& a, const gmp_real<digits10>& x, long y)
+inline void multiply(gmp_float<digits10>& a, const gmp_float<digits10>& x, long y)
{
if(y < 0)
{
@@ -488,12 +488,12 @@
mpf_mul_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& a, unsigned long x, const gmp_real<digits10>& y)
+inline void multiply(gmp_float<digits10>& a, unsigned long x, const gmp_float<digits10>& y)
{
mpf_mul_ui(a.data(), y.data(), x);
}
template <unsigned digits10>
-inline void multiply(gmp_real<digits10>& a, long x, const gmp_real<digits10>& y)
+inline void multiply(gmp_float<digits10>& a, long x, const gmp_float<digits10>& y)
{
if(x < 0)
{
@@ -505,17 +505,17 @@
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& a, const gmp_real<digits10>& x, const gmp_real<digits10>& y)
+inline void divide(gmp_float<digits10>& a, const gmp_float<digits10>& x, const gmp_float<digits10>& y)
{
mpf_div(a.data(), x.data(), y.data());
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& a, const gmp_real<digits10>& x, unsigned long y)
+inline void divide(gmp_float<digits10>& a, const gmp_float<digits10>& x, unsigned long y)
{
mpf_div_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& a, const gmp_real<digits10>& x, long y)
+inline void divide(gmp_float<digits10>& a, const gmp_float<digits10>& x, long y)
{
if(y < 0)
{
@@ -526,12 +526,12 @@
mpf_div_ui(a.data(), x.data(), y);
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& a, unsigned long x, const gmp_real<digits10>& y)
+inline void divide(gmp_float<digits10>& a, unsigned long x, const gmp_float<digits10>& y)
{
mpf_ui_div(a.data(), x, y.data());
}
template <unsigned digits10>
-inline void divide(gmp_real<digits10>& a, long x, const gmp_real<digits10>& y)
+inline void divide(gmp_float<digits10>& a, long x, const gmp_float<digits10>& y)
{
if(x < 0)
{
@@ -543,36 +543,36 @@
}
template <unsigned digits10>
-inline bool is_zero(const gmp_real<digits10>& val)
+inline bool is_zero(const gmp_float<digits10>& val)
{
return mpf_sgn(val.data()) == 0;
}
template <unsigned digits10>
-inline int get_sign(const gmp_real<digits10>& val)
+inline int get_sign(const gmp_float<digits10>& val)
{
return mpf_sgn(val.data());
}
template <unsigned digits10>
-inline void convert_to(unsigned long* result, const gmp_real<digits10>& val)
+inline void convert_to(unsigned long* result, const gmp_float<digits10>& val)
{
*result = mpf_get_ui(val.data());
}
template <unsigned digits10>
-inline void convert_to(long* result, const gmp_real<digits10>& val)
+inline void convert_to(long* result, const gmp_float<digits10>& val)
{
*result = mpf_get_si(val.data());
}
template <unsigned digits10>
-inline void convert_to(double* result, const gmp_real<digits10>& val)
+inline void convert_to(double* result, const gmp_float<digits10>& val)
{
*result = mpf_get_d(val.data());
}
#ifdef BOOST_HAS_LONG_LONG
template <unsigned digits10>
-inline void convert_to(long long* result, const gmp_real<digits10>& val)
+inline void convert_to(long long* result, const gmp_float<digits10>& val)
{
- gmp_real<digits10> t(val);
+ gmp_float<digits10> t(val);
if(get_sign(t) < 0)
t.negate();
@@ -602,9 +602,9 @@
*result = -*result;
}
template <unsigned digits10>
-inline void convert_to(unsigned long long* result, const gmp_real<digits10>& val)
+inline void convert_to(unsigned long long* result, const gmp_float<digits10>& val)
{
- gmp_real<digits10> t(val);
+ gmp_float<digits10> t(val);
long digits = std::numeric_limits<long long>::digits - std::numeric_limits<long>::digits;
@@ -635,39 +635,39 @@
// Native non-member operations:
//
template <unsigned Digits10>
-inline void eval_sqrt(gmp_real<Digits10>& result, const gmp_real<Digits10>& val)
+inline void eval_sqrt(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
mpf_sqrt(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_abs(gmp_real<Digits10>& result, const gmp_real<Digits10>& val)
+inline void eval_abs(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
mpf_abs(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_fabs(gmp_real<Digits10>& result, const gmp_real<Digits10>& val)
+inline void eval_fabs(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
mpf_abs(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_ceil(gmp_real<Digits10>& result, const gmp_real<Digits10>& val)
+inline void eval_ceil(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
mpf_ceil(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_floor(gmp_real<Digits10>& result, const gmp_real<Digits10>& val)
+inline void eval_floor(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
mpf_floor(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_trunc(gmp_real<Digits10>& result, const gmp_real<Digits10>& val)
+inline void eval_trunc(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
mpf_trunc(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_ldexp(gmp_real<Digits10>& result, const gmp_real<Digits10>& val, long e)
+inline void eval_ldexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long e)
{
if(e > 0)
mpf_mul_2exp(result.data(), val.data(), e);
@@ -677,7 +677,7 @@
result = val;
}
template <unsigned Digits10>
-inline void eval_frexp(gmp_real<Digits10>& result, const gmp_real<Digits10>& val, int* e)
+inline void eval_frexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, int* e)
{
long v;
mpf_get_d_2exp(&v, val.data());
@@ -685,7 +685,7 @@
eval_ldexp(result, val, -v);
}
template <unsigned Digits10>
-inline void eval_frexp(gmp_real<Digits10>& result, const gmp_real<Digits10>& val, long* e)
+inline void eval_frexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long* e)
{
mpf_get_d_2exp(e, val.data());
eval_ldexp(result, val, -*e);
@@ -1208,8 +1208,8 @@
using std::frexp;
using std::ldexp;
using std::floor;
- using big_num_default_ops::add;
- using big_num_default_ops::subtract;
+ using default_ops::add;
+ using default_ops::subtract;
if (a == 0) {
mpq_set_si(m_data, 0, 1);
@@ -1374,11 +1374,11 @@
template<>
struct number_category<gmp_rational> : public mpl::int_<number_kind_rational>{};
-typedef mp_number<gmp_real<50> > mpf_real_50;
-typedef mp_number<gmp_real<100> > mpf_real_100;
-typedef mp_number<gmp_real<500> > mpf_real_500;
-typedef mp_number<gmp_real<1000> > mpf_real_1000;
-typedef mp_number<gmp_real<0> > mpf_real;
+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;
@@ -1394,9 +1394,9 @@
// numeric_limits [partial] specializations for the types declared in this header:
//
template<unsigned Digits10>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<Digits10> > >
+class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10> > >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_real<Digits10> > number_type;
+ typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10> > number_type;
public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
BOOST_STATIC_CONSTEXPR number_type (min)() noexcept
@@ -1486,10 +1486,10 @@
{
data_initializer()
{
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<digits10> > >::epsilon();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<digits10> > >::round_error();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<digits10> > >::min)();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<digits10> > >::max)();
+ 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)();
}
void do_nothing()const{}
};
@@ -1497,12 +1497,12 @@
};
template<unsigned Digits10>
-const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<Digits10> > >::data_initializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<Digits10> > >::initializer;
+const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10> > >::data_initializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<Digits10> > >::initializer;
template<>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_real<0> > >
+class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::gmp_float<0> > >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_real<0> > number_type;
+ typedef boost::multiprecision::mp_number<boost::multiprecision::gmp_float<0> > number_type;
public:
BOOST_STATIC_CONSTEXPR bool is_specialized = false;
BOOST_STATIC_CONSTEXPR number_type (min)() noexcept { return number_type(); }
Modified: sandbox/big_number/boost/multiprecision/mp_number.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mp_number.hpp (original)
+++ sandbox/big_number/boost/multiprecision/mp_number.hpp 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -111,7 +111,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator+=(const V& v)
{
- using big_num_default_ops::add;
+ using default_ops::add;
add(m_backend, canonical_value(v));
return *this;
}
@@ -142,7 +142,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator-=(const V& v)
{
- using big_num_default_ops::subtract;
+ using default_ops::subtract;
subtract(m_backend, canonical_value(v));
return *this;
}
@@ -175,7 +175,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator*=(const V& v)
{
- using big_num_default_ops::multiply;
+ using default_ops::multiply;
multiply(m_backend, canonical_value(v));
return *this;
}
@@ -207,7 +207,7 @@
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 big_num_default_ops::modulus;
+ using default_ops::modulus;
modulus(m_backend, canonical_value(v));
return *this;
}
@@ -222,21 +222,21 @@
//
mp_number& operator++()
{
- using big_num_default_ops::increment;
+ using default_ops::increment;
increment(m_backend);
return *this;
}
mp_number& operator--()
{
- using big_num_default_ops::decrement;
+ using default_ops::decrement;
decrement(m_backend);
return *this;
}
mp_number operator++(int)
{
- using big_num_default_ops::increment;
+ using default_ops::increment;
self_type temp(*this);
increment(m_backend);
return temp;
@@ -244,7 +244,7 @@
mp_number operator--(int)
{
- using big_num_default_ops::decrement;
+ using default_ops::decrement;
self_type temp(*this);
decrement(m_backend);
return temp;
@@ -294,7 +294,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator/=(const V& v)
{
- using big_num_default_ops::divide;
+ using default_ops::divide;
divide(m_backend, canonical_value(v));
return *this;
}
@@ -326,7 +326,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator&=(const V& v)
{
- using big_num_default_ops::bitwise_and;
+ using default_ops::bitwise_and;
bitwise_and(m_backend, canonical_value(v));
return *this;
}
@@ -358,7 +358,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator|=(const V& v)
{
- using big_num_default_ops::bitwise_or;
+ using default_ops::bitwise_or;
bitwise_or(m_backend, canonical_value(v));
return *this;
}
@@ -388,7 +388,7 @@
typename enable_if<boost::is_arithmetic<V>, mp_number<Backend>& >::type
operator^=(const V& v)
{
- using big_num_default_ops::bitwise_xor;
+ using default_ops::bitwise_xor;
bitwise_xor(m_backend, canonical_value(v));
return *this;
}
@@ -414,12 +414,12 @@
//
bool is_zero()const
{
- using big_num_default_ops::is_zero;
+ using default_ops::is_zero;
return is_zero(m_backend);
}
int sign()const
{
- using big_num_default_ops::get_sign;
+ using default_ops::get_sign;
return get_sign(m_backend);
}
//
@@ -432,7 +432,7 @@
template <class T>
T convert_to()const
{
- using big_num_default_ops::convert_to;
+ using default_ops::convert_to;
T result;
convert_to(&result, m_backend);
return result;
@@ -466,7 +466,7 @@
template <class V>
typename enable_if<is_arithmetic<V>, int>::type compare(const V& o)const
{
- using big_num_default_ops::get_sign;
+ using default_ops::get_sign;
if(o == 0)
return get_sign(m_backend);
return m_backend.compare(canonical_value(o));
@@ -506,14 +506,14 @@
template <class Exp>
void do_assign(const Exp& e, const detail::add_immediates&)
{
- using big_num_default_ops::add;
+ using default_ops::add;
add(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
/*
template <class Exp>
void do_assign(const Exp& e, const detail::add_and_negate_immediates&)
{
- using big_num_default_ops::add;
+ using default_ops::add;
add(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
m_backend.negate();
}
@@ -521,14 +521,14 @@
template <class Exp>
void do_assign(const Exp& e, const detail::subtract_immediates&)
{
- using big_num_default_ops::subtract;
+ using default_ops::subtract;
subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
/*
template <class Exp>
void do_assign(const Exp& e, const detail::subtract_and_negate_immediates&)
{
- using big_num_default_ops::subtract;
+ using default_ops::subtract;
subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
m_backend.negate();
}
@@ -536,14 +536,14 @@
template <class Exp>
void do_assign(const Exp& e, const detail::multiply_immediates&)
{
- using big_num_default_ops::multiply;
+ using default_ops::multiply;
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 big_num_default_ops::divide;
+ using default_ops::divide;
divide(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
@@ -729,7 +729,7 @@
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 big_num_default_ops::modulus;
+ using default_ops::modulus;
modulus(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
@@ -774,7 +774,7 @@
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 big_num_default_ops::bitwise_and;
+ using default_ops::bitwise_and;
bitwise_and(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
@@ -819,7 +819,7 @@
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 big_num_default_ops::bitwise_or;
+ using default_ops::bitwise_or;
bitwise_or(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
@@ -864,7 +864,7 @@
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 big_num_default_ops::bitwise_xor;
+ using default_ops::bitwise_xor;
bitwise_xor(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
}
template <class Exp>
@@ -912,7 +912,7 @@
template <class Exp>
void do_assign(const Exp& e, const detail::bitwise_complement&)
{
- using big_num_default_ops::complement;
+ using default_ops::complement;
self_type temp(e.left());
complement(m_backend, temp.backend());
}
@@ -920,28 +920,28 @@
template <class Exp>
void do_assign(const Exp& e, const detail::complement_immediates&)
{
- using big_num_default_ops::complement;
+ using default_ops::complement;
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&)
{
- using big_num_default_ops::right_shift;
+ using default_ops::right_shift;
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&)
{
- using big_num_default_ops::left_shift;
+ using default_ops::left_shift;
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&)
{
- using big_num_default_ops::right_shift;
+ using default_ops::right_shift;
self_type temp(e);
right_shift(m_backend, temp.backend(), val);
}
@@ -949,7 +949,7 @@
template <class Exp, class Val, class Tag>
void do_assign_left_shift(const Exp& e, const Val& val, const Tag&)
{
- using big_num_default_ops::left_shift;
+ using default_ops::left_shift;
self_type temp(e);
left_shift(m_backend, temp.backend(), val);
}
@@ -1014,7 +1014,7 @@
template <class Exp>
void do_add(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::add;
+ using default_ops::add;
add(m_backend, canonical_value(e.value()));
}
@@ -1053,22 +1053,22 @@
template <class Exp>
void do_add(const Exp& e, const detail::add_immediates&)
{
- using big_num_default_ops::add;
+ using default_ops::add;
add(m_backend, canonical_value(e.left().value()));
add(m_backend, canonical_value(e.right().value()));
}
template <class Exp>
void do_add(const Exp& e, const detail::subtract_immediates&)
{
- using big_num_default_ops::add;
- using big_num_default_ops::subtract;
+ using default_ops::add;
+ using default_ops::subtract;
add(m_backend, canonical_value(e.left().value()));
subtract(m_backend, canonical_value(e.right().value()));
}
template <class Exp>
void do_subtract(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::subtract;
+ using default_ops::subtract;
subtract(m_backend, canonical_value(e.value()));
}
@@ -1099,15 +1099,15 @@
template <class Exp>
void do_subtract(const Exp& e, const detail::add_immediates&)
{
- using big_num_default_ops::subtract;
+ using default_ops::subtract;
subtract(m_backend, canonical_value(e.left().value()));
subtract(m_backend, canonical_value(e.right().value()));
}
template <class Exp>
void do_subtract(const Exp& e, const detail::subtract_immediates&)
{
- using big_num_default_ops::add;
- using big_num_default_ops::subtract;
+ using default_ops::add;
+ using default_ops::subtract;
subtract(m_backend, canonical_value(e.left().value()));
add(m_backend, canonical_value(e.right().value()));
}
@@ -1121,7 +1121,7 @@
template <class Exp>
void do_multiplies(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::multiply;
+ using default_ops::multiply;
multiply(m_backend, canonical_value(e.value()));
}
@@ -1154,22 +1154,22 @@
template <class Exp>
void do_multiplies(const Exp& e, const detail::multiply_immediates&)
{
- using big_num_default_ops::multiply;
+ using default_ops::multiply;
multiply(m_backend, canonical_value(e.left().value()));
multiply(m_backend, canonical_value(e.right().value()));
}
template <class Exp>
void do_multiplies(const Exp& e, const detail::divide_immediates&)
{
- using big_num_default_ops::multiply;
- using big_num_default_ops::divide;
+ using default_ops::multiply;
+ using default_ops::divide;
multiply(m_backend, canonical_value(e.left().value()));
divide(m_backend, canonical_value(e.right().value()));
}
template <class Exp, class unknown>
void do_multiplies(const Exp& e, const unknown&)
{
- using big_num_default_ops::multiply;
+ using default_ops::multiply;
self_type temp(e);
multiply(m_backend, temp.m_backend);
}
@@ -1177,7 +1177,7 @@
template <class Exp>
void do_divide(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::divide;
+ using default_ops::divide;
divide(m_backend, canonical_value(e.value()));
}
@@ -1210,15 +1210,15 @@
template <class Exp>
void do_divides(const Exp& e, const detail::multiply_immediates&)
{
- using big_num_default_ops::divide;
+ using default_ops::divide;
divide(m_backend, canonical_value(e.left().value()));
divide(m_backend, canonical_value(e.right().value()));
}
template <class Exp>
void do_divides(const Exp& e, const detail::divide_immediates&)
{
- using big_num_default_ops::multiply;
- using big_num_default_ops::divide;
+ using default_ops::multiply;
+ using default_ops::divide;
divide(m_backend, canonical_value(e.left().value()));
mutiply(m_backend, canonical_value(e.right().value()));
}
@@ -1226,7 +1226,7 @@
template <class Exp, class unknown>
void do_divide(const Exp& e, const unknown&)
{
- using big_num_default_ops::multiply;
+ using default_ops::multiply;
self_type temp(e);
divide(m_backend, temp.m_backend);
}
@@ -1235,7 +1235,7 @@
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 big_num_default_ops::modulus;
+ using default_ops::modulus;
modulus(m_backend, canonical_value(e.value()));
}
@@ -1243,7 +1243,7 @@
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 big_num_default_ops::modulus;
+ using default_ops::modulus;
self_type temp(e);
modulus(m_backend, canonical_value(temp));
}
@@ -1251,7 +1251,7 @@
template <class Exp>
void do_bitwise_and(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::bitwise_and;
+ using default_ops::bitwise_and;
bitwise_and(m_backend, canonical_value(e.value()));
}
template <class Exp>
@@ -1265,7 +1265,7 @@
template <class Exp, class unknown>
void do_bitwise_and(const Exp& e, const unknown&)
{
- using big_num_default_ops::bitwise_and;
+ using default_ops::bitwise_and;
self_type temp(e);
bitwise_and(m_backend, temp.m_backend);
}
@@ -1273,7 +1273,7 @@
template <class Exp>
void do_bitwise_or(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::bitwise_or;
+ using default_ops::bitwise_or;
bitwise_or(m_backend, canonical_value(e.value()));
}
template <class Exp>
@@ -1287,7 +1287,7 @@
template <class Exp, class unknown>
void do_bitwise_or(const Exp& e, const unknown&)
{
- using big_num_default_ops::bitwise_or;
+ using default_ops::bitwise_or;
self_type temp(e);
bitwise_or(m_backend, temp.m_backend);
}
@@ -1295,7 +1295,7 @@
template <class Exp>
void do_bitwise_xor(const Exp& e, const detail::terminal&)
{
- using big_num_default_ops::bitwise_xor;
+ using default_ops::bitwise_xor;
bitwise_xor(m_backend, canonical_value(e.value()));
}
template <class Exp>
@@ -1309,7 +1309,7 @@
template <class Exp, class unknown>
void do_bitwise_xor(const Exp& e, const unknown&)
{
- using big_num_default_ops::bitwise_xor;
+ using default_ops::bitwise_xor;
self_type temp(e);
bitwise_xor(m_backend, temp.m_backend);
}
@@ -1323,7 +1323,7 @@
template <class Exp>
bool contains_self(const Exp& e, mpl::int_<0> const&)const
{
- return is_really_self(e.value());
+ return is_floatly_self(e.value());
}
template <class Exp>
bool contains_self(const Exp& e, mpl::int_<1> const&)const
@@ -1359,7 +1359,7 @@
template <class Exp>
bool is_self(const Exp& e, mpl::int_<0> const&)const
{
- return is_really_self(e.value());
+ return is_floatly_self(e.value());
}
template <class Exp, int v>
bool is_self(const Exp& e, mpl::int_<v> const&)const
@@ -1368,8 +1368,8 @@
}
template <class Val>
- bool is_really_self(const Val&)const { return false; }
- bool is_really_self(const self_type& v)const { return &v == this; }
+ bool is_floatly_self(const Val&)const { return false; }
+ bool is_floatly_self(const self_type& v)const { return &v == this; }
static const Backend& canonical_value(const self_type& v){ return v.m_backend; }
//static const Backend& canonical_value(const self_type* v){ return v->m_backend; }
Modified: sandbox/big_number/boost/multiprecision/mpfr.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mpfr.hpp (original)
+++ sandbox/big_number/boost/multiprecision/mpfr.hpp 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -18,47 +18,47 @@
namespace boost{ namespace multiprecision{
template <unsigned digits10>
-struct mpfr_real_backend;
+struct mpfr_float_backend;
namespace detail{
long get_default_precision() { return 50; }
template <unsigned digits10>
-struct mpfr_real_imp
+struct mpfr_float_imp
{
typedef mpl::list<long, long long> signed_types;
typedef mpl::list<unsigned long, unsigned long long> unsigned_types;
typedef mpl::list<double, long double> real_types;
typedef long exponent_type;
- mpfr_real_imp(){}
+ mpfr_float_imp(){}
- mpfr_real_imp(const mpfr_real_imp& o)
+ mpfr_float_imp(const mpfr_float_imp& o)
{
mpfr_init2(m_data, (((digits10 ? digits10 : get_default_precision()) + 1) * 1000L) / 301L);
mpfr_set(m_data, o.m_data, GMP_RNDN);
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- mpfr_real_imp(mpfr_real_imp&& o)
+ mpfr_float_imp(mpfr_float_imp&& o)
{
m_data[0] = o.m_data[0];
o.m_data[0]._mpfr_d = 0;
}
#endif
- mpfr_real_imp& operator = (const mpfr_real_imp& o)
+ mpfr_float_imp& operator = (const mpfr_float_imp& o)
{
mpfr_set(m_data, o.m_data, GMP_RNDN);
return *this;
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- mpfr_real_imp& operator = (mpfr_real_imp&& o)
+ mpfr_float_imp& operator = (mpfr_float_imp&& o)
{
mpfr_swap(m_data, o.m_data);
return *this;
}
#endif
- mpfr_real_imp& operator = (boost::uintmax_t i)
+ mpfr_float_imp& operator = (boost::uintmax_t i)
{
boost::uintmax_t mask = ((1uLL << std::numeric_limits<unsigned>::digits) - 1);
unsigned shift = 0;
@@ -77,7 +77,7 @@
mpfr_clear(t);
return *this;
}
- mpfr_real_imp& operator = (boost::intmax_t i)
+ mpfr_float_imp& operator = (boost::intmax_t i)
{
bool neg = i < 0;
*this = static_cast<boost::uintmax_t>(std::abs(i));
@@ -85,22 +85,22 @@
mpfr_neg(m_data, m_data, GMP_RNDN);
return *this;
}
- mpfr_real_imp& operator = (unsigned long i)
+ mpfr_float_imp& operator = (unsigned long i)
{
mpfr_set_ui(m_data, i, GMP_RNDN);
return *this;
}
- mpfr_real_imp& operator = (long i)
+ mpfr_float_imp& operator = (long i)
{
mpfr_set_si(m_data, i, GMP_RNDN);
return *this;
}
- mpfr_real_imp& operator = (double d)
+ mpfr_float_imp& operator = (double d)
{
mpfr_set_d(m_data, d, GMP_RNDN);
return *this;
}
- mpfr_real_imp& operator = (long double a)
+ mpfr_float_imp& operator = (long double a)
{
using std::frexp;
using std::ldexp;
@@ -146,12 +146,12 @@
mpfr_div_2exp(m_data, m_data, -e, GMP_RNDN);
return *this;
}
- mpfr_real_imp& operator = (const char* s)
+ mpfr_float_imp& operator = (const char* s)
{
mpfr_set_str(m_data, s, 10, GMP_RNDN);
return *this;
}
- void swap(mpfr_real_imp& o)
+ void swap(mpfr_float_imp& o)
{
mpfr_swap(m_data, o.m_data);
}
@@ -192,7 +192,7 @@
mpfr_free_str(ps);
return result;
}
- ~mpfr_real_imp()
+ ~mpfr_float_imp()
{
if(m_data[0]._mpfr_d)
mpfr_clear(m_data);
@@ -201,7 +201,7 @@
{
mpfr_neg(m_data, m_data, GMP_RNDN);
}
- int compare(const mpfr_real_backend<digits10>& o)const
+ int compare(const mpfr_float_backend<digits10>& o)const
{
return mpfr_cmp(m_data, o.m_data);
}
@@ -216,7 +216,7 @@
template <class V>
int compare(V v)const
{
- mpfr_real_backend<digits10> d;
+ mpfr_float_backend<digits10> d;
d = v;
return compare(d);
}
@@ -234,73 +234,73 @@
} // namespace detail
template <unsigned digits10>
-struct mpfr_real_backend : public detail::mpfr_real_imp<digits10>
+struct mpfr_float_backend : public detail::mpfr_float_imp<digits10>
{
- mpfr_real_backend()
+ mpfr_float_backend()
{
mpfr_init2(this->m_data, ((digits10 + 1) * 1000L) / 301L);
}
- mpfr_real_backend(const mpfr_real_backend& o) : detail::mpfr_real_imp<digits10>(o) {}
+ mpfr_float_backend(const mpfr_float_backend& o) : detail::mpfr_float_imp<digits10>(o) {}
#ifndef BOOST_NO_RVALUE_REFERENCES
- mpfr_real_backend(mpfr_real_backend&& o) : detail::mpfr_real_imp<digits10>(o) {}
+ mpfr_float_backend(mpfr_float_backend&& o) : detail::mpfr_float_imp<digits10>(o) {}
#endif
- mpfr_real_backend& operator=(const mpfr_real_backend& o)
+ mpfr_float_backend& operator=(const mpfr_float_backend& o)
{
- *static_cast<detail::mpfr_real_imp<digits10>*>(this) = static_cast<detail::mpfr_real_imp<digits10> const&>(o);
+ *static_cast<detail::mpfr_float_imp<digits10>*>(this) = static_cast<detail::mpfr_float_imp<digits10> const&>(o);
return *this;
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- mpfr_real_backend& operator=(mpfr_real_backend&& o)
+ mpfr_float_backend& operator=(mpfr_float_backend&& o)
{
- *static_cast<detail::mpfr_real_imp<digits10>*>(this) = static_cast<detail::mpfr_real_imp<digits10>&&>(o);
+ *static_cast<detail::mpfr_float_imp<digits10>*>(this) = static_cast<detail::mpfr_float_imp<digits10>&&>(o);
return *this;
}
#endif
template <class V>
- mpfr_real_backend& operator=(const V& v)
+ mpfr_float_backend& operator=(const V& v)
{
- *static_cast<detail::mpfr_real_imp<digits10>*>(this) = v;
+ *static_cast<detail::mpfr_float_imp<digits10>*>(this) = v;
return *this;
}
};
template <>
-struct mpfr_real_backend<0> : public detail::mpfr_real_imp<0>
+struct mpfr_float_backend<0> : public detail::mpfr_float_imp<0>
{
- mpfr_real_backend()
+ mpfr_float_backend()
{
mpfr_init2(this->m_data, ((get_default_precision() + 1) * 1000L) / 301L);
}
- mpfr_real_backend(unsigned digits10)
+ mpfr_float_backend(unsigned digits10)
{
mpfr_init2(this->m_data, ((digits10 + 1) * 1000L) / 301L);
}
- mpfr_real_backend(const mpfr_real_backend& o) : detail::mpfr_real_imp<0>(o) {}
+ mpfr_float_backend(const mpfr_float_backend& o) : detail::mpfr_float_imp<0>(o) {}
#ifndef BOOST_NO_RVALUE_REFERENCES
- mpfr_real_backend(mpfr_real_backend&& o) : detail::mpfr_real_imp<0>(o) {}
+ mpfr_float_backend(mpfr_float_backend&& o) : detail::mpfr_float_imp<0>(o) {}
#endif
- mpfr_real_backend(const mpfr_real_backend& o, unsigned digits10)
+ mpfr_float_backend(const mpfr_float_backend& o, unsigned digits10)
{
mpfr_init2(this->m_data, ((digits10 + 1) * 1000L) / 301L);
*this = o;
}
- mpfr_real_backend& operator=(const mpfr_real_backend& o)
+ mpfr_float_backend& operator=(const mpfr_float_backend& o)
{
- *static_cast<detail::mpfr_real_imp<0>*>(this) = static_cast<detail::mpfr_real_imp<0> const&>(o);
+ *static_cast<detail::mpfr_float_imp<0>*>(this) = static_cast<detail::mpfr_float_imp<0> const&>(o);
return *this;
}
#ifndef BOOST_NO_RVALUE_REFERENCES
- mpfr_real_backend& operator=(mpfr_real_backend&& o)
+ mpfr_float_backend& operator=(mpfr_float_backend&& o)
{
- *static_cast<detail::mpfr_real_imp<0>*>(this) = static_cast<detail::mpfr_real_imp<0> &&>(o);
+ *static_cast<detail::mpfr_float_imp<0>*>(this) = static_cast<detail::mpfr_float_imp<0> &&>(o);
return *this;
}
#endif
template <class V>
- mpfr_real_backend& operator=(const V& v)
+ mpfr_float_backend& operator=(const V& v)
{
- *static_cast<detail::mpfr_real_imp<0>*>(this) = v;
+ *static_cast<detail::mpfr_float_imp<0>*>(this) = v;
return *this;
}
static unsigned default_precision()
@@ -322,47 +322,47 @@
};
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& result, const mpfr_real_backend<digits10>& o)
+inline void add(mpfr_float_backend<digits10>& result, const mpfr_float_backend<digits10>& o)
{
mpfr_add(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& result, const mpfr_real_backend<digits10>& o)
+inline void subtract(mpfr_float_backend<digits10>& result, const mpfr_float_backend<digits10>& o)
{
mpfr_sub(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& result, const mpfr_real_backend<digits10>& o)
+inline void multiply(mpfr_float_backend<digits10>& result, const mpfr_float_backend<digits10>& o)
{
mpfr_mul(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& result, const mpfr_real_backend<digits10>& o)
+inline void divide(mpfr_float_backend<digits10>& result, const mpfr_float_backend<digits10>& o)
{
mpfr_div(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& result, unsigned long i)
+inline void add(mpfr_float_backend<digits10>& result, unsigned long i)
{
mpfr_add_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& result, unsigned long i)
+inline void subtract(mpfr_float_backend<digits10>& result, unsigned long i)
{
mpfr_sub_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& result, unsigned long i)
+inline void multiply(mpfr_float_backend<digits10>& result, unsigned long i)
{
mpfr_mul_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& result, unsigned long i)
+inline void divide(mpfr_float_backend<digits10>& result, unsigned long i)
{
mpfr_div_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& result, long i)
+inline void add(mpfr_float_backend<digits10>& result, long i)
{
if(i > 0)
mpfr_add_ui(result.data(), result.data(), i, GMP_RNDN);
@@ -370,7 +370,7 @@
mpfr_sub_ui(result.data(), result.data(), std::abs(i), GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& result, long i)
+inline void subtract(mpfr_float_backend<digits10>& result, long i)
{
if(i > 0)
mpfr_sub_ui(result.data(), result.data(), i, GMP_RNDN);
@@ -378,14 +378,14 @@
mpfr_add_ui(result.data(), result.data(), std::abs(i), GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& result, long i)
+inline void multiply(mpfr_float_backend<digits10>& result, long i)
{
mpfr_mul_ui(result.data(), result.data(), std::abs(i), GMP_RNDN);
if(i < 0)
mpfr_neg(result.data(), result.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& result, long i)
+inline void divide(mpfr_float_backend<digits10>& result, long i)
{
mpfr_div_ui(result.data(), result.data(), std::abs(i), GMP_RNDN);
if(i < 0)
@@ -395,17 +395,17 @@
// Specialised 3 arg versions of the basic operators:
//
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, const mpfr_real_backend<digits10>& y)
+inline void add(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, const mpfr_float_backend<digits10>& y)
{
mpfr_add(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, unsigned long y)
+inline void add(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, unsigned long y)
{
mpfr_add_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, long y)
+inline void add(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, long y)
{
if(y < 0)
mpfr_sub_ui(a.data(), x.data(), -y, GMP_RNDN);
@@ -413,12 +413,12 @@
mpfr_add_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& a, unsigned long x, const mpfr_real_backend<digits10>& y)
+inline void add(mpfr_float_backend<digits10>& a, unsigned long x, const mpfr_float_backend<digits10>& y)
{
mpfr_add_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned digits10>
-inline void add(mpfr_real_backend<digits10>& a, long x, const mpfr_real_backend<digits10>& y)
+inline void add(mpfr_float_backend<digits10>& a, long x, const mpfr_float_backend<digits10>& y)
{
if(x < 0)
{
@@ -429,17 +429,17 @@
mpfr_add_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, const mpfr_real_backend<digits10>& y)
+inline void subtract(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, const mpfr_float_backend<digits10>& y)
{
mpfr_sub(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, unsigned long y)
+inline void subtract(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, unsigned long y)
{
mpfr_sub_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, long y)
+inline void subtract(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, long y)
{
if(y < 0)
mpfr_add_ui(a.data(), x.data(), -y, GMP_RNDN);
@@ -447,12 +447,12 @@
mpfr_sub_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& a, unsigned long x, const mpfr_real_backend<digits10>& y)
+inline void subtract(mpfr_float_backend<digits10>& a, unsigned long x, const mpfr_float_backend<digits10>& y)
{
mpfr_ui_sub(a.data(), x, y.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void subtract(mpfr_real_backend<digits10>& a, long x, const mpfr_real_backend<digits10>& y)
+inline void subtract(mpfr_float_backend<digits10>& a, long x, const mpfr_float_backend<digits10>& y)
{
if(x < 0)
{
@@ -464,17 +464,17 @@
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, const mpfr_real_backend<digits10>& y)
+inline void multiply(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, const mpfr_float_backend<digits10>& y)
{
mpfr_mul(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, unsigned long y)
+inline void multiply(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, unsigned long y)
{
mpfr_mul_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, long y)
+inline void multiply(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, long y)
{
if(y < 0)
{
@@ -485,12 +485,12 @@
mpfr_mul_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& a, unsigned long x, const mpfr_real_backend<digits10>& y)
+inline void multiply(mpfr_float_backend<digits10>& a, unsigned long x, const mpfr_float_backend<digits10>& y)
{
mpfr_mul_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned digits10>
-inline void multiply(mpfr_real_backend<digits10>& a, long x, const mpfr_real_backend<digits10>& y)
+inline void multiply(mpfr_float_backend<digits10>& a, long x, const mpfr_float_backend<digits10>& y)
{
if(x < 0)
{
@@ -502,17 +502,17 @@
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, const mpfr_real_backend<digits10>& y)
+inline void divide(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, const mpfr_float_backend<digits10>& y)
{
mpfr_div(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, unsigned long y)
+inline void divide(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, unsigned long y)
{
mpfr_div_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& a, const mpfr_real_backend<digits10>& x, long y)
+inline void divide(mpfr_float_backend<digits10>& a, const mpfr_float_backend<digits10>& x, long y)
{
if(y < 0)
{
@@ -523,12 +523,12 @@
mpfr_div_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& a, unsigned long x, const mpfr_real_backend<digits10>& y)
+inline void divide(mpfr_float_backend<digits10>& a, unsigned long x, const mpfr_float_backend<digits10>& y)
{
mpfr_ui_div(a.data(), x, y.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void divide(mpfr_real_backend<digits10>& a, long x, const mpfr_real_backend<digits10>& y)
+inline void divide(mpfr_float_backend<digits10>& a, long x, const mpfr_float_backend<digits10>& y)
{
if(x < 0)
{
@@ -540,45 +540,45 @@
}
template <unsigned digits10>
-inline bool is_zero(const mpfr_real_backend<digits10>& val)
+inline bool is_zero(const mpfr_float_backend<digits10>& val)
{
return 0 != mpfr_zero_p(val.data());
}
template <unsigned digits10>
-inline int get_sign(const mpfr_real_backend<digits10>& val)
+inline int get_sign(const mpfr_float_backend<digits10>& val)
{
return mpfr_sgn(val.data());
}
template <unsigned digits10>
-inline void convert_to(unsigned long* result, const mpfr_real_backend<digits10>& val)
+inline void convert_to(unsigned long* result, const mpfr_float_backend<digits10>& val)
{
*result = mpfr_get_ui(val.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void convert_to(long* result, const mpfr_real_backend<digits10>& val)
+inline void convert_to(long* result, const mpfr_float_backend<digits10>& val)
{
*result = mpfr_get_si(val.data(), GMP_RNDN);
}
#ifdef _MPFR_H_HAVE_INTMAX_T
template <unsigned digits10>
-inline void convert_to(boost::uintmax_t* result, const mpfr_real_backend<digits10>& val)
+inline void convert_to(boost::uintmax_t* result, const mpfr_float_backend<digits10>& val)
{
*result = mpfr_get_uj(val.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void convert_to(boost::intmax_t* result, const mpfr_real_backend<digits10>& val)
+inline void convert_to(boost::intmax_t* result, const mpfr_float_backend<digits10>& val)
{
*result = mpfr_get_sj(val.data(), GMP_RNDN);
}
#endif
template <unsigned digits10>
-inline void convert_to(double* result, const mpfr_real_backend<digits10>& val)
+inline void convert_to(double* result, const mpfr_float_backend<digits10>& val)
{
*result = mpfr_get_d(val.data(), GMP_RNDN);
}
template <unsigned digits10>
-inline void convert_to(long double* result, const mpfr_real_backend<digits10>& val)
+inline void convert_to(long double* result, const mpfr_float_backend<digits10>& val)
{
*result = mpfr_get_ld(val.data(), GMP_RNDN);
}
@@ -587,39 +587,39 @@
// Native non-member operations:
//
template <unsigned Digits10>
-inline void eval_sqrt(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val)
+inline void eval_sqrt(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val)
{
mpfr_sqrt(result.data(), val.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_abs(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val)
+inline void eval_abs(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val)
{
mpfr_abs(result.data(), val.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_fabs(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val)
+inline void eval_fabs(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val)
{
mpfr_abs(result.data(), val.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_ceil(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val)
+inline void eval_ceil(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val)
{
mpfr_ceil(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_floor(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val)
+inline void eval_floor(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val)
{
mpfr_floor(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_trunc(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val)
+inline void eval_trunc(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val)
{
mpfr_trunc(result.data(), val.data());
}
template <unsigned Digits10>
-inline void eval_ldexp(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val, long e)
+inline void eval_ldexp(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val, long e)
{
if(e > 0)
mpfr_mul_2exp(result.data(), val.data(), e, GMP_RNDN);
@@ -629,7 +629,7 @@
result = val;
}
template <unsigned Digits10>
-inline void eval_frexp(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val, int* e)
+inline void eval_frexp(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val, int* e)
{
long v;
mpfr_get_d_2exp(&v, val.data(), GMP_RNDN);
@@ -637,107 +637,107 @@
eval_ldexp(result, val, -v);
}
template <unsigned Digits10>
-inline void eval_frexp(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& val, long* e)
+inline void eval_frexp(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& val, long* e)
{
mpfr_get_d_2exp(e, val.data(), GMP_RNDN);
return eval_ldexp(result, val, -*e);
}
template <unsigned Digits10>
-inline int eval_fpclassify(const mpfr_real_backend<Digits10>& val)
+inline int eval_fpclassify(const mpfr_float_backend<Digits10>& val)
{
return mpfr_inf_p(val.data()) ? FP_INFINITE : mpfr_nan_p(val.data()) ? FP_NAN : mpfr_zero_p(val.data()) ? FP_ZERO : FP_NORMAL;
}
template <unsigned Digits10>
-inline void eval_pow(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& b, const mpfr_real_backend<Digits10>& e)
+inline void eval_pow(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& b, const mpfr_float_backend<Digits10>& e)
{
mpfr_pow(result.data(), b.data(), e.data(), GMP_RNDN);
}
template <unsigned Digits10, class Integer>
-inline typename enable_if<mpl::and_<is_signed<Integer>, mpl::bool_<sizeof(Integer) <= sizeof(long)> > >::type eval_pow(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& b, const Integer& e)
+inline typename enable_if<mpl::and_<is_signed<Integer>, mpl::bool_<sizeof(Integer) <= sizeof(long)> > >::type eval_pow(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& b, const Integer& e)
{
mpfr_pow_si(result.data(), b.data(), e, GMP_RNDN);
}
template <unsigned Digits10, class Integer>
-inline typename enable_if<mpl::and_<is_unsigned<Integer>, mpl::bool_<sizeof(Integer) <= sizeof(long)> > >::type eval_pow(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& b, const Integer& e)
+inline typename enable_if<mpl::and_<is_unsigned<Integer>, mpl::bool_<sizeof(Integer) <= sizeof(long)> > >::type eval_pow(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& b, const Integer& e)
{
mpfr_pow_ui(result.data(), b.data(), e, GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_exp(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_exp(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_exp(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_log(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_log(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_log(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_sin(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_sin(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_sin(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_cos(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_cos(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_cos(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_tan(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_tan(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_tan(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_asin(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_asin(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_asin(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_acos(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_acos(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_acos(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_atan(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_atan(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_atan(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_sinh(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_sinh(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_sinh(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_cosh(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_cosh(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_cosh(result.data(), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
-inline void eval_tanh(mpfr_real_backend<Digits10>& result, const mpfr_real_backend<Digits10>& arg)
+inline void eval_tanh(mpfr_float_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
mpfr_tanh(result.data(), arg.data(), GMP_RNDN);
}
-typedef mp_number<mpfr_real_backend<50> > mpfr_real_50;
-typedef mp_number<mpfr_real_backend<100> > mpfr_real_100;
-typedef mp_number<mpfr_real_backend<500> > mpfr_real_500;
-typedef mp_number<mpfr_real_backend<1000> > mpfr_real_1000;
-typedef mp_number<mpfr_real_backend<0> > mpfr_real;
+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;
} // namespace boost
@@ -746,7 +746,7 @@
namespace lanczos{
template<unsigned Digits10, class Policy>
-struct lanczos<multiprecision::mp_number<multiprecision::mpfr_real_backend<Digits10> >, Policy>
+struct lanczos<multiprecision::mp_number<multiprecision::mpfr_float_backend<Digits10> >, Policy>
{
typedef typename mpl::if_c<
Digits10 <= 36,
@@ -778,9 +778,9 @@
// numeric_limits [partial] specializations for the types declared in this header:
//
template<unsigned Digits10>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<Digits10> > >
+class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10> > >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<Digits10> > number_type;
+ typedef boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10> > number_type;
public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
BOOST_STATIC_CONSTEXPR number_type (min)() noexcept
@@ -897,12 +897,12 @@
{
data_initializer()
{
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<digits10> > >::epsilon();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<digits10> > >::round_error();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<digits10> > >::min)();
- (std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<digits10> > >::max)();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<digits10> > >::infinity();
- std::numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<digits10> > >::quiet_NaN();
+ 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();
}
void do_nothing()const{}
};
@@ -910,12 +910,12 @@
};
template<unsigned Digits10>
-const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<Digits10> > >::data_initializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<Digits10> > >::initializer;
+const typename numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10> > >::data_initializer numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10> > >::initializer;
template<>
-class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<0> > >
+class numeric_limits<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<0> > >
{
- typedef boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<0> > number_type;
+ typedef boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<0> > number_type;
public:
BOOST_STATIC_CONSTEXPR bool is_specialized = false;
BOOST_STATIC_CONSTEXPR number_type (min)() noexcept { return number_type(0); }
Modified: sandbox/big_number/libs/multiprecision/test/Jamfile.v2
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/Jamfile.v2 (original)
+++ sandbox/big_number/libs/multiprecision/test/Jamfile.v2 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -63,7 +63,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_arithmetic_mpf50 ;
@@ -126,7 +126,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_numeric_limits_mpf50 ;
@@ -187,11 +187,19 @@
[ check-target-builds ../config//has_mpfr : : <build>no ]
: big_number_concept_check_mpfr_50 ;
+run mp_number_concept_check.cpp gmp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_MPF_50
+ [ check-target-builds ../config//has_gmp : : <build>no ]
+ : big_number_concept_check_mpf50 ;
+
run test_exp.cpp gmp
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_exp_mpf50 ;
@@ -199,7 +207,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_log_mpf50 ;
@@ -207,7 +215,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_pow_mpf50 ;
@@ -215,7 +223,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_sinh_mpf50 ;
@@ -223,7 +231,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_cosh_mpf50 ;
@@ -231,7 +239,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_tanh_mpf50 ;
@@ -287,7 +295,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_sin_mpf50 ;
@@ -303,7 +311,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_cos_mpf50 ;
@@ -319,7 +327,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_asin_mpf50 ;
@@ -335,7 +343,7 @@
: # command line
: # input files
: # requirements
- <define>TEST_MPF50
+ <define>TEST_MPF_50
[ check-target-builds ../config//has_gmp : : <build>no ]
: test_acos_mpf50 ;
@@ -347,3 +355,18 @@
[ check-target-builds ../config//has_mpfr : : <build>no ]
: test_acos_mpfr_50 ;
+run test_atan.cpp gmp
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_MPF_50
+ [ check-target-builds ../config//has_gmp : : <build>no ]
+ : test_atan_mpf50 ;
+
+run test_atan.cpp mpfr
+ : # command line
+ : # input files
+ : # requirements
+ <define>TEST_MPFR_50
+ [ check-target-builds ../config//has_mpfr : : <build>no ]
+ : test_atan_mpfr_50 ;
Modified: sandbox/big_number/libs/multiprecision/test/linpack-benchmark.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/linpack-benchmark.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/linpack-benchmark.cpp 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -21,10 +21,10 @@
#ifdef TEST_MPF_100
#include <boost/multiprecision/gmp.hpp>
-typedef boost::multiprecision::mpf_real_100 real_type;
+typedef boost::multiprecision::mpf_float_100 real_type;
#elif defined(TEST_MPFR_100)
#include <boost/multiprecision/mpfr.hpp>
-typedef boost::multiprecision::mpfr_real_100 real_type;
+typedef boost::multiprecision::mpfr_float_100 real_type;
#elif defined(TEST_GMPXX)
#include <gmpxx.h>
typedef mpf_class real_type;
@@ -99,9 +99,9 @@
extern "C" int MAIN__()
{
#ifdef TEST_MPF_100
- std::cout << "Testing mp_number<mpf_real<100> >" << std::endl;
+ std::cout << "Testing mp_number<mpf_float<100> >" << std::endl;
#elif defined(TEST_MPFR_100)
- std::cout << "Testing mp_number<mpf_real<100> >" << std::endl;
+ std::cout << "Testing mp_number<mpf_float<100> >" << std::endl;
#elif defined(TEST_GMPXX)
std::cout << "Testing mpf_class at 100 decimal degits" << std::endl;
mpf_set_default_prec(((100 + 1) * 1000L) / 301L);
@@ -1229,7 +1229,7 @@
266.45 0.798 267.24 2.5021 0.79933 4772.2
-mp_number<gmp_real<100> >:
+mp_number<gmp_float<100> >:
~~~~~~~~~~~~~~~~~~~~~~~~~~~
norm. resid resid machep x(1) x(n)
Modified: sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp (original)
+++ sandbox/big_number/libs/multiprecision/test/mp_number_concept_check.cpp 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -20,8 +20,8 @@
# pragma warning(disable:4503) // decorated name length exceeded, name was truncated
#endif
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50)
+# define TEST_MPF_50
# define TEST_MPF
# define TEST_BACKEND
# define TEST_MPZ
@@ -38,7 +38,7 @@
#endif
-#if defined(TEST_MPF50) || defined(TEST_MPF) || defined(TEST_MPZ)
+#if defined(TEST_MPF_50) || defined(TEST_MPF) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
@@ -57,19 +57,19 @@
void foo()
{
#ifdef TEST_BACKEND
- instantiate(boost::multiprecision::mp_number_real_architype());
+ instantiate(boost::multiprecision::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
- instantiate(boost::multiprecision::mpf_real_50());
+ instantiate(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPF
- instantiate(boost::multiprecision::mpf_real());
+ instantiate(boost::multiprecision::mpf_float());
#endif
#ifdef TEST_MPFR_50
- instantiate(boost::multiprecision::mpfr_real_50());
+ instantiate(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR
- instantiate(boost::multiprecision::mpfr_real());
+ instantiate(boost::multiprecision::mpfr_float());
#endif
#ifdef TEST_E_FLOAT
instantiate(boost::multiprecision::e_float());
@@ -79,19 +79,19 @@
int main()
{
#ifdef TEST_BACKEND
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::math::concepts::mp_number_real_architype>));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::math::concepts::mp_number_float_architype>));
#endif
#ifdef TEST_MPF_50
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpf_real_50>));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpf_float_50>));
#endif
#ifdef TEST_MPF
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpf_real>));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpf_float>));
#endif
#ifdef TEST_MPFR_50
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_real_50>));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
#endif
#ifdef TEST_MPFR
- BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_real>));
+ BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float>));
#endif
#ifdef TEST_E_FLOAT
BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::e_float>));
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -86,15 +86,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -6,8 +6,8 @@
#include <boost/detail/lightweight_test.hpp>
#include <boost/math/special_functions/pow.hpp>
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
# define TEST_MPF
# define TEST_BACKEND
# define TEST_MPZ
@@ -25,7 +25,7 @@
#endif
-#if defined(TEST_MPF50) || defined(TEST_MPF) || defined(TEST_MPZ) || defined(TEST_MPQ)
+#if defined(TEST_MPF_50) || defined(TEST_MPF) || defined(TEST_MPZ) || defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
@@ -267,10 +267,10 @@
}
template <class Real, class T>
-void test_real_ops(const T&){}
+void test_float_ops(const T&){}
template <class Real>
-void test_real_ops(const boost::mpl::int_<boost::multiprecision::number_kind_floating_point>&)
+void test_float_ops(const boost::mpl::int_<boost::multiprecision::number_kind_floating_point>&)
{
#if defined(TEST_MPF) || defined(TEST_MPF_50) || defined(TEST_BACKEND) || defined(TEST_MPFR)
BOOST_TEST(abs(Real(2)) == 2);
@@ -570,7 +570,7 @@
//
// Real number only functions:
//
- test_real_ops<Real>(typename boost::multiprecision::number_category<Real>::type());
+ test_float_ops<Real>(typename boost::multiprecision::number_category<Real>::type());
//
// Test basic arithmetic:
//
@@ -859,20 +859,20 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
#endif
#ifdef TEST_MPF
- boost::multiprecision::mpf_real::default_precision(1000);
+ boost::multiprecision::mpf_float::default_precision(1000);
/*
- boost::multiprecision::mpf_real r;
+ boost::multiprecision::mpf_float r;
r.precision(50);
BOOST_TEST(r.precision() >= 50);
*/
- BOOST_TEST(boost::multiprecision::mpf_real::default_precision() == 1000);
- test<boost::multiprecision::mpf_real>();
+ BOOST_TEST(boost::multiprecision::mpf_float::default_precision() == 1000);
+ test<boost::multiprecision::mpf_float>();
#endif
#ifdef TEST_MPZ
test<boost::multiprecision::mpz_int>();
@@ -884,10 +884,10 @@
test<boost::multiprecision::e_float>();
#endif
#ifdef TEST_MPFR
- test<boost::multiprecision::mpfr_real>();
+ test<boost::multiprecision::mpfr_float>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
+ test<boost::multiprecision::mpfr_float_50>();
#endif
return boost::report_errors();
}
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -83,15 +83,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -44,7 +44,7 @@
T atan2_def(T y, T x)
{
T t;
- t.backend() = boost::multiprecision::big_num_default_ops::get_constant_pi<typename T::backend_type>();
+ t.backend() = boost::multiprecision::default_ops::get_constant_pi<typename T::backend_type>();
T t2;
if(x)
t2 = atan(y / x);
@@ -56,8 +56,10 @@
template <class T>
struct is_mpfr_type : public boost::mpl::false_ {};
+#ifdef TEST_MPFR_50
template <unsigned Digits10>
-struct is_mpfr_type<boost::multiprecision::mp_number<boost::multiprecision::mpfr_real_backend<Digits10> > > : public boost::mpl::true_{};
+struct is_mpfr_type<boost::multiprecision::mp_number<boost::multiprecision::mpfr_float_backend<Digits10> > > : public boost::mpl::true_{};
+#endif
template <class T>
void test()
@@ -188,7 +190,7 @@
max_err = err;
T pi;
- pi.backend() = boost::multiprecision::big_num_default_ops::get_constant_pi<typename T::backend_type>();
+ pi.backend() = boost::multiprecision::default_ops::get_constant_pi<typename T::backend_type>();
err = relative_error(T(atan2(T(1), T(0))), T(pi / 2)).template convert_to<unsigned>();
if(err > max_err)
@@ -227,15 +229,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -272,15 +272,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -118,15 +118,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -163,15 +163,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR_50
@@ -176,15 +176,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -5,8 +5,8 @@
#include <boost/detail/lightweight_test.hpp>
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
# define TEST_MPF
# define TEST_BACKEND
# define TEST_MPZ
@@ -24,7 +24,7 @@
#endif
-#if defined(TEST_MPF50) || defined(TEST_MPF) || defined(TEST_MPZ) || defined(TEST_MPQ)
+#if defined(TEST_MPF_50) || defined(TEST_MPF) || defined(TEST_MPZ) || defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
@@ -138,20 +138,20 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
#endif
#ifdef TEST_MPF
- boost::multiprecision::mpf_real::default_precision(1000);
+ boost::multiprecision::mpf_float::default_precision(1000);
/*
- boost::multiprecision::mpf_real r;
+ boost::multiprecision::mpf_float r;
r.precision(50);
BOOST_TEST(r.precision() >= 50);
*/
- BOOST_TEST(boost::multiprecision::mpf_real::default_precision() == 1000);
- test<boost::multiprecision::mpf_real>();
+ BOOST_TEST(boost::multiprecision::mpf_float::default_precision() == 1000);
+ test<boost::multiprecision::mpf_float>();
#endif
#ifdef TEST_MPZ
test<boost::multiprecision::mpz_int>();
@@ -163,10 +163,10 @@
test<boost::multiprecision::e_float>();
#endif
#ifdef TEST_MPFR
- test<boost::multiprecision::mpfr_real>();
+ test<boost::multiprecision::mpfr_float>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
+ test<boost::multiprecision::mpfr_float_50>();
#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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -28,7 +28,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -566,15 +566,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -278,15 +278,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -118,15 +118,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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 2011-10-23 07:23:13 EDT (Sun, 23 Oct 2011)
@@ -12,8 +12,8 @@
#include <boost/array.hpp>
#include "test.hpp"
-#if !defined(TEST_MPF50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
-# define TEST_MPF50
+#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_E_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ)
+# define TEST_MPF_50
//# define TEST_MPF
# define TEST_BACKEND
# define TEST_E_FLOAT
@@ -27,7 +27,7 @@
#endif
-#if defined(TEST_MPF50)
+#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
@@ -118,15 +118,15 @@
int main()
{
#ifdef TEST_BACKEND
- test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_real_architype> >();
+ test<boost::multiprecision::mp_number<boost::multiprecision::concepts::mp_number_backend_float_architype> >();
#endif
-#ifdef TEST_MPF50
- test<boost::multiprecision::mpf_real_50>();
- test<boost::multiprecision::mpf_real_100>();
+#ifdef TEST_MPF_50
+ test<boost::multiprecision::mpf_float_50>();
+ test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
- test<boost::multiprecision::mpfr_real_50>();
- test<boost::multiprecision::mpfr_real_100>();
+ test<boost::multiprecision::mpfr_float_50>();
+ test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_E_FLOAT
test<boost::multiprecision::e_float>();
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