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 # define _SCL_SECURE_NO_WARNINGS
10 #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT)\
11 && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128)\
12 && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_CPP_DEC_FLOAT_2) && !defined(TEST_CPP_DEC_FLOAT_3)\
13 && !defined(TEST_CPP_DEC_FLOAT_4) && !defined(TEST_CPP_DEC_FLOAT_5)
17 # define TEST_CPP_DEC_FLOAT
18 # define TEST_CPP_DEC_FLOAT_2
19 # define TEST_CPP_DEC_FLOAT_3
20 # define TEST_CPP_DEC_FLOAT_4
21 # define TEST_CPP_DEC_FLOAT_5
22 # define TEST_FLOAT128
23 # define TEST_CPP_BIN_FLOAT
26 #pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
29 #pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
34 #if defined(TEST_MPF_50)
35 #include <boost/multiprecision/gmp.hpp>
38 #include <boost/multiprecision/mpfr.hpp>
41 #include <boost/multiprecision/mpfi.hpp>
43 #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)
44 #include <boost/multiprecision/cpp_dec_float.hpp>
46 #ifdef TEST_CPP_BIN_FLOAT
47 #include <boost/multiprecision/cpp_bin_float.hpp>
48 #include <boost/multiprecision/debug_adaptor.hpp>
51 #include <boost/multiprecision/float128.hpp>
54 #include <boost/math/constants/constants.hpp>
82 #ifdef MPFR_VERSION_MAJOR
83 #define BOOST_MPFR_VERSION MPFR_VERSION_MAJOR * 10000 + MPFR_VERSION_MINOR * 100 + MPFR_VERSION_PATCHLEVEL
86 template <class T
, class U
>
87 void test_less(T a
, U b
)
91 BOOST_CHECK(!(a
> b
));
92 BOOST_CHECK(!(a
>= b
));
93 BOOST_CHECK(!(a
== b
));
94 BOOST_CHECK((a
!= b
));
98 BOOST_CHECK(!(b
< a
));
99 BOOST_CHECK(!(b
<= a
));
100 BOOST_CHECK(!(b
== a
));
101 BOOST_CHECK((b
!= a
));
103 BOOST_CHECK(isless(a
, b
));
104 BOOST_CHECK(islessequal(a
, b
));
105 BOOST_CHECK(!isgreater(a
, b
));
106 BOOST_CHECK(!isgreaterequal(a
, b
));
107 BOOST_CHECK(islessgreater(a
, b
));
109 BOOST_CHECK(!isless(b
, a
));
110 BOOST_CHECK(!islessequal(b
, a
));
111 BOOST_CHECK(isgreater(b
, a
));
112 BOOST_CHECK(isgreaterequal(b
, a
));
113 BOOST_CHECK(islessgreater(b
, a
));
115 template <class T
, class U
>
116 void test_equal(T a
, U b
)
118 BOOST_CHECK(!(a
< b
));
120 BOOST_CHECK(!(a
> b
));
121 BOOST_CHECK((a
>= b
));
122 BOOST_CHECK((a
== b
));
123 BOOST_CHECK(!(a
!= b
));
125 BOOST_CHECK(!(b
> a
));
127 BOOST_CHECK(!(b
< a
));
128 BOOST_CHECK((b
<= a
));
129 BOOST_CHECK((b
== a
));
130 BOOST_CHECK(!(b
!= a
));
132 BOOST_CHECK(!isless(a
, b
));
133 BOOST_CHECK(islessequal(a
, b
));
134 BOOST_CHECK(!isgreater(a
, b
));
135 BOOST_CHECK(isgreaterequal(a
, b
));
136 BOOST_CHECK(!islessgreater(a
, b
));
138 BOOST_CHECK(!isless(b
, a
));
139 BOOST_CHECK(islessequal(b
, a
));
140 BOOST_CHECK(!isgreater(b
, a
));
141 BOOST_CHECK(isgreaterequal(b
, a
));
142 BOOST_CHECK(!islessgreater(b
, a
));
144 template <class T
, class U
>
145 void test_unordered(T a
, U b
)
147 BOOST_CHECK(!(a
< b
));
148 BOOST_CHECK(!(a
<= b
));
149 BOOST_CHECK(!(a
> b
));
150 BOOST_CHECK(!(a
>= b
));
151 BOOST_CHECK(!(a
== b
));
152 BOOST_CHECK((a
!= b
));
154 BOOST_CHECK(!(b
> a
));
155 BOOST_CHECK(!(b
>= a
));
156 BOOST_CHECK(!(b
< a
));
157 BOOST_CHECK(!(b
<= a
));
158 BOOST_CHECK(!(b
== a
));
159 BOOST_CHECK((b
!= a
));
161 BOOST_CHECK(!isless(a
, b
));
162 BOOST_CHECK(!islessequal(a
, b
));
163 BOOST_CHECK(!isgreater(a
, b
));
164 BOOST_CHECK(!isgreaterequal(a
, b
));
165 BOOST_CHECK(!islessgreater(a
, b
));
167 BOOST_CHECK(!isless(b
, a
));
168 BOOST_CHECK(!islessequal(b
, a
));
169 BOOST_CHECK(!isgreater(b
, a
));
170 BOOST_CHECK(!isgreaterequal(b
, a
));
171 BOOST_CHECK(!islessgreater(b
, a
));
178 // Basic sanity checks for C99 functions which are just imported versions
179 // from Boost.Math. These should still be found via ADL so no using declarations here...
182 BOOST_CHECK(signbit(val
) == 0);
183 BOOST_CHECK(signbit(val
+ 2) == 0);
185 BOOST_CHECK(signbit(val
));
186 BOOST_CHECK(signbit(val
* 2));
189 BOOST_CHECK_EQUAL(sign(val
), 1);
190 BOOST_CHECK_EQUAL(sign(val
+ 2), 1);
192 BOOST_CHECK_EQUAL(sign(val
), -1);
193 BOOST_CHECK_EQUAL(sign(val
* 2), -1);
195 BOOST_CHECK_EQUAL(sign(val
), 0);
196 BOOST_CHECK_EQUAL(sign(val
* 2), 0);
199 BOOST_CHECK_EQUAL(changesign(val
), -2);
200 BOOST_CHECK_EQUAL(changesign(val
* 2), -4);
202 BOOST_CHECK_EQUAL(changesign(val
), 2);
203 BOOST_CHECK_EQUAL(changesign(val
* 2), 4);
205 BOOST_CHECK_EQUAL(changesign(val
), 0);
206 BOOST_CHECK_EQUAL(changesign(val
* 2), 0);
207 // Things involving signed zero, need to detect it first:
208 T neg_zero_test
= -(std::numeric_limits
<T
>::min
)();
209 neg_zero_test
/= (std::numeric_limits
<T
>::max
)();
211 bool test_signed_zero
= !boost::multiprecision::is_interval_number
<T
>::value
&& std::numeric_limits
<T
>::has_infinity
&& (one
/ neg_zero_test
< 0);
214 BOOST_CHECK(signbit(changesign(val
)));
215 BOOST_CHECK(signbit(changesign(val
* 2)));
220 BOOST_CHECK_EQUAL(copysign(val
, s
), 3);
221 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), -3);
222 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), 6);
223 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), 6);
225 BOOST_CHECK_EQUAL(copysign(val
, s
), -3);
226 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), 3);
227 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), -6);
228 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), -6);
230 BOOST_CHECK_EQUAL(copysign(val
, s
), -3);
231 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), 3);
232 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), -6);
233 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), -6);
235 BOOST_CHECK_EQUAL(copysign(val
, s
), 3);
236 // Things involving signed zero, need to detect it first:
239 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), -3);
241 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), 6);
242 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), 6);
243 // Things involving signed zero, need to detect it first:
249 BOOST_CHECK_EQUAL(copysign(val
, s
), -3);
250 BOOST_CHECK_EQUAL(copysign(val
, s
* -2), 3);
251 BOOST_CHECK_EQUAL(copysign(-2 * val
, s
), -6);
252 BOOST_CHECK_EQUAL(copysign(-2 * val
, 2 * s
), -6);
257 BOOST_CHECK_EQUAL(fpclassify(val
), FP_NORMAL
);
258 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_NORMAL
);
259 BOOST_CHECK(!isinf(val
));
260 BOOST_CHECK(!isinf(val
+ 2));
261 BOOST_CHECK(!isnan(val
));
262 BOOST_CHECK(!isnan(val
+ 2));
263 BOOST_CHECK(isnormal(val
));
264 BOOST_CHECK(isnormal(val
+ 2));
266 BOOST_CHECK_EQUAL(fpclassify(val
), FP_NORMAL
);
267 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_NORMAL
);
268 BOOST_CHECK(!isinf(val
));
269 BOOST_CHECK(!isinf(val
+ 2));
270 BOOST_CHECK(!isnan(val
));
271 BOOST_CHECK(!isnan(val
+ 2));
272 BOOST_CHECK(isnormal(val
));
273 BOOST_CHECK(isnormal(val
+ 2));
275 BOOST_CHECK_EQUAL(fpclassify(val
), FP_ZERO
);
276 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_ZERO
);
277 BOOST_CHECK(!isinf(val
));
278 BOOST_CHECK(!isinf(val
+ 2));
279 BOOST_CHECK(!isnan(val
));
280 BOOST_CHECK(!isnan(val
+ 2));
281 BOOST_CHECK(!isnormal(val
));
282 BOOST_CHECK(!isnormal(val
* 2));
283 BOOST_CHECK(!isnormal(val
* -2));
284 if(std::numeric_limits
<T
>::has_infinity
)
286 val
= std::numeric_limits
<T
>::infinity();
287 BOOST_CHECK_EQUAL(fpclassify(val
), FP_INFINITE
);
288 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_INFINITE
);
289 BOOST_CHECK(isinf(val
));
290 BOOST_CHECK(isinf(val
+ 2));
291 BOOST_CHECK(!isnan(val
));
292 BOOST_CHECK(!isnan(val
+ 2));
293 BOOST_CHECK(!isnormal(val
));
294 BOOST_CHECK(!isnormal(val
+ 2));
296 BOOST_CHECK_EQUAL(fpclassify(val
), FP_INFINITE
);
297 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_INFINITE
);
298 BOOST_CHECK(isinf(val
));
299 BOOST_CHECK(isinf(val
+ 2));
300 BOOST_CHECK(!isnan(val
));
301 BOOST_CHECK(!isnan(val
+ 2));
302 BOOST_CHECK(!isnormal(val
));
303 BOOST_CHECK(!isnormal(val
+ 2));
305 if(std::numeric_limits
<T
>::has_quiet_NaN
)
307 val
= std::numeric_limits
<T
>::quiet_NaN();
308 BOOST_CHECK_EQUAL(fpclassify(val
), FP_NAN
);
309 BOOST_CHECK_EQUAL(fpclassify(val
* 3), FP_NAN
);
310 BOOST_CHECK(!isinf(val
));
311 BOOST_CHECK(!isinf(val
+ 2));
312 BOOST_CHECK(isnan(val
));
313 BOOST_CHECK(isnan(val
+ 2));
314 BOOST_CHECK(!isnormal(val
));
315 BOOST_CHECK(!isnormal(val
+ 2));
317 s
= 8 * std::numeric_limits
<T
>::epsilon();
319 BOOST_CHECK_CLOSE_FRACTION(asinh(val
), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s
);
320 BOOST_CHECK_CLOSE_FRACTION(asinh(val
+ T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s
);
321 BOOST_CHECK_CLOSE_FRACTION(acosh(val
), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s
);
322 BOOST_CHECK_CLOSE_FRACTION(acosh(val
+ T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s
);
324 BOOST_CHECK_CLOSE_FRACTION(atanh(val
), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s
);
325 BOOST_CHECK_CLOSE_FRACTION(atanh(val
+ T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s
);
327 BOOST_CHECK_CLOSE_FRACTION(cbrt(val
), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s
);
328 BOOST_CHECK_CLOSE_FRACTION(cbrt(val
+ T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s
);
329 if(!boost::multiprecision::is_interval_number
<T
>::value
)
332 BOOST_CHECK_CLOSE_FRACTION(erf(val
), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s
);
333 BOOST_CHECK_CLOSE_FRACTION(erf(val
+ T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s
);
334 BOOST_CHECK_CLOSE_FRACTION(erfc(val
), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s
);
335 BOOST_CHECK_CLOSE_FRACTION(erfc(val
+ T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s
);
338 BOOST_CHECK_CLOSE_FRACTION(expm1(val
), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s
);
339 BOOST_CHECK_CLOSE_FRACTION(expm1(val
+ T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s
);
343 BOOST_CHECK_EQUAL(fdim(val
, s
), 18);
344 BOOST_CHECK_EQUAL(fdim(s
, val
), 0);
345 BOOST_CHECK_EQUAL(fdim(val
, s
* 2), 16);
346 BOOST_CHECK_EQUAL(fdim(s
* 2, val
), 0);
347 BOOST_CHECK_EQUAL(fdim(val
, 2), 18);
348 BOOST_CHECK_EQUAL(fdim(2, val
), 0);
350 BOOST_CHECK_EQUAL(fmax(val
, s
), val
);
351 BOOST_CHECK_EQUAL(fmax(s
, val
), val
);
352 BOOST_CHECK_EQUAL(fmax(val
* 2, s
), val
* 2);
353 BOOST_CHECK_EQUAL(fmax(val
, s
* 2), val
);
354 BOOST_CHECK_EQUAL(fmax(val
* 2, s
* 2), val
* 2);
355 BOOST_CHECK_EQUAL(fmin(val
, s
), s
);
356 BOOST_CHECK_EQUAL(fmin(s
, val
), s
);
357 BOOST_CHECK_EQUAL(fmin(val
* 2, s
), s
);
358 BOOST_CHECK_EQUAL(fmin(val
, s
* 2), s
* 2);
359 BOOST_CHECK_EQUAL(fmin(val
* 2, s
* 2), s
* 2);
361 BOOST_CHECK_EQUAL(fmax(val
, 2), val
);
362 BOOST_CHECK_EQUAL(fmax(val
, 2.0), val
);
363 BOOST_CHECK_EQUAL(fmax(20, s
), val
);
364 BOOST_CHECK_EQUAL(fmax(20.0, s
), val
);
365 BOOST_CHECK_EQUAL(fmin(val
, 2), s
);
366 BOOST_CHECK_EQUAL(fmin(val
, 2.0), s
);
367 BOOST_CHECK_EQUAL(fmin(20, s
), s
);
368 BOOST_CHECK_EQUAL(fmin(20.0, s
), s
);
369 if(std::numeric_limits
<T
>::has_quiet_NaN
)
371 BOOST_CHECK_EQUAL(fmax(val
, std::numeric_limits
<T
>::quiet_NaN()), val
);
372 BOOST_CHECK_EQUAL(fmax(std::numeric_limits
<T
>::quiet_NaN(), val
), val
);
373 BOOST_CHECK_EQUAL(fmin(val
, std::numeric_limits
<T
>::quiet_NaN()), val
);
374 BOOST_CHECK_EQUAL(fmin(std::numeric_limits
<T
>::quiet_NaN(), val
), val
);
376 if(std::numeric_limits
<double>::has_quiet_NaN
)
378 BOOST_CHECK_EQUAL(fmax(val
, std::numeric_limits
<double>::quiet_NaN()), val
);
379 BOOST_CHECK_EQUAL(fmax(std::numeric_limits
<double>::quiet_NaN(), val
), val
);
380 BOOST_CHECK_EQUAL(fmin(val
, std::numeric_limits
<double>::quiet_NaN()), val
);
381 BOOST_CHECK_EQUAL(fmin(std::numeric_limits
<double>::quiet_NaN(), val
), val
);
387 test_less(s
+ 0, val
);
388 test_less(s
, val
* 1);
389 test_less(s
* 1, val
* 1);
390 test_less(s
* 1, 20);
391 test_less(s
+ 2, val
* 2);
393 test_equal(val
, val
);
396 test_equal(val
+ 0, val
);
397 test_equal(val
, val
* 1);
398 test_equal(val
* 1, val
* 1);
399 test_equal(val
* 1, 20);
400 test_equal(val
* 20, val
* 20);
402 if(std::numeric_limits
<T
>::has_quiet_NaN
)
404 s
= std::numeric_limits
<T
>::quiet_NaN();
405 test_unordered(s
, val
);
406 test_unordered(s
, 20);
407 test_unordered(s
+ 0, val
);
408 test_unordered(s
, val
* 1);
409 test_unordered(s
* 1, val
* 1);
410 test_unordered(s
* 1, 20);
411 test_unordered(s
+ 2, val
* 2);
412 if(std::numeric_limits
<double>::has_quiet_NaN
)
414 double n
= std::numeric_limits
<double>::quiet_NaN();
415 test_unordered(n
, val
);
419 T tol
= 8 * std::numeric_limits
<T
>::epsilon();
421 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
422 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
423 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
424 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
425 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
426 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, s
)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
427 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, s
* 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
428 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
429 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val
* 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
430 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s
* 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
431 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s
* 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol
);
433 BOOST_CHECK_CLOSE_FRACTION(lgamma(val
), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol
);
434 BOOST_CHECK_CLOSE_FRACTION(lgamma(val
+ 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol
);
436 BOOST_CHECK_EQUAL(lrint(val
), 20);
437 BOOST_CHECK_EQUAL(lrint(val
* 2), 40);
438 BOOST_CHECK_EQUAL(llrint(val
), 20);
439 BOOST_CHECK_EQUAL(llrint(val
* 2), 40);
442 BOOST_CHECK_CLOSE_FRACTION(log1p(val
), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol
);
443 BOOST_CHECK_CLOSE_FRACTION(log1p(val
+ 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol
);
445 BOOST_CHECK_CLOSE_FRACTION(T(log2(val
)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol
);
446 BOOST_CHECK_CLOSE_FRACTION(T(log2(val
+ 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol
);
448 BOOST_CHECK_EQUAL(T(nearbyint(val
)), 20);
449 BOOST_CHECK_EQUAL(T(nearbyint(val
+ 0.25)), 20);
450 BOOST_CHECK_EQUAL(T(rint(val
)), 20);
451 BOOST_CHECK_EQUAL(T(rint(val
+ 0.25)), 20);
453 BOOST_CHECK_GT(nextafter(val
, T(200)), val
);
454 BOOST_CHECK_GT(nextafter(val
+ 0, T(200)), val
);
455 BOOST_CHECK_GT(nextafter(val
+ 0, T(200) + 1), val
);
456 BOOST_CHECK_GT(nextafter(val
, T(200) + 1), val
);
458 BOOST_CHECK_GT(nexttoward(val
, T(200)), val
);
459 BOOST_CHECK_GT(nexttoward(val
+ 0, T(200)), val
);
460 BOOST_CHECK_GT(nexttoward(val
+ 0, T(200) + 1), val
);
461 BOOST_CHECK_GT(nexttoward(val
, T(200) + 1), val
);
465 BOOST_CHECK_EQUAL(T(remainder(val
, s
)), 1);
466 BOOST_CHECK_EQUAL(T(remainder(val
, 5)), 1);
467 BOOST_CHECK_EQUAL(T(remainder(21, s
)), 1);
468 BOOST_CHECK_EQUAL(T(remainder(val
* 1, s
)), 1);
469 BOOST_CHECK_EQUAL(T(remainder(val
* 1, s
* 1)), 1);
470 BOOST_CHECK_EQUAL(T(remainder(val
, s
* 1)), 1);
471 BOOST_CHECK_EQUAL(T(remainder(val
* 1, 5)), 1);
472 BOOST_CHECK_EQUAL(T(remainder(21, s
* 1)), 1);
474 BOOST_CHECK_EQUAL(T(remquo(val
, s
, &i
)), 1);
475 BOOST_CHECK_EQUAL(i
, 4);
477 BOOST_CHECK_EQUAL(T(remquo(val
, 5, &i
)), 1);
478 BOOST_CHECK_EQUAL(i
, 4);
480 BOOST_CHECK_EQUAL(T(remquo(21, s
, &i
)), 1);
481 BOOST_CHECK_EQUAL(i
, 4);
483 BOOST_CHECK_EQUAL(T(remquo(val
* 1, s
, &i
)), 1);
484 BOOST_CHECK_EQUAL(i
, 4);
486 BOOST_CHECK_EQUAL(T(remquo(val
* 1, s
* 1, &i
)), 1);
487 BOOST_CHECK_EQUAL(i
, 4);
489 BOOST_CHECK_EQUAL(T(remquo(val
, s
* 1, &i
)), 1);
490 BOOST_CHECK_EQUAL(i
, 4);
492 BOOST_CHECK_EQUAL(T(remquo(val
* 1, 5, &i
)), 1);
493 BOOST_CHECK_EQUAL(i
, 4);
495 BOOST_CHECK_EQUAL(T(remquo(21, s
* 1, &i
)), 1);
496 BOOST_CHECK_EQUAL(i
, 4);
500 BOOST_CHECK_CLOSE_FRACTION(tgamma(val
), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol
);
501 BOOST_CHECK_CLOSE_FRACTION(tgamma(val
+ 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol
);
503 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol
);
504 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
+ 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol
);
506 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
)), T(32768uL), tol
);
507 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val
+ 1)), T(65536uL), tol
);
509 i
= fpclassify(val
) + isgreaterequal(val
, s
) + islessequal(val
, s
) + isnan(val
) + isunordered(val
, s
)
510 + isfinite(val
) + isinf(val
) + islessgreater(val
, s
) + isnormal(val
) + signbit(val
) + isgreater(val
, s
) + isless(val
, s
);
516 // use these macros as proxies for determining C99 support:
517 #if defined(FP_ILOGB0) && defined(FP_INFINITE)
519 // These tests verify that our function overloads for Boost.Multiprecision
520 // don't do anything nasty to the std:: overloads for built in types:
523 using namespace boost::multiprecision
;
524 //using namespace boost::math;
526 T
a(2), b(0.3f
), c(4), result(0);
531 result
+= fmod(a
, b
);
533 result
+= remquo(a
, b
, &i
);
536 result
+= frexp(a
, &i
);
541 result
+= hypot(a
, b
);
547 result
+= modf(a
, &b
);
548 result
+= scalbln(a
, i
);
551 result
+= ldexp(a
, i
);
552 result
+= scalbn(a
, i
);
557 result
+= atan2(a
, c
);
562 result
+= fdim(a
, b
);
563 result
+= llround(a
);
564 result
+= nearbyint(a
);
569 result
+= nextafter(a
, b
);
572 result
+= fma(a
, b
, c
);
574 result
+= nexttoward(a
, b
);
576 result
+= copysign(a
, b
);
577 result
+= fmax(a
, b
);
582 result
+= fmin(a
, b
);
584 result
+= remainder(a
, b
);
589 #if !BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 60000)
591 i
= fpclassify(a
) + isgreaterequal(a
, b
) + islessequal(a
, b
) + isnan(a
) + isunordered(a
, b
)
592 + isfinite(a
) + isinf(a
) + islessgreater(a
, b
) + isnormal(a
) + signbit(a
) + isgreater(a
, b
) + isless(a
, b
);
598 bool type_sets_errno(const T
&)
603 template<unsigned Digits10
, boost::multiprecision::mpfr_allocation_type AllocateType
, boost::multiprecision::expression_template_option ExpressionTemplates
>
604 bool type_sets_errno(const boost::multiprecision::number
<boost::multiprecision::mpfr_float_backend
<Digits10
, AllocateType
>, ExpressionTemplates
> &)
610 bool type_sets_errno(const boost::multiprecision::float128
&)
617 typename
boost::enable_if_c
<std::numeric_limits
<T
>::is_specialized
>::type
check_invalid(const T
& val
)
619 if(std::numeric_limits
<T
>::has_quiet_NaN
)
621 BOOST_CHECK(isnan(val
));
625 BOOST_CHECK_EQUAL(val
, 0);
627 if(type_sets_errno(val
))
628 BOOST_CHECK_EQUAL(errno
, EDOM
);
633 typename
boost::disable_if_c
<std::numeric_limits
<T
>::is_specialized
>::type
check_invalid(const T
& val
)
635 check_invalid(static_cast<typename
T::result_type
>(val
));
639 void check_erange(const T
& val
)
641 if(type_sets_errno(val
))
642 BOOST_CHECK_EQUAL(errno
, ERANGE
);
647 void test_c99_appendix_F()
650 // Tests conformance to non-normative appendix F.9.1 of C99, basically how to handle
651 // special cases, infinities and NaN's.
654 T tol
= std::numeric_limits
<T
>::epsilon();
658 BOOST_CHECK_EQUAL(val
, 0);
659 BOOST_CHECK(signbit(val
) == 0);
661 check_invalid(acos(arg
));
663 check_invalid(acos(arg
));
664 if(std::numeric_limits
<T
>::has_infinity
)
666 arg
= std::numeric_limits
<T
>::infinity();
667 check_invalid(acos(arg
));
668 arg
= -std::numeric_limits
<T
>::infinity();
669 check_invalid(acos(arg
));
671 if(std::numeric_limits
<T
>::has_quiet_NaN
)
673 arg
= std::numeric_limits
<T
>::quiet_NaN();
674 check_invalid(acos(arg
));
675 arg
= -std::numeric_limits
<T
>::quiet_NaN();
676 check_invalid(acos(arg
));
681 BOOST_CHECK_EQUAL(val
, 0);
682 BOOST_CHECK(signbit(val
) == 0);
687 BOOST_CHECK_EQUAL(val
, 0);
688 BOOST_CHECK(signbit(val
));
691 check_invalid(asin(arg
));
693 check_invalid(asin(arg
));
694 if(std::numeric_limits
<T
>::has_infinity
)
696 arg
= std::numeric_limits
<T
>::infinity();
697 check_invalid(asin(arg
));
698 arg
= -std::numeric_limits
<T
>::infinity();
699 check_invalid(asin(arg
));
701 if(std::numeric_limits
<T
>::has_quiet_NaN
)
703 arg
= std::numeric_limits
<T
>::quiet_NaN();
704 check_invalid(asin(arg
));
705 arg
= -std::numeric_limits
<T
>::quiet_NaN();
706 check_invalid(asin(arg
));
711 BOOST_CHECK_EQUAL(val
, 0);
712 BOOST_CHECK(signbit(val
) == 0);
717 BOOST_CHECK_EQUAL(val
, 0);
718 BOOST_CHECK(signbit(val
));
720 if(std::numeric_limits
<T
>::has_infinity
)
722 arg
= std::numeric_limits
<T
>::infinity();
724 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
725 arg
= -std::numeric_limits
<T
>::infinity();
727 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
729 if(std::numeric_limits
<T
>::has_quiet_NaN
)
731 arg
= std::numeric_limits
<T
>::quiet_NaN();
732 check_invalid(asin(arg
));
733 arg
= -std::numeric_limits
<T
>::quiet_NaN();
734 check_invalid(asin(arg
));
739 val
= atan2(arg
, arg2
);
740 BOOST_CHECK_EQUAL(val
, 0);
741 BOOST_CHECK(signbit(val
) == 0);
745 val
= atan2(arg
, arg2
);
746 BOOST_CHECK_EQUAL(val
, 0);
747 BOOST_CHECK(signbit(val
));
753 val
= atan2(arg
, arg2
);
754 BOOST_CHECK_EQUAL(val
, boost::math::constants::pi
<T
>());
755 BOOST_CHECK(signbit(val
) == 0);
757 val
= atan2(arg
, arg2
);
758 BOOST_CHECK_EQUAL(val
, -boost::math::constants::pi
<T
>());
759 BOOST_CHECK(signbit(val
));
763 val
= atan2(arg
, arg2
);
764 BOOST_CHECK_EQUAL(val
, boost::math::constants::pi
<T
>());
768 val
= atan2(arg
, arg2
);
769 BOOST_CHECK_EQUAL(val
, -boost::math::constants::pi
<T
>());
773 val
= atan2(arg
, arg2
);
774 BOOST_CHECK_EQUAL(val
, 0);
775 BOOST_CHECK(signbit(val
) == 0);
779 val
= atan2(arg
, arg2
);
780 BOOST_CHECK_EQUAL(val
, 0);
781 BOOST_CHECK(signbit(val
));
785 val
= atan2(arg
, arg2
);
786 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
790 val
= atan2(arg
, arg2
);
791 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
795 val
= atan2(arg
, arg2
);
796 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
800 val
= atan2(arg
, arg2
);
801 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
803 if(std::numeric_limits
<T
>::has_infinity
)
806 arg2
= -std::numeric_limits
<T
>::infinity();
807 val
= atan2(arg
, arg2
);
808 BOOST_CHECK_EQUAL(val
, boost::math::constants::pi
<T
>());
810 val
= atan2(arg
, arg2
);
811 BOOST_CHECK_EQUAL(val
, -boost::math::constants::pi
<T
>());
813 arg2
= std::numeric_limits
<T
>::infinity();
814 val
= atan2(arg
, arg2
);
815 BOOST_CHECK_EQUAL(val
, 0);
816 BOOST_CHECK(signbit(val
) == 0);
820 val
= atan2(arg
, arg2
);
821 BOOST_CHECK_EQUAL(val
, 0);
822 BOOST_CHECK(signbit(val
));
824 arg
= std::numeric_limits
<T
>::infinity();
826 val
= atan2(arg
, arg2
);
827 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
829 val
= atan2(arg
, arg2
);
830 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
831 arg
= std::numeric_limits
<T
>::infinity();
833 val
= atan2(arg
, arg2
);
834 BOOST_CHECK_EQUAL(val
, boost::math::constants::half_pi
<T
>());
836 val
= atan2(arg
, arg2
);
837 BOOST_CHECK_EQUAL(val
, -boost::math::constants::half_pi
<T
>());
838 arg
= std::numeric_limits
<T
>::infinity();
839 arg2
= -std::numeric_limits
<T
>::infinity();
840 val
= atan2(arg
, arg2
);
841 BOOST_CHECK_CLOSE_FRACTION(val
, boost::math::constants::three_quarters_pi
<T
>(), tol
);
843 val
= atan2(arg
, arg2
);
844 BOOST_CHECK_CLOSE_FRACTION(val
, -boost::math::constants::three_quarters_pi
<T
>(), tol
);
845 arg
= std::numeric_limits
<T
>::infinity();
846 arg2
= std::numeric_limits
<T
>::infinity();
847 val
= atan2(arg
, arg2
);
848 BOOST_CHECK_CLOSE_FRACTION(val
, ldexp(boost::math::constants::pi
<T
>(), -2), tol
);
850 val
= atan2(arg
, arg2
);
851 BOOST_CHECK_CLOSE_FRACTION(val
, -ldexp(boost::math::constants::pi
<T
>(), -2), tol
);
852 if(std::numeric_limits
<T
>::has_quiet_NaN
)
854 arg
= std::numeric_limits
<T
>::quiet_NaN();
856 check_invalid(atan2(arg
, arg2
));
857 std::swap(arg
, arg2
);
858 check_invalid(atan2(arg
, arg2
));
859 arg
= std::numeric_limits
<T
>::quiet_NaN();
860 check_invalid(atan2(arg
, arg2
));
866 BOOST_CHECK_EQUAL(val
, 1);
868 BOOST_CHECK_EQUAL(val
, 1);
869 if(std::numeric_limits
<T
>::has_infinity
)
871 arg
= std::numeric_limits
<T
>::infinity();
872 check_invalid(cos(arg
));
873 arg
= -std::numeric_limits
<T
>::infinity();
874 check_invalid(cos(arg
));
876 if(std::numeric_limits
<T
>::has_quiet_NaN
)
878 arg
= std::numeric_limits
<T
>::quiet_NaN();
879 check_invalid(cos(arg
));
880 arg
= -std::numeric_limits
<T
>::quiet_NaN();
881 check_invalid(cos(arg
));
886 BOOST_CHECK_EQUAL(val
, 0);
887 BOOST_CHECK(signbit(val
) == 0);
892 BOOST_CHECK_EQUAL(val
, 0);
893 BOOST_CHECK(signbit(val
));
895 if(std::numeric_limits
<T
>::has_infinity
)
897 arg
= std::numeric_limits
<T
>::infinity();
898 check_invalid(sin(arg
));
899 arg
= -std::numeric_limits
<T
>::infinity();
900 check_invalid(sin(arg
));
902 if(std::numeric_limits
<T
>::has_quiet_NaN
)
904 arg
= std::numeric_limits
<T
>::quiet_NaN();
905 check_invalid(sin(arg
));
906 arg
= -std::numeric_limits
<T
>::quiet_NaN();
907 check_invalid(sin(arg
));
912 BOOST_CHECK_EQUAL(val
, 0);
913 BOOST_CHECK(signbit(val
) == 0);
918 BOOST_CHECK_EQUAL(val
, 0);
919 BOOST_CHECK(signbit(val
));
921 if(std::numeric_limits
<T
>::has_infinity
)
923 arg
= std::numeric_limits
<T
>::infinity();
924 check_invalid(tan(arg
));
925 arg
= -std::numeric_limits
<T
>::infinity();
926 check_invalid(tan(arg
));
928 if(std::numeric_limits
<T
>::has_quiet_NaN
)
930 arg
= std::numeric_limits
<T
>::quiet_NaN();
931 check_invalid(tan(arg
));
932 arg
= -std::numeric_limits
<T
>::quiet_NaN();
933 check_invalid(tan(arg
));
938 BOOST_CHECK_EQUAL(val
, 0);
939 BOOST_CHECK(signbit(val
) == 0);
941 check_invalid(acosh(arg
));
942 if(std::numeric_limits
<T
>::has_infinity
)
944 arg
= std::numeric_limits
<T
>::infinity();
946 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
948 arg
= -std::numeric_limits
<T
>::infinity();
949 check_invalid(acosh(arg
));
951 if(std::numeric_limits
<T
>::has_quiet_NaN
)
953 arg
= std::numeric_limits
<T
>::quiet_NaN();
954 check_invalid(acosh(arg
));
955 arg
= -std::numeric_limits
<T
>::quiet_NaN();
956 check_invalid(acosh(arg
));
961 BOOST_CHECK_EQUAL(val
, 0);
962 BOOST_CHECK(signbit(val
) == 0);
967 BOOST_CHECK_EQUAL(val
, 0);
968 BOOST_CHECK(signbit(val
));
970 if(std::numeric_limits
<T
>::has_infinity
)
972 arg
= std::numeric_limits
<T
>::infinity();
974 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
976 arg
= -std::numeric_limits
<T
>::infinity();
978 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
980 if(std::numeric_limits
<T
>::has_quiet_NaN
)
982 arg
= std::numeric_limits
<T
>::quiet_NaN();
983 check_invalid(asinh(arg
));
984 arg
= -std::numeric_limits
<T
>::quiet_NaN();
985 check_invalid(asinh(arg
));
990 BOOST_CHECK_EQUAL(val
, 0);
991 BOOST_CHECK(signbit(val
) == 0);
996 BOOST_CHECK_EQUAL(val
, 0);
997 BOOST_CHECK(signbit(val
));
1000 check_invalid(atanh(arg
));
1002 check_invalid(atanh(arg
));
1004 if(std::numeric_limits
<T
>::has_infinity
)
1008 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1009 BOOST_CHECK(signbit(val
) == 0);
1013 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1014 BOOST_CHECK(signbit(val
));
1017 arg
= std::numeric_limits
<T
>::infinity();
1018 check_invalid(atanh(arg
));
1019 arg
= -std::numeric_limits
<T
>::infinity();
1020 check_invalid(atanh(arg
));
1022 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1024 arg
= std::numeric_limits
<T
>::quiet_NaN();
1025 check_invalid(atanh(arg
));
1026 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1027 check_invalid(atanh(arg
));
1032 BOOST_CHECK_EQUAL(val
, 1);
1037 BOOST_CHECK_EQUAL(val
, 1);
1039 if(std::numeric_limits
<T
>::has_infinity
)
1041 arg
= (std::numeric_limits
<T
>::max
)();
1043 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1046 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1047 arg
= std::numeric_limits
<T
>::infinity();
1049 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1052 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1054 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1056 arg
= std::numeric_limits
<T
>::quiet_NaN();
1057 check_invalid(cosh(arg
));
1058 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1059 check_invalid(cosh(arg
));
1064 BOOST_CHECK_EQUAL(val
, 0);
1065 BOOST_CHECK(signbit(val
) == 0);
1070 BOOST_CHECK_EQUAL(val
, 0);
1071 BOOST_CHECK(signbit(val
));
1073 if(std::numeric_limits
<T
>::has_infinity
)
1075 arg
= (std::numeric_limits
<T
>::max
)();
1077 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1080 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1081 arg
= std::numeric_limits
<T
>::infinity();
1083 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1086 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1088 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1090 arg
= std::numeric_limits
<T
>::quiet_NaN();
1091 check_invalid(sinh(arg
));
1092 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1093 check_invalid(sinh(arg
));
1098 BOOST_CHECK_EQUAL(val
, 0);
1099 BOOST_CHECK(signbit(val
) == 0);
1104 BOOST_CHECK_EQUAL(val
, 0);
1105 BOOST_CHECK(signbit(val
));
1107 arg
= (std::numeric_limits
<T
>::max
)();
1109 BOOST_CHECK_EQUAL(val
, 1);
1112 BOOST_CHECK_EQUAL(val
, -1);
1113 if(std::numeric_limits
<T
>::has_infinity
)
1115 arg
= std::numeric_limits
<T
>::infinity();
1117 BOOST_CHECK_EQUAL(val
, 1);
1120 BOOST_CHECK_EQUAL(val
, -1);
1122 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1124 arg
= std::numeric_limits
<T
>::quiet_NaN();
1125 check_invalid(tanh(arg
));
1126 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1127 check_invalid(tanh(arg
));
1132 BOOST_CHECK_EQUAL(val
, 1);
1137 BOOST_CHECK_EQUAL(val
, 1);
1139 if(std::numeric_limits
<T
>::has_infinity
)
1141 arg
= std::numeric_limits
<T
>::infinity();
1143 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1146 BOOST_CHECK_EQUAL(val
, 0);
1147 BOOST_CHECK(signbit(val
) == 0);
1148 arg
= (std::numeric_limits
<T
>::max
)();
1150 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1153 BOOST_CHECK_EQUAL(val
, 0);
1154 BOOST_CHECK(signbit(val
) == 0);
1156 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1158 arg
= std::numeric_limits
<T
>::quiet_NaN();
1159 check_invalid(exp(arg
));
1160 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1161 check_invalid(exp(arg
));
1166 BOOST_CHECK_EQUAL(val
, 1);
1171 BOOST_CHECK_EQUAL(val
, 1);
1173 if(std::numeric_limits
<T
>::has_infinity
)
1175 arg
= std::numeric_limits
<T
>::infinity();
1177 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1180 BOOST_CHECK_EQUAL(val
, 0);
1181 BOOST_CHECK(signbit(val
) == 0);
1182 arg
= (std::numeric_limits
<T
>::max
)();
1184 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1187 BOOST_CHECK_EQUAL(val
, 0);
1188 BOOST_CHECK(signbit(val
) == 0);
1190 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1192 arg
= std::numeric_limits
<T
>::quiet_NaN();
1193 check_invalid(exp2(arg
));
1194 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1195 check_invalid(exp2(arg
));
1200 BOOST_CHECK_EQUAL(val
, 0);
1201 BOOST_CHECK(signbit(val
) == 0);
1206 BOOST_CHECK_EQUAL(val
, 0);
1207 BOOST_CHECK(signbit(val
));
1209 if(std::numeric_limits
<T
>::has_infinity
)
1211 arg
= std::numeric_limits
<T
>::infinity();
1213 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1216 BOOST_CHECK_EQUAL(val
, -1);
1217 arg
= (std::numeric_limits
<T
>::max
)();
1219 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1222 BOOST_CHECK_EQUAL(val
, -1);
1224 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1226 arg
= std::numeric_limits
<T
>::quiet_NaN();
1227 check_invalid(expm1(arg
));
1228 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1229 check_invalid(expm1(arg
));
1234 val
= frexp(arg
, &ival
);
1235 BOOST_CHECK_EQUAL(val
, 0);
1236 BOOST_CHECK_EQUAL(ival
, 0);
1237 BOOST_CHECK(signbit(val
) == 0);
1241 val
= frexp(arg
, &ival
);
1242 BOOST_CHECK_EQUAL(val
, 0);
1243 BOOST_CHECK(signbit(val
));
1244 BOOST_CHECK(signbit(val
));
1246 if(std::numeric_limits
<T
>::has_infinity
)
1248 arg
= std::numeric_limits
<T
>::infinity();
1249 val
= frexp(arg
, &ival
);
1250 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1252 val
= frexp(arg
, &ival
);
1253 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1255 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1257 arg
= std::numeric_limits
<T
>::quiet_NaN();
1258 val
= frexp(arg
, &ival
);
1259 BOOST_CHECK(isnan(val
));
1262 typename
T::backend_type::exponent_type eval
;
1263 typename
T::backend_type::exponent_type fp_ilogb0
= (std::numeric_limits
<typename
T::backend_type::exponent_type
>::min
)();
1264 typename
T::backend_type::exponent_type fp_ilogbnan
=
1266 FP_ILOGBNAN
< 0 ? (std::numeric_limits
<typename
T::backend_type::exponent_type
>::min
)() : (std::numeric_limits
<typename
T::backend_type::exponent_type
>::max
)();
1273 BOOST_CHECK_EQUAL(eval
, fp_ilogb0
);
1274 if(std::numeric_limits
<T
>::has_infinity
)
1276 arg
= std::numeric_limits
<T
>::infinity();
1278 BOOST_CHECK_EQUAL(eval
, (std::numeric_limits
<typename
T::backend_type::exponent_type
>::max
)());
1281 BOOST_CHECK_EQUAL(eval
, (std::numeric_limits
<typename
T::backend_type::exponent_type
>::max
)());
1283 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1285 arg
= std::numeric_limits
<T
>::quiet_NaN();
1287 BOOST_CHECK_EQUAL(eval
, fp_ilogbnan
);
1292 BOOST_CHECK_EQUAL(val
, 0);
1293 BOOST_CHECK(signbit(val
) == 0);
1294 if(std::numeric_limits
<T
>::has_infinity
)
1298 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1304 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1308 check_invalid(log(arg
));
1309 arg
= -std::numeric_limits
<T
>::infinity();
1310 check_invalid(log(arg
));
1311 arg
= std::numeric_limits
<T
>::infinity();
1313 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1315 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1317 arg
= std::numeric_limits
<T
>::quiet_NaN();
1318 check_invalid(log(arg
));
1319 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1320 check_invalid(log(arg
));
1325 BOOST_CHECK_EQUAL(val
, 0);
1326 BOOST_CHECK(signbit(val
) == 0);
1327 if(std::numeric_limits
<T
>::has_infinity
)
1331 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1337 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1341 check_invalid(log10(arg
));
1342 arg
= -std::numeric_limits
<T
>::infinity();
1343 check_invalid(log10(arg
));
1344 arg
= std::numeric_limits
<T
>::infinity();
1346 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1348 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1350 arg
= std::numeric_limits
<T
>::quiet_NaN();
1351 check_invalid(log10(arg
));
1352 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1353 check_invalid(log10(arg
));
1358 BOOST_CHECK_EQUAL(val
, 0);
1359 BOOST_CHECK(signbit(val
) == 0);
1364 BOOST_CHECK_EQUAL(val
, 0);
1365 BOOST_CHECK(signbit(val
));
1367 if(std::numeric_limits
<T
>::has_infinity
)
1371 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1374 check_invalid(log1p(arg
));
1375 arg
= -std::numeric_limits
<T
>::infinity();
1376 check_invalid(log1p(arg
));
1377 arg
= std::numeric_limits
<T
>::infinity();
1379 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1381 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1383 arg
= std::numeric_limits
<T
>::quiet_NaN();
1384 check_invalid(log1p(arg
));
1385 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1386 check_invalid(log1p(arg
));
1391 BOOST_CHECK_EQUAL(val
, 0);
1392 BOOST_CHECK(signbit(val
) == 0);
1393 if(std::numeric_limits
<T
>::has_infinity
)
1397 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1403 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1407 check_invalid(log2(arg
));
1408 arg
= -std::numeric_limits
<T
>::infinity();
1409 check_invalid(log2(arg
));
1410 arg
= std::numeric_limits
<T
>::infinity();
1412 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1414 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1416 arg
= std::numeric_limits
<T
>::quiet_NaN();
1417 check_invalid(log2(arg
));
1418 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1419 check_invalid(log2(arg
));
1422 if(std::numeric_limits
<T
>::has_infinity
)
1426 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1432 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1435 arg
= std::numeric_limits
<T
>::infinity();
1437 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1438 arg
= -std::numeric_limits
<T
>::infinity();
1440 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1442 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1444 arg
= std::numeric_limits
<T
>::quiet_NaN();
1445 check_invalid(logb(arg
));
1446 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1447 check_invalid(logb(arg
));
1451 val
= scalbn(arg
, 2);
1452 BOOST_CHECK_EQUAL(val
, 0);
1453 BOOST_CHECK(signbit(val
) == 0);
1457 val
= scalbn(arg
, 2);
1458 BOOST_CHECK_EQUAL(val
, 0);
1459 BOOST_CHECK(signbit(val
));
1461 if(std::numeric_limits
<T
>::has_infinity
)
1463 arg
= std::numeric_limits
<T
>::infinity();
1464 val
= scalbn(arg
, -100);
1465 BOOST_CHECK_EQUAL(val
, arg
);
1467 val
= scalbn(arg
, -100);
1468 BOOST_CHECK_EQUAL(val
, arg
);
1473 BOOST_CHECK_EQUAL(val
, 0);
1474 BOOST_CHECK(signbit(val
) == 0);
1479 BOOST_CHECK_EQUAL(val
, 0);
1480 BOOST_CHECK(signbit(val
));
1482 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1484 // This test fails with early implementations of libquadmath - not our issue!
1486 if(std::numeric_limits
<T
>::has_infinity
)
1488 arg
= std::numeric_limits
<T
>::infinity();
1490 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1491 arg
= -std::numeric_limits
<T
>::infinity();
1493 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1496 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1498 arg
= std::numeric_limits
<T
>::quiet_NaN();
1499 check_invalid(cbrt(arg
));
1500 arg
= -std::numeric_limits
<T
>::quiet_NaN();
1501 check_invalid(cbrt(arg
));
1506 BOOST_CHECK_EQUAL(val
, 0);
1507 BOOST_CHECK(signbit(val
) == 0);
1512 BOOST_CHECK_EQUAL(val
, 0);
1513 BOOST_CHECK(signbit(val
) == 0);
1515 if(std::numeric_limits
<T
>::has_infinity
)
1517 arg
= std::numeric_limits
<T
>::infinity();
1519 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1520 arg
= -std::numeric_limits
<T
>::infinity();
1522 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1527 val
= hypot(arg
, arg2
);
1528 BOOST_CHECK_EQUAL(val
, arg
);
1530 val
= hypot(arg
, arg2
);
1531 BOOST_CHECK_EQUAL(val
, arg
);
1532 if(std::numeric_limits
<T
>::has_infinity
)
1534 arg
= std::numeric_limits
<T
>::infinity();
1536 val
= hypot(arg
, arg2
);
1537 BOOST_CHECK_EQUAL(val
, arg
);
1539 val
= hypot(arg
, arg2
);
1540 BOOST_CHECK_EQUAL(val
, -arg
);
1541 arg2
= std::numeric_limits
<T
>::quiet_NaN();
1542 val
= hypot(arg
, arg2
);
1543 BOOST_CHECK_EQUAL(val
, -arg
);
1545 val
= hypot(arg
, arg2
);
1546 BOOST_CHECK_EQUAL(val
, arg
);
1549 if(std::numeric_limits
<T
>::has_infinity
)
1553 val
= pow(arg
, arg2
);
1554 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1559 val
= pow(arg
, arg2
);
1560 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1565 val
= pow(arg
, arg2
);
1566 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1571 val
= pow(arg
, arg2
);
1572 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1577 val
= pow(arg
, arg2
);
1578 BOOST_CHECK_EQUAL(val
, 0);
1579 BOOST_CHECK(signbit(val
) == 0);
1583 val
= pow(arg
, arg2
);
1584 BOOST_CHECK_EQUAL(val
, 0);
1585 BOOST_CHECK(signbit(val
));
1589 val
= pow(arg
, arg2
);
1590 BOOST_CHECK_EQUAL(val
, 0);
1591 BOOST_CHECK(signbit(val
) == 0);
1595 val
= pow(arg
, arg2
);
1596 BOOST_CHECK_EQUAL(val
, 0);
1597 BOOST_CHECK(signbit(val
) == 0);
1600 arg2
= std::numeric_limits
<T
>::infinity();
1601 val
= pow(arg
, arg2
);
1602 BOOST_CHECK_EQUAL(val
, 1);
1603 arg2
= -std::numeric_limits
<T
>::infinity();
1604 val
= pow(arg
, arg2
);
1605 BOOST_CHECK_EQUAL(val
, 1);
1608 val
= pow(arg
, arg2
);
1609 BOOST_CHECK_EQUAL(val
, 1);
1610 arg2
= std::numeric_limits
<T
>::infinity();
1611 val
= pow(arg
, arg2
);
1612 BOOST_CHECK_EQUAL(val
, 1);
1613 arg2
= -std::numeric_limits
<T
>::infinity();
1614 val
= pow(arg
, arg2
);
1615 BOOST_CHECK_EQUAL(val
, 1);
1616 arg2
= std::numeric_limits
<T
>::quiet_NaN();
1617 val
= pow(arg
, arg2
);
1618 BOOST_CHECK_EQUAL(val
, 1);
1621 val
= pow(arg
, arg2
);
1622 BOOST_CHECK_EQUAL(val
, 1);
1624 val
= pow(arg
, arg2
);
1625 BOOST_CHECK_EQUAL(val
, 1);
1626 arg
= std::numeric_limits
<T
>::infinity();
1627 val
= pow(arg
, arg2
);
1628 BOOST_CHECK_EQUAL(val
, 1);
1630 val
= pow(arg
, arg2
);
1631 BOOST_CHECK_EQUAL(val
, 1);
1632 arg
= std::numeric_limits
<T
>::quiet_NaN();
1633 val
= pow(arg
, arg2
);
1634 BOOST_CHECK_EQUAL(val
, 1);
1636 val
= pow(arg
, arg2
);
1637 BOOST_CHECK_EQUAL(val
, 1);
1639 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1643 check_invalid(pow(arg
, arg2
));
1645 if(std::numeric_limits
<T
>::has_infinity
)
1648 arg2
= -std::numeric_limits
<T
>::infinity();
1649 val
= pow(arg
, arg2
);
1650 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1652 val
= pow(arg
, arg2
);
1653 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1655 arg2
= -std::numeric_limits
<T
>::infinity();
1656 val
= pow(arg
, arg2
);
1657 BOOST_CHECK_EQUAL(val
, 0);
1659 val
= pow(arg
, arg2
);
1660 BOOST_CHECK_EQUAL(val
, 0);
1662 arg2
= std::numeric_limits
<T
>::infinity();
1663 val
= pow(arg
, arg2
);
1664 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1666 val
= pow(arg
, arg2
);
1667 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1668 arg
= -std::numeric_limits
<T
>::infinity();
1670 val
= pow(arg
, arg2
);
1671 BOOST_CHECK_EQUAL(val
, 0);
1673 BOOST_CHECK(signbit(val
));
1675 val
= pow(arg
, arg2
);
1676 BOOST_CHECK_EQUAL(val
, 0);
1677 BOOST_CHECK(signbit(val
) == 0);
1679 val
= pow(arg
, arg2
);
1680 BOOST_CHECK_EQUAL(val
, 0);
1681 BOOST_CHECK(signbit(val
) == 0);
1683 val
= pow(arg
, arg2
);
1684 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1686 val
= pow(arg
, arg2
);
1687 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1689 val
= pow(arg
, arg2
);
1690 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1693 val
= pow(arg
, arg2
);
1694 BOOST_CHECK_EQUAL(val
, 0);
1695 BOOST_CHECK(signbit(val
) == 0);
1697 val
= pow(arg
, arg2
);
1698 BOOST_CHECK_EQUAL(val
, 0);
1699 BOOST_CHECK(signbit(val
) == 0);
1701 val
= pow(arg
, arg2
);
1702 BOOST_CHECK_EQUAL(val
, 0);
1703 BOOST_CHECK(signbit(val
) == 0);
1705 val
= pow(arg
, arg2
);
1706 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1708 val
= pow(arg
, arg2
);
1709 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1711 val
= pow(arg
, arg2
);
1712 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1717 BOOST_CHECK_EQUAL(val
, 0);
1718 BOOST_CHECK(signbit(val
) == 0);
1723 BOOST_CHECK_EQUAL(val
, 0);
1724 BOOST_CHECK(signbit(val
));
1726 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1728 // This test fails with early implementations of libquadmath - not our issue!
1730 if(std::numeric_limits
<T
>::has_infinity
)
1732 arg
= std::numeric_limits
<T
>::infinity();
1734 BOOST_CHECK_EQUAL(val
, arg
);
1736 check_invalid(sqrt(arg
));
1739 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1741 arg
= std::numeric_limits
<T
>::quiet_NaN();
1742 check_invalid(sqrt(arg
));
1747 BOOST_CHECK_EQUAL(val
, 0);
1748 BOOST_CHECK(signbit(val
) == 0);
1753 BOOST_CHECK_EQUAL(val
, 0);
1754 BOOST_CHECK(signbit(val
));
1756 if(std::numeric_limits
<T
>::has_infinity
)
1758 arg
= std::numeric_limits
<T
>::infinity();
1760 BOOST_CHECK_EQUAL(val
, 1);
1763 BOOST_CHECK_EQUAL(val
, -1);
1765 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1767 arg
= std::numeric_limits
<T
>::quiet_NaN();
1768 check_invalid(erf(arg
));
1771 if(std::numeric_limits
<T
>::has_infinity
)
1773 arg
= std::numeric_limits
<T
>::infinity();
1775 BOOST_CHECK_EQUAL(val
, 0);
1776 BOOST_CHECK(signbit(val
) == 0);
1779 BOOST_CHECK_EQUAL(val
, 2);
1781 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1783 arg
= std::numeric_limits
<T
>::quiet_NaN();
1784 check_invalid(erfc(arg
));
1789 BOOST_CHECK_EQUAL(val
, 0);
1790 BOOST_CHECK(signbit(val
) == 0);
1793 BOOST_CHECK_EQUAL(val
, 0);
1794 BOOST_CHECK(signbit(val
) == 0);
1795 #if !defined(BOOST_MPFR_VERSION) || (BOOST_MPFR_VERSION > 30103)
1798 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1802 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1806 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1808 arg
= -std::numeric_limits
<T
>::infinity();
1810 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1812 arg
= std::numeric_limits
<T
>::infinity();
1814 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1815 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1817 arg
= std::numeric_limits
<T
>::quiet_NaN();
1818 check_invalid(lgamma(arg
));
1821 if(std::numeric_limits
<T
>::has_infinity
)
1825 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1831 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1835 check_invalid(tgamma(arg
));
1836 arg
= -std::numeric_limits
<T
>::infinity();
1837 check_invalid(tgamma(arg
));
1838 arg
= std::numeric_limits
<T
>::infinity();
1840 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1842 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1844 arg
= std::numeric_limits
<T
>::quiet_NaN();
1845 check_invalid(tgamma(arg
));
1850 BOOST_CHECK_EQUAL(val
, 0);
1851 BOOST_CHECK(signbit(val
) == 0);
1856 BOOST_CHECK_EQUAL(val
, 0);
1857 BOOST_CHECK(signbit(val
));
1859 if(std::numeric_limits
<T
>::has_infinity
)
1861 arg
= std::numeric_limits
<T
>::infinity();
1863 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1866 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1868 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1870 arg
= std::numeric_limits
<T
>::quiet_NaN();
1871 check_invalid(ceil(arg
));
1876 BOOST_CHECK_EQUAL(val
, 0);
1877 BOOST_CHECK(signbit(val
) == 0);
1882 BOOST_CHECK_EQUAL(val
, 0);
1883 BOOST_CHECK(signbit(val
));
1885 if(std::numeric_limits
<T
>::has_infinity
)
1887 arg
= std::numeric_limits
<T
>::infinity();
1889 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1892 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1894 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1896 arg
= std::numeric_limits
<T
>::quiet_NaN();
1897 check_invalid(floor(arg
));
1901 val
= nearbyint(arg
);
1902 BOOST_CHECK_EQUAL(val
, 0);
1903 BOOST_CHECK(signbit(val
) == 0);
1907 val
= nearbyint(arg
);
1908 BOOST_CHECK_EQUAL(val
, 0);
1909 BOOST_CHECK(signbit(val
));
1911 if(std::numeric_limits
<T
>::has_infinity
)
1913 arg
= std::numeric_limits
<T
>::infinity();
1914 val
= nearbyint(arg
);
1915 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1917 val
= nearbyint(arg
);
1918 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1920 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1922 arg
= std::numeric_limits
<T
>::quiet_NaN();
1923 check_invalid(nearbyint(arg
));
1928 BOOST_CHECK_EQUAL(val
, 0);
1929 BOOST_CHECK(signbit(val
) == 0);
1934 BOOST_CHECK_EQUAL(val
, 0);
1935 BOOST_CHECK(signbit(val
));
1937 if(std::numeric_limits
<T
>::has_infinity
)
1939 arg
= std::numeric_limits
<T
>::infinity();
1941 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1944 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1946 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1948 arg
= std::numeric_limits
<T
>::quiet_NaN();
1949 check_invalid(rint(arg
));
1954 BOOST_CHECK_EQUAL(val
, 0);
1955 BOOST_CHECK(signbit(val
) == 0);
1960 BOOST_CHECK_EQUAL(val
, 0);
1961 BOOST_CHECK(signbit(val
));
1963 if(std::numeric_limits
<T
>::has_infinity
)
1965 arg
= std::numeric_limits
<T
>::infinity();
1967 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1970 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1972 if(std::numeric_limits
<T
>::has_quiet_NaN
)
1974 arg
= std::numeric_limits
<T
>::quiet_NaN();
1975 check_invalid(round(arg
));
1980 BOOST_CHECK_EQUAL(val
, 0);
1981 BOOST_CHECK(signbit(val
) == 0);
1986 BOOST_CHECK_EQUAL(val
, 0);
1987 BOOST_CHECK(signbit(val
));
1989 if(std::numeric_limits
<T
>::has_infinity
)
1991 arg
= std::numeric_limits
<T
>::infinity();
1993 BOOST_CHECK_EQUAL(val
, std::numeric_limits
<T
>::infinity());
1996 BOOST_CHECK_EQUAL(val
, -std::numeric_limits
<T
>::infinity());
1998 if(std::numeric_limits
<T
>::has_quiet_NaN
)
2000 arg
= std::numeric_limits
<T
>::quiet_NaN();
2001 check_invalid(trunc(arg
));
2006 val
= fmod(arg
, arg2
);
2007 BOOST_CHECK_EQUAL(val
, 0);
2008 BOOST_CHECK(signbit(val
) == 0);
2012 val
= fmod(arg
, arg2
);
2013 BOOST_CHECK_EQUAL(val
, 0);
2014 BOOST_CHECK(signbit(val
));
2016 if(std::numeric_limits
<T
>::has_infinity
)
2018 arg
= std::numeric_limits
<T
>::infinity();
2019 check_invalid(fmod(arg
, arg2
));
2021 check_invalid(fmod(arg
, arg2
));
2024 check_invalid(fmod(arg
, arg2
));
2025 check_invalid(fmod(arg
, -arg2
));
2027 if(std::numeric_limits
<T
>::has_quiet_NaN
)
2029 arg
= std::numeric_limits
<T
>::quiet_NaN();
2031 check_invalid(fmod(arg
, arg2
));
2033 check_invalid(fmod(arg
, arg2
));
2034 check_invalid(fmod(arg2
, arg2
));
2040 test_poison
<float>();
2041 test_poison
<double>();
2043 test
<boost::multiprecision::mpf_float_50
>();
2044 test
<boost::multiprecision::mpf_float_100
>();
2047 std::cout
<< "Testing MPFR: " << MPFR_VERSION_STRING
<< std::endl
;
2048 test
<boost::multiprecision::mpfr_float_50
>();
2049 test
<boost::multiprecision::mpfr_float_100
>();
2050 test_c99_appendix_F
<boost::multiprecision::mpfr_float_50
>();
2053 test
<boost::multiprecision::mpfi_float_50
>();
2054 test
<boost::multiprecision::mpfi_float_100
>();
2056 #ifdef TEST_CPP_DEC_FLOAT
2057 test
<boost::multiprecision::cpp_dec_float_50
>();
2058 #if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2059 test
<boost::multiprecision::cpp_dec_float_100
>();
2061 test_c99_appendix_F
<boost::multiprecision::cpp_dec_float_50
>();
2063 #ifdef TEST_CPP_DEC_FLOAT_2
2064 // Some "peculiar" digit counts which stress our code:
2065 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<65> > >();
2066 #if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2067 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<64> > >();
2070 #ifdef TEST_CPP_DEC_FLOAT_3
2071 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<63> > >();
2072 #if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2073 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<62> > >();
2076 #ifdef TEST_CPP_DEC_FLOAT_4
2077 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<61, long long> > >();
2078 #if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2079 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<60, long long> > >();
2082 #ifdef TEST_CPP_DEC_FLOAT_5
2083 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<59, long long, std::allocator
<void> > > >();
2084 #if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2085 test
<boost::multiprecision::number
<boost::multiprecision::cpp_dec_float
<58, long long, std::allocator
<void> > > >();
2088 #ifdef TEST_CPP_BIN_FLOAT
2089 test
<boost::multiprecision::cpp_bin_float_50
>();
2090 test
<boost::multiprecision::number
<boost::multiprecision::cpp_bin_float
<100>, boost::multiprecision::et_on
> >();
2091 test_c99_appendix_F
<boost::multiprecision::cpp_bin_float_50
>();
2092 test_c99_appendix_F
<boost::multiprecision::number
<boost::multiprecision::cpp_bin_float
<100>, boost::multiprecision::et_on
> >();
2094 #ifdef TEST_FLOAT128
2095 test
<boost::multiprecision::float128
>();
2096 test_c99_appendix_F
<boost::multiprecision::float128
>();
2099 return boost::report_errors();