ceph/src/boost/libs/math/include/boost/math/tools/promotion.hpp

   1 // boost\math\tools\promotion.hpp
   2
   3 // Copyright John Maddock 2006.
   4 // Copyright Paul A. Bristow 2006.
   5
   6 // Use, modification and distribution are subject to the
   7 // Boost Software License, Version 1.0.
   8 // (See accompanying file LICENSE_1_0.txt
   9 // or copy at http://www.boost.org/LICENSE_1_0.txt)
  10
  11 // Promote arguments functions to allow math functions to have arguments
  12 // provided as integer OR real (floating-point, built-in or UDT)
  13 // (called ArithmeticType in functions that use promotion)
  14 // that help to reduce the risk of creating multiple instantiations.
  15 // Allows creation of an inline wrapper that forwards to a foo(RT, RT) function,
  16 // so you never get to instantiate any mixed foo(RT, IT) functions.
  17
  18 #ifndef BOOST_MATH_PROMOTION_HPP
  19 #define BOOST_MATH_PROMOTION_HPP
  20
  21 #ifdef _MSC_VER
  22 #pragma once
  23 #endif
  24
  25 // Boost type traits:
  26 #include <boost/math/tools/config.hpp>
  27 #include <boost/type_traits/is_floating_point.hpp> // for boost::is_floating_point;
  28 #include <boost/type_traits/is_integral.hpp> // for boost::is_integral
  29 #include <boost/type_traits/is_convertible.hpp> // for boost::is_convertible
  30 #include <boost/type_traits/is_same.hpp>// for boost::is_same
  31 #include <boost/type_traits/remove_cv.hpp>// for boost::remove_cv
  32 // Boost Template meta programming:
  33 #include <boost/mpl/if.hpp> // for boost::mpl::if_c.
  34 #include <boost/mpl/and.hpp> // for boost::mpl::if_c.
  35 #include <boost/mpl/or.hpp> // for boost::mpl::if_c.
  36 #include <boost/mpl/not.hpp> // for boost::mpl::if_c.
  37
  38 #ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
  39 #include <boost/static_assert.hpp>
  40 #endif
  41
  42 namespace boost
  43 {
  44   namespace math
  45   {
  46     namespace tools
  47     {
  48       // If either T1 or T2 is an integer type,
  49       // pretend it was a double (for the purposes of further analysis).
  50       // Then pick the wider of the two floating-point types
  51       // as the actual signature to forward to.
  52       // For example:
  53       // foo(int, short) -> double foo(double, double);
  54       // foo(int, float) -> double foo(double, double);
  55       // Note: NOT float foo(float, float)
  56       // foo(int, double) -> foo(double, double);
  57       // foo(double, float) -> double foo(double, double);
  58       // foo(double, float) -> double foo(double, double);
  59       // foo(any-int-or-float-type, long double) -> foo(long double, long double);
  60       // but ONLY float foo(float, float) is unchanged.
  61       // So the only way to get an entirely float version is to call foo(1.F, 2.F),
  62       // But since most (all?) the math functions convert to double internally,
  63       // probably there would not be the hoped-for gain by using float here.
  64
  65       // This follows the C-compatible conversion rules of pow, etc
  66       // where pow(int, float) is converted to pow(double, double).
  67
  68       template <class T>
  69       struct promote_arg
  70       { // If T is integral type, then promote to double.
  71         typedef typename mpl::if_<is_integral<T>, double, T>::type type;
  72       };
  73       // These full specialisations reduce mpl::if_ usage and speed up
  74       // compilation:
  75       template <> struct promote_arg<float> { typedef float type; };
  76       template <> struct promote_arg<double>{ typedef double type; };
  77       template <> struct promote_arg<long double> { typedef long double type; };
  78       template <> struct promote_arg<int> {  typedef double type; };
  79
  80       template <class T1, class T2>
  81       struct promote_args_2
  82       { // Promote, if necessary, & pick the wider of the two floating-point types.
  83         // for both parameter types, if integral promote to double.
  84         typedef typename promote_arg<T1>::type T1P; // T1 perhaps promoted.
  85         typedef typename promote_arg<T2>::type T2P; // T2 perhaps promoted.
  86
  87         typedef typename mpl::if_<
  88           typename mpl::and_<is_floating_point<T1P>, is_floating_point<T2P> >::type, // both T1P and T2P are floating-point?
  89 #ifdef BOOST_MATH_USE_FLOAT128
  90            typename mpl::if_< typename mpl::or_<is_same<__float128, T1P>, is_same<__float128, T2P> >::type, // either long double?
  91             __float128,
  92 #endif
  93              typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type, // either long double?
  94                long double, // then result type is long double.
  95                typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type, // either double?
  96                   double, // result type is double.
  97                   float // else result type is float.
  98              >::type
  99 #ifdef BOOST_MATH_USE_FLOAT128
 100              >::type
 101 #endif
 102              >::type,
 103           // else one or the other is a user-defined type:
 104           typename mpl::if_< typename mpl::and_<mpl::not_<is_floating_point<T2P> >, ::boost::is_convertible<T1P, T2P> >, T2P, T1P>::type>::type type;
 105       }; // promote_arg2
 106       // These full specialisations reduce mpl::if_ usage and speed up
 107       // compilation:
 108       template <> struct promote_args_2<float, float> { typedef float type; };
 109       template <> struct promote_args_2<double, double>{ typedef double type; };
 110       template <> struct promote_args_2<long double, long double> { typedef long double type; };
 111       template <> struct promote_args_2<int, int> {  typedef double type; };
 112       template <> struct promote_args_2<int, float> {  typedef double type; };
 113       template <> struct promote_args_2<float, int> {  typedef double type; };
 114       template <> struct promote_args_2<int, double> {  typedef double type; };
 115       template <> struct promote_args_2<double, int> {  typedef double type; };
 116       template <> struct promote_args_2<int, long double> {  typedef long double type; };
 117       template <> struct promote_args_2<long double, int> {  typedef long double type; };
 118       template <> struct promote_args_2<float, double> {  typedef double type; };
 119       template <> struct promote_args_2<double, float> {  typedef double type; };
 120       template <> struct promote_args_2<float, long double> {  typedef long double type; };
 121       template <> struct promote_args_2<long double, float> {  typedef long double type; };
 122       template <> struct promote_args_2<double, long double> {  typedef long double type; };
 123       template <> struct promote_args_2<long double, double> {  typedef long double type; };
 124
 125       template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
 126       struct promote_args
 127       {
 128          typedef typename promote_args_2<
 129             typename remove_cv<T1>::type,
 130             typename promote_args_2<
 131                typename remove_cv<T2>::type,
 132                typename promote_args_2<
 133                   typename remove_cv<T3>::type,
 134                   typename promote_args_2<
 135                      typename remove_cv<T4>::type,
 136                      typename promote_args_2<
 137                         typename remove_cv<T5>::type, typename remove_cv<T6>::type
 138                      >::type
 139                   >::type
 140                >::type
 141             >::type
 142          >::type type;
 143
 144 #ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
 145          //
 146          // Guard against use of long double if it's not supported:
 147          //
 148          BOOST_STATIC_ASSERT_MSG((0 == ::boost::is_same<type, long double>::value), "Sorry, but this platform does not have sufficient long double support for the special functions to be reliably implemented.");
 149 #endif
 150       };
 151
 152       //
 153       // This struct is the same as above, but has no static assert on long double usage,
 154       // it should be used only on functions that can be implemented for long double
 155       // even when std lib support is missing or broken for that type.
 156       //
 157       template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
 158       struct promote_args_permissive
 159       {
 160          typedef typename promote_args_2<
 161             typename remove_cv<T1>::type,
 162             typename promote_args_2<
 163                typename remove_cv<T2>::type,
 164                typename promote_args_2<
 165                   typename remove_cv<T3>::type,
 166                   typename promote_args_2<
 167                      typename remove_cv<T4>::type,
 168                      typename promote_args_2<
 169                         typename remove_cv<T5>::type, typename remove_cv<T6>::type
 170                      >::type
 171                   >::type
 172                >::type
 173             >::type
 174          >::type type;
 175       };
 176
 177     } // namespace tools
 178   } // namespace math
 179 } // namespace boost
 180
 181 #endif // BOOST_MATH_PROMOTION_HPP
 182