1 // (C) Copyright John Maddock 2016.
2 // Use, modification and distribution are subject to the
3 // Boost Software License, Version 1.0. (See accompanying file
4 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 #pragma warning(disable : 4127) // conditional expression is constant
10 #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) \
11 && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) \
12 && !defined(TEST_CPP_DEC_FLOAT_2) && !defined(TEST_CPP_DEC_FLOAT_3) && !defined(TEST_CPP_DEC_FLOAT_4) \
13 && !defined(TEST_CPP_DEC_FLOAT_5) && !defined(TEST_CPP_DEC_FLOAT_6) && !defined(TEST_CPP_BIN_FLOAT_2) && !defined(TEST_CPP_BIN_FLOAT_3)\
14 && !defined(TEST_MPFI_DEBUG_ADAPTOR) && !defined(TEST_MPFR_DEBUG_ADAPTOR) && !defined(TEST_MPFI_LOGGED_ADAPTOR) && !defined(TEST_MPFR_LOGGED_ADAPTOR)
18 #define TEST_CPP_DEC_FLOAT
19 #define TEST_CPP_DEC_FLOAT_2
20 #define TEST_CPP_DEC_FLOAT_3
21 #define TEST_CPP_DEC_FLOAT_4
22 #define TEST_CPP_DEC_FLOAT_5
23 #define TEST_CPP_DEC_FLOAT_6
25 #define TEST_CPP_BIN_FLOAT
26 #define TEST_CPP_BIN_FLOAT_2
27 #define TEST_CPP_BIN_FLOAT_3
28 #define TEST_MPFI_DEBUG_ADAPTOR
29 #define TEST_MPFR_DEBUG_ADAPTOR
30 #define TEST_MPFI_LOGGED_ADAPTOR
31 #define TEST_MPFR_LOGGED_ADAPTOR
34 #pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
37 #pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
42 #if defined(TEST_MPF_50)
43 #include <boost/multiprecision/gmp.hpp>
46 #include <boost/multiprecision/mpfr.hpp>
49 #include <boost/multiprecision/mpfi.hpp>
51 #if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_2) || defined(TEST_CPP_DEC_FLOAT_3) || defined(TEST_CPP_DEC_FLOAT_4) || defined(TEST_CPP_DEC_FLOAT_5) || defined(TEST_CPP_DEC_FLOAT_6)
52 #include <boost/multiprecision/cpp_dec_float.hpp>
54 #if defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_BIN_FLOAT_2) || defined(TEST_CPP_BIN_FLOAT_3)
55 #include <boost/multiprecision/cpp_bin_float.hpp>
56 #include <boost/multiprecision/debug_adaptor.hpp>
59 #include <boost/multiprecision/float128.hpp>
61 #ifdef TEST_MPFI_DEBUG_ADAPTOR
62 # include <boost/multiprecision/mpfi.hpp>
63 # include <boost/multiprecision/debug_adaptor.hpp>
65 #ifdef TEST_MPFR_DEBUG_ADAPTOR
66 # include <boost/multiprecision/mpfr.hpp>
67 # include <boost/multiprecision/debug_adaptor.hpp>
69 #ifdef TEST_MPFI_LOGGED_ADAPTOR
70 # include <boost/multiprecision/mpfi.hpp>
71 # include <boost/multiprecision/logged_adaptor.hpp>
73 #ifdef TEST_MPFR_LOGGED_ADAPTOR
74 # include <boost/multiprecision/mpfr.hpp>
75 # include <boost/multiprecision/logged_adaptor.hpp>
78 #include <boost/math/constants/constants.hpp>
79 #include <boost/math/special_functions/gamma.hpp>
107 #ifdef MPFR_VERSION_MAJOR
108 #define BOOST_MPFR_VERSION MPFR_VERSION_MAJOR * 10000 + MPFR_VERSION_MINOR * 100 + MPFR_VERSION_PATCHLEVEL
111 template <class T
, class U
>
112 void test_less(T a
, U b
)
116 BOOST_CHECK(!(a
> b
));
117 BOOST_CHECK(!(a
>= b
));
118 BOOST_CHECK(!(a
== b
));
119 BOOST_CHECK((a
!= b
));
123 BOOST_CHECK(!(b
< a
));
124 BOOST_CHECK(!(b
<= a
));
125 BOOST_CHECK(!(b
== a
));
126 BOOST_CHECK((b
!= a
));
128 BOOST_CHECK(isless(a
, b
));
129 BOOST_CHECK(islessequal(a
, b
));
130 BOOST_CHECK(!isgreater(a
, b
));
131 BOOST_CHECK(!isgreaterequal(a
, b
));
132 BOOST_CHECK(islessgreater(a
, b
));
134 BOOST_CHECK(!isless(b
, a
));
135 BOOST_CHECK(!islessequal(b
, a
));
136 BOOST_CHECK(isgreater(b
, a
));
137 BOOST_CHECK(isgreaterequal(b
, a
));
138 BOOST_CHECK(islessgreater(b
, a
));
140 template <class T
, class U
>
141 void test_equal(T a
, U b
)
143 BOOST_CHECK(!(a
< b
));
145 BOOST_CHECK(!(a
> b
));
146 BOOST_CHECK((a
>= b
));
147 BOOST_CHECK((a
== b
));
148 BOOST_CHECK(!(a
!= b
));
150 BOOST_CHECK(!(b
> a
));
152 BOOST_CHECK(!(b
< a
));
153 BOOST_CHECK((b
<= a
));
154 BOOST_CHECK((b
== a
));
155 BOOST_CHECK(!(b
!= a
));
157 BOOST_CHECK(!isless(a
, b
));
158 BOOST_CHECK(islessequal(a
, b
));
159 BOOST_CHECK(!isgreater(a
, b
));
160 BOOST_CHECK(isgreaterequal(a
, b
));
161 BOOST_CHECK(!islessgreater(a
, b
));
163 BOOST_CHECK(!isless(b
, a
));
164 BOOST_CHECK(islessequal(b
, a
));
165 BOOST_CHECK(!isgreater(b
, a
));
166 BOOST_CHECK(isgreaterequal(b
, a
));
167 BOOST_CHECK(!islessgreater(b
, a
));
169 template <class T
, class U
>
170 void test_unordered(T a
, U b
)
172 BOOST_CHECK(!(a
< b
));
173 BOOST_CHECK(!(a
<= b
));
174 BOOST_CHECK(!(a
> b
));
175 BOOST_CHECK(!(a
>= b
));
176 BOOST_CHECK(!(a
== b
));
177 BOOST_CHECK((a
!= b
));
179 BOOST_CHECK(!(b
> a
));
180 BOOST_CHECK(!(b
>= a
));
181 BOOST_CHECK(!(b
< a
));
182 BOOST_CHECK(!(b
<= a
));
183 BOOST_CHECK(!(b
== a
));
184 BOOST_CHECK((b
!= a
));
186 BOOST_CHECK(!isless(a
, b
));
187 BOOST_CHECK(!islessequal(a
, b
));
188 BOOST_CHECK(!isgreater(a
, b
));
189 BOOST_CHECK(!isgreaterequal(a
, b
));
190 BOOST_CHECK(!islessgreater(a
, b
));
192 BOOST_CHECK(!isless(b
, a
));
193 BOOST_CHECK(!islessequal(b
, a
));
194 BOOST_CHECK(!isgreater(b
, a
));
195 BOOST_CHECK(!isgreaterequal(b
, a
));
196 BOOST_CHECK(!islessgreater(b
, a
));
203 // Basic sanity checks for C99 functions which are just imported versions
204 // from Boost.Math. These should still be found via ADL so no using declarations here...
207 BOOST_CHECK(signbit(val
) == 0);
208 BOOST_CHECK(signbit(val
+ 2) == 0);
210 BOOST_CHECK(signbit(val
));
211 BOOST_CHECK(signbit(val
* 2));
214 BOOST_CHECK_EQUAL(sign(val
), 1);
215 BOOST_CHECK_EQUAL(sign(val
+ 2), 1);
217 BOOST_CHECK_EQUAL(sign(val
), -1);
218 BOOST_CHECK_EQUAL(sign(val
* 2), -1);
220 BOOST_CHECK_EQUAL(sign(val
), 0);
221 BOOST_CHECK_EQUAL(sign(val
* 2), 0);
224 BOOST_CHECK_EQUAL(changesign(val
), -2);
225 BOOST_CHECK_EQUAL(changesign(val
* 2), -4);
227 BOOST_CHECK_EQUAL(changesign(val
), 2);
228 BOOST_CHECK_EQUAL(changesign(val
* 2), 4);
230 BOOST_CHECK_EQUAL(changesign(val
), 0);
231 BOOST_CHECK_EQUAL(changesign(val
* 2), 0);
232 // Things involving signed zero, need to detect it first:
233 T neg_zero_test
= -(std::numeric_limits
<T
>::min
)();
234 neg_zero_test
/= (std::numeric_limits
<T
>::max
)();
236 bool test_signed_zero
= !boost::multiprecision::is_interval_number
<T
>::value
&& std::numeric_limits
<T
>::has_infinity
&& (one
/ neg_zero_test
< 0);
237 if (test_signed_zero
)
239 BOOST_CHECK(signbit(changesign(val
)));
240 BOOST_CHECK(signbit(changesign(val
* 2)));
245 BOOST_CHECK_EQUAL(copysign(val
, s
), 3);
246 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), -3);
247 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), 6);
248 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), 6);
250 BOOST_CHECK_EQUAL(copysign(val
, s
), -3);
251 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), 3);
252 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), -6);
253 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), -6);
255 BOOST_CHECK_EQUAL(copysign(val
, s
), -3);
256 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), 3);
257 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), -6);
258 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), -6);
260 BOOST_CHECK_EQUAL(copysign(val
, s
), 3);
261 // Things involving signed zero, need to detect it first:
262 if (test_signed_zero
)
264 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), -3);
266 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), 6);
267 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), 6);
268 // Things involving signed zero, need to detect it first:
269 if (test_signed_zero
)
274 BOOST_CHECK_EQUAL(copysign(val
, s
), -3);
275 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), 3);
276 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), -6);
277 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), -6);
282 BOOST_CHECK_EQUAL(fpclassify(val
), FP_NORMAL
);
283 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_NORMAL
);
284 BOOST_CHECK(!isinf(val
));
285 BOOST_CHECK(!isinf(val
+ 2));
286 BOOST_CHECK(!isnan(val
));
287 BOOST_CHECK(!isnan(val
+ 2));
288 BOOST_CHECK(isnormal(val
));
289 BOOST_CHECK(isnormal(val
+ 2));
291 BOOST_CHECK_EQUAL(fpclassify(val
), FP_NORMAL
);
292 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_NORMAL
);
293 BOOST_CHECK(!isinf(val
));
294 BOOST_CHECK(!isinf(val
+ 2));
295 BOOST_CHECK(!isnan(val
));
296 BOOST_CHECK(!isnan(val
+ 2));
297 BOOST_CHECK(isnormal(val
));
298 BOOST_CHECK(isnormal(val
+ 2));
300 BOOST_CHECK_EQUAL(fpclassify(val
), FP_ZERO
);
301 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_ZERO
);
302 BOOST_CHECK(!isinf(val
));
303 BOOST_CHECK(!isinf(val
+ 2));
304 BOOST_CHECK(!isnan(val
));
305 BOOST_CHECK(!isnan(val
+ 2));
306 BOOST_CHECK(!isnormal(val
));
307 BOOST_CHECK(!isnormal(val
* 2));
308 BOOST_CHECK(!isnormal(val
* -2));
309 if (std::numeric_limits
<T
>::has_infinity
)
311 val
= std::numeric_limits
<T
>::infinity();
312 BOOST_CHECK_EQUAL(fpclassify(val
), FP_INFINITE
);
313 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_INFINITE
);
314 BOOST_CHECK(isinf(val
));
315 BOOST_CHECK(isinf(val
+ 2));
316 BOOST_CHECK(!isnan(val
));
317 BOOST_CHECK(!isnan(val
+ 2));
318 BOOST_CHECK(!isnormal(val
));
319 BOOST_CHECK(!isnormal(val
+ 2));
321 BOOST_CHECK_EQUAL(fpclassify(val
), FP_INFINITE
);
322 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_INFINITE
);
323 BOOST_CHECK(isinf(val
));
324 BOOST_CHECK(isinf(val
+ 2));
325 BOOST_CHECK(!isnan(val
));
326 BOOST_CHECK(!isnan(val
+ 2));
327 BOOST_CHECK(!isnormal(val
));
328 BOOST_CHECK(!isnormal(val
+ 2));
330 if (std::numeric_limits
<T
>::has_quiet_NaN
)
332 val
= std::numeric_limits
<T
>::quiet_NaN();
333 BOOST_CHECK_EQUAL(fpclassify(val
), FP_NAN
);
334 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_NAN
);
335 BOOST_CHECK(!isinf(val
));
336 BOOST_CHECK(!isinf(val
+ 2));
337 BOOST_CHECK(isnan(val
));
338 BOOST_CHECK(isnan(val
+ 2));
339 BOOST_CHECK(!isnormal(val
));
340 BOOST_CHECK(!isnormal(val
+ 2));
342 s
= 8 * std::numeric_limits
<T
>::epsilon();
344 BOOST_CHECK_CLOSE_FRACTION(asinh(val
), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s
);
345 BOOST_CHECK_CLOSE_FRACTION(asinh(val
+ T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s
);
346 BOOST_CHECK_CLOSE_FRACTION(acosh(val
), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s
);
347 BOOST_CHECK_CLOSE_FRACTION(acosh(val
+ T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s
);
349 BOOST_CHECK_CLOSE_FRACTION(atanh(val
), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s
);
350 BOOST_CHECK_CLOSE_FRACTION(atanh(val
+ T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s
);
352 BOOST_CHECK_CLOSE_FRACTION(cbrt(val
), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s
);
353 BOOST_CHECK_CLOSE_FRACTION(cbrt(val
+ T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s
);
354 if (!boost::multiprecision::is_interval_number
<T
>::value
)
357 BOOST_CHECK_CLOSE_FRACTION(erf(val
), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s
);
358 BOOST_CHECK_CLOSE_FRACTION(erf(val
+ T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s
);
359 BOOST_CHECK_CLOSE_FRACTION(erfc(val
), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s
);
360 BOOST_CHECK_CLOSE_FRACTION(erfc(val
+ T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s
);
363 BOOST_CHECK_CLOSE_FRACTION(expm1(val
), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s
);
364 BOOST_CHECK_CLOSE_FRACTION(expm1(val
+ T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s
);
368 BOOST_CHECK_EQUAL(fdim(val
, s
), 18);
369 BOOST_CHECK_EQUAL(fdim(s
, val
), 0);
370 BOOST_CHECK_EQUAL(fdim(val
, s
* 2), 16);
371 BOOST_CHECK_EQUAL(fdim(s
* 2, val
), 0);
372 BOOST_CHECK_EQUAL(fdim(val
, 2), 18);
373 BOOST_CHECK_EQUAL(fdim(2, val
), 0);
375 BOOST_CHECK_EQUAL(fmax(val
, s
), val
);
376 BOOST_CHECK_EQUAL(fmax(s
, val
), val
);
377 BOOST_CHECK_EQUAL(fmax(val
* 2, s
), val
* 2);
378 BOOST_CHECK_EQUAL(fmax(val
, s
* 2), val
);
379 BOOST_CHECK_EQUAL(fmax(val
* 2, s
* 2), val
* 2);
380 BOOST_CHECK_EQUAL(fmin(val
, s
), s
);
381 BOOST_CHECK_EQUAL(fmin(s
, val
), s
);
382 BOOST_CHECK_EQUAL(fmin(val
* 2, s
), s
);
383 BOOST_CHECK_EQUAL(fmin(val
, s
* 2), s
* 2);
384 BOOST_CHECK_EQUAL(fmin(val
* 2, s
* 2), s
* 2);
386 BOOST_CHECK_EQUAL(fmax(val
, 2), val
);
387 BOOST_CHECK_EQUAL(fmax(val
, 2.0), val
);
388 BOOST_CHECK_EQUAL(fmax(20, s
), val
);
389 BOOST_CHECK_EQUAL(fmax(20.0, s
), val
);
390 BOOST_CHECK_EQUAL(fmin(val
, 2), s
);
391 BOOST_CHECK_EQUAL(fmin(val
, 2.0), s
);
392 BOOST_CHECK_EQUAL(fmin(20, s
), s
);
393 BOOST_CHECK_EQUAL(fmin(20.0, s
), s
);
394 if (std::numeric_limits
<T
>::has_quiet_NaN
)
396 BOOST_CHECK_EQUAL(fmax(val
, std::numeric_limits
<T
>::quiet_NaN()), val
);
397 BOOST_CHECK_EQUAL(fmax(std::numeric_limits
<T
>::quiet_NaN(), val
), val
);
398 BOOST_CHECK_EQUAL(fmin(val
, std::numeric_limits
<T
>::quiet_NaN()), val
);
399 BOOST_CHECK_EQUAL(fmin(std::numeric_limits
<T
>::quiet_NaN(), val
), val
);
401 if (std::numeric_limits
<double>::has_quiet_NaN
)
403 BOOST_CHECK_EQUAL(fmax(val
, std::numeric_limits
<double>::quiet_NaN()), val
);
404 BOOST_CHECK_EQUAL(fmax(std::numeric_limits
<double>::quiet_NaN(), val
), val
);
405 BOOST_CHECK_EQUAL(fmin(val
, std::numeric_limits
<double>::quiet_NaN()), val
);
406 BOOST_CHECK_EQUAL(fmin(std::numeric_limits
<double>::quiet_NaN(), val
), val
);
412 test_less(s
+ 0, val
);
413 test_less(s
, val
* 1);
414 test_less(s
* 1, val
* 1);
415 test_less(s
* 1, 20);
416 test_less(s
+ 2, val
* 2);
418 test_equal(val
, val
);
421 test_equal(val
+ 0, val
);
422 test_equal(val
, val
* 1);
423 test_equal(val
* 1, val
* 1);
424 test_equal(val
* 1, 20);
425 test_equal(val
* 20, val
* 20);
427 if (std::numeric_limits
<T
>::has_quiet_NaN
)
429 s
= std::numeric_limits
<T
>::quiet_NaN();
430 test_unordered(s
, val
);
431 test_unordered(s
, 20);
432 test_unordered(s
+ 0, val
);
433 test_unordered(s
, val
* 1);
434 test_unordered(s
* 1, val
* 1);
435 test_unordered(s
* 1, 20);
436 test_unordered(s
+ 2, val
* 2);
437 if (std::numeric_limits
<double>::has_quiet_NaN
)
439 double n
= std::numeric_limits
<double>::quiet_NaN();
440 test_unordered(n
, val
);
444 T tol
= 8 * std::numeric_limits
<T
>::epsilon();
446 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
447 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
448 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
449 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
450 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
451 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
452 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, s
* 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
453 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
454 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
455 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s
* 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
456 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s
* 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
458 BOOST_CHECK_CLOSE_FRACTION(lgamma(val
), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol
);
459 BOOST_CHECK_CLOSE_FRACTION(lgamma(val
+ 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol
);
461 BOOST_CHECK_EQUAL(lrint(val
), 20);
462 BOOST_CHECK_EQUAL(lrint(val
* 2), 40);
463 BOOST_CHECK_EQUAL(llrint(val
), 20);
464 BOOST_CHECK_EQUAL(llrint(val
* 2), 40);
467 BOOST_CHECK_CLOSE_FRACTION(log1p(val
), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol
);
468 BOOST_CHECK_CLOSE_FRACTION(log1p(val
+ 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol
);
470 BOOST_CHECK_CLOSE_FRACTION(T(log2(val
)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol
);
471 BOOST_CHECK_CLOSE_FRACTION(T(log2(val
+ 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol
);
473 BOOST_CHECK_EQUAL(T(nearbyint(val
)), 20);
474 BOOST_CHECK_EQUAL(T(nearbyint(val
+ 0.25)), 20);
475 BOOST_CHECK_EQUAL(T(rint(val
)), 20);
476 BOOST_CHECK_EQUAL(T(rint(val
+ 0.25)), 20);
478 BOOST_CHECK_GT(nextafter(val
, T(200)), val
);
479 BOOST_CHECK_GT(nextafter(val
+ 0, T(200)), val
);
480 BOOST_CHECK_GT(nextafter(val
+ 0, T(200) + 1), val
);
481 BOOST_CHECK_GT(nextafter(val
, T(200) + 1), val
);
483 BOOST_CHECK_GT(nexttoward(val
, T(200)), val
);
484 BOOST_CHECK_GT(nexttoward(val
+ 0, T(200)), val
);
485 BOOST_CHECK_GT(nexttoward(val
+ 0, T(200) + 1), val
);
486 BOOST_CHECK_GT(nexttoward(val
, T(200) + 1), val
);
490 BOOST_CHECK_EQUAL(T(remainder(val
, s
)), 1);
491 BOOST_CHECK_EQUAL(T(remainder(val
, 5)), 1);
492 BOOST_CHECK_EQUAL(T(remainder(21, s
)), 1);
493 BOOST_CHECK_EQUAL(T(remainder(val
* 1, s
)), 1);
494 BOOST_CHECK_EQUAL(T(remainder(val
* 1, s
* 1)), 1);
495 BOOST_CHECK_EQUAL(T(remainder(val
, s
* 1)), 1);
496 BOOST_CHECK_EQUAL(T(remainder(val
* 1, 5)), 1);
497 BOOST_CHECK_EQUAL(T(remainder(21, s
* 1)), 1);
499 BOOST_CHECK_EQUAL(T(remquo(val
, s
, &i
)), 1);
500 BOOST_CHECK_EQUAL(i
, 4);
502 BOOST_CHECK_EQUAL(T(remquo(val
, 5, &i
)), 1);
503 BOOST_CHECK_EQUAL(i
, 4);
505 BOOST_CHECK_EQUAL(T(remquo(21, s
, &i
)), 1);
506 BOOST_CHECK_EQUAL(i
, 4);
508 BOOST_CHECK_EQUAL(T(remquo(val
* 1, s
, &i
)), 1);
509 BOOST_CHECK_EQUAL(i
, 4);
511 BOOST_CHECK_EQUAL(T(remquo(val
* 1, s
* 1, &i
)), 1);
512 BOOST_CHECK_EQUAL(i
, 4);
514 BOOST_CHECK_EQUAL(T(remquo(val
, s
* 1, &i
)), 1);
515 BOOST_CHECK_EQUAL(i
, 4);
517 BOOST_CHECK_EQUAL(T(remquo(val
* 1, 5, &i
)), 1);
518 BOOST_CHECK_EQUAL(i
, 4);
520 BOOST_CHECK_EQUAL(T(remquo(21, s
* 1, &i
)), 1);
521 BOOST_CHECK_EQUAL(i
, 4);
525 BOOST_CHECK_CLOSE_FRACTION(tgamma(val
), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol
);
526 BOOST_CHECK_CLOSE_FRACTION(tgamma(val
+ 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol
);
528 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol
);
529 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
+ 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol
);
531 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
)), T(32768uL), tol
);
532 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
+ 1)), T(65536uL), tol
);
534 i
= fpclassify(val
) + isgreaterequal(val
, s
) + islessequal(val
, s
) + isnan(val
) + isunordered(val
, s
) + isfinite(val
) + isinf(val
) + islessgreater(val
, s
) + isnormal(val
) + signbit(val
) + isgreater(val
, s
) + isless(val
, s
);
540 // use these macros as proxies for determining C99 support:
541 #if defined(FP_ILOGB0) && defined(FP_INFINITE)
543 // These tests verify that our function overloads for Boost.Multiprecision
544 // don't do anything nasty to the std:: overloads for built in types:
547 using namespace boost::multiprecision
;
548 //using namespace boost::math;
550 T
a(2), b(0.3f
), c(4), result(0);
555 result
+= fmod(a
, b
);
557 result
+= remquo(a
, b
, &i
);
560 result
+= frexp(a
, &i
);
565 result
+= hypot(a
, b
);
571 result
+= modf(a
, &b
);
572 result
+= scalbln(a
, i
);
575 result
+= ldexp(a
, i
);
576 result
+= scalbn(a
, i
);
581 result
+= atan2(a
, c
);
586 result
+= fdim(a
, b
);
587 result
+= llround(a
);
588 result
+= nearbyint(a
);
593 result
+= nextafter(a
, b
);
596 result
+= fma(a
, b
, c
);
598 result
+= nexttoward(a
, b
);
600 result
+= copysign(a
, b
);
601 result
+= fmax(a
, b
);
606 result
+= fmin(a
, b
);
608 result
+= remainder(a
, b
);
610 result
+= (min
)(a
, b
);
611 result
+= (max
)(a
, b
);
613 #if !BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 60000)
615 i
= fpclassify(a
) + isgreaterequal(a
, b
) + islessequal(a
, b
) + isnan(a
) + isunordered(a
, b
) + isfinite(a
) + isinf(a
) + islessgreater(a
, b
) + isnormal(a
) + signbit(a
) + isgreater(a
, b
) + isless(a
, b
);
621 bool type_sets_errno(const T
&)
626 template <unsigned Digits10
, boost::multiprecision::mpfr_allocation_type AllocateType
, boost::multiprecision::expression_template_option ExpressionTemplates
>
627 bool type_sets_errno(const boost::multiprecision::number
<boost::multiprecision::mpfr_float_backend
<Digits10
, AllocateType
>, ExpressionTemplates
>&)
632 #ifdef TEST_MPFR_DEBUG_ADAPTOR
633 template <unsigned Digits10
, boost::multiprecision::mpfr_allocation_type AllocateType
, boost::multiprecision::expression_template_option ExpressionTemplates
>
634 bool type_sets_errno(const boost::multiprecision::number
<boost::multiprecision::debug_adaptor
<boost::multiprecision::mpfr_float_backend
<Digits10
, AllocateType
> >, ExpressionTemplates
>&)
639 #ifdef TEST_MPFI_DEBUG_ADAPTOR
640 template <unsigned Digits10
, boost::multiprecision::expression_template_option ExpressionTemplates
>
641 bool type_sets_errno(const boost::multiprecision::number
<boost::multiprecision::debug_adaptor
<boost::multiprecision::mpfi_float_backend
<Digits10
> >, ExpressionTemplates
>&)
646 #ifdef TEST_MPFR_LOGGED_ADAPTOR
647 template <unsigned Digits10
, boost::multiprecision::mpfr_allocation_type AllocateType
, boost::multiprecision::expression_template_option ExpressionTemplates
>
648 bool type_sets_errno(const boost::multiprecision::number
<boost::multiprecision::logged_adaptor
<boost::multiprecision::mpfr_float_backend
<Digits10
, AllocateType
> >, ExpressionTemplates
>&)
653 #ifdef TEST_MPFI_LOGGED_ADAPTOR
654 template <unsigned Digits10
, boost::multiprecision::expression_template_option ExpressionTemplates
>
655 bool type_sets_errno(const boost::multiprecision::number
<boost::multiprecision::logged_adaptor
<boost::multiprecision::mpfi_float_backend
<Digits10
> >, ExpressionTemplates
>&)
661 bool type_sets_errno(const boost::multiprecision::float128
&)
668 typename
std::enable_if
<std::numeric_limits
<T
>::is_specialized
>::type
check_invalid(const T
& val
)
670 if (std::numeric_limits
<T
>::has_quiet_NaN
)
672 BOOST_CHECK(isnan(val
));
676 BOOST_CHECK_EQUAL(val
, 0);
678 if (type_sets_errno(val
))
679 BOOST_CHECK_EQUAL(errno
, EDOM
);
684 typename
std::enable_if
<!std::numeric_limits
<T
>::is_specialized
>::type
check_invalid(const T
& val
)
686 check_invalid(static_cast<typename
T::result_type
>(val
));
690 void check_erange(const T
& val
)
692 if (type_sets_errno(val
))
693 BOOST_CHECK_EQUAL(errno
, ERANGE
);
698 void test_c99_appendix_F()
701 // Tests conformance to non-normative appendix F.9.1 of C99, basically how to handle
702 // special cases, infinities and NaN's.
705 T tol
= std::numeric_limits
<T
>::epsilon();
709 BOOST_CHECK_EQUAL(val
, 0);
710 BOOST_CHECK(signbit(val
) == 0);
712 check_invalid(acos(arg
));
714 check_invalid(acos(arg
));
715 if (std::numeric_limits
<T
>::has_infinity
)
717 arg
= std::numeric_limits
<T
>::infinity();
718 check_invalid(acos(arg
));
719 arg
= -std::numeric_limits
<T
>::infinity();
720 check_invalid(acos(arg
));
722 if (std::numeric_limits
<T
>::has_quiet_NaN
)
724 arg
= std::numeric_limits
<T
>::quiet_NaN();
725 check_invalid(acos(arg
));
726 arg
= -std::numeric_limits
<T
>::quiet_NaN();
727 check_invalid(acos(arg
));
732 BOOST_CHECK_EQUAL(val
, 0);
733 BOOST_CHECK(signbit(val
) == 0);
738 BOOST_CHECK_EQUAL(val
, 0);
739 BOOST_CHECK(signbit(val
));
742 check_invalid(asin(arg
));
744 check_invalid(asin(arg
));
745 if (std::numeric_limits
<T
>::has_infinity
)
747 arg
= std::numeric_limits
<T
>::infinity();
748 check_invalid(asin(arg
));
749 arg
= -std::numeric_limits
<T
>::infinity();
750 check_invalid(asin(arg
));
752 if (std::numeric_limits
<T
>::has_quiet_NaN
)
754 arg
= std::numeric_limits
<T
>::quiet_NaN();
755 check_invalid(asin(arg
));
756 arg
= -std::numeric_limits
<T
>::quiet_NaN();
757 check_invalid(asin(arg
));
762 BOOST_CHECK_EQUAL(val
, 0);
763 BOOST_CHECK(signbit(val
) == 0);
768 BOOST_CHECK_EQUAL(val
, 0);
769 BOOST_CHECK(signbit(val
));
771 if (std::numeric_limits
<T
>::has_infinity
)
773 arg
= std::numeric_limits
<T
>::infinity();
775 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
776 arg
= -std::numeric_limits
<T
>::infinity();
778 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
780 if (std::numeric_limits
<T
>::has_quiet_NaN
)
782 arg
= std::numeric_limits
<T
>::quiet_NaN();
783 check_invalid(asin(arg
));
784 arg
= -std::numeric_limits
<T
>::quiet_NaN();
785 check_invalid(asin(arg
));
790 val
= atan2(arg
, arg2
);
791 BOOST_CHECK_EQUAL(val
, 0);
792 BOOST_CHECK(signbit(val
) == 0);
796 val
= atan2(arg
, arg2
);
797 BOOST_CHECK_EQUAL(val
, 0);
798 BOOST_CHECK(signbit(val
));
804 val
= atan2(arg
, arg2
);
805 BOOST_CHECK_EQUAL(val
, boost::math::constants::pi
<T
>());
806 BOOST_CHECK(signbit(val
) == 0);
808 val
= atan2(arg
, arg2
);
809 BOOST_CHECK_EQUAL(val
, -boost::math::constants::pi
<T
>());
810 BOOST_CHECK(signbit(val
));
814 val
= atan2(arg
, arg2
);
815 BOOST_CHECK_EQUAL(val
, boost::math::constants::pi
<T
>());
819 val
= atan2(arg
, arg2
);
820 BOOST_CHECK_EQUAL(val
, -boost::math::constants::pi
<T
>());
824 val
= atan2(arg
, arg2
);
825 BOOST_CHECK_EQUAL(val
, 0);
826 BOOST_CHECK(signbit(val
) == 0);
830 val
= atan2(arg
, arg2
);
831 BOOST_CHECK_EQUAL(val
, 0);
832 BOOST_CHECK(signbit(val
));
836 val
= atan2(arg
, arg2
);
837 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
841 val
= atan2(arg
, arg2
);
842 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
846 val
= atan2(arg
, arg2
);
847 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
851 val
= atan2(arg
, arg2
);
852 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
854 if (std::numeric_limits
<T
>::has_infinity
)
857 arg2
= -std::numeric_limits
<T
>::infinity();
858 val
= atan2(arg
, arg2
);
859 BOOST_CHECK_EQUAL(val
, boost::math::constants::pi
<T
>());
861 val
= atan2(arg
, arg2
);
862 BOOST_CHECK_EQUAL(val
, -boost::math::constants::pi
<T
>());
864 arg2
= std::numeric_limits
<T
>::infinity();
865 val
= atan2(arg
, arg2
);
866 BOOST_CHECK_EQUAL(val
, 0);
867 BOOST_CHECK(signbit(val
) == 0);
871 val
= atan2(arg
, arg2
);
872 BOOST_CHECK_EQUAL(val
, 0);
873 BOOST_CHECK(signbit(val
));
875 arg
= std::numeric_limits
<T
>::infinity();
877 val
= atan2(arg
, arg2
);
878 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
880 val
= atan2(arg
, arg2
);
881 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
882 arg
= std::numeric_limits
<T
>::infinity();
884 val
= atan2(arg
, arg2
);
885 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
887 val
= atan2(arg
, arg2
);
888 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
889 arg
= std::numeric_limits
<T
>::infinity();
890 arg2
= -std::numeric_limits
<T
>::infinity();
891 val
= atan2(arg
, arg2
);
892 BOOST_CHECK_CLOSE_FRACTION(val
, boost::math::constants::three_quarters_pi
<T
>(), tol
);
894 val
= atan2(arg
, arg2
);
895 BOOST_CHECK_CLOSE_FRACTION(val
, -boost::math::constants::three_quarters_pi
<T
>(), tol
);
896 arg
= std::numeric_limits
<T
>::infinity();
897 arg2
= std::numeric_limits
<T
>::infinity();
898 val
= atan2(arg
, arg2
);
899 BOOST_CHECK_CLOSE_FRACTION(val
, ldexp(boost::math::constants::pi
<T
>(), -2), tol
);
901 val
= atan2(arg
, arg2
);
902 BOOST_CHECK_CLOSE_FRACTION(val
, -ldexp(boost::math::constants::pi
<T
>(), -2), tol
);
903 if (std::numeric_limits
<T
>::has_quiet_NaN
)
905 arg
= std::numeric_limits
<T
>::quiet_NaN();
907 check_invalid(atan2(arg
, arg2
));
908 std::swap(arg
, arg2
);
909 check_invalid(atan2(arg
, arg2
));
910 arg
= std::numeric_limits
<T
>::quiet_NaN();
911 check_invalid(atan2(arg
, arg2
));
917 BOOST_CHECK_EQUAL(val
, 1);
919 BOOST_CHECK_EQUAL(val
, 1);
920 if (std::numeric_limits
<T
>::has_infinity
)
922 arg
= std::numeric_limits
<T
>::infinity();
923 check_invalid(cos(arg
));
924 arg
= -std::numeric_limits
<T
>::infinity();
925 check_invalid(cos(arg
));
927 if (std::numeric_limits
<T
>::has_quiet_NaN
)
929 arg
= std::numeric_limits
<T
>::quiet_NaN();
930 check_invalid(cos(arg
));
931 arg
= -std::numeric_limits
<T
>::quiet_NaN();
932 check_invalid(cos(arg
));
937 BOOST_CHECK_EQUAL(val
, 0);
938 BOOST_CHECK(signbit(val
) == 0);
943 BOOST_CHECK_EQUAL(val
, 0);
944 BOOST_CHECK(signbit(val
));
946 if (std::numeric_limits
<T
>::has_infinity
)
948 arg
= std::numeric_limits
<T
>::infinity();
949 check_invalid(sin(arg
));
950 arg
= -std::numeric_limits
<T
>::infinity();
951 check_invalid(sin(arg
));
953 if (std::numeric_limits
<T
>::has_quiet_NaN
)
955 arg
= std::numeric_limits
<T
>::quiet_NaN();
956 check_invalid(sin(arg
));
957 arg
= -std::numeric_limits
<T
>::quiet_NaN();
958 check_invalid(sin(arg
));
963 BOOST_CHECK_EQUAL(val
, 0);
964 BOOST_CHECK(signbit(val
) == 0);
969 BOOST_CHECK_EQUAL(val
, 0);
970 BOOST_CHECK(signbit(val
));
972 if (std::numeric_limits
<T
>::has_infinity
)
974 arg
= std::numeric_limits
<T
>::infinity();
975 check_invalid(tan(arg
));
976 arg
= -std::numeric_limits
<T
>::infinity();
977 check_invalid(tan(arg
));
979 if (std::numeric_limits
<T
>::has_quiet_NaN
)
981 arg
= std::numeric_limits
<T
>::quiet_NaN();
982 check_invalid(tan(arg
));
983 arg
= -std::numeric_limits
<T
>::quiet_NaN();
984 check_invalid(tan(arg
));
989 BOOST_CHECK_EQUAL(val
, 0);
990 BOOST_CHECK(signbit(val
) == 0);
992 check_invalid(acosh(arg
));
993 if (std::numeric_limits
<T
>::has_infinity
)
995 arg
= std::numeric_limits
<T
>::infinity();
997 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
999 arg
= -std::numeric_limits
<T
>::infinity();
1000 check_invalid(acosh(arg
));
1002 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1004 arg
= std::numeric_limits
<T
>::quiet_NaN();
1005 check_invalid(acosh(arg
));
1006 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1007 check_invalid(acosh(arg
));
1012 BOOST_CHECK_EQUAL(val
, 0);
1013 BOOST_CHECK(signbit(val
) == 0);
1018 BOOST_CHECK_EQUAL(val
, 0);
1019 BOOST_CHECK(signbit(val
));
1021 if (std::numeric_limits
<T
>::has_infinity
)
1023 arg
= std::numeric_limits
<T
>::infinity();
1025 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1027 arg
= -std::numeric_limits
<T
>::infinity();
1029 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1031 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1033 arg
= std::numeric_limits
<T
>::quiet_NaN();
1034 check_invalid(asinh(arg
));
1035 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1036 check_invalid(asinh(arg
));
1041 BOOST_CHECK_EQUAL(val
, 0);
1042 BOOST_CHECK(signbit(val
) == 0);
1047 BOOST_CHECK_EQUAL(val
, 0);
1048 BOOST_CHECK(signbit(val
));
1051 check_invalid(atanh(arg
));
1053 check_invalid(atanh(arg
));
1055 if (std::numeric_limits
<T
>::has_infinity
)
1059 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1060 BOOST_CHECK(signbit(val
) == 0);
1064 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1065 BOOST_CHECK(signbit(val
));
1068 arg
= std::numeric_limits
<T
>::infinity();
1069 check_invalid(atanh(arg
));
1070 arg
= -std::numeric_limits
<T
>::infinity();
1071 check_invalid(atanh(arg
));
1073 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1075 arg
= std::numeric_limits
<T
>::quiet_NaN();
1076 check_invalid(atanh(arg
));
1077 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1078 check_invalid(atanh(arg
));
1083 BOOST_CHECK_EQUAL(val
, 1);
1088 BOOST_CHECK_EQUAL(val
, 1);
1090 if (std::numeric_limits
<T
>::has_infinity
)
1092 arg
= (std::numeric_limits
<T
>::max
)();
1094 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1097 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1098 arg
= std::numeric_limits
<T
>::infinity();
1100 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1103 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1105 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1107 arg
= std::numeric_limits
<T
>::quiet_NaN();
1108 check_invalid(cosh(arg
));
1109 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1110 check_invalid(cosh(arg
));
1115 BOOST_CHECK_EQUAL(val
, 0);
1116 BOOST_CHECK(signbit(val
) == 0);
1121 BOOST_CHECK_EQUAL(val
, 0);
1122 BOOST_CHECK(signbit(val
));
1124 if (std::numeric_limits
<T
>::has_infinity
)
1126 arg
= (std::numeric_limits
<T
>::max
)();
1128 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1131 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1132 arg
= std::numeric_limits
<T
>::infinity();
1134 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1137 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1139 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1141 arg
= std::numeric_limits
<T
>::quiet_NaN();
1142 check_invalid(sinh(arg
));
1143 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1144 check_invalid(sinh(arg
));
1149 BOOST_CHECK_EQUAL(val
, 0);
1150 BOOST_CHECK(signbit(val
) == 0);
1155 BOOST_CHECK_EQUAL(val
, 0);
1156 BOOST_CHECK(signbit(val
));
1158 arg
= (std::numeric_limits
<T
>::max
)();
1160 BOOST_CHECK_EQUAL(val
, 1);
1163 BOOST_CHECK_EQUAL(val
, -1);
1164 if (std::numeric_limits
<T
>::has_infinity
)
1166 arg
= std::numeric_limits
<T
>::infinity();
1168 BOOST_CHECK_EQUAL(val
, 1);
1171 BOOST_CHECK_EQUAL(val
, -1);
1173 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1175 arg
= std::numeric_limits
<T
>::quiet_NaN();
1176 check_invalid(tanh(arg
));
1177 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1178 check_invalid(tanh(arg
));
1183 BOOST_CHECK_EQUAL(val
, 1);
1188 BOOST_CHECK_EQUAL(val
, 1);
1190 if (std::numeric_limits
<T
>::has_infinity
)
1192 arg
= std::numeric_limits
<T
>::infinity();
1194 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1197 BOOST_CHECK_EQUAL(val
, 0);
1198 BOOST_CHECK(signbit(val
) == 0);
1199 arg
= (std::numeric_limits
<T
>::max
)();
1201 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1204 BOOST_CHECK_EQUAL(val
, 0);
1205 BOOST_CHECK(signbit(val
) == 0);
1207 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1209 arg
= std::numeric_limits
<T
>::quiet_NaN();
1210 check_invalid(exp(arg
));
1211 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1212 check_invalid(exp(arg
));
1217 BOOST_CHECK_EQUAL(val
, 1);
1222 BOOST_CHECK_EQUAL(val
, 1);
1224 if (std::numeric_limits
<T
>::has_infinity
)
1226 arg
= std::numeric_limits
<T
>::infinity();
1228 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1231 BOOST_CHECK_EQUAL(val
, 0);
1232 BOOST_CHECK(signbit(val
) == 0);
1233 arg
= (std::numeric_limits
<T
>::max
)();
1235 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1238 BOOST_CHECK_EQUAL(val
, 0);
1239 BOOST_CHECK(signbit(val
) == 0);
1241 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1243 arg
= std::numeric_limits
<T
>::quiet_NaN();
1244 check_invalid(exp2(arg
));
1245 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1246 check_invalid(exp2(arg
));
1251 BOOST_CHECK_EQUAL(val
, 0);
1252 BOOST_CHECK(signbit(val
) == 0);
1257 BOOST_CHECK_EQUAL(val
, 0);
1258 BOOST_CHECK(signbit(val
));
1260 if (std::numeric_limits
<T
>::has_infinity
)
1262 arg
= std::numeric_limits
<T
>::infinity();
1264 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1267 BOOST_CHECK_EQUAL(val
, -1);
1268 arg
= (std::numeric_limits
<T
>::max
)();
1270 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1273 BOOST_CHECK_EQUAL(val
, -1);
1275 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1277 arg
= std::numeric_limits
<T
>::quiet_NaN();
1278 check_invalid(expm1(arg
));
1279 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1280 check_invalid(expm1(arg
));
1285 val
= frexp(arg
, &ival
);
1286 BOOST_CHECK_EQUAL(val
, 0);
1287 BOOST_CHECK_EQUAL(ival
, 0);
1288 BOOST_CHECK(signbit(val
) == 0);
1292 val
= frexp(arg
, &ival
);
1293 BOOST_CHECK_EQUAL(val
, 0);
1294 BOOST_CHECK(signbit(val
));
1295 BOOST_CHECK(signbit(val
));
1297 if (std::numeric_limits
<T
>::has_infinity
)
1299 arg
= std::numeric_limits
<T
>::infinity();
1300 val
= frexp(arg
, &ival
);
1301 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1303 val
= frexp(arg
, &ival
);
1304 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1306 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1308 arg
= std::numeric_limits
<T
>::quiet_NaN();
1309 val
= frexp(arg
, &ival
);
1310 BOOST_CHECK(isnan(val
));
1313 typename
T::backend_type::exponent_type eval
;
1314 typename
T::backend_type::exponent_type fp_ilogb0
= (std::numeric_limits
<typename
T::backend_type::exponent_type
>::min
)();
1315 typename
T::backend_type::exponent_type fp_ilogbnan
=
1317 FP_ILOGBNAN
< 0 ? (std::numeric_limits
<typename
T::backend_type::exponent_type
>::min
)() : (std::numeric_limits
<typename
T::backend_type::exponent_type
>::max
)();
1324 BOOST_CHECK_EQUAL(eval
, fp_ilogb0
);
1325 if (std::numeric_limits
<T
>::has_infinity
)
1327 arg
= std::numeric_limits
<T
>::infinity();
1329 BOOST_CHECK_EQUAL(eval
, (std::numeric_limits
<typename
T::backend_type::exponent_type
>::max
)());
1332 BOOST_CHECK_EQUAL(eval
, (std::numeric_limits
<typename
T::backend_type::exponent_type
>::max
)());
1334 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1336 arg
= std::numeric_limits
<T
>::quiet_NaN();
1338 BOOST_CHECK_EQUAL(eval
, fp_ilogbnan
);
1343 BOOST_CHECK_EQUAL(val
, 0);
1344 BOOST_CHECK(signbit(val
) == 0);
1345 if (std::numeric_limits
<T
>::has_infinity
)
1349 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1355 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1359 check_invalid(log(arg
));
1360 arg
= -std::numeric_limits
<T
>::infinity();
1361 check_invalid(log(arg
));
1362 arg
= std::numeric_limits
<T
>::infinity();
1364 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1366 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1368 arg
= std::numeric_limits
<T
>::quiet_NaN();
1369 check_invalid(log(arg
));
1370 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1371 check_invalid(log(arg
));
1376 BOOST_CHECK_EQUAL(val
, 0);
1377 BOOST_CHECK(signbit(val
) == 0);
1378 if (std::numeric_limits
<T
>::has_infinity
)
1382 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1388 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1392 check_invalid(log10(arg
));
1393 arg
= -std::numeric_limits
<T
>::infinity();
1394 check_invalid(log10(arg
));
1395 arg
= std::numeric_limits
<T
>::infinity();
1397 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1399 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1401 arg
= std::numeric_limits
<T
>::quiet_NaN();
1402 check_invalid(log10(arg
));
1403 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1404 check_invalid(log10(arg
));
1409 BOOST_CHECK_EQUAL(val
, 0);
1410 BOOST_CHECK(signbit(val
) == 0);
1415 BOOST_CHECK_EQUAL(val
, 0);
1416 BOOST_CHECK(signbit(val
));
1418 if (std::numeric_limits
<T
>::has_infinity
)
1422 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1425 check_invalid(log1p(arg
));
1426 arg
= -std::numeric_limits
<T
>::infinity();
1427 check_invalid(log1p(arg
));
1428 arg
= std::numeric_limits
<T
>::infinity();
1430 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1432 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1434 arg
= std::numeric_limits
<T
>::quiet_NaN();
1435 check_invalid(log1p(arg
));
1436 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1437 check_invalid(log1p(arg
));
1442 BOOST_CHECK_EQUAL(val
, 0);
1443 BOOST_CHECK(signbit(val
) == 0);
1444 if (std::numeric_limits
<T
>::has_infinity
)
1448 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1454 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1458 check_invalid(log2(arg
));
1459 arg
= -std::numeric_limits
<T
>::infinity();
1460 check_invalid(log2(arg
));
1461 arg
= std::numeric_limits
<T
>::infinity();
1463 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1465 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1467 arg
= std::numeric_limits
<T
>::quiet_NaN();
1468 check_invalid(log2(arg
));
1469 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1470 check_invalid(log2(arg
));
1473 if (std::numeric_limits
<T
>::has_infinity
)
1477 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1483 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1486 arg
= std::numeric_limits
<T
>::infinity();
1488 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1489 arg
= -std::numeric_limits
<T
>::infinity();
1491 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1493 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1495 arg
= std::numeric_limits
<T
>::quiet_NaN();
1496 check_invalid(logb(arg
));
1497 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1498 check_invalid(logb(arg
));
1502 val
= scalbn(arg
, 2);
1503 BOOST_CHECK_EQUAL(val
, 0);
1504 BOOST_CHECK(signbit(val
) == 0);
1508 val
= scalbn(arg
, 2);
1509 BOOST_CHECK_EQUAL(val
, 0);
1510 BOOST_CHECK(signbit(val
));
1512 if (std::numeric_limits
<T
>::has_infinity
)
1514 arg
= std::numeric_limits
<T
>::infinity();
1515 val
= scalbn(arg
, -100);
1516 BOOST_CHECK_EQUAL(val
, arg
);
1518 val
= scalbn(arg
, -100);
1519 BOOST_CHECK_EQUAL(val
, arg
);
1524 BOOST_CHECK_EQUAL(val
, 0);
1525 BOOST_CHECK(signbit(val
) == 0);
1530 BOOST_CHECK_EQUAL(val
, 0);
1531 BOOST_CHECK(signbit(val
));
1533 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1535 // This test fails with early implementations of libquadmath - not our issue!
1537 if (std::numeric_limits
<T
>::has_infinity
)
1539 arg
= std::numeric_limits
<T
>::infinity();
1541 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1542 arg
= -std::numeric_limits
<T
>::infinity();
1544 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1547 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1549 arg
= std::numeric_limits
<T
>::quiet_NaN();
1550 check_invalid(cbrt(arg
));
1551 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1552 check_invalid(cbrt(arg
));
1557 BOOST_CHECK_EQUAL(val
, 0);
1558 BOOST_CHECK(signbit(val
) == 0);
1563 BOOST_CHECK_EQUAL(val
, 0);
1564 BOOST_CHECK(signbit(val
) == 0);
1566 if (std::numeric_limits
<T
>::has_infinity
)
1568 arg
= std::numeric_limits
<T
>::infinity();
1570 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1571 arg
= -std::numeric_limits
<T
>::infinity();
1573 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1578 val
= hypot(arg
, arg2
);
1579 BOOST_CHECK_EQUAL(val
, arg
);
1581 val
= hypot(arg
, arg2
);
1582 BOOST_CHECK_EQUAL(val
, arg
);
1583 if (std::numeric_limits
<T
>::has_infinity
)
1585 arg
= std::numeric_limits
<T
>::infinity();
1587 val
= hypot(arg
, arg2
);
1588 BOOST_CHECK_EQUAL(val
, arg
);
1590 val
= hypot(arg
, arg2
);
1591 BOOST_CHECK_EQUAL(val
, -arg
);
1592 arg2
= std::numeric_limits
<T
>::quiet_NaN();
1593 val
= hypot(arg
, arg2
);
1594 BOOST_CHECK_EQUAL(val
, -arg
);
1596 val
= hypot(arg
, arg2
);
1597 BOOST_CHECK_EQUAL(val
, arg
);
1600 if (std::numeric_limits
<T
>::has_infinity
)
1604 val
= pow(arg
, arg2
);
1605 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1610 val
= pow(arg
, arg2
);
1611 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1616 val
= pow(arg
, arg2
);
1617 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1622 val
= pow(arg
, arg2
);
1623 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1628 val
= pow(arg
, arg2
);
1629 BOOST_CHECK_EQUAL(val
, 0);
1630 BOOST_CHECK(signbit(val
) == 0);
1634 val
= pow(arg
, arg2
);
1635 BOOST_CHECK_EQUAL(val
, 0);
1636 BOOST_CHECK(signbit(val
));
1640 val
= pow(arg
, arg2
);
1641 BOOST_CHECK_EQUAL(val
, 0);
1642 BOOST_CHECK(signbit(val
) == 0);
1646 val
= pow(arg
, arg2
);
1647 BOOST_CHECK_EQUAL(val
, 0);
1648 BOOST_CHECK(signbit(val
) == 0);
1651 arg2
= std::numeric_limits
<T
>::infinity();
1652 val
= pow(arg
, arg2
);
1653 BOOST_CHECK_EQUAL(val
, 1);
1654 arg2
= -std::numeric_limits
<T
>::infinity();
1655 val
= pow(arg
, arg2
);
1656 BOOST_CHECK_EQUAL(val
, 1);
1659 val
= pow(arg
, arg2
);
1660 BOOST_CHECK_EQUAL(val
, 1);
1661 arg2
= std::numeric_limits
<T
>::infinity();
1662 val
= pow(arg
, arg2
);
1663 BOOST_CHECK_EQUAL(val
, 1);
1664 arg2
= -std::numeric_limits
<T
>::infinity();
1665 val
= pow(arg
, arg2
);
1666 BOOST_CHECK_EQUAL(val
, 1);
1667 arg2
= std::numeric_limits
<T
>::quiet_NaN();
1668 val
= pow(arg
, arg2
);
1669 BOOST_CHECK_EQUAL(val
, 1);
1672 val
= pow(arg
, arg2
);
1673 BOOST_CHECK_EQUAL(val
, 1);
1675 val
= pow(arg
, arg2
);
1676 BOOST_CHECK_EQUAL(val
, 1);
1677 arg
= std::numeric_limits
<T
>::infinity();
1678 val
= pow(arg
, arg2
);
1679 BOOST_CHECK_EQUAL(val
, 1);
1681 val
= pow(arg
, arg2
);
1682 BOOST_CHECK_EQUAL(val
, 1);
1683 arg
= std::numeric_limits
<T
>::quiet_NaN();
1684 val
= pow(arg
, arg2
);
1685 BOOST_CHECK_EQUAL(val
, 1);
1687 val
= pow(arg
, arg2
);
1688 BOOST_CHECK_EQUAL(val
, 1);
1690 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1694 check_invalid(pow(arg
, arg2
));
1696 if (std::numeric_limits
<T
>::has_infinity
)
1699 arg2
= -std::numeric_limits
<T
>::infinity();
1700 val
= pow(arg
, arg2
);
1701 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1703 val
= pow(arg
, arg2
);
1704 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1706 arg2
= -std::numeric_limits
<T
>::infinity();
1707 val
= pow(arg
, arg2
);
1708 BOOST_CHECK_EQUAL(val
, 0);
1710 val
= pow(arg
, arg2
);
1711 BOOST_CHECK_EQUAL(val
, 0);
1713 arg2
= std::numeric_limits
<T
>::infinity();
1714 val
= pow(arg
, arg2
);
1715 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1717 val
= pow(arg
, arg2
);
1718 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1719 arg
= -std::numeric_limits
<T
>::infinity();
1721 val
= pow(arg
, arg2
);
1722 BOOST_CHECK_EQUAL(val
, 0);
1724 BOOST_CHECK(signbit(val
));
1726 val
= pow(arg
, arg2
);
1727 BOOST_CHECK_EQUAL(val
, 0);
1728 BOOST_CHECK(signbit(val
) == 0);
1730 val
= pow(arg
, arg2
);
1731 BOOST_CHECK_EQUAL(val
, 0);
1732 BOOST_CHECK(signbit(val
) == 0);
1734 val
= pow(arg
, arg2
);
1735 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1737 val
= pow(arg
, arg2
);
1738 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1740 val
= pow(arg
, arg2
);
1741 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1744 val
= pow(arg
, arg2
);
1745 BOOST_CHECK_EQUAL(val
, 0);
1746 BOOST_CHECK(signbit(val
) == 0);
1748 val
= pow(arg
, arg2
);
1749 BOOST_CHECK_EQUAL(val
, 0);
1750 BOOST_CHECK(signbit(val
) == 0);
1752 val
= pow(arg
, arg2
);
1753 BOOST_CHECK_EQUAL(val
, 0);
1754 BOOST_CHECK(signbit(val
) == 0);
1756 val
= pow(arg
, arg2
);
1757 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1759 val
= pow(arg
, arg2
);
1760 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1762 val
= pow(arg
, arg2
);
1763 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1768 BOOST_CHECK_EQUAL(val
, 0);
1769 BOOST_CHECK(signbit(val
) == 0);
1774 BOOST_CHECK_EQUAL(val
, 0);
1775 BOOST_CHECK(signbit(val
));
1777 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1779 // This test fails with early implementations of libquadmath - not our issue!
1781 if (std::numeric_limits
<T
>::has_infinity
)
1783 arg
= std::numeric_limits
<T
>::infinity();
1785 BOOST_CHECK_EQUAL(val
, arg
);
1787 check_invalid(sqrt(arg
));
1790 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1792 arg
= std::numeric_limits
<T
>::quiet_NaN();
1793 check_invalid(sqrt(arg
));
1798 BOOST_CHECK_EQUAL(val
, 0);
1799 BOOST_CHECK(signbit(val
) == 0);
1804 BOOST_CHECK_EQUAL(val
, 0);
1805 BOOST_CHECK(signbit(val
));
1807 if (std::numeric_limits
<T
>::has_infinity
)
1809 arg
= std::numeric_limits
<T
>::infinity();
1811 BOOST_CHECK_EQUAL(val
, 1);
1814 BOOST_CHECK_EQUAL(val
, -1);
1816 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1818 arg
= std::numeric_limits
<T
>::quiet_NaN();
1819 check_invalid(erf(arg
));
1822 if (std::numeric_limits
<T
>::has_infinity
)
1824 arg
= std::numeric_limits
<T
>::infinity();
1826 BOOST_CHECK_EQUAL(val
, 0);
1827 BOOST_CHECK(signbit(val
) == 0);
1830 BOOST_CHECK_EQUAL(val
, 2);
1832 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1834 arg
= std::numeric_limits
<T
>::quiet_NaN();
1835 check_invalid(erfc(arg
));
1840 BOOST_CHECK_EQUAL(val
, 0);
1841 BOOST_CHECK(signbit(val
) == 0);
1844 BOOST_CHECK_EQUAL(val
, 0);
1845 BOOST_CHECK(signbit(val
) == 0);
1846 #if !defined(BOOST_MPFR_VERSION) || (BOOST_MPFR_VERSION > 30103)
1849 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1853 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1857 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1859 arg
= -std::numeric_limits
<T
>::infinity();
1861 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1863 arg
= std::numeric_limits
<T
>::infinity();
1865 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1866 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1868 arg
= std::numeric_limits
<T
>::quiet_NaN();
1869 check_invalid(lgamma(arg
));
1872 if (std::numeric_limits
<T
>::has_infinity
)
1876 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1882 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1886 check_invalid(tgamma(arg
));
1887 arg
= -std::numeric_limits
<T
>::infinity();
1888 check_invalid(tgamma(arg
));
1889 arg
= std::numeric_limits
<T
>::infinity();
1891 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1893 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1895 arg
= std::numeric_limits
<T
>::quiet_NaN();
1896 check_invalid(tgamma(arg
));
1901 BOOST_CHECK_EQUAL(val
, 0);
1902 BOOST_CHECK(signbit(val
) == 0);
1907 BOOST_CHECK_EQUAL(val
, 0);
1908 BOOST_CHECK(signbit(val
));
1910 if (std::numeric_limits
<T
>::has_infinity
)
1912 arg
= std::numeric_limits
<T
>::infinity();
1914 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1917 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1919 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1921 arg
= std::numeric_limits
<T
>::quiet_NaN();
1922 check_invalid(ceil(arg
));
1927 BOOST_CHECK_EQUAL(val
, 0);
1928 BOOST_CHECK(signbit(val
) == 0);
1933 BOOST_CHECK_EQUAL(val
, 0);
1934 BOOST_CHECK(signbit(val
));
1936 if (std::numeric_limits
<T
>::has_infinity
)
1938 arg
= std::numeric_limits
<T
>::infinity();
1940 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1943 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1945 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1947 arg
= std::numeric_limits
<T
>::quiet_NaN();
1948 check_invalid(floor(arg
));
1952 val
= nearbyint(arg
);
1953 BOOST_CHECK_EQUAL(val
, 0);
1954 BOOST_CHECK(signbit(val
) == 0);
1958 val
= nearbyint(arg
);
1959 BOOST_CHECK_EQUAL(val
, 0);
1960 BOOST_CHECK(signbit(val
));
1962 if (std::numeric_limits
<T
>::has_infinity
)
1964 arg
= std::numeric_limits
<T
>::infinity();
1965 val
= nearbyint(arg
);
1966 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1968 val
= nearbyint(arg
);
1969 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1971 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1973 arg
= std::numeric_limits
<T
>::quiet_NaN();
1974 check_invalid(nearbyint(arg
));
1979 BOOST_CHECK_EQUAL(val
, 0);
1980 BOOST_CHECK(signbit(val
) == 0);
1985 BOOST_CHECK_EQUAL(val
, 0);
1986 BOOST_CHECK(signbit(val
));
1988 if (std::numeric_limits
<T
>::has_infinity
)
1990 arg
= std::numeric_limits
<T
>::infinity();
1992 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1995 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1997 if (std::numeric_limits
<T
>::has_quiet_NaN
)
1999 arg
= std::numeric_limits
<T
>::quiet_NaN();
2000 check_invalid(rint(arg
));
2005 BOOST_CHECK_EQUAL(val
, 0);
2006 BOOST_CHECK(signbit(val
) == 0);
2011 BOOST_CHECK_EQUAL(val
, 0);
2012 BOOST_CHECK(signbit(val
));
2014 if (std::numeric_limits
<T
>::has_infinity
)
2016 arg
= std::numeric_limits
<T
>::infinity();
2018 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
2021 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
2023 if (std::numeric_limits
<T
>::has_quiet_NaN
)
2025 arg
= std::numeric_limits
<T
>::quiet_NaN();
2026 check_invalid(round(arg
));
2031 BOOST_CHECK_EQUAL(val
, 0);
2032 BOOST_CHECK(signbit(val
) == 0);
2037 BOOST_CHECK_EQUAL(val
, 0);
2038 BOOST_CHECK(signbit(val
));
2040 if (std::numeric_limits
<T
>::has_infinity
)
2042 arg
= std::numeric_limits
<T
>::infinity();
2044 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
2047 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
2049 if (std::numeric_limits
<T
>::has_quiet_NaN
)
2051 arg
= std::numeric_limits
<T
>::quiet_NaN();
2052 check_invalid(trunc(arg
));
2057 val
= fmod(arg
, arg2
);
2058 BOOST_CHECK_EQUAL(val
, 0);
2059 BOOST_CHECK(signbit(val
) == 0);
2063 val
= fmod(arg
, arg2
);
2064 BOOST_CHECK_EQUAL(val
, 0);
2065 BOOST_CHECK(signbit(val
));
2067 if (std::numeric_limits
<T
>::has_infinity
)
2069 arg
= std::numeric_limits
<T
>::infinity();
2070 check_invalid(fmod(arg
, arg2
));
2072 check_invalid(fmod(arg
, arg2
));
2075 check_invalid(fmod(arg
, arg2
));
2076 check_invalid(fmod(arg
, -arg2
));
2078 if (std::numeric_limits
<T
>::has_quiet_NaN
)
2080 arg
= std::numeric_limits
<T
>::quiet_NaN();
2082 check_invalid(fmod(arg
, arg2
));
2084 check_invalid(fmod(arg
, arg2
));
2085 check_invalid(fmod(arg2
, arg2
));
2091 boost::math::lgamma(T(0.000001), &sign
);
2092 BOOST_CHECK_EQUAL(sign
, 1);
2094 boost::math::lgamma(T(0.5), &sign
);
2095 BOOST_CHECK_EQUAL(sign
, 1);
2097 boost::math::lgamma(T(0.9), &sign
);
2098 BOOST_CHECK_EQUAL(sign
, 1);
2100 boost::math::lgamma(T(1.1), &sign
);
2101 BOOST_CHECK_EQUAL(sign
, 1);
2103 boost::math::lgamma(T(1.9), &sign
);
2104 BOOST_CHECK_EQUAL(sign
, 1);
2106 boost::math::lgamma(T(2.1), &sign
);
2107 BOOST_CHECK_EQUAL(sign
, 1);
2109 boost::math::lgamma(T(20), &sign
);
2110 BOOST_CHECK_EQUAL(sign
, 1);
2112 boost::math::lgamma(T(-0.0000000000001), &sign
);
2113 BOOST_CHECK_EQUAL(sign
, -1);
2115 boost::math::lgamma(T(-0.5), &sign
);
2116 BOOST_CHECK_EQUAL(sign
, -1);
2118 boost::math::lgamma(T(-1.5), &sign
);
2119 BOOST_CHECK_EQUAL(sign
, 1);
2121 boost::math::lgamma(T(-2.5), &sign
);
2122 BOOST_CHECK_EQUAL(sign
, -1);
2124 boost::math::lgamma(T(-3.5), &sign
);
2125 BOOST_CHECK_EQUAL(sign
, 1);
2129 void test_c99_appendix_F_tgammaq_addon_for_float128()
2131 #if defined(TEST_FLOAT128)
2132 // Special tests of tgamma for positive and negative
2133 // real values in the neighborhood of the origin.
2135 // At Wolfram Alpha: N[Gamma[1/3], 201]
2136 const T tgamma_third
2139 "67893853470774763365569294097467764412868937795730"
2140 "11009504283275904176101677438195409828890411887894"
2141 "19159049200072263335719084569504472259977713367708"
2142 "46976816728982305000321834255032224715694181755545"
2145 // Create a string such as "1e-84", where 84 exemplifies (digits10*5 + 5)/6
2146 // and the exponent varies depending on the value of digits10 for the type.
2147 // Consider, for instance digits10=100. In this case n_exp=(100*5 + 5)/6 = 84.
2149 const int n_exp
=(std::max
)(((std::numeric_limits
<T
>::digits10
* 5) + 5) / 6, 1);
2151 const T
tgamma_tol("1e-" + boost::lexical_cast
<std::string
>(n_exp
));
2153 // Check tgamma(1/3 - n) for n in 0...24.
2154 for(int n
= 0; n
< 25; ++n
)
2156 const T tgamma_val
= tgamma(T((T(1) / T(3)) - T(n
)));
2158 T
tgamma_control(tgamma_third
);
2160 for(unsigned int k
= 0U; k
< static_cast<unsigned int>(n
); ++k
)
2162 tgamma_control
*= -3;
2163 tgamma_control
/= ((3U * (k
+ 1U)) - 1U);
2166 BOOST_CHECK_CLOSE_FRACTION(tgamma_val
, tgamma_control
, tgamma_tol
);
2169 // Check tgamma(1/3 + n) for n in 0...24.
2170 for(unsigned int n
= 0U; n
< 25U; ++n
)
2172 const T tgamma_val
= tgamma(T((T(1) / T(3)) + T(n
)));
2174 T
tgamma_control(tgamma_third
);
2176 for(unsigned int k
= 0U; k
< n
; ++k
)
2178 tgamma_control
/= 3;
2179 tgamma_control
*= ((3U * (k
+ 1U)) - 2U);
2182 BOOST_CHECK_CLOSE_FRACTION(tgamma_val
, tgamma_control
, tgamma_tol
);
2189 test_poison
<float>();
2190 test_poison
<double>();
2192 test
<boost::multiprecision::mpf_float_50
>();
2193 test
<boost::multiprecision::mpf_float_100
>();
2196 std::cout
<< "Testing MPFR: " << MPFR_VERSION_STRING
<< std::endl
;
2197 test
<boost::multiprecision::mpfr_float_50
>();
2198 test
<boost::multiprecision::mpfr_float_100
>();
2199 test_c99_appendix_F
<boost::multiprecision::mpfr_float_50
>();
2202 test
<boost::multiprecision::mpfi_float_50
>();
2203 test
<boost::multiprecision::mpfi_float_100
>();
2205 #ifdef TEST_CPP_DEC_FLOAT
2206 test
<boost::multiprecision::cpp_dec_float_50
>();
2207 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2208 test
<boost::multiprecision::cpp_dec_float_100
>();
2210 test_c99_appendix_F
<boost::multiprecision::cpp_dec_float_50
>();
2212 #ifdef TEST_CPP_DEC_FLOAT_2
2213 // Some "peculiar" digit counts which stress our code:
2214 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<65> > >();
2215 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2216 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<64> > >();
2219 #ifdef TEST_CPP_DEC_FLOAT_3
2220 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<63> > >();
2221 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2222 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<62> > >();
2225 #ifdef TEST_CPP_DEC_FLOAT_4
2226 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<61, long long> > >();
2227 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2228 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<60, long long> > >();
2231 #ifdef TEST_CPP_DEC_FLOAT_5
2232 #if defined(__MINGW32__) || defined(__MINGW64__) // Weak workaround just to, let's say, get green
2233 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<59, long long > > >();
2235 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<59, long long, std::allocator
<char> > > >();
2238 #ifdef TEST_CPP_DEC_FLOAT_6
2239 #if defined(__MINGW32__) || defined(__MINGW64__) // Weak workaround just to, let's say, get green
2240 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<58, long long > > >();
2242 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<58, long long, std::allocator
<char> > > >();
2245 #ifdef TEST_CPP_BIN_FLOAT
2246 test
<boost::multiprecision::cpp_bin_float_50
>();
2247 test
<boost::multiprecision::number
<boost::multiprecision::cpp_bin_float
<100>, boost::multiprecision::et_on
> >();
2249 #ifdef TEST_CPP_BIN_FLOAT_2
2250 test
<boost::multiprecision::number
<boost::multiprecision::cpp_bin_float
<35, boost::multiprecision::digit_base_10
, std::allocator
<char>, long long> > >();
2252 #ifdef TEST_CPP_BIN_FLOAT_3
2253 test_c99_appendix_F
<boost::multiprecision::cpp_bin_float_50
>();
2254 test_c99_appendix_F
<boost::multiprecision::number
<boost::multiprecision::cpp_bin_float
<100>, boost::multiprecision::et_on
> >();
2256 #ifdef TEST_FLOAT128
2257 test
<boost::multiprecision::float128
>();
2258 test_c99_appendix_F
<boost::multiprecision::float128
>();
2259 test_c99_appendix_F_tgammaq_addon_for_float128
<boost::multiprecision::float128
>();
2261 #ifdef TEST_MPFI_DEBUG_ADAPTOR
2262 test
<boost::multiprecision::number
<boost::multiprecision::debug_adaptor
<boost::multiprecision::mpfi_float_backend
<50> > > >();
2263 //test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
2265 #ifdef TEST_MPFR_DEBUG_ADAPTOR
2266 test
<boost::multiprecision::number
<boost::multiprecision::debug_adaptor
<boost::multiprecision::mpfr_float_backend
<50> > > >();
2267 test_c99_appendix_F
<boost::multiprecision::number
<boost::multiprecision::debug_adaptor
<boost::multiprecision::mpfr_float_backend
<50> > > >();
2269 #ifdef TEST_MPFI_LOGGED_ADAPTOR
2270 test
<boost::multiprecision::number
<boost::multiprecision::logged_adaptor
<boost::multiprecision::mpfi_float_backend
<50> > > >();
2271 //test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
2273 #ifdef TEST_MPFR_LOGGED_ADAPTOR
2274 test
<boost::multiprecision::number
<boost::multiprecision::logged_adaptor
<boost::multiprecision::mpfr_float_backend
<50> > > >();
2275 test_c99_appendix_F
<boost::multiprecision::number
<boost::multiprecision::logged_adaptor
<boost::multiprecision::mpfr_float_backend
<50> > > >();
2278 return boost::report_errors();