1 // Copyright Christopher Kormanyos 2014.
2 // Copyright John Maddock 2014.
3 // Copyright Paul A. Bristow 2014.
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 #include <cmath>
10 #include <complex>
11 #include <limits>
12 #include <iostream>
13 #include <iomanip>
14 #include <sstream>
15 #include <string>
16 #include <boost/cstdfloat.hpp>
17
18 #ifdef _MSC_VER
19 # pragma warning(disable : 4127) // conditional expression is constant.
20 # pragma warning(disable : 4512) // assignment operator could not be generated.
21 # pragma warning(disable : 4996) // use -D_SCL_SECURE_NO_WARNINGS.
22 #endif
23
24 #define BOOST_TEST_MAIN
25 #include <boost/test/unit_test.hpp> // Boost.Test
26 #include <boost/test/tools/floating_point_comparison.hpp>
27 #include <boost/scoped_array.hpp>
28
29 //
30 // We need to define an iostream operator for __float128 in order to
31 // compile this test:
32 //
33
34 //
35 // DESCRIPTION:
36 // ~~~~~~~~~~~~
37 //
38 // This file tests the implementation of floating-point typedefs having
39 // specified widths, as implemented in <boost/cstdfloat.hpp> and described
40 // in N3626 (proposed for C++14).
41
42 // For more information on <boost/cstdfloat.hpp> and the corresponding
43 // proposal of "Floating-Point Typedefs Having Specified Widths",
44 // see: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3626.pdf
45
46 // The tests:
47 //
48 // Perform sanity checks on boost::float16_t, boost::float32_t,
49 // boost::float64_t, boost::float80_t, and boost::float128_t when
50 // these types are available. In the sanity checks, we verify the
51 // formal behavior of the types and the macros for creating literal
52 // floating-point constants.
53 //
54 // An extended check is included for boost::float128_t. This checks
55 // the functionality of <cmath>, I/O stream operations, and <complex>
56 // functions for boost::float128_t.
57
58 // For some reason the (x != x) check fails on Mingw:
59 #if !defined(__MINGW64__)
60 #define TEST_CSTDFLOAT_SANITY_CHECK_NAN(the_digits) \
61 { \
62 using std::sqrt; \
63 const float_type x = sqrt(float_type(test_cstdfloat::minus_one)); \
64 const bool the_nan_test = ( std::numeric_limits<float_type>::has_quiet_NaN \
65 && (x != x)); \
66 BOOST_CHECK_EQUAL( the_nan_test, true ); \
67 }
68 #else
69 #define TEST_CSTDFLOAT_SANITY_CHECK_NAN(the_digits)
70 #endif
71
72 #define TEST_CSTDFLOAT_SANITY_CHECK(the_digits) \
73 void sanity_check_##the_digits##_func() \
74 { \
75 typedef boost::float##the_digits##_t float_type; \
76 \
77 BOOST_CONSTEXPR_OR_CONST int my_digits10 = std::numeric_limits<float_type>::digits10; \
78 \
79 { \
80 BOOST_CONSTEXPR_OR_CONST float_type x = \
81 BOOST_FLOAT##the_digits##_C(0.33333333333333333333333333333333333333333); \
82 std::stringstream ss; \
83 ss << std::setprecision(my_digits10 - 1) \
84 << x; \
85 std::string str = "0."; \
86 str += std::string(std::string::size_type(my_digits10 - 1), char('3')); \
87 BOOST_CHECK_EQUAL( ss.str(), str ); \
88 } \
89 { \
90 BOOST_CONSTEXPR_OR_CONST float_type x = \
91 BOOST_FLOAT##the_digits##_C(0.66666666666666666666666666666666666666666); \
92 std::stringstream ss; \
93 ss << std::setprecision(my_digits10 - 1) \
94 << x; \
95 std::string str = "0."; \
96 str += std::string(std::string::size_type(my_digits10 - 2), char('6')); \
97 str += "7"; \
98 BOOST_CHECK_EQUAL( ss.str(), str ); \
99 } \
100 { \
101 const float_type x = BOOST_FLOAT##the_digits##_C(1.0) / test_cstdfloat::zero; \
102 const bool the_inf_test = ( std::numeric_limits<float_type>::has_infinity \
103 && (x == std::numeric_limits<float_type>::infinity())); \
104 BOOST_CHECK_EQUAL( the_inf_test, true ); \
105 } \
106 TEST_CSTDFLOAT_SANITY_CHECK_NAN(the_digits)\
107 { \
108 const bool the_lim_test = \
109 (std::numeric_limits<boost::floatmax_t>::digits >= std::numeric_limits<float_type>::digits); \
110 BOOST_CHECK_EQUAL( the_lim_test, true ); \
111 } \
112 }
113
114 namespace test_cstdfloat
115 {
116 #if defined(BOOST_FLOAT128_C)
117
118 template <class T, class U>
test_less(T a,U b)119 void test_less(T a, U b)
120 {
121 BOOST_CHECK(a < b);
122 BOOST_CHECK(a <= b);
123 BOOST_CHECK(!(a > b));
124 BOOST_CHECK(!(a >= b));
125 BOOST_CHECK(!(a == b));
126 BOOST_CHECK((a != b));
127
128 BOOST_CHECK(b > a);
129 BOOST_CHECK(b >= a);
130 BOOST_CHECK(!(b < a));
131 BOOST_CHECK(!(b <= a));
132 BOOST_CHECK(!(b == a));
133 BOOST_CHECK((b != a));
134
135 BOOST_CHECK(std::isless(a, b));
136 BOOST_CHECK(std::islessequal(a, b));
137 BOOST_CHECK(!std::isgreater(a, b));
138 BOOST_CHECK(!std::isgreaterequal(a, b));
139 BOOST_CHECK(std::islessgreater(a, b));
140
141 BOOST_CHECK(!std::isless(b, a));
142 BOOST_CHECK(!std::islessequal(b, a));
143 BOOST_CHECK(std::isgreater(b, a));
144 BOOST_CHECK(std::isgreaterequal(b, a));
145 BOOST_CHECK(std::islessgreater(b, a));
146 }
147 template <class T, class U>
test_equal(T a,U b)148 void test_equal(T a, U b)
149 {
150 BOOST_CHECK(!(a < b));
151 BOOST_CHECK(a <= b);
152 BOOST_CHECK(!(a > b));
153 BOOST_CHECK((a >= b));
154 BOOST_CHECK((a == b));
155 BOOST_CHECK(!(a != b));
156
157 BOOST_CHECK(!(b > a));
158 BOOST_CHECK(b >= a);
159 BOOST_CHECK(!(b < a));
160 BOOST_CHECK((b <= a));
161 BOOST_CHECK((b == a));
162 BOOST_CHECK(!(b != a));
163
164 BOOST_CHECK(!std::isless(a, b));
165 BOOST_CHECK(std::islessequal(a, b));
166 BOOST_CHECK(!std::isgreater(a, b));
167 BOOST_CHECK(std::isgreaterequal(a, b));
168 BOOST_CHECK(!std::islessgreater(a, b));
169
170 BOOST_CHECK(!std::isless(b, a));
171 BOOST_CHECK(std::islessequal(b, a));
172 BOOST_CHECK(!std::isgreater(b, a));
173 BOOST_CHECK(std::isgreaterequal(b, a));
174 BOOST_CHECK(!std::islessgreater(b, a));
175 }
176 template <class T, class U>
test_unordered(T a,U b)177 void test_unordered(T a, U b)
178 {
179 BOOST_CHECK(!(a < b));
180 BOOST_CHECK(!(a <= b));
181 BOOST_CHECK(!(a > b));
182 BOOST_CHECK(!(a >= b));
183 BOOST_CHECK(!(a == b));
184 BOOST_CHECK((a != b));
185
186 BOOST_CHECK(!(b > a));
187 BOOST_CHECK(!(b >= a));
188 BOOST_CHECK(!(b < a));
189 BOOST_CHECK(!(b <= a));
190 BOOST_CHECK(!(b == a));
191 BOOST_CHECK((b != a));
192
193 BOOST_CHECK(!std::isless(a, b));
194 BOOST_CHECK(!std::islessequal(a, b));
195 BOOST_CHECK(!std::isgreater(a, b));
196 BOOST_CHECK(!std::isgreaterequal(a, b));
197 BOOST_CHECK(!std::islessgreater(a, b));
198
199 BOOST_CHECK(!std::isless(b, a));
200 BOOST_CHECK(!std::islessequal(b, a));
201 BOOST_CHECK(!std::isgreater(b, a));
202 BOOST_CHECK(!std::isgreaterequal(b, a));
203 BOOST_CHECK(!std::islessgreater(b, a));
204 }
205
206 template <class T>
test()207 void test()
208 {
209 //
210 // Basic sanity checks for C99 functions which are just imported versions
211 // from Boost.Math. These should still be found via ADL so no using declarations here...
212 //
213 T val = 2;
214 BOOST_CHECK(std::signbit(val) == 0);
215 BOOST_CHECK(std::signbit(val + 2) == 0);
216 val = -val;
217 BOOST_CHECK(std::signbit(val));
218 BOOST_CHECK(std::signbit(val * 2));
219
220 T s = 2;
221 val = 3;
222 BOOST_CHECK_EQUAL(std::copysign(val, s), 3);
223 BOOST_CHECK_EQUAL(std::copysign(val, s * -2), -3);
224 BOOST_CHECK_EQUAL(std::copysign(-2 * val, s), 6);
225 BOOST_CHECK_EQUAL(std::copysign(-2 * val, 2 * s), 6);
226 s = -2;
227 BOOST_CHECK_EQUAL(std::copysign(val, s), -3);
228 BOOST_CHECK_EQUAL(std::copysign(val, s * -2), 3);
229 BOOST_CHECK_EQUAL(std::copysign(-2 * val, s), -6);
230 BOOST_CHECK_EQUAL(std::copysign(-2 * val, 2 * s), -6);
231 val = -3;
232 BOOST_CHECK_EQUAL(std::copysign(val, s), -3);
233 BOOST_CHECK_EQUAL(std::copysign(val, s * -2), 3);
234 BOOST_CHECK_EQUAL(std::copysign(-2 * val, s), -6);
235 BOOST_CHECK_EQUAL(std::copysign(-2 * val, 2 * s), -6);
236 s = 0;
237 BOOST_CHECK_EQUAL(std::copysign(val, s), 3);
238 BOOST_CHECK_EQUAL(std::copysign(val, s * -2), -3);
239
240 BOOST_CHECK_EQUAL(std::copysign(-2 * val, s), 6);
241 BOOST_CHECK_EQUAL(std::copysign(-2 * val, 2 * s), 6);
242 // Things involving signed zero, need to detect it first:
243
244 val = 3;
245 BOOST_CHECK_EQUAL(std::fpclassify(val), FP_NORMAL);
246 BOOST_CHECK_EQUAL(std::fpclassify(val * 3), FP_NORMAL);
247 BOOST_CHECK(!std::isinf(val));
248 BOOST_CHECK(!std::isinf(val + 2));
249 BOOST_CHECK(!std::isnan(val));
250 BOOST_CHECK(!std::isnan(val + 2));
251 BOOST_CHECK(std::isnormal(val));
252 BOOST_CHECK(std::isnormal(val + 2));
253 val = -3;
254 BOOST_CHECK_EQUAL(std::fpclassify(val), FP_NORMAL);
255 BOOST_CHECK_EQUAL(std::fpclassify(val * 3), FP_NORMAL);
256 BOOST_CHECK(!std::isinf(val));
257 BOOST_CHECK(!std::isinf(val + 2));
258 BOOST_CHECK(!std::isnan(val));
259 BOOST_CHECK(!std::isnan(val + 2));
260 BOOST_CHECK(std::isnormal(val));
261 BOOST_CHECK(std::isnormal(val + 2));
262 val = 0;
263 BOOST_CHECK_EQUAL(std::fpclassify(val), FP_ZERO);
264 BOOST_CHECK_EQUAL(std::fpclassify(val * 3), FP_ZERO);
265 BOOST_CHECK(!std::isinf(val));
266 BOOST_CHECK(!std::isinf(val + 2));
267 BOOST_CHECK(!std::isnan(val));
268 BOOST_CHECK(!std::isnan(val + 2));
269 BOOST_CHECK(!std::isnormal(val));
270 BOOST_CHECK(!std::isnormal(val * 2));
271 BOOST_CHECK(!std::isnormal(val * -2));
272 if (std::numeric_limits<T>::has_infinity)
273 {
274 val = std::numeric_limits<T>::infinity();
275 BOOST_CHECK_EQUAL(std::fpclassify(val), FP_INFINITE);
276 BOOST_CHECK_EQUAL(std::fpclassify(val * 3), FP_INFINITE);
277 BOOST_CHECK(std::isinf(val));
278 BOOST_CHECK(std::isinf(val + 2));
279 BOOST_CHECK(!std::isnan(val));
280 BOOST_CHECK(!std::isnan(val + 2));
281 BOOST_CHECK(!std::isnormal(val));
282 BOOST_CHECK(!std::isnormal(val + 2));
283 val = -val;
284 BOOST_CHECK_EQUAL(std::fpclassify(val), FP_INFINITE);
285 BOOST_CHECK_EQUAL(std::fpclassify(val * 3), FP_INFINITE);
286 BOOST_CHECK(std::isinf(val));
287 BOOST_CHECK(std::isinf(val + 2));
288 BOOST_CHECK(!std::isnan(val));
289 BOOST_CHECK(!std::isnan(val + 2));
290 BOOST_CHECK(!std::isnormal(val));
291 BOOST_CHECK(!std::isnormal(val + 2));
292 }
293 if (std::numeric_limits<T>::has_quiet_NaN)
294 {
295 val = std::numeric_limits <T>::quiet_NaN();
296 BOOST_CHECK_EQUAL(std::fpclassify(val), FP_NAN);
297 BOOST_CHECK_EQUAL(std::fpclassify(val * 3), FP_NAN);
298 BOOST_CHECK(!std::isinf(val));
299 BOOST_CHECK(!std::isinf(val + 2));
300 BOOST_CHECK(std::isnan(val));
301 BOOST_CHECK(std::isnan(val + 2));
302 BOOST_CHECK(!std::isnormal(val));
303 BOOST_CHECK(!std::isnormal(val + 2));
304 }
305 s = 8 * std::numeric_limits<T>::epsilon();
306 val = 2.5;
307 BOOST_CHECK_CLOSE_FRACTION(std::asinh(val), T(1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434Q), s);
308 BOOST_CHECK_CLOSE_FRACTION(std::acosh(val), T(1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050Q), s);
309 val = 0.5;
310 BOOST_CHECK_CLOSE_FRACTION(std::atanh(val), T(0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753Q), s);
311 val = 55.25;
312 BOOST_CHECK_CLOSE_FRACTION(std::cbrt(val), T(3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118Q), s);
313 val = 2.75;
314 BOOST_CHECK_CLOSE_FRACTION(std::erf(val), T(0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487Q), s);
315 BOOST_CHECK_CLOSE_FRACTION(std::erfc(val), T(0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512Q), s);
316 val = 0.125;
317 BOOST_CHECK_CLOSE_FRACTION(std::expm1(val), T(0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449Q), s);
318
319 val = 20;
320 s = 2;
321 BOOST_CHECK_EQUAL(std::fdim(val, s), 18);
322 BOOST_CHECK_EQUAL(std::fdim(s, val), 0);
323 BOOST_CHECK_EQUAL(std::fdim(val, s * 2), 16);
324 BOOST_CHECK_EQUAL(std::fdim(s * 2, val), 0);
325 BOOST_CHECK_EQUAL(std::fdim(val, 2), 18);
326 BOOST_CHECK_EQUAL(std::fdim(2, val), 0);
327
328 BOOST_CHECK_EQUAL(std::fmax(val, s), val);
329 BOOST_CHECK_EQUAL(std::fmax(s, val), val);
330 BOOST_CHECK_EQUAL(std::fmax(val * 2, s), val * 2);
331 BOOST_CHECK_EQUAL(std::fmax(val, s * 2), val);
332 BOOST_CHECK_EQUAL(std::fmax(val * 2, s * 2), val * 2);
333 BOOST_CHECK_EQUAL(std::fmin(val, s), s);
334 BOOST_CHECK_EQUAL(std::fmin(s, val), s);
335 BOOST_CHECK_EQUAL(std::fmin(val * 2, s), s);
336 BOOST_CHECK_EQUAL(std::fmin(val, s * 2), s * 2);
337 BOOST_CHECK_EQUAL(std::fmin(val * 2, s * 2), s * 2);
338
339 BOOST_CHECK_EQUAL(std::fmax(val, 2), val);
340 BOOST_CHECK_EQUAL(std::fmax(val, 2.0), val);
341 BOOST_CHECK_EQUAL(std::fmax(20, s), val);
342 BOOST_CHECK_EQUAL(std::fmax(20.0, s), val);
343 BOOST_CHECK_EQUAL(std::fmin(val, 2), s);
344 BOOST_CHECK_EQUAL(std::fmin(val, 2.0), s);
345 BOOST_CHECK_EQUAL(std::fmin(20, s), s);
346 BOOST_CHECK_EQUAL(std::fmin(20.0, s), s);
347 if (std::numeric_limits<T>::has_quiet_NaN)
348 {
349 BOOST_CHECK_EQUAL(std::fmax(val, std::numeric_limits<T>::quiet_NaN()), val);
350 BOOST_CHECK_EQUAL(std::fmax(std::numeric_limits<T>::quiet_NaN(), val), val);
351 BOOST_CHECK_EQUAL(std::fmin(val, std::numeric_limits<T>::quiet_NaN()), val);
352 BOOST_CHECK_EQUAL(std::fmin(std::numeric_limits<T>::quiet_NaN(), val), val);
353 }
354 if (std::numeric_limits<double>::has_quiet_NaN)
355 {
356 BOOST_CHECK_EQUAL(std::fmax(val, std::numeric_limits<double>::quiet_NaN()), val);
357 BOOST_CHECK_EQUAL(std::fmax(std::numeric_limits<double>::quiet_NaN(), val), val);
358 BOOST_CHECK_EQUAL(std::fmin(val, std::numeric_limits<double>::quiet_NaN()), val);
359 BOOST_CHECK_EQUAL(std::fmin(std::numeric_limits<double>::quiet_NaN(), val), val);
360 }
361
362 test_less(s, val);
363 test_less(2, val);
364 test_less(s, 20);
365 test_less(s + 0, val);
366 test_less(s, val * 1);
367 test_less(s * 1, val * 1);
368 test_less(s * 1, 20);
369 test_less(s + 2, val * 2);
370
371 test_equal(val, val);
372 test_equal(20, val);
373 test_equal(val, 20);
374 test_equal(val + 0, val);
375 test_equal(val, val * 1);
376 test_equal(val * 1, val * 1);
377 test_equal(val * 1, 20);
378 test_equal(val * 20, val * 20);
379
380 if (std::numeric_limits<T>::has_quiet_NaN)
381 {
382 s = std::numeric_limits<T>::quiet_NaN();
383 test_unordered(s, val);
384 test_unordered(s, 20);
385 test_unordered(s + 0, val);
386 test_unordered(s, val * 1);
387 test_unordered(s * 1, val * 1);
388 test_unordered(s * 1, 20);
389 test_unordered(s + 2, val * 2);
390 if (std::numeric_limits<double>::has_quiet_NaN)
391 {
392 double n = std::numeric_limits<double>::quiet_NaN();
393 test_unordered(n, val);
394 }
395 }
396
397 T tol = 8 * std::numeric_limits<T>::epsilon();
398 s = 2;
399 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val, s)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
400 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val, 2)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
401 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val, 2.0)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
402 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(20, s)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
403 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(20.0, s)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
404 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val * 1, s)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
405 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val * 1, s * 1)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
406 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val * 1, 2)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
407 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(val * 1, 2.0)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
408 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(20, s * 1)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
409 BOOST_CHECK_CLOSE_FRACTION(T(std::hypot(20.0, s * 1)), T(20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530Q), tol);
410
411 BOOST_CHECK_CLOSE_FRACTION(std::lgamma(val), T(39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582Q), tol);
412 BOOST_CHECK_CLOSE_FRACTION(std::lgamma(val + 0), T(39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582Q), tol);
413
414 BOOST_CHECK_EQUAL(std::lrint(val), 20);
415 BOOST_CHECK_EQUAL(std::lrint(val * 2), 40);
416 BOOST_CHECK_EQUAL(std::llrint(val), 20);
417 BOOST_CHECK_EQUAL(std::llrint(val * 2), 40);
418
419 val = 0.125;
420 BOOST_CHECK_CLOSE_FRACTION(std::log1p(val), T(0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070Q), tol);
421 BOOST_CHECK_CLOSE_FRACTION(std::log1p(val + 0), T(0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070Q), tol);
422 val = 20;
423 BOOST_CHECK_CLOSE_FRACTION(T(std::log2(val)), T(4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710Q), tol);
424 BOOST_CHECK_CLOSE_FRACTION(T(std::log2(val + 0)), T(4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710Q), tol);
425
426 BOOST_CHECK_EQUAL(T(std::nearbyint(val)), 20);
427 BOOST_CHECK_EQUAL(T(std::nearbyint(val + 0.25)), 20);
428 BOOST_CHECK_EQUAL(T(std::rint(val)), 20);
429 BOOST_CHECK_EQUAL(T(std::rint(val + 0.25)), 20);
430
431 BOOST_CHECK_GT(std::nextafter(val, T(200)), val);
432 BOOST_CHECK_GT(std::nextafter(val + 0, T(200)), val);
433 BOOST_CHECK_GT(std::nextafter(val + 0, T(200) + 1), val);
434 BOOST_CHECK_GT(std::nextafter(val, T(200) + 1), val);
435
436 BOOST_CHECK_GT(std::nexttoward(val, T(200)), val);
437 BOOST_CHECK_GT(std::nexttoward(val + 0, T(200)), val);
438 BOOST_CHECK_GT(std::nexttoward(val + 0, T(200) + 1), val);
439 BOOST_CHECK_GT(std::nexttoward(val, T(200) + 1), val);
440
441 val = 21;
442 s = 5;
443 BOOST_CHECK_EQUAL(T(std::remainder(val, s)), 1);
444 BOOST_CHECK_EQUAL(T(std::remainder(val, 5)), 1);
445 BOOST_CHECK_EQUAL(T(std::remainder(21, s)), 1);
446 BOOST_CHECK_EQUAL(T(std::remainder(val * 1, s)), 1);
447 BOOST_CHECK_EQUAL(T(std::remainder(val * 1, s * 1)), 1);
448 BOOST_CHECK_EQUAL(T(std::remainder(val, s * 1)), 1);
449 BOOST_CHECK_EQUAL(T(std::remainder(val * 1, 5)), 1);
450 BOOST_CHECK_EQUAL(T(std::remainder(21, s * 1)), 1);
451 int i(0);
452 BOOST_CHECK_EQUAL(T(std::remquo(val, s, &i)), 1);
453 BOOST_CHECK_EQUAL(i, 4);
454 i = 0;
455 BOOST_CHECK_EQUAL(T(std::remquo(val, 5, &i)), 1);
456 BOOST_CHECK_EQUAL(i, 4);
457 i = 0;
458 BOOST_CHECK_EQUAL(T(std::remquo(21, s, &i)), 1);
459 BOOST_CHECK_EQUAL(i, 4);
460 i = 0;
461 BOOST_CHECK_EQUAL(T(std::remquo(val * 1, s, &i)), 1);
462 BOOST_CHECK_EQUAL(i, 4);
463 i = 0;
464 BOOST_CHECK_EQUAL(T(std::remquo(val * 1, s * 1, &i)), 1);
465 BOOST_CHECK_EQUAL(i, 4);
466 i = 0;
467 BOOST_CHECK_EQUAL(T(std::remquo(val, s * 1, &i)), 1);
468 BOOST_CHECK_EQUAL(i, 4);
469 i = 0;
470 BOOST_CHECK_EQUAL(T(std::remquo(val * 1, 5, &i)), 1);
471 BOOST_CHECK_EQUAL(i, 4);
472 i = 0;
473 BOOST_CHECK_EQUAL(T(std::remquo(21, s * 1, &i)), 1);
474 BOOST_CHECK_EQUAL(i, 4);
475 i = 0;
476 val = 5.25;
477 tol = 3000;
478 BOOST_CHECK_CLOSE_FRACTION(std::tgamma(val), T(35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544Q), tol);
479 BOOST_CHECK_CLOSE_FRACTION(std::tgamma(val + 1), T(184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160Q), tol);
480
481 BOOST_CHECK_CLOSE_FRACTION(T(std::exp2(val)), T(38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792Q), tol);
482 BOOST_CHECK_CLOSE_FRACTION(T(std::exp2(val + 1)), T(76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585Q), tol);
483 val = 15;
484 BOOST_CHECK_CLOSE_FRACTION(T(std::exp2(val)), T(32768uL), tol);
485 BOOST_CHECK_CLOSE_FRACTION(T(std::exp2(val + 1)), T(65536uL), tol);
486
487 i = std::fpclassify(val) + std::isgreaterequal(val, s) + std::islessequal(val, s) + std::isnan(val) + std::isunordered(val, s)
488 + std::isfinite(val) + std::isinf(val) + std::islessgreater(val, s) + std::isnormal(val) + std::signbit(val) + std::isgreater(val, s) + std::isless(val, s);
489 }
490
491 #endif
492
493 int zero;
494 int minus_one;
495
496 #if defined(BOOST_FLOATMAX_C)
497 BOOST_CONSTEXPR_OR_CONST int has_floatmax_t = 1;
498 #else
499 BOOST_CONSTEXPR_OR_CONST int has_floatmax_t = 0;
500 #endif
501
502 #if defined(BOOST_FLOAT16_C)
503 TEST_CSTDFLOAT_SANITY_CHECK(16)
504 #endif
505
506 #if defined(BOOST_FLOAT32_C)
507 TEST_CSTDFLOAT_SANITY_CHECK(32)
508 #endif
509
510 #if defined(BOOST_FLOAT64_C)
511 TEST_CSTDFLOAT_SANITY_CHECK(64)
512 #endif
513
514 #if defined(BOOST_FLOAT80_C)
515 TEST_CSTDFLOAT_SANITY_CHECK(80)
516 #endif
517
518 #if defined(BOOST_FLOAT128_C)
519 TEST_CSTDFLOAT_SANITY_CHECK(128)
520
extend_check_128_func()521 void extend_check_128_func()
522 {
523 test<boost::float128_t>();
524 }
525 #endif // defined (BOOST_FLOAT128_C)
526 }
527
BOOST_AUTO_TEST_CASE(test_main)528 BOOST_AUTO_TEST_CASE(test_main)
529 {
530 test_cstdfloat::zero = 0;
531 test_cstdfloat::minus_one = -1;
532
533 // Perform basic sanity checks that verify both the existence of the proper
534 // floating-point literal macros as well as the correct digit handling
535 // for a given floating-point typedef having specified width.
536
537 BOOST_CHECK_EQUAL(test_cstdfloat::has_floatmax_t, 1);
538
539 #if defined(BOOST_FLOAT16_C)
540 test_cstdfloat::sanity_check_16_func();
541 #endif
542
543 #if defined(BOOST_FLOAT32_C)
544 test_cstdfloat::sanity_check_32_func();
545 #endif
546
547 #if defined(BOOST_FLOAT64_C)
548 test_cstdfloat::sanity_check_64_func();
549 #endif
550
551 #if defined(BOOST_FLOAT80_C)
552 test_cstdfloat::sanity_check_80_func();
553 #endif
554
555 #if defined(BOOST_FLOAT128_C)
556 test_cstdfloat::sanity_check_128_func();
557
558 // Perform an extended check of boost::float128_t including
559 // a variety of functions from the C++ standard library.
560 test_cstdfloat::extend_check_128_func();
561 #endif // defined (BOOST_FLOAT128_C)
562 }
563