1 //  (C) Copyright John Maddock 2005.

     2 //  Use, modification and distribution are subject to the

     3 //  Boost Software License, Version 1.0. (See accompanying file

     4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

     5 

     6 #ifndef BOOST_TR1_COMPLEX_HPP_INCLUDED

     7 #  define BOOST_TR1_COMPLEX_HPP_INCLUDED

     8 #  include <boost/tr1/detail/config.hpp>

     9 #  include <complex>

    10 

    11 #ifndef BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG

    12 

    13 #include <boost/math/complex.hpp>

    14 

    15 namespace std {

    16 namespace tr1 {

    17 

    18 using boost::math::acos;

    19 using boost::math::asin;

    20 using boost::math::atan;

    21 using boost::math::acosh;

    22 using boost::math::asinh;

    23 using boost::math::atanh;

    24 using boost::math::fabs;

    25 

    26 } }

    27 

    28 #else

    29 

    30 #  ifdef BOOST_HAS_INCLUDE_NEXT

    31 #     include_next BOOST_TR1_HEADER(complex)

    32 #  else

    33 #     include <boost/tr1/detail/config_all.hpp>

    34 #     include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(complex))

    35 #  endif

    36 

    37 #endif

    38 

    39 #ifndef BOOST_HAS_TR1_COMPLEX_OVERLOADS

    40 

    41 #include <boost/tr1/detail/math_overloads.hpp>

    42 #include <boost/assert.hpp>

    43 #include <boost/detail/workaround.hpp>

    44 #include <boost/config/no_tr1/cmath.hpp>

    45 

    46 namespace std{ 

    47 

    48 #ifdef BOOST_NO_STDC_NAMESPACE

    49    using :: atan2;

    50 #endif

    51 

    52 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

    53 template <class T>

    54 inline BOOST_TR1_MATH_RETURN(double) arg(const T& t)

    55 {

    56    return ::std::atan2(0.0, static_cast<double>(t));

    57 }

    58 #else

    59 inline double arg(const double& t)

    60 {

    61    return ::std::atan2(0.0, t);

    62 }

    63 #endif

    64 inline long double arg(const long double& t)

    65 {

    66    return ::std::atan2(0.0L, static_cast<long double>(t));

    67 }

    68 inline float arg(const float& t)

    69 {

    70    return ::std::atan2(0.0F, static_cast<float>(t));

    71 }

    72 

    73 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

    74 template <class T>

    75 inline BOOST_TR1_MATH_RETURN(double) norm(const T& t)

    76 {

    77    double r = static_cast<double>(t);

    78    return r*r;

    79 }

    80 #else

    81 inline double norm(const double& t)

    82 {

    83    return t*t;

    84 }

    85 #endif

    86 inline long double norm(const long double& t)

    87 {

    88    long double l = t;

    89    return l*l;

    90 }

    91 inline float norm(const float& t)

    92 {

    93    float f = t;

    94    return f*f;

    95 }

    96 

    97 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

    98 template <class T>

    99 inline BOOST_TR1_MATH_RETURN(std::complex<double>) conj(const T& t)

   100 {

   101    return ::std::conj(std::complex<double>(static_cast<double>(t)));

   102 }

   103 #else

   104 inline std::complex<double> conj(const double& t)

   105 {

   106    return ::std::conj(std::complex<double>(t));

   107 }

   108 #endif

   109 inline std::complex<long double> conj(const long double& t)

   110 {

   111    return ::std::conj(std::complex<long double>(t));

   112 }

   113 inline std::complex<float> conj(const float& t)

   114 {

   115    std::complex<float> ct(t);

   116    ct = ::std::conj(ct);

   117    return ct;

   118 }

   119 

   120 #if !BOOST_WORKAROUND(__BORLANDC__, <=0x570) && !BOOST_WORKAROUND(BOOST_MSVC, < 1310)

   121 inline complex<double> polar(const char& rho, const char& theta = 0)

   122 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   123 inline complex<double> polar(const unsigned char& rho, const unsigned char& theta = 0)

   124 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   125 inline complex<double> polar(const signed char& rho, const signed char& theta = 0)

   126 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   127 inline complex<double> polar(const short& rho, const short& theta = 0)

   128 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   129 inline complex<double> polar(const unsigned short& rho, const unsigned short& theta = 0)

   130 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   131 inline complex<double> polar(const int& rho, const int& theta = 0)

   132 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   133 inline complex<double> polar(const unsigned int& rho, const unsigned int& theta = 0)

   134 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   135 inline complex<double> polar(const long& rho, const long& theta = 0)

   136 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   137 inline complex<double> polar(const unsigned long& rho, const unsigned long& theta = 0)

   138 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   139 #ifdef BOOST_HAS_LONG_LONG

   140 inline complex<double> polar(const long long& rho, const long long& theta = 0)

   141 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   142 inline complex<double> polar(const unsigned long long& rho, const unsigned long long& theta = 0)

   143 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   144 #elif defined(BOOST_HAS_MS_INT64)

   145 inline complex<double> polar(const __int64& rho, const __int64& theta = 0)

   146 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   147 inline complex<double> polar(const unsigned __int64& rho, const unsigned __int64& theta = 0)

   148 { return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }

   149 #endif

   150 

   151 template<class T, class U> 

   152 inline complex<typename boost::tr1_detail::promote_to_real<T, U>::type> 

   153    polar(const T& rho, const U& theta)

   154 {

   155    typedef typename boost::tr1_detail::promote_to_real<T, U>::type real_type;

   156    return std::polar(static_cast<real_type>(rho), static_cast<real_type>(theta));

   157 }

   158 #endif

   159 

   160 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   161 template <class T>

   162 inline BOOST_TR1_MATH_RETURN(double) imag(const T& )

   163 {

   164    return 0;

   165 }

   166 #else

   167 inline double imag(const double& )

   168 {

   169    return 0;

   170 }

   171 #endif

   172 inline long double imag(const long double& )

   173 {

   174    return 0;

   175 }

   176 inline float imag(const float& )

   177 {

   178    return 0;

   179 }

   180 

   181 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   182 template <class T>

   183 inline BOOST_TR1_MATH_RETURN(double) real(const T& t)

   184 {

   185    return static_cast<double>(t);

   186 }

   187 #else

   188 inline double real(const double& t)

   189 {

   190    return t;

   191 }

   192 #endif

   193 inline long double real(const long double& t)

   194 {

   195    return t;

   196 }

   197 inline float real(const float& t)

   198 {

   199    return t;

   200 }

   201 

   202 template<class T, class U>

   203 inline complex<typename boost::tr1_detail::largest_real<T, U>::type>

   204    pow(const complex<T>& x, const complex<U>& y)

   205 {

   206    typedef complex<typename boost::tr1_detail::largest_real<T, U>::type> result_type;

   207    typedef typename boost::mpl::if_<boost::is_same<result_type, complex<T> >, result_type const&, result_type>::type cast1_type;

   208    typedef typename boost::mpl::if_<boost::is_same<result_type, complex<U> >, result_type const&, result_type>::type cast2_type;

   209    cast1_type x1(x);

   210    cast2_type y1(y);

   211    return std::pow(x1, y1);

   212 }

   213 template<class T, class U> 

   214 inline complex<typename boost::tr1_detail::promote_to_real<T, U>::type>

   215    pow (const complex<T>& x, const U& y)

   216 {

   217    typedef typename boost::tr1_detail::promote_to_real<T, U>::type real_type;

   218    typedef complex<typename boost::tr1_detail::promote_to_real<T, U>::type> result_type;

   219    typedef typename boost::mpl::if_<boost::is_same<result_type, complex<T> >, result_type const&, result_type>::type cast1_type;

   220    real_type r = y;

   221    cast1_type x1(x);

   222    std::complex<real_type> y1(r);

   223    return std::pow(x1, y1);

   224 }

   225 

   226 template<class T, class U> 

   227 inline complex<typename boost::tr1_detail::promote_to_real<T, U>::type>

   228    pow (const T& x, const complex<U>& y)

   229 {

   230    typedef typename boost::tr1_detail::promote_to_real<T, U>::type real_type;

   231    typedef complex<typename boost::tr1_detail::promote_to_real<T, U>::type> result_type;

   232    typedef typename boost::mpl::if_<boost::is_same<result_type, complex<U> >, result_type const&, result_type>::type cast_type;

   233    real_type r = x;

   234    std::complex<real_type> x1(r);

   235    cast_type y1(y);

   236    return std::pow(x1, y1);

   237 }

   238 

   239 }

   240 

   241 #endif

   242 

   243 #endif

   244