]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /////////////////////////////////////////////////////////////// |
2 | // Copyright 2012 John Maddock. Distributed under the Boost | |
3 | // Software License, Version 1.0. (See accompanying file | |
4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_ | |
5 | ||
6 | #ifndef BOOST_MATH_CONCEPTS_ER_HPP | |
7 | #define BOOST_MATH_CONCEPTS_ER_HPP | |
8 | ||
9 | #include <iostream> | |
10 | #include <sstream> | |
11 | #include <iomanip> | |
12 | #include <cmath> | |
13 | #include <boost/cstdint.hpp> | |
14 | #include <boost/multiprecision/number.hpp> | |
15 | #include <boost/math/special_functions/fpclassify.hpp> | |
16 | #include <boost/mpl/list.hpp> | |
17 | ||
18 | namespace boost{ | |
19 | namespace multiprecision{ | |
20 | namespace concepts{ | |
21 | ||
22 | #ifdef BOOST_MSVC | |
23 | #pragma warning(push) | |
24 | #pragma warning(disable:4244) | |
25 | #endif | |
26 | ||
27 | struct number_backend_float_architype | |
28 | { | |
29 | typedef mpl::list<boost::long_long_type> signed_types; | |
30 | typedef mpl::list<boost::ulong_long_type> unsigned_types; | |
31 | typedef mpl::list<long double> float_types; | |
32 | typedef int exponent_type; | |
33 | ||
34 | number_backend_float_architype() | |
35 | { | |
36 | m_value = 0; | |
37 | std::cout << "Default construct" << std::endl; | |
38 | } | |
39 | number_backend_float_architype(const number_backend_float_architype& o) | |
40 | { | |
41 | std::cout << "Copy construct" << std::endl; | |
42 | m_value = o.m_value; | |
43 | } | |
44 | number_backend_float_architype& operator = (const number_backend_float_architype& o) | |
45 | { | |
46 | m_value = o.m_value; | |
47 | std::cout << "Assignment (" << m_value << ")" << std::endl; | |
48 | return *this; | |
49 | } | |
50 | number_backend_float_architype& operator = (boost::ulong_long_type i) | |
51 | { | |
52 | m_value = i; | |
53 | std::cout << "UInt Assignment (" << i << ")" << std::endl; | |
54 | return *this; | |
55 | } | |
56 | number_backend_float_architype& operator = (boost::long_long_type i) | |
57 | { | |
58 | m_value = i; | |
59 | std::cout << "Int Assignment (" << i << ")" << std::endl; | |
60 | return *this; | |
61 | } | |
62 | number_backend_float_architype& operator = (long double d) | |
63 | { | |
64 | m_value = d; | |
65 | std::cout << "long double Assignment (" << d << ")" << std::endl; | |
66 | return *this; | |
67 | } | |
68 | number_backend_float_architype& operator = (const char* s) | |
69 | { | |
70 | #ifndef BOOST_NO_EXCEPTIONS | |
71 | try | |
72 | { | |
73 | #endif | |
74 | m_value = boost::lexical_cast<long double>(s); | |
75 | #ifndef BOOST_NO_EXCEPTIONS | |
76 | } | |
77 | catch(const std::exception&) | |
78 | { | |
79 | BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Unable to parse input string: \"") + s + std::string("\" as a valid floating point number."))); | |
80 | } | |
81 | #endif | |
82 | std::cout << "const char* Assignment (" << s << ")" << std::endl; | |
83 | return *this; | |
84 | } | |
85 | void swap(number_backend_float_architype& o) | |
86 | { | |
87 | std::cout << "Swapping (" << m_value << " with " << o.m_value << ")" << std::endl; | |
88 | std::swap(m_value, o.m_value); | |
89 | } | |
90 | std::string str(std::streamsize digits, std::ios_base::fmtflags f)const | |
91 | { | |
92 | std::stringstream ss; | |
93 | ss.flags(f); | |
94 | if(digits) | |
95 | ss.precision(digits); | |
96 | else | |
97 | ss.precision(std::numeric_limits<long double>::digits10 + 3); | |
98 | boost::intmax_t i = m_value; | |
99 | boost::uintmax_t u = m_value; | |
100 | if(!(f & std::ios_base::scientific) && m_value == i) | |
101 | ss << i; | |
102 | else if(!(f & std::ios_base::scientific) && m_value == u) | |
103 | ss << u; | |
104 | else | |
105 | ss << m_value; | |
106 | std::string s = ss.str(); | |
107 | std::cout << "Converting to string (" << s << ")" << std::endl; | |
108 | return s; | |
109 | } | |
110 | void negate() | |
111 | { | |
112 | std::cout << "Negating (" << m_value << ")" << std::endl; | |
113 | m_value = -m_value; | |
114 | } | |
115 | int compare(const number_backend_float_architype& o)const | |
116 | { | |
117 | std::cout << "Comparison" << std::endl; | |
118 | return m_value > o.m_value ? 1 : (m_value < o.m_value ? -1 : 0); | |
119 | } | |
120 | int compare(boost::long_long_type i)const | |
121 | { | |
122 | std::cout << "Comparison with int" << std::endl; | |
123 | return m_value > i ? 1 : (m_value < i ? -1 : 0); | |
124 | } | |
125 | int compare(boost::ulong_long_type i)const | |
126 | { | |
127 | std::cout << "Comparison with unsigned" << std::endl; | |
128 | return m_value > i ? 1 : (m_value < i ? -1 : 0); | |
129 | } | |
130 | int compare(long double d)const | |
131 | { | |
132 | std::cout << "Comparison with long double" << std::endl; | |
133 | return m_value > d ? 1 : (m_value < d ? -1 : 0); | |
134 | } | |
135 | long double m_value; | |
136 | }; | |
137 | ||
138 | inline void eval_add(number_backend_float_architype& result, const number_backend_float_architype& o) | |
139 | { | |
140 | std::cout << "Addition (" << result.m_value << " += " << o.m_value << ")" << std::endl; | |
141 | result.m_value += o.m_value; | |
142 | } | |
143 | inline void eval_subtract(number_backend_float_architype& result, const number_backend_float_architype& o) | |
144 | { | |
145 | std::cout << "Subtraction (" << result.m_value << " -= " << o.m_value << ")" << std::endl; | |
146 | result.m_value -= o.m_value; | |
147 | } | |
148 | inline void eval_multiply(number_backend_float_architype& result, const number_backend_float_architype& o) | |
149 | { | |
150 | std::cout << "Multiplication (" << result.m_value << " *= " << o.m_value << ")" << std::endl; | |
151 | result.m_value *= o.m_value; | |
152 | } | |
153 | inline void eval_divide(number_backend_float_architype& result, const number_backend_float_architype& o) | |
154 | { | |
155 | std::cout << "Division (" << result.m_value << " /= " << o.m_value << ")" << std::endl; | |
156 | result.m_value /= o.m_value; | |
157 | } | |
158 | ||
159 | inline void eval_convert_to(boost::ulong_long_type* result, const number_backend_float_architype& val) | |
160 | { | |
161 | *result = static_cast<boost::ulong_long_type>(val.m_value); | |
162 | } | |
163 | inline void eval_convert_to(boost::long_long_type* result, const number_backend_float_architype& val) | |
164 | { | |
165 | *result = static_cast<boost::long_long_type>(val.m_value); | |
166 | } | |
167 | inline void eval_convert_to(long double* result, number_backend_float_architype& val) | |
168 | { | |
169 | *result = val.m_value; | |
170 | } | |
171 | ||
172 | inline void eval_frexp(number_backend_float_architype& result, const number_backend_float_architype& arg, int* exp) | |
173 | { | |
174 | result = std::frexp(arg.m_value, exp); | |
175 | } | |
176 | ||
177 | inline void eval_ldexp(number_backend_float_architype& result, const number_backend_float_architype& arg, int exp) | |
178 | { | |
179 | result = std::ldexp(arg.m_value, exp); | |
180 | } | |
181 | ||
182 | inline void eval_floor(number_backend_float_architype& result, const number_backend_float_architype& arg) | |
183 | { | |
184 | result = std::floor(arg.m_value); | |
185 | } | |
186 | ||
187 | inline void eval_ceil(number_backend_float_architype& result, const number_backend_float_architype& arg) | |
188 | { | |
189 | result = std::ceil(arg.m_value); | |
190 | } | |
191 | ||
192 | inline void eval_sqrt(number_backend_float_architype& result, const number_backend_float_architype& arg) | |
193 | { | |
194 | result = std::sqrt(arg.m_value); | |
195 | } | |
196 | ||
197 | inline int eval_fpclassify(const number_backend_float_architype& arg) | |
198 | { | |
199 | return (boost::math::fpclassify)(arg.m_value); | |
200 | } | |
201 | ||
202 | typedef boost::multiprecision::number<number_backend_float_architype> mp_number_float_architype; | |
203 | ||
204 | } // namespace | |
205 | ||
206 | template<> | |
207 | struct number_category<concepts::number_backend_float_architype> : public mpl::int_<number_kind_floating_point>{}; | |
208 | ||
209 | }} // namespaces | |
210 | ||
211 | namespace std{ | |
212 | ||
213 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
214 | class numeric_limits<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype, ExpressionTemplates> > : public std::numeric_limits<long double> | |
215 | { | |
216 | typedef std::numeric_limits<long double> base_type; | |
217 | typedef boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype, ExpressionTemplates> number_type; | |
218 | public: | |
219 | static number_type (min)() BOOST_NOEXCEPT { return (base_type::min)(); } | |
220 | static number_type (max)() BOOST_NOEXCEPT { return (base_type::max)(); } | |
221 | static number_type lowest() BOOST_NOEXCEPT { return -(max)(); } | |
222 | static number_type epsilon() BOOST_NOEXCEPT { return base_type::epsilon(); } | |
223 | static number_type round_error() BOOST_NOEXCEPT { return base_type::round_error(); } | |
224 | static number_type infinity() BOOST_NOEXCEPT { return base_type::infinity(); } | |
225 | static number_type quiet_NaN() BOOST_NOEXCEPT { return base_type::quiet_NaN(); } | |
226 | static number_type signaling_NaN() BOOST_NOEXCEPT { return base_type::signaling_NaN(); } | |
227 | static number_type denorm_min() BOOST_NOEXCEPT { return base_type::denorm_min(); } | |
228 | }; | |
229 | ||
230 | } | |
231 | ||
232 | #ifdef BOOST_MSVC | |
233 | #pragma warning(pop) | |
234 | #endif | |
235 | ||
236 | #endif |