1 // Copyright John Maddock 2011.
2
3 // Use, modification and distribution are subject to the
4 // Boost Software License, Version 1.0.
5 // (See accompanying file LICENSE_1_0.txt
6 // or copy at http://www.boost.org/LICENSE_1_0.txt)
7
8 #ifdef _MSC_VER
9 #define _SCL_SECURE_NO_WARNINGS
10 #endif
11
12 #if !defined(TEST_MPF_50) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128)
13 #define TEST_MPF_50
14 #define TEST_CPP_DEC_FLOAT
15 #define TEST_MPFR_50
16 #define TEST_MPFI_50
17 #define TEST_FLOAT128
18
19 #ifdef _MSC_VER
20 #pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
21 #endif
22 #ifdef __GNUC__
23 #pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
24 #endif
25
26 #endif
27
28 #if defined(TEST_MPF_50)
29 #include <boost/multiprecision/gmp.hpp>
30 #endif
31 #if defined(TEST_MPFR_50)
32 #include <boost/multiprecision/mpfr.hpp>
33 #endif
34 #if defined(TEST_MPFI_50)
35 #include <boost/multiprecision/mpfi.hpp>
36 #endif
37 #ifdef TEST_CPP_DEC_FLOAT
38 #include <boost/multiprecision/cpp_dec_float.hpp>
39 #endif
40 #ifdef TEST_FLOAT128
41 #include <boost/multiprecision/float128.hpp>
42 #endif
43
44 #include <boost/random/mersenne_twister.hpp>
45 #include <boost/random/uniform_int.hpp>
46 #include "test.hpp"
47 #include <boost/array.hpp>
48 #include <iostream>
49 #include <iomanip>
50
51 #ifdef BOOST_MSVC
52 #pragma warning(disable : 4127)
53 #endif
54
55 #if defined(TEST_MPF_50)
56 template <unsigned N, boost::multiprecision::expression_template_option ET>
has_bad_bankers_rounding(const boost::multiprecision::number<boost::multiprecision::gmp_float<N>,ET> &)57 bool has_bad_bankers_rounding(const boost::multiprecision::number<boost::multiprecision::gmp_float<N>, ET>&)
58 {
59 return true;
60 }
61 #endif
62 #if defined(TEST_FLOAT128) && defined(BOOST_INTEL)
has_bad_bankers_rounding(const boost::multiprecision::float128 &)63 bool has_bad_bankers_rounding(const boost::multiprecision::float128&)
64 {
65 return true;
66 }
67 #endif
68 template <class T>
has_bad_bankers_rounding(const T &)69 bool has_bad_bankers_rounding(const T&)
70 {
71 return false;
72 }
73
is_bankers_rounding_error(const std::string & s,const char * expect)74 bool is_bankers_rounding_error(const std::string& s, const char* expect)
75 {
76 // This check isn't foolproof: that would require *much* more sophisticated code!!!
77 std::string::size_type l = std::strlen(expect);
78 if (l != s.size())
79 return false;
80 std::string::size_type len = s.find('e');
81 if (len == std::string::npos)
82 len = l - 1;
83 else
84 --len;
85 if (s.compare(0, len, expect, len))
86 return false;
87 if (s[len] != expect[len] + 1)
88 return false;
89 return true;
90 }
91
print_flags(std::ios_base::fmtflags f)92 void print_flags(std::ios_base::fmtflags f)
93 {
94 std::cout << "Formatting flags were: ";
95 if (f & std::ios_base::scientific)
96 std::cout << "scientific ";
97 if (f & std::ios_base::fixed)
98 std::cout << "fixed ";
99 if (f & std::ios_base::showpoint)
100 std::cout << "showpoint ";
101 if (f & std::ios_base::showpos)
102 std::cout << "showpos ";
103 std::cout << std::endl;
104 }
105
106 template <class T>
test()107 void test()
108 {
109 typedef T mp_t;
110 boost::array<std::ios_base::fmtflags, 9> f =
111 {{std::ios_base::fmtflags(0), std::ios_base::showpoint, std::ios_base::showpos, std::ios_base::scientific, std::ios_base::scientific | std::ios_base::showpos,
112 std::ios_base::scientific | std::ios_base::showpoint, std::ios_base::fixed, std::ios_base::fixed | std::ios_base::showpoint,
113 std::ios_base::fixed | std::ios_base::showpos}};
114
115 boost::array<boost::array<const char*, 13 * 9>, 40> string_data = {{
116 #include "libs/multiprecision/test/string_data.ipp"
117 }};
118
119 double num = 123456789.0;
120 double denom = 1;
121 double val = num;
122 for (unsigned j = 0; j < 40; ++j)
123 {
124 unsigned col = 0;
125 for (unsigned prec = 1; prec < 14; ++prec)
126 {
127 for (unsigned i = 0; i < f.size(); ++i, ++col)
128 {
129 std::stringstream ss;
130 ss.precision(prec);
131 ss.flags(f[i]);
132 ss << mp_t(val);
133 const char* expect = string_data[j][col];
134 if (ss.str() != expect)
135 {
136 if (has_bad_bankers_rounding(mp_t()) && is_bankers_rounding_error(ss.str(), expect))
137 {
138 std::cout << "Ignoring bankers-rounding error with GMP mp_f.\n";
139 }
140 else
141 {
142 std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
143 print_flags(f[i]);
144 std::cout << "Precision is: " << prec << std::endl;
145 std::cout << "Got: " << ss.str() << std::endl;
146 std::cout << "Expected: " << expect << std::endl;
147 ++boost::detail::test_errors();
148 mp_t(val).str(prec, f[i]); // for debugging
149 }
150 }
151 }
152 }
153 num = -num;
154 if (j & 1)
155 denom *= 8;
156 val = num / denom;
157 }
158
159 boost::array<const char*, 13 * 9> zeros =
160 {{"0", "0.", "+0", "0.0e+00", "+0.0e+00", "0.0e+00", "0.0", "0.0", "+0.0", "0", "0.0", "+0", "0.00e+00", "+0.00e+00", "0.00e+00", "0.00", "0.00", "+0.00", "0", "0.00", "+0", "0.000e+00", "+0.000e+00", "0.000e+00", "0.000", "0.000", "+0.000", "0", "0.000", "+0", "0.0000e+00", "+0.0000e+00", "0.0000e+00", "0.0000", "0.0000", "+0.0000", "0", "0.0000", "+0", "0.00000e+00", "+0.00000e+00", "0.00000e+00", "0.00000", "0.00000", "+0.00000", "0", "0.00000", "+0", "0.000000e+00", "+0.000000e+00", "0.000000e+00", "0.000000", "0.000000", "+0.000000", "0", "0.000000", "+0", "0.0000000e+00", "+0.0000000e+00", "0.0000000e+00", "0.0000000", "0.0000000", "+0.0000000", "0", "0.0000000", "+0", "0.00000000e+00", "+0.00000000e+00", "0.00000000e+00", "0.00000000", "0.00000000", "+0.00000000", "0", "0.00000000", "+0", "0.000000000e+00", "+0.000000000e+00", "0.000000000e+00", "0.000000000", "0.000000000", "+0.000000000", "0", "0.000000000", "+0", "0.0000000000e+00", "+0.0000000000e+00", "0.0000000000e+00", "0.0000000000", "0.0000000000", "+0.0000000000", "0", "0.0000000000", "+0", "0.00000000000e+00", "+0.00000000000e+00", "0.00000000000e+00", "0.00000000000", "0.00000000000", "+0.00000000000", "0", "0.00000000000", "+0", "0.000000000000e+00", "+0.000000000000e+00", "0.000000000000e+00", "0.000000000000", "0.000000000000", "+0.000000000000", "0", "0.000000000000", "+0", "0.0000000000000e+00", "+0.0000000000000e+00", "0.0000000000000e+00", "0.0000000000000", "0.0000000000000", "+0.0000000000000"}};
161
162 unsigned col = 0;
163 val = 0;
164 for (unsigned prec = 1; prec < 14; ++prec)
165 {
166 for (unsigned i = 0; i < f.size(); ++i, ++col)
167 {
168 std::stringstream ss;
169 ss.precision(prec);
170 ss.flags(f[i]);
171 ss << mp_t(val);
172 const char* expect = zeros[col];
173 if (ss.str() != expect)
174 {
175 std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
176 print_flags(f[i]);
177 std::cout << "Precision is: " << prec << std::endl;
178 std::cout << "Got: " << ss.str() << std::endl;
179 std::cout << "Expected: " << expect << std::endl;
180 ++boost::detail::test_errors();
181 mp_t(val).str(prec, f[i]); // for debugging
182 }
183 }
184 }
185
186 if (std::numeric_limits<mp_t>::has_infinity)
187 {
188 T val = std::numeric_limits<T>::infinity();
189 BOOST_CHECK_EQUAL(val.str(), "inf");
190 BOOST_CHECK_EQUAL(val.str(0, std::ios_base::showpos), "+inf");
191 val = -val;
192 BOOST_CHECK_EQUAL(val.str(), "-inf");
193 BOOST_CHECK_EQUAL(val.str(0, std::ios_base::showpos), "-inf");
194
195 val = static_cast<T>("inf");
196 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
197 val = static_cast<T>("+inf");
198 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
199 val = static_cast<T>("-inf");
200 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
201 }
202 if (std::numeric_limits<mp_t>::has_quiet_NaN)
203 {
204 T val = std::numeric_limits<T>::quiet_NaN();
205 BOOST_CHECK_EQUAL(val.str(), "nan");
206 val = static_cast<T>("nan");
207 BOOST_CHECK((boost::math::isnan)(val));
208 }
209 //
210 // Bug cases:
211 //
212 // https://github.com/boostorg/multiprecision/issues/113
213 //
214 {
215 T val("99.9809");
216 BOOST_CHECK_EQUAL(val.str(3, std::ios_base::fixed), "99.981");
217 }
218 }
219
220 template <class T>
generate_random()221 T generate_random()
222 {
223 typedef typename T::backend_type::exponent_type e_type;
224 static boost::random::mt19937 gen;
225 T val = gen();
226 T prev_val = -1;
227 while (val != prev_val)
228 {
229 val *= (gen.max)();
230 prev_val = val;
231 val += gen();
232 }
233 e_type e;
234 val = frexp(val, &e);
235
236 static boost::random::uniform_int_distribution<e_type> ui(0, std::numeric_limits<T>::max_exponent - 10);
237 return ldexp(val, ui(gen));
238 }
239
240 template <class T>
241 struct max_digits10_proxy
242 {
243 static const unsigned value = std::numeric_limits<T>::digits10 + 5;
244 };
245 #ifdef TEST_CPP_DEC_FLOAT
246 template <unsigned D, boost::multiprecision::expression_template_option ET>
247 struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >
248 {
249 static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >::max_digits10;
250 };
251 #endif
252 #ifdef TEST_MPF_50
253 template <unsigned D, boost::multiprecision::expression_template_option ET>
254 struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >
255 {
256 static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >::max_digits10;
257 };
258 #endif
259 #ifdef TEST_MPFR_50
260 template <unsigned D, boost::multiprecision::expression_template_option ET>
261 struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >
262 {
263 static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >::max_digits10;
264 };
265 #endif
266
267 template <class T>
do_round_trip(const T & val,std::ios_base::fmtflags f)268 void do_round_trip(const T& val, std::ios_base::fmtflags f)
269 {
270 std::stringstream ss;
271 #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
272 ss << std::setprecision(std::numeric_limits<T>::max_digits10);
273 #else
274 ss << std::setprecision(max_digits10_proxy<T>::value);
275 #endif
276 ss.flags(f);
277 ss << val;
278 T new_val = static_cast<T>(ss.str());
279 BOOST_CHECK_EQUAL(new_val, val);
280 new_val = static_cast<T>(val.str(0, f));
281 BOOST_CHECK_EQUAL(new_val, val);
282 }
283
284 template <class T>
do_round_trip(const T & val)285 void do_round_trip(const T& val)
286 {
287 do_round_trip(val, std::ios_base::fmtflags(0));
288 do_round_trip(val, std::ios_base::fmtflags(std::ios_base::scientific));
289 if ((fabs(val) > 1) && (fabs(val) < 1e100))
290 do_round_trip(val, std::ios_base::fmtflags(std::ios_base::fixed));
291 }
292
293 template <class T>
test_round_trip()294 void test_round_trip()
295 {
296 for (unsigned i = 0; i < 1000; ++i)
297 {
298 T val = generate_random<T>();
299 do_round_trip(val);
300 do_round_trip(T(-val));
301 do_round_trip(T(1 / val));
302 do_round_trip(T(-1 / val));
303 }
304 }
305
306 #ifdef TEST_FLOAT128
test_hexadecimal_floating_point()307 void test_hexadecimal_floating_point()
308 {
309 using boost::multiprecision::float128;
310
311 float128 x = 0x1p+0Q;
312
313 std::string s = x.str(0, std::ios_base::fmtflags(std::ios_base::fixed | std::ios_base::scientific));
314 BOOST_CHECK_EQUAL(s, "0x1p+0");
315
316 s = x.str(0, std::ios_base::fmtflags(std::ios_base::floatfield));
317 BOOST_CHECK_EQUAL(s, "0x1p+0");
318
319 x = -1;
320 s = x.str(0, std::ios_base::fmtflags(std::ios_base::floatfield));
321 BOOST_CHECK_EQUAL(s, "-0x1p+0");
322
323 // hexadecimal representation of pi; test a round trip:
324 float128 pi1 = 0x1.921fb54442d18469898cc51701b8p+1Q;
325 s = pi1.str(0, std::ios_base::fmtflags(std::ios_base::floatfield));
326 float128 pi2(s);
327 BOOST_CHECK_EQUAL(pi1, pi2);
328 }
329 #endif
330
main()331 int main()
332 {
333 #ifdef TEST_MPFR_50
334 test<boost::multiprecision::mpfr_float_50>();
335 test<boost::multiprecision::mpfr_float_100>();
336
337 test_round_trip<boost::multiprecision::mpfr_float_50>();
338 test_round_trip<boost::multiprecision::mpfr_float_100>();
339 #endif
340 #ifdef TEST_MPFI_50
341 test<boost::multiprecision::mpfr_float_50>();
342 test<boost::multiprecision::mpfr_float_100>();
343
344 test_round_trip<boost::multiprecision::mpfr_float_50>();
345 test_round_trip<boost::multiprecision::mpfr_float_100>();
346 #endif
347 #ifdef TEST_CPP_DEC_FLOAT
348 test<boost::multiprecision::cpp_dec_float_50>();
349 test<boost::multiprecision::cpp_dec_float_100>();
350
351 // cpp_dec_float has extra guard digits that messes this up:
352 test_round_trip<boost::multiprecision::cpp_dec_float_50>();
353 test_round_trip<boost::multiprecision::cpp_dec_float_100>();
354 #endif
355 #ifdef TEST_MPF_50
356 test<boost::multiprecision::mpf_float_50>();
357 test<boost::multiprecision::mpf_float_100>();
358 /*
359 // I can't get this to work with mpf_t - mpf_str appears
360 // not to actually print enough decimal digits:
361 test_round_trip<boost::multiprecision::mpf_float_50>();
362 test_round_trip<boost::multiprecision::mpf_float_100>();
363 */
364 #endif
365 #ifdef TEST_FLOAT128
366 test<boost::multiprecision::float128>();
367 test_hexadecimal_floating_point();
368 #ifndef BOOST_INTEL
369 test_round_trip<boost::multiprecision::float128>();
370 #endif
371 #endif
372 return boost::report_errors();
373 }
374