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