BVB Source Codes

mars Show promotion.hpp Source code

Return Download mars: download promotion.hpp Source code - Download mars Source code - Type:.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 mars_boost::is_floating_point;
  28. #include <boost/type_traits/is_integral.hpp> // for mars_boost::is_integral
  29. #include <boost/type_traits/is_convertible.hpp> // for mars_boost::is_convertible
  30. #include <boost/type_traits/is_same.hpp>// for mars_boost::is_same
  31. #include <boost/type_traits/remove_cv.hpp>// for mars_boost::remove_cv
  32. // Boost Template meta programming:
  33. #include <boost/mpl/if.hpp> // for mars_boost::mpl::if_c.
  34. #include <boost/mpl/and.hpp> // for mars_boost::mpl::if_c.
  35. #include <boost/mpl/or.hpp> // for mars_boost::mpl::if_c.
  36. #include <boost/mpl/not.hpp> // for mars_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 mars_boost {} namespace boost = mars_boost; namespace mars_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> >, ::mars_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 == ::mars_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 mars_boost
  180.  
  181. #endif // BOOST_MATH_PROMOTION_HPP
  182.  
  183.  
downloadpromotion.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top