projects / platform / upstream / boost.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Imported Upstream version 1.72.0
[platform/upstream/boost.git] / boost / multiprecision / complex_adaptor.hpp
diff --git a/boost/multiprecision/complex_adaptor.hpp b/boost/multiprecision/complex_adaptor.hpp
index e86b1ff..dbf70b1 100644 (file)
--- a/boost/multiprecision/complex_adaptor.hpp
+++ b/boost/multiprecision/complex_adaptor.hpp
@@ -15,17 +15,18 @@
 #include <algorithm>
 #include <complex>
 
-namespace boost{
-namespace multiprecision{
-namespace backends{
+namespace boost {
+namespace multiprecision {
+namespace backends {
 
 template <class Backend>
 struct complex_adaptor
 {
-protected:
+ protected:
    Backend m_real, m_imag;
-public:
-   Backend& real_data() 
+
+ public:
+   Backend& real_data()
    {
       return m_real;
    }
@@ -42,18 +43,20 @@ public:
       return m_imag;
    }
 
-   typedef typename Backend::signed_types     signed_types;
-   typedef typename Backend::unsigned_types   unsigned_types;
-   typedef typename Backend::float_types      float_types;
-   typedef typename Backend::exponent_type    exponent_type;
+   typedef typename Backend::signed_types   signed_types;
+   typedef typename Backend::unsigned_types unsigned_types;
+   typedef typename Backend::float_types    float_types;
+   typedef typename Backend::exponent_type  exponent_type;
 
    complex_adaptor() {}
    complex_adaptor(const complex_adaptor& o) : m_real(o.real_data()), m_imag(o.imag_data()) {}
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-   complex_adaptor(complex_adaptor&& o) : m_real(std::move(o.real_data())), m_imag(std::move(o.imag_data())) {}
+   complex_adaptor(complex_adaptor&& o) : m_real(std::move(o.real_data())), m_imag(std::move(o.imag_data()))
+   {}
 #endif
    complex_adaptor(const Backend& val)
-       : m_real(val) {}
+       : m_real(val)
+   {}
 
    complex_adaptor(const std::complex<float>& val)
    {
@@ -70,7 +73,7 @@ public:
       m_real = val.real();
       m_imag = val.imag();
    }
-   
+
    complex_adaptor& operator=(const complex_adaptor& o)
    {
       m_real = o.real_data();
@@ -100,10 +103,10 @@ public:
       m_imag = (long double)val.imag();
       return *this;
    }
-   complex_adaptor& operator = (const char* s)
+   complex_adaptor& operator=(const char* s)
    {
       typedef typename mpl::front<unsigned_types>::type ui_type;
-      ui_type zero = 0u;
+      ui_type                                           zero = 0u;
 
       using default_ops::eval_fpclassify;
 
@@ -114,7 +117,7 @@ public:
          while (*p && (*p != ',') && (*p != ')'))
             ++p;
          part.assign(s, p);
-         if(part.size())
+         if (part.size())
             real_data() = part.c_str();
          else
             real_data() = zero;
@@ -128,7 +131,7 @@ public:
          }
          else
             part.erase();
-         if(part.size())
+         if (part.size())
             imag_data() = part.c_str();
          else
             imag_data() = zero;
@@ -146,13 +149,13 @@ public:
       return *this;
    }
 
-   int compare(const complex_adaptor& o)const
+   int compare(const complex_adaptor& o) const
    {
       // They are either equal or not:
       return (m_real.compare(o.real_data()) == 0) && (m_imag.compare(o.imag_data()) == 0) ? 0 : 1;
    }
    template <class T>
-   int compare(const T& val)const
+   int compare(const T& val) const
    {
       using default_ops::eval_is_zero;
       return (m_real.compare(val) == 0) && eval_is_zero(m_imag) ? 0 : 1;
@@ -162,7 +165,7 @@ public:
       real_data().swap(o.real_data());
       imag_data().swap(o.imag_data());
    }
-   std::string str(std::streamsize dig, std::ios_base::fmtflags f)const
+   std::string str(std::streamsize dig, std::ios_base::fmtflags f) const
    {
       using default_ops::eval_is_zero;
       if (eval_is_zero(imag_data()))
@@ -211,12 +214,12 @@ template <class Backend>
 inline void eval_divide(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& z)
 {
    // (a+bi) / (c + di)
-   using default_ops::eval_fabs;
+   using default_ops::eval_add;
    using default_ops::eval_divide;
+   using default_ops::eval_fabs;
+   using default_ops::eval_is_zero;
    using default_ops::eval_multiply;
    using default_ops::eval_subtract;
-   using default_ops::eval_add;
-   using default_ops::eval_is_zero;
    Backend t1, t2;
 
    if (eval_is_zero(z.imag_data()))
@@ -226,7 +229,6 @@ inline void eval_divide(complex_adaptor<Backend>& result, const complex_adaptor<
       return;
    }
 
-
    eval_fabs(t1, z.real_data());
    eval_fabs(t2, z.imag_data());
    if (t1.compare(t2) < 0)
@@ -246,10 +248,10 @@ inline void eval_divide(complex_adaptor<Backend>& result, const complex_adaptor<
    }
    else
    {
-      eval_divide(t1, z.imag_data(), z.real_data());  // t1 = d/c
+      eval_divide(t1, z.imag_data(), z.real_data()); // t1 = d/c
       eval_multiply(t2, z.imag_data(), t1);
-      eval_add(t2, z.real_data());   // denom = d * d/c + c
-      
+      eval_add(t2, z.real_data()); // denom = d * d/c + c
+
       Backend r_t(result.real_data());
       Backend i_t(result.imag_data());
 
@@ -336,8 +338,8 @@ inline int eval_get_sign(const complex_adaptor<Backend>&)
 template <class Result, class Backend>
 inline typename disable_if_c<boost::is_complex<Result>::value>::type eval_convert_to(Result* result, const complex_adaptor<Backend>& val)
 {
-   using default_ops::eval_is_zero;
    using default_ops::eval_convert_to;
+   using default_ops::eval_is_zero;
    if (!eval_is_zero(val.imag_data()))
    {
       BOOST_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
@@ -363,13 +365,13 @@ inline void eval_sqrt(complex_adaptor<Backend>& result, const complex_adaptor<Ba
    //           (|zi| / 2s, +-s)   for zr <  0
    // where s = sqrt{ [ |zr| + sqrt(zr^2 + zi^2) ] / 2 },
    // and the +- sign is the same as the sign of zi.
-   using default_ops::eval_get_sign;
    using default_ops::eval_abs;
-   using default_ops::eval_divide;
    using default_ops::eval_add;
+   using default_ops::eval_divide;
+   using default_ops::eval_get_sign;
    using default_ops::eval_is_zero;
 
-   if (eval_is_zero(val.imag_data()) && (eval_get_sign(val.real_data())>= 0))
+   if (eval_is_zero(val.imag_data()) && (eval_get_sign(val.real_data()) >= 0))
    {
       static const typename mpl::front<typename Backend::unsigned_types>::type zero = 0u;
       eval_sqrt(result.real_data(), val.real_data());
@@ -424,12 +426,12 @@ inline void eval_abs(Backend& result, const complex_adaptor<Backend>& val)
 template <class Backend>
 inline void eval_pow(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& b, const complex_adaptor<Backend>& e)
 {
-   using default_ops::eval_is_zero;
-   using default_ops::eval_get_sign;
    using default_ops::eval_acos;
-   using default_ops::eval_multiply;
-   using default_ops::eval_exp;
    using default_ops::eval_cos;
+   using default_ops::eval_exp;
+   using default_ops::eval_get_sign;
+   using default_ops::eval_is_zero;
+   using default_ops::eval_multiply;
    using default_ops::eval_sin;
 
    if (eval_is_zero(e))
@@ -442,13 +444,13 @@ inline void eval_pow(complex_adaptor<Backend>& result, const complex_adaptor<Bac
    {
       if (eval_is_zero(e.real_data()))
       {
-         Backend n = std::numeric_limits<number<Backend> >::quiet_NaN().backend();
+         Backend n          = std::numeric_limits<number<Backend> >::quiet_NaN().backend();
          result.real_data() = n;
          result.imag_data() = n;
       }
       else if (eval_get_sign(e.real_data()) < 0)
       {
-         Backend n = std::numeric_limits<number<Backend> >::infinity().backend();
+         Backend n          = std::numeric_limits<number<Backend> >::infinity().backend();
          result.real_data() = n;
          typename mpl::front<typename Backend::unsigned_types>::type zero(0);
          if (eval_is_zero(e.imag_data()))
@@ -472,11 +474,11 @@ inline void eval_pow(complex_adaptor<Backend>& result, const complex_adaptor<Bac
 template <class Backend>
 inline void eval_exp(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_sin;
    using default_ops::eval_cos;
    using default_ops::eval_exp;
-   using default_ops::eval_multiply;
    using default_ops::eval_is_zero;
+   using default_ops::eval_multiply;
+   using default_ops::eval_sin;
 
    if (eval_is_zero(arg.imag_data()))
    {
@@ -500,12 +502,12 @@ inline void eval_exp(complex_adaptor<Backend>& result, const complex_adaptor<Bac
 template <class Backend>
 inline void eval_log(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_log;
-   using default_ops::eval_multiply;
    using default_ops::eval_add;
    using default_ops::eval_atan2;
-   using default_ops::eval_is_zero;
    using default_ops::eval_get_sign;
+   using default_ops::eval_is_zero;
+   using default_ops::eval_log;
+   using default_ops::eval_multiply;
 
    if (eval_is_zero(arg.imag_data()) && (eval_get_sign(arg.real_data()) >= 0))
    {
@@ -527,8 +529,8 @@ inline void eval_log(complex_adaptor<Backend>& result, const complex_adaptor<Bac
 template <class Backend>
 inline void eval_log10(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_log;
    using default_ops::eval_divide;
+   using default_ops::eval_log;
 
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
 
@@ -543,10 +545,10 @@ inline void eval_log10(complex_adaptor<Backend>& result, const complex_adaptor<B
 template <class Backend>
 inline void eval_sin(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_sin;
    using default_ops::eval_cos;
-   using default_ops::eval_sinh;
    using default_ops::eval_cosh;
+   using default_ops::eval_sin;
+   using default_ops::eval_sinh;
 
    Backend t1, t2;
    eval_sin(t1, arg.real_data());
@@ -561,10 +563,10 @@ inline void eval_sin(complex_adaptor<Backend>& result, const complex_adaptor<Bac
 template <class Backend>
 inline void eval_cos(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_sin;
    using default_ops::eval_cos;
-   using default_ops::eval_sinh;
    using default_ops::eval_cosh;
+   using default_ops::eval_sin;
+   using default_ops::eval_sinh;
 
    Backend t1, t2;
    eval_cos(t1, arg.real_data());
@@ -611,7 +613,7 @@ template <class Backend>
 inline void eval_acos(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
-   
+
    using default_ops::eval_asin;
 
    Backend half_pi, t1;
@@ -626,12 +628,12 @@ template <class Backend>
 inline void eval_atan(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
-   ui_type one = (ui_type)1u;
+   ui_type                                                             one = (ui_type)1u;
 
    using default_ops::eval_add;
+   using default_ops::eval_is_zero;
    using default_ops::eval_log;
    using default_ops::eval_subtract;
-   using default_ops::eval_is_zero;
 
    complex_adaptor<Backend> __my_z_times_i, t1, t2, t3;
    assign_components(__my_z_times_i, arg.imag_data(), arg.real_data());
@@ -645,17 +647,17 @@ inline void eval_atan(complex_adaptor<Backend>& result, const complex_adaptor<Ba
 
    eval_ldexp(result.real_data(), t1.imag_data(), -1);
    eval_ldexp(result.imag_data(), t1.real_data(), -1);
-   if(!eval_is_zero(result.real_data()))
+   if (!eval_is_zero(result.real_data()))
       result.real_data().negate();
 }
 
 template <class Backend>
 inline void eval_sinh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_sin;
    using default_ops::eval_cos;
-   using default_ops::eval_sinh;
    using default_ops::eval_cosh;
+   using default_ops::eval_sin;
+   using default_ops::eval_sinh;
 
    Backend t1, t2;
    eval_cos(t1, arg.imag_data());
@@ -670,10 +672,10 @@ inline void eval_sinh(complex_adaptor<Backend>& result, const complex_adaptor<Ba
 template <class Backend>
 inline void eval_cosh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
-   using default_ops::eval_sin;
    using default_ops::eval_cos;
-   using default_ops::eval_sinh;
    using default_ops::eval_cosh;
+   using default_ops::eval_sin;
+   using default_ops::eval_sinh;
 
    Backend t1, t2;
    eval_cos(t1, arg.imag_data());
@@ -699,7 +701,7 @@ template <class Backend>
 inline void eval_asinh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
-   ui_type one = (ui_type)1u;
+   ui_type                                                             one = (ui_type)1u;
 
    using default_ops::eval_add;
    using default_ops::eval_log;
@@ -717,13 +719,13 @@ template <class Backend>
 inline void eval_acosh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
-   ui_type one = (ui_type)1u;
+   ui_type                                                             one = (ui_type)1u;
 
    using default_ops::eval_add;
-   using default_ops::eval_log;
    using default_ops::eval_divide;
-   using default_ops::eval_subtract;
+   using default_ops::eval_log;
    using default_ops::eval_multiply;
+   using default_ops::eval_subtract;
 
    complex_adaptor<Backend> __my_zp(arg);
    eval_add(__my_zp.real_data(), one);
@@ -742,13 +744,13 @@ template <class Backend>
 inline void eval_atanh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
 {
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
-   ui_type one = (ui_type)1u;
+   ui_type                                                             one = (ui_type)1u;
 
    using default_ops::eval_add;
-   using default_ops::eval_log;
    using default_ops::eval_divide;
-   using default_ops::eval_subtract;
+   using default_ops::eval_log;
    using default_ops::eval_multiply;
+   using default_ops::eval_subtract;
 
    complex_adaptor<Backend> t1, t2, t3;
    eval_add(t1, arg, one);
@@ -774,7 +776,7 @@ inline void eval_proj(complex_adaptor<Backend>& result, const complex_adaptor<Ba
    using default_ops::eval_get_sign;
 
    typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
-   ui_type zero = (ui_type)0u;
+   ui_type                                                             zero = (ui_type)0u;
 
    int c1 = eval_fpclassify(arg.real_data());
    int c2 = eval_fpclassify(arg.imag_data());
@@ -826,7 +828,7 @@ inline void eval_set_real(complex_adaptor<Backend>& result, const T& arg)
 template <class Backend>
 inline std::size_t hash_value(const complex_adaptor<Backend>& val)
 {
-   std::size_t result = hash_value(val.real_data());
+   std::size_t result  = hash_value(val.real_data());
    std::size_t result2 = hash_value(val.imag_data());
    boost::hash_combine(result, result2);
    return result;
@@ -834,11 +836,11 @@ inline std::size_t hash_value(const complex_adaptor<Backend>& val)
 
 } // namespace backends
 
-
 using boost::multiprecision::backends::complex_adaptor;
 
 template <class Backend>
-struct number_category<complex_adaptor<Backend> > : public boost::mpl::int_<boost::multiprecision::number_kind_complex> {};
+struct number_category<complex_adaptor<Backend> > : public boost::mpl::int_<boost::multiprecision::number_kind_complex>
+{};
 
 template <class Backend, expression_template_option ExpressionTemplates>
 struct component_type<number<complex_adaptor<Backend>, ExpressionTemplates> >
@@ -852,9 +854,8 @@ struct complex_result_from_scalar<number<Backend, ExpressionTemplates> >
    typedef number<complex_adaptor<Backend>, ExpressionTemplates> type;
 };
 
+}
 
-} // namespace multiprecision
-
-}  // namespaces
+} // namespace boost::multiprecision
 
 #endif
Domain: System / Base;