#include <complex>
#ifndef BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION
-# define BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION 20
+#define BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION 20
#endif
-namespace boost{
-namespace multiprecision{
-namespace backends{
+namespace boost {
+namespace multiprecision {
+namespace backends {
template <unsigned digits10>
struct mpc_complex_backend;
} // namespace backends
template <unsigned digits10>
-struct number_category<backends::mpc_complex_backend<digits10> > : public mpl::int_<number_kind_complex>{};
+struct number_category<backends::mpc_complex_backend<digits10> > : public mpl::int_<number_kind_complex>
+{};
-namespace backends{
-
-namespace detail{
+namespace backends {
+namespace detail {
inline void mpc_copy_precision(mpc_t dest, const mpc_t src)
{
mpfr_prec_t p_dest = mpc_get_prec(dest);
- mpfr_prec_t p_src = mpc_get_prec(src);
+ mpfr_prec_t p_src = mpc_get_prec(src);
if (p_dest != p_src)
mpc_set_prec(dest, p_src);
}
mpc_set_prec(dest, p_src1);
}
-
template <unsigned digits10>
struct mpc_complex_imp
{
#ifdef BOOST_HAS_LONG_LONG
- typedef mpl::list<long, boost::long_long_type> signed_types;
- typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
+ typedef mpl::list<long, boost::long_long_type> signed_types;
+ typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
#else
- typedef mpl::list<long> signed_types;
- typedef mpl::list<unsigned long> unsigned_types;
+ typedef mpl::list<long> signed_types;
+ typedef mpl::list<unsigned long> unsigned_types;
#endif
- typedef mpl::list<double, long double> float_types;
- typedef long exponent_type;
+ typedef mpl::list<double, long double> float_types;
+ typedef long exponent_type;
mpc_complex_imp()
{
mpc_complex_imp(const mpc_complex_imp& o)
{
mpc_init2(m_data, mpc_get_prec(o.m_data));
- if(o.m_data[0].re[0]._mpfr_d)
+ if (o.m_data[0].re[0]._mpfr_d)
mpc_set(m_data, o.m_data, GMP_RNDN);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
mpc_complex_imp(mpc_complex_imp&& o) BOOST_NOEXCEPT
{
- m_data[0] = o.m_data[0];
+ m_data[0] = o.m_data[0];
o.m_data[0].re[0]._mpfr_d = 0;
}
#endif
- mpc_complex_imp& operator = (const mpc_complex_imp& o)
+ mpc_complex_imp& operator=(const mpc_complex_imp& o)
{
- if( (o.m_data[0].re[0]._mpfr_d) && (this != &o) )
+ if ((o.m_data[0].re[0]._mpfr_d) && (this != &o))
{
if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, mpc_get_prec(o.m_data));
return *this;
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- mpc_complex_imp& operator = (mpc_complex_imp&& o) BOOST_NOEXCEPT
+ mpc_complex_imp& operator=(mpc_complex_imp&& o) BOOST_NOEXCEPT
{
mpc_swap(m_data, o.m_data);
return *this;
#endif
#ifdef BOOST_HAS_LONG_LONG
#ifdef _MPFR_H_HAVE_INTMAX_T
- mpc_complex_imp& operator = (boost::ulong_long_type i)
+ mpc_complex_imp& operator=(boost::ulong_long_type i)
{
- if(m_data[0].re[0]._mpfr_d == 0)
+ if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_uj(data(), i, GMP_RNDD);
return *this;
}
- mpc_complex_imp& operator = (boost::long_long_type i)
+ mpc_complex_imp& operator=(boost::long_long_type i)
{
- if(m_data[0].re[0]._mpfr_d == 0)
+ if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_sj(data(), i, GMP_RNDD);
return *this;
}
#else
- mpc_complex_imp& operator = (boost::ulong_long_type i)
+ mpc_complex_imp& operator=(boost::ulong_long_type i)
{
mpfr_float_backend<digits10> f(0uL, mpc_get_prec(m_data));
f = i;
mpc_set_fr(this->data(), f.data(), GMP_RNDN);
return *this;
}
- mpc_complex_imp& operator = (boost::long_long_type i)
+ mpc_complex_imp& operator=(boost::long_long_type i)
{
mpfr_float_backend<digits10> f(0uL, mpc_get_prec(m_data));
f = i;
}
#endif
#endif
- mpc_complex_imp& operator = (unsigned long i)
+ mpc_complex_imp& operator=(unsigned long i)
{
- if(m_data[0].re[0]._mpfr_d == 0)
+ if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_ui(m_data, i, GMP_RNDN);
return *this;
}
- mpc_complex_imp& operator = (long i)
+ mpc_complex_imp& operator=(long i)
{
- if(m_data[0].re[0]._mpfr_d == 0)
+ if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_si(m_data, i, GMP_RNDN);
return *this;
}
- mpc_complex_imp& operator = (double d)
+ mpc_complex_imp& operator=(double d)
{
- if(m_data[0].re[0]._mpfr_d == 0)
+ if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_d(m_data, d, GMP_RNDN);
return *this;
}
- mpc_complex_imp& operator = (long double d)
+ mpc_complex_imp& operator=(long double d)
{
if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_ld(m_data, d, GMP_RNDN);
return *this;
}
- mpc_complex_imp& operator = (mpz_t i)
+ mpc_complex_imp& operator=(mpz_t i)
{
if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_z(m_data, i, GMP_RNDN);
return *this;
}
- mpc_complex_imp& operator = (gmp_int i)
+ mpc_complex_imp& operator=(gmp_int i)
{
if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpc_set_z(m_data, i.data(), GMP_RNDN);
return *this;
}
-
- mpc_complex_imp& operator = (const char* s)
+
+ mpc_complex_imp& operator=(const char* s)
{
using default_ops::eval_fpclassify;
- if(m_data[0].re[0]._mpfr_d == 0)
+ if (m_data[0].re[0]._mpfr_d == 0)
mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpfr_float_backend<digits10> a(0uL, mpc_get_prec(m_data)), b(0uL, mpc_get_prec(m_data));
- if(s && (*s == '('))
+ if (s && (*s == '('))
{
std::string part;
const char* p = ++s;
- while(*p && (*p != ',') && (*p != ')'))
+ while (*p && (*p != ',') && (*p != ')'))
++p;
part.assign(s, p);
- if(part.size())
+ if (part.size())
a = part.c_str();
else
a = 0uL;
s = p;
- if(*p && (*p != ')'))
+ if (*p && (*p != ')'))
{
++p;
- while(*p && (*p != ')'))
+ while (*p && (*p != ')'))
++p;
part.assign(s + 1, p);
}
else
part.erase();
- if(part.size())
+ if (part.size())
b = part.c_str();
else
b = 0uL;
b = 0uL;
}
- if(eval_fpclassify(a) == (int)FP_NAN)
+ if (eval_fpclassify(a) == (int)FP_NAN)
{
mpc_set_fr(this->data(), a.data(), GMP_RNDN);
}
- else if(eval_fpclassify(b) == (int)FP_NAN)
+ else if (eval_fpclassify(b) == (int)FP_NAN)
{
mpc_set_fr(this->data(), b.data(), GMP_RNDN);
}
{
mpc_swap(m_data, o.m_data);
}
- std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
+ std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
{
BOOST_ASSERT(m_data[0].re[0]._mpfr_d);
mpc_real(a.data(), m_data, GMP_RNDD);
mpc_imag(b.data(), m_data, GMP_RNDD);
- if(eval_is_zero(b))
+ if (eval_is_zero(b))
return a.str(digits, f);
return "(" + a.str(digits, f) + "," + b.str(digits, f) + ")";
}
~mpc_complex_imp() BOOST_NOEXCEPT
{
- if(m_data[0].re[0]._mpfr_d)
+ if (m_data[0].re[0]._mpfr_d)
mpc_clear(m_data);
}
void negate() BOOST_NOEXCEPT
BOOST_ASSERT(m_data[0].re[0]._mpfr_d);
mpc_neg(m_data, m_data, GMP_RNDD);
}
- int compare(const mpc_complex_imp& o)const BOOST_NOEXCEPT
+ int compare(const mpc_complex_imp& o) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0].re[0]._mpfr_d && o.m_data[0].re[0]._mpfr_d);
return mpc_cmp(m_data, o.m_data);
}
- int compare(const mpc_complex_backend<digits10>& o)const BOOST_NOEXCEPT
+ int compare(const mpc_complex_backend<digits10>& o) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0].re[0]._mpfr_d && o.m_data[0].re[0]._mpfr_d);
return mpc_cmp(m_data, o.data());
}
- int compare(long int i)const BOOST_NOEXCEPT
+ int compare(long int i) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0].re[0]._mpfr_d);
return mpc_cmp_si(m_data, i);
}
- int compare(unsigned long int i)const BOOST_NOEXCEPT
+ int compare(unsigned long int i) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0].re[0]._mpfr_d);
static const unsigned long int max_val = (std::numeric_limits<long>::max)();
return mpc_cmp_si(m_data, (long)i);
}
template <class V>
- int compare(const V& v)const BOOST_NOEXCEPT
+ int compare(const V& v) const BOOST_NOEXCEPT
{
mpc_complex_imp d(mpc_get_prec(m_data));
d = v;
BOOST_ASSERT(m_data[0].re[0]._mpfr_d);
return m_data;
}
- const mpc_t& data()const BOOST_NOEXCEPT
+ const mpc_t& data() const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0].re[0]._mpfr_d);
return m_data;
}
-protected:
- mpc_t m_data;
+
+ protected:
+ mpc_t m_data;
static unsigned& get_default_precision() BOOST_NOEXCEPT
{
static unsigned val = BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION;
mpc_complex_backend() : detail::mpc_complex_imp<digits10>() {}
mpc_complex_backend(const mpc_complex_backend& o) : detail::mpc_complex_imp<digits10>(o) {}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- mpc_complex_backend(mpc_complex_backend&& o) : detail::mpc_complex_imp<digits10>(static_cast<detail::mpc_complex_imp<digits10>&&>(o)) {}
+ mpc_complex_backend(mpc_complex_backend&& o) : detail::mpc_complex_imp<digits10>(static_cast<detail::mpc_complex_imp<digits10>&&>(o))
+ {}
#endif
template <unsigned D>
mpc_complex_backend(const mpc_complex_backend<D>& val, typename enable_if_c<D <= digits10>::type* = 0)
{
mpc_complex_backend() : detail::mpc_complex_imp<0>() {}
mpc_complex_backend(const mpc_t val)
- : detail::mpc_complex_imp<0>(mpc_get_prec(val))
+ : detail::mpc_complex_imp<0>(mpc_get_prec(val))
{
mpc_set(this->m_data, val, GMP_RNDN);
}
mpc_complex_backend(const mpc_complex_backend& o) : detail::mpc_complex_imp<0>(o) {}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- mpc_complex_backend(mpc_complex_backend&& o) BOOST_NOEXCEPT : detail::mpc_complex_imp<0>(static_cast<detail::mpc_complex_imp<0>&&>(o)) {}
+ mpc_complex_backend(mpc_complex_backend&& o) BOOST_NOEXCEPT : detail::mpc_complex_imp<0>(static_cast<detail::mpc_complex_imp<0>&&>(o))
+ {}
#endif
mpc_complex_backend(const mpc_complex_backend& o, unsigned digits10)
- : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
+ : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
{
mpc_set(this->m_data, o.data(), GMP_RNDN);
}
template <unsigned D>
mpc_complex_backend(const mpc_complex_backend<D>& val)
- : detail::mpc_complex_imp<0>(mpc_get_prec(val.data()))
+ : detail::mpc_complex_imp<0>(mpc_get_prec(val.data()))
{
mpc_set(this->m_data, val.data(), GMP_RNDN);
}
template <unsigned D>
mpc_complex_backend(const mpfr_float_backend<D>& val)
- : detail::mpc_complex_imp<0>(mpfr_get_prec(val.data()))
+ : detail::mpc_complex_imp<0>(mpfr_get_prec(val.data()))
{
mpc_set_fr(this->m_data, val.data(), GMP_RNDN);
}
mpc_set_z(this->m_data, val, GMP_RNDN);
return *this;
}
- mpc_complex_backend(gmp_int const& val) : detail::mpc_complex_imp<0>()
+ mpc_complex_backend(gmp_int const& val) : detail::mpc_complex_imp<0>()
{
mpc_set_z(this->m_data, val.data(), GMP_RNDN);
}
template <unsigned digits10>
mpc_complex_backend& operator=(gmp_float<digits10> const& val)
{
- if (mpc_get_prec(data()) != mpf_get_prec(val.data()))
+ if (mpc_get_prec(data()) != (mpfr_prec_t)mpf_get_prec(val.data()))
{
mpc_complex_backend t(val);
t.swap(*this);
return *this;
}
mpc_complex_backend(const std::complex<float>& val)
- : detail::mpc_complex_imp<0>()
+ : detail::mpc_complex_imp<0>()
{
mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
}
mpc_complex_backend(const std::complex<double>& val)
- : detail::mpc_complex_imp<0>()
+ : detail::mpc_complex_imp<0>()
{
mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
}
mpc_complex_backend(const std::complex<long double>& val)
- : detail::mpc_complex_imp<0>()
+ : detail::mpc_complex_imp<0>()
{
mpc_set_ld_ld(this->m_data, val.real(), val.imag(), GMP_RNDN);
}
// Construction with precision:
template <class T, class U>
mpc_complex_backend(const T& a, const U& b, unsigned digits10)
- : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
+ : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
{
// We can't use assign_components here because it copies the precision of
// a and b, not digits10....
}
template <unsigned N>
mpc_complex_backend(const mpfr_float_backend<N>& a, const mpfr_float_backend<N>& b, unsigned digits10)
- : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
+ : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
{
mpc_set_fr_fr(this->data(), a.data(), b.data(), GMP_RNDN);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
mpc_complex_backend& operator=(mpc_complex_backend&& o) BOOST_NOEXCEPT
{
- *static_cast<detail::mpc_complex_imp<0>*>(this) = static_cast<detail::mpc_complex_imp<0> &&>(o);
+ *static_cast<detail::mpc_complex_imp<0>*>(this) = static_cast<detail::mpc_complex_imp<0>&&>(o);
return *this;
}
#endif
{
get_default_precision() = v;
}
- unsigned precision()const BOOST_NOEXCEPT
+ unsigned precision() const BOOST_NOEXCEPT
{
return multiprecision::detail::digits2_2_10(mpc_get_prec(this->m_data));
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& result, const mpc_complex_backend<D2>& o)
{
- if((void*)&result == (void*)&o)
+ if ((void*)&result == (void*)&o)
mpc_sqr(result.data(), o.data(), GMP_RNDN);
else
mpc_mul(result.data(), result.data(), o.data(), GMP_RNDN);
template <unsigned digits10>
inline void eval_add(mpc_complex_backend<digits10>& result, long i)
{
- if(i > 0)
+ if (i > 0)
mpc_add_ui(result.data(), result.data(), i, GMP_RNDN);
else
mpc_sub_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
template <unsigned digits10>
inline void eval_subtract(mpc_complex_backend<digits10>& result, long i)
{
- if(i > 0)
+ if (i > 0)
mpc_sub_ui(result.data(), result.data(), i, GMP_RNDN);
else
mpc_add_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
inline void eval_multiply(mpc_complex_backend<digits10>& result, long i)
{
mpc_mul_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
- if(i < 0)
+ if (i < 0)
mpc_neg(result.data(), result.data(), GMP_RNDN);
}
template <unsigned digits10>
inline void eval_divide(mpc_complex_backend<digits10>& result, long i)
{
mpc_div_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
- if(i < 0)
+ if (i < 0)
mpc_neg(result.data(), result.data(), GMP_RNDN);
}
//
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
mpc_sub_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDD);
else
mpc_add_ui(a.data(), x.data(), y, GMP_RNDD);
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpc_ui_sub(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data(), GMP_RNDN);
mpc_neg(a.data(), a.data(), GMP_RNDD);
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
mpc_add_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDD);
else
mpc_sub_ui(a.data(), x.data(), y, GMP_RNDD);
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpc_add_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x), GMP_RNDD);
mpc_neg(a.data(), a.data(), GMP_RNDD);
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
- if((void*)&x == (void*)&y)
+ if ((void*)&x == (void*)&y)
mpc_sqr(a.data(), x.data(), GMP_RNDD);
else
mpc_mul(a.data(), x.data(), y.data(), GMP_RNDD);
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
{
mpc_mul_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDD);
a.negate();
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpc_mul_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x), GMP_RNDD);
mpc_neg(a.data(), a.data(), GMP_RNDD);
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
{
mpc_div_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDD);
a.negate();
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpc_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data(), GMP_RNDD);
mpc_neg(a.data(), a.data(), GMP_RNDD);
//
if (!D1)
{
- unsigned long prec = std::max(mpfr_get_prec(a.data()), mpfr_get_prec(b.data()));
+ unsigned long prec = (std::max)(mpfr_get_prec(a.data()), mpfr_get_prec(b.data()));
mpc_set_prec(result.data(), prec);
}
using default_ops::eval_fpclassify;
- if(eval_fpclassify(a) == (int)FP_NAN)
+ if (eval_fpclassify(a) == (int)FP_NAN)
{
mpc_set_fr(result.data(), a.data(), GMP_RNDN);
}
- else if(eval_fpclassify(b) == (int)FP_NAN)
+ else if (eval_fpclassify(b) == (int)FP_NAN)
{
mpc_set_fr(result.data(), b.data(), GMP_RNDN);
}
inline std::size_t hash_value(const mpc_complex_backend<Digits10>& val)
{
std::size_t result = 0;
- std::size_t len = val.data()[0].re[0]._mpfr_prec / mp_bits_per_limb;
- if(val.data()[0].re[0]._mpfr_prec % mp_bits_per_limb)
+ std::size_t len = val.data()[0].re[0]._mpfr_prec / mp_bits_per_limb;
+ if (val.data()[0].re[0]._mpfr_prec % mp_bits_per_limb)
++len;
- for(std::size_t i = 0; i < len; ++i)
+ for (std::size_t i = 0; i < len; ++i)
boost::hash_combine(result, val.data()[0].re[0]._mpfr_d[i]);
boost::hash_combine(result, val.data()[0].re[0]._mpfr_exp);
boost::hash_combine(result, val.data()[0].re[0]._mpfr_sign);
len = val.data()[0].im[0]._mpfr_prec / mp_bits_per_limb;
- if(val.data()[0].im[0]._mpfr_prec % mp_bits_per_limb)
+ if (val.data()[0].im[0]._mpfr_prec % mp_bits_per_limb)
++len;
- for(std::size_t i = 0; i < len; ++i)
+ for (std::size_t i = 0; i < len; ++i)
boost::hash_combine(result, val.data()[0].im[0]._mpfr_d[i]);
boost::hash_combine(result, val.data()[0].im[0]._mpfr_exp);
boost::hash_combine(result, val.data()[0].im[0]._mpfr_sign);
#ifdef BOOST_NO_SFINAE_EXPR
-namespace detail{
+namespace detail {
-template<unsigned D1, unsigned D2>
-struct is_explicitly_convertible<backends::mpc_complex_backend<D1>, backends::mpc_complex_backend<D2> > : public mpl::true_ {};
+template <unsigned D1, unsigned D2>
+struct is_explicitly_convertible<backends::mpc_complex_backend<D1>, backends::mpc_complex_backend<D2> > : public mpl::true_
+{};
-}
+} // namespace detail
#endif
-namespace detail
-{
- template<>
- struct is_variable_precision<backends::mpc_complex_backend<0> > : public true_type {};
-}
+namespace detail {
+template <>
+struct is_variable_precision<backends::mpc_complex_backend<0> > : public true_type
+{};
+} // namespace detail
-template<>
-struct number_category<detail::canonical<mpc_t, backends::mpc_complex_backend<0> >::type> : public mpl::int_<number_kind_floating_point>{};
+template <>
+struct number_category<detail::canonical<mpc_t, backends::mpc_complex_backend<0> >::type> : public mpl::int_<number_kind_floating_point>
+{};
using boost::multiprecision::backends::mpc_complex_backend;
-typedef number<mpc_complex_backend<50> > mpc_complex_50;
-typedef number<mpc_complex_backend<100> > mpc_complex_100;
-typedef number<mpc_complex_backend<500> > mpc_complex_500;
-typedef number<mpc_complex_backend<1000> > mpc_complex_1000;
-typedef number<mpc_complex_backend<0> > mpc_complex;
+typedef number<mpc_complex_backend<50> > mpc_complex_50;
+typedef number<mpc_complex_backend<100> > mpc_complex_100;
+typedef number<mpc_complex_backend<500> > mpc_complex_500;
+typedef number<mpc_complex_backend<1000> > mpc_complex_1000;
+typedef number<mpc_complex_backend<0> > mpc_complex;
template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct component_type<number<mpc_complex_backend<Digits10>, ExpressionTemplates> >
typedef number<mpc_complex_backend<Digits10>, ExpressionTemplates> type;
};
-} // namespace multiprecision
+}
-} // namespaces
+} // namespace boost::multiprecision
#endif
projects / platform / upstream / boost.git / blobdiff