]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 |