]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright John Maddock 2006. |
2 | // (C) Copyright Johan Rade 2006. | |
3 | // (C) Copyright Paul A. Bristow 2011 (added changesign). | |
4 | ||
5 | // Use, modification and distribution are subject to the | |
6 | // Boost Software License, Version 1.0. (See accompanying file | |
7 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
8 | ||
9 | #ifndef BOOST_MATH_TOOLS_SIGN_HPP | |
10 | #define BOOST_MATH_TOOLS_SIGN_HPP | |
11 | ||
12 | #ifdef _MSC_VER | |
13 | #pragma once | |
14 | #endif | |
15 | ||
16 | #include <boost/math/tools/config.hpp> | |
17 | #include <boost/math/special_functions/math_fwd.hpp> | |
18 | #include <boost/math/special_functions/detail/fp_traits.hpp> | |
19 | ||
20 | namespace boost{ namespace math{ | |
21 | ||
22 | namespace detail { | |
23 | ||
24 | // signbit | |
25 | ||
26 | #ifdef BOOST_MATH_USE_STD_FPCLASSIFY | |
27 | template<class T> | |
28 | inline int signbit_impl(T x, native_tag const&) | |
29 | { | |
30 | return (std::signbit)(x); | |
31 | } | |
32 | #endif | |
33 | ||
34 | // Generic versions first, note that these do not handle | |
35 | // signed zero or NaN. | |
36 | ||
37 | template<class T> | |
38 | inline int signbit_impl(T x, generic_tag<true> const&) | |
39 | { | |
40 | return x < 0; | |
41 | } | |
42 | ||
43 | template<class T> | |
44 | inline int signbit_impl(T x, generic_tag<false> const&) | |
45 | { | |
46 | return x < 0; | |
47 | } | |
48 | ||
49 | #if defined(__GNUC__) && (LDBL_MANT_DIG == 106) | |
50 | // | |
51 | // Special handling for GCC's "double double" type, | |
52 | // in this case the sign is the same as the sign we | |
53 | // get by casting to double, no overflow/underflow | |
54 | // can occur since the exponents are the same magnitude | |
55 | // for the two types: | |
56 | // | |
57 | inline int signbit_impl(long double x, generic_tag<true> const&) | |
58 | { | |
59 | return (boost::math::signbit)(static_cast<double>(x)); | |
60 | } | |
61 | inline int signbit_impl(long double x, generic_tag<false> const&) | |
62 | { | |
63 | return (boost::math::signbit)(static_cast<double>(x)); | |
64 | } | |
65 | #endif | |
66 | ||
67 | template<class T> | |
68 | inline int signbit_impl(T x, ieee_copy_all_bits_tag const&) | |
69 | { | |
70 | typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; | |
71 | ||
72 | BOOST_DEDUCED_TYPENAME traits::bits a; | |
73 | traits::get_bits(x,a); | |
74 | return a & traits::sign ? 1 : 0; | |
75 | } | |
76 | ||
77 | template<class T> | |
78 | inline int signbit_impl(T x, ieee_copy_leading_bits_tag const&) | |
79 | { | |
80 | typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits; | |
81 | ||
82 | BOOST_DEDUCED_TYPENAME traits::bits a; | |
83 | traits::get_bits(x,a); | |
84 | ||
85 | return a & traits::sign ? 1 : 0; | |
86 | } | |
87 | ||
88 | // Changesign | |
89 | ||
90 | // Generic versions first, note that these do not handle | |
91 | // signed zero or NaN. | |
92 | ||
93 | template<class T> | |
94 | inline T (changesign_impl)(T x, generic_tag<true> const&) | |
95 | { | |
96 | return -x; | |
97 | } | |
98 | ||
99 | template<class T> | |
100 | inline T (changesign_impl)(T x, generic_tag<false> const&) | |
101 | { | |
102 | return -x; | |
103 | } | |
104 | #if defined(__GNUC__) && (LDBL_MANT_DIG == 106) | |
105 | // | |
106 | // Special handling for GCC's "double double" type, | |
107 | // in this case we need to change the sign of both | |
108 | // components of the "double double": | |
109 | // | |
110 | inline long double (changesign_impl)(long double x, generic_tag<true> const&) | |
111 | { | |
112 | double* pd = reinterpret_cast<double*>(&x); | |
113 | pd[0] = boost::math::changesign(pd[0]); | |
114 | pd[1] = boost::math::changesign(pd[1]); | |
115 | return x; | |
116 | } | |
117 | inline long double (changesign_impl)(long double x, generic_tag<false> const&) | |
118 | { | |
119 | double* pd = reinterpret_cast<double*>(&x); | |
120 | pd[0] = boost::math::changesign(pd[0]); | |
121 | pd[1] = boost::math::changesign(pd[1]); | |
122 | return x; | |
123 | } | |
124 | #endif | |
125 | ||
126 | template<class T> | |
127 | inline T changesign_impl(T x, ieee_copy_all_bits_tag const&) | |
128 | { | |
129 | typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::sign_change_type traits; | |
130 | ||
131 | BOOST_DEDUCED_TYPENAME traits::bits a; | |
132 | traits::get_bits(x,a); | |
133 | a ^= traits::sign; | |
134 | traits::set_bits(x,a); | |
135 | return x; | |
136 | } | |
137 | ||
138 | template<class T> | |
139 | inline T (changesign_impl)(T x, ieee_copy_leading_bits_tag const&) | |
140 | { | |
141 | typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::sign_change_type traits; | |
142 | ||
143 | BOOST_DEDUCED_TYPENAME traits::bits a; | |
144 | traits::get_bits(x,a); | |
145 | a ^= traits::sign; | |
146 | traits::set_bits(x,a); | |
147 | return x; | |
148 | } | |
149 | ||
150 | ||
151 | } // namespace detail | |
152 | ||
153 | template<class T> int (signbit)(T x) | |
154 | { | |
155 | typedef typename detail::fp_traits<T>::type traits; | |
156 | typedef typename traits::method method; | |
157 | // typedef typename boost::is_floating_point<T>::type fp_tag; | |
158 | typedef typename tools::promote_args_permissive<T>::type result_type; | |
159 | return detail::signbit_impl(static_cast<result_type>(x), method()); | |
160 | } | |
161 | ||
162 | template <class T> | |
163 | inline int sign BOOST_NO_MACRO_EXPAND(const T& z) | |
164 | { | |
165 | return (z == 0) ? 0 : (boost::math::signbit)(z) ? -1 : 1; | |
166 | } | |
167 | ||
168 | template <class T> typename tools::promote_args_permissive<T>::type (changesign)(const T& x) | |
169 | { //!< \brief return unchanged binary pattern of x, except for change of sign bit. | |
170 | typedef typename detail::fp_traits<T>::sign_change_type traits; | |
171 | typedef typename traits::method method; | |
172 | // typedef typename boost::is_floating_point<T>::type fp_tag; | |
173 | typedef typename tools::promote_args_permissive<T>::type result_type; | |
174 | ||
175 | return detail::changesign_impl(static_cast<result_type>(x), method()); | |
176 | } | |
177 | ||
178 | template <class T, class U> | |
179 | inline typename tools::promote_args_permissive<T, U>::type | |
180 | copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y) | |
181 | { | |
182 | BOOST_MATH_STD_USING | |
183 | typedef typename tools::promote_args_permissive<T, U>::type result_type; | |
184 | return (boost::math::signbit)(static_cast<result_type>(x)) != (boost::math::signbit)(static_cast<result_type>(y)) | |
185 | ? (boost::math::changesign)(static_cast<result_type>(x)) : static_cast<result_type>(x); | |
186 | } | |
187 | ||
188 | } // namespace math | |
189 | } // namespace boost | |
190 | ||
191 | ||
192 | #endif // BOOST_MATH_TOOLS_SIGN_HPP | |
193 | ||
194 |