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) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_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) && !defined(TEST_CPP_BIN_FLOAT_2) && !defined(TEST_CPP_BIN_FLOAT_3)
14 #define TEST_CPP_DEC_FLOAT
15 #define TEST_CPP_DEC_FLOAT_2
16 #define TEST_CPP_DEC_FLOAT_3
17 #define TEST_CPP_DEC_FLOAT_4
18 #define TEST_CPP_DEC_FLOAT_5
19 #define TEST_CPP_DEC_FLOAT_6
21 #define TEST_CPP_BIN_FLOAT
22 #define TEST_CPP_BIN_FLOAT_2
23 #define TEST_CPP_BIN_FLOAT_3
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) || defined(TEST_CPP_DEC_FLOAT_6)
44 #include <boost/multiprecision/cpp_dec_float.hpp>
46 #if defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_BIN_FLOAT_2) || defined(TEST_CPP_BIN_FLOAT_3)
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>
55 #include <boost/math/special_functions/gamma.hpp>
83 #ifdef MPFR_VERSION_MAJOR
84 #define BOOST_MPFR_VERSION MPFR_VERSION_MAJOR * 10000 + MPFR_VERSION_MINOR * 100 + MPFR_VERSION_PATCHLEVEL
87 template <class T, class U>
88 void test_less(T a, U b)
92 BOOST_CHECK(!(a > b));
93 BOOST_CHECK(!(a >= b));
94 BOOST_CHECK(!(a == b));
95 BOOST_CHECK((a != b));
99 BOOST_CHECK(!(b < a));
100 BOOST_CHECK(!(b <= a));
101 BOOST_CHECK(!(b == a));
102 BOOST_CHECK((b != a));
104 BOOST_CHECK(isless(a, b));
105 BOOST_CHECK(islessequal(a, b));
106 BOOST_CHECK(!isgreater(a, b));
107 BOOST_CHECK(!isgreaterequal(a, b));
108 BOOST_CHECK(islessgreater(a, b));
110 BOOST_CHECK(!isless(b, a));
111 BOOST_CHECK(!islessequal(b, a));
112 BOOST_CHECK(isgreater(b, a));
113 BOOST_CHECK(isgreaterequal(b, a));
114 BOOST_CHECK(islessgreater(b, a));
116 template <class T, class U>
117 void test_equal(T a, U b)
119 BOOST_CHECK(!(a < b));
121 BOOST_CHECK(!(a > b));
122 BOOST_CHECK((a >= b));
123 BOOST_CHECK((a == b));
124 BOOST_CHECK(!(a != b));
126 BOOST_CHECK(!(b > a));
128 BOOST_CHECK(!(b < a));
129 BOOST_CHECK((b <= a));
130 BOOST_CHECK((b == a));
131 BOOST_CHECK(!(b != a));
133 BOOST_CHECK(!isless(a, b));
134 BOOST_CHECK(islessequal(a, b));
135 BOOST_CHECK(!isgreater(a, b));
136 BOOST_CHECK(isgreaterequal(a, b));
137 BOOST_CHECK(!islessgreater(a, b));
139 BOOST_CHECK(!isless(b, a));
140 BOOST_CHECK(islessequal(b, a));
141 BOOST_CHECK(!isgreater(b, a));
142 BOOST_CHECK(isgreaterequal(b, a));
143 BOOST_CHECK(!islessgreater(b, a));
145 template <class T, class U>
146 void test_unordered(T a, U 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));
153 BOOST_CHECK((a != b));
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));
160 BOOST_CHECK((b != a));
162 BOOST_CHECK(!isless(a, b));
163 BOOST_CHECK(!islessequal(a, b));
164 BOOST_CHECK(!isgreater(a, b));
165 BOOST_CHECK(!isgreaterequal(a, b));
166 BOOST_CHECK(!islessgreater(a, b));
168 BOOST_CHECK(!isless(b, a));
169 BOOST_CHECK(!islessequal(b, a));
170 BOOST_CHECK(!isgreater(b, a));
171 BOOST_CHECK(!isgreaterequal(b, a));
172 BOOST_CHECK(!islessgreater(b, a));
179 // Basic sanity checks for C99 functions which are just imported versions
180 // from Boost.Math. These should still be found via ADL so no using declarations here...
183 BOOST_CHECK(signbit(val) == 0);
184 BOOST_CHECK(signbit(val + 2) == 0);
186 BOOST_CHECK(signbit(val));
187 BOOST_CHECK(signbit(val * 2));
190 BOOST_CHECK_EQUAL(sign(val), 1);
191 BOOST_CHECK_EQUAL(sign(val + 2), 1);
193 BOOST_CHECK_EQUAL(sign(val), -1);
194 BOOST_CHECK_EQUAL(sign(val * 2), -1);
196 BOOST_CHECK_EQUAL(sign(val), 0);
197 BOOST_CHECK_EQUAL(sign(val * 2), 0);
200 BOOST_CHECK_EQUAL(changesign(val), -2);
201 BOOST_CHECK_EQUAL(changesign(val * 2), -4);
203 BOOST_CHECK_EQUAL(changesign(val), 2);
204 BOOST_CHECK_EQUAL(changesign(val * 2), 4);
206 BOOST_CHECK_EQUAL(changesign(val), 0);
207 BOOST_CHECK_EQUAL(changesign(val * 2), 0);
208 // Things involving signed zero, need to detect it first:
209 T neg_zero_test = -(std::numeric_limits<T>::min)();
210 neg_zero_test /= (std::numeric_limits<T>::max)();
212 bool test_signed_zero = !boost::multiprecision::is_interval_number<T>::value && std::numeric_limits<T>::has_infinity && (one / neg_zero_test < 0);
213 if (test_signed_zero)
215 BOOST_CHECK(signbit(changesign(val)));
216 BOOST_CHECK(signbit(changesign(val * 2)));
221 BOOST_CHECK_EQUAL(copysign(val, s), 3);
222 BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
223 BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
224 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
226 BOOST_CHECK_EQUAL(copysign(val, s), -3);
227 BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
228 BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
229 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
231 BOOST_CHECK_EQUAL(copysign(val, s), -3);
232 BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
233 BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
234 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
236 BOOST_CHECK_EQUAL(copysign(val, s), 3);
237 // Things involving signed zero, need to detect it first:
238 if (test_signed_zero)
240 BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
242 BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
243 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
244 // Things involving signed zero, need to detect it first:
245 if (test_signed_zero)
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);
258 BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
259 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
260 BOOST_CHECK(!isinf(val));
261 BOOST_CHECK(!isinf(val + 2));
262 BOOST_CHECK(!isnan(val));
263 BOOST_CHECK(!isnan(val + 2));
264 BOOST_CHECK(isnormal(val));
265 BOOST_CHECK(isnormal(val + 2));
267 BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
268 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
269 BOOST_CHECK(!isinf(val));
270 BOOST_CHECK(!isinf(val + 2));
271 BOOST_CHECK(!isnan(val));
272 BOOST_CHECK(!isnan(val + 2));
273 BOOST_CHECK(isnormal(val));
274 BOOST_CHECK(isnormal(val + 2));
276 BOOST_CHECK_EQUAL(fpclassify(val), FP_ZERO);
277 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_ZERO);
278 BOOST_CHECK(!isinf(val));
279 BOOST_CHECK(!isinf(val + 2));
280 BOOST_CHECK(!isnan(val));
281 BOOST_CHECK(!isnan(val + 2));
282 BOOST_CHECK(!isnormal(val));
283 BOOST_CHECK(!isnormal(val * 2));
284 BOOST_CHECK(!isnormal(val * -2));
285 if (std::numeric_limits<T>::has_infinity)
287 val = std::numeric_limits<T>::infinity();
288 BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
289 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
290 BOOST_CHECK(isinf(val));
291 BOOST_CHECK(isinf(val + 2));
292 BOOST_CHECK(!isnan(val));
293 BOOST_CHECK(!isnan(val + 2));
294 BOOST_CHECK(!isnormal(val));
295 BOOST_CHECK(!isnormal(val + 2));
297 BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
298 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
299 BOOST_CHECK(isinf(val));
300 BOOST_CHECK(isinf(val + 2));
301 BOOST_CHECK(!isnan(val));
302 BOOST_CHECK(!isnan(val + 2));
303 BOOST_CHECK(!isnormal(val));
304 BOOST_CHECK(!isnormal(val + 2));
306 if (std::numeric_limits<T>::has_quiet_NaN)
308 val = std::numeric_limits<T>::quiet_NaN();
309 BOOST_CHECK_EQUAL(fpclassify(val), FP_NAN);
310 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NAN);
311 BOOST_CHECK(!isinf(val));
312 BOOST_CHECK(!isinf(val + 2));
313 BOOST_CHECK(isnan(val));
314 BOOST_CHECK(isnan(val + 2));
315 BOOST_CHECK(!isnormal(val));
316 BOOST_CHECK(!isnormal(val + 2));
318 s = 8 * std::numeric_limits<T>::epsilon();
320 BOOST_CHECK_CLOSE_FRACTION(asinh(val), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
321 BOOST_CHECK_CLOSE_FRACTION(asinh(val + T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
322 BOOST_CHECK_CLOSE_FRACTION(acosh(val), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
323 BOOST_CHECK_CLOSE_FRACTION(acosh(val + T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
325 BOOST_CHECK_CLOSE_FRACTION(atanh(val), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
326 BOOST_CHECK_CLOSE_FRACTION(atanh(val + T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
328 BOOST_CHECK_CLOSE_FRACTION(cbrt(val), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
329 BOOST_CHECK_CLOSE_FRACTION(cbrt(val + T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
330 if (!boost::multiprecision::is_interval_number<T>::value)
333 BOOST_CHECK_CLOSE_FRACTION(erf(val), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
334 BOOST_CHECK_CLOSE_FRACTION(erf(val + T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
335 BOOST_CHECK_CLOSE_FRACTION(erfc(val), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
336 BOOST_CHECK_CLOSE_FRACTION(erfc(val + T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
339 BOOST_CHECK_CLOSE_FRACTION(expm1(val), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
340 BOOST_CHECK_CLOSE_FRACTION(expm1(val + T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
344 BOOST_CHECK_EQUAL(fdim(val, s), 18);
345 BOOST_CHECK_EQUAL(fdim(s, val), 0);
346 BOOST_CHECK_EQUAL(fdim(val, s * 2), 16);
347 BOOST_CHECK_EQUAL(fdim(s * 2, val), 0);
348 BOOST_CHECK_EQUAL(fdim(val, 2), 18);
349 BOOST_CHECK_EQUAL(fdim(2, val), 0);
351 BOOST_CHECK_EQUAL(fmax(val, s), val);
352 BOOST_CHECK_EQUAL(fmax(s, val), val);
353 BOOST_CHECK_EQUAL(fmax(val * 2, s), val * 2);
354 BOOST_CHECK_EQUAL(fmax(val, s * 2), val);
355 BOOST_CHECK_EQUAL(fmax(val * 2, s * 2), val * 2);
356 BOOST_CHECK_EQUAL(fmin(val, s), s);
357 BOOST_CHECK_EQUAL(fmin(s, val), s);
358 BOOST_CHECK_EQUAL(fmin(val * 2, s), s);
359 BOOST_CHECK_EQUAL(fmin(val, s * 2), s * 2);
360 BOOST_CHECK_EQUAL(fmin(val * 2, s * 2), s * 2);
362 BOOST_CHECK_EQUAL(fmax(val, 2), val);
363 BOOST_CHECK_EQUAL(fmax(val, 2.0), val);
364 BOOST_CHECK_EQUAL(fmax(20, s), val);
365 BOOST_CHECK_EQUAL(fmax(20.0, s), val);
366 BOOST_CHECK_EQUAL(fmin(val, 2), s);
367 BOOST_CHECK_EQUAL(fmin(val, 2.0), s);
368 BOOST_CHECK_EQUAL(fmin(20, s), s);
369 BOOST_CHECK_EQUAL(fmin(20.0, s), s);
370 if (std::numeric_limits<T>::has_quiet_NaN)
372 BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<T>::quiet_NaN()), val);
373 BOOST_CHECK_EQUAL(fmax(std::numeric_limits<T>::quiet_NaN(), val), val);
374 BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<T>::quiet_NaN()), val);
375 BOOST_CHECK_EQUAL(fmin(std::numeric_limits<T>::quiet_NaN(), val), val);
377 if (std::numeric_limits<double>::has_quiet_NaN)
379 BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<double>::quiet_NaN()), val);
380 BOOST_CHECK_EQUAL(fmax(std::numeric_limits<double>::quiet_NaN(), val), val);
381 BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<double>::quiet_NaN()), val);
382 BOOST_CHECK_EQUAL(fmin(std::numeric_limits<double>::quiet_NaN(), val), val);
388 test_less(s + 0, val);
389 test_less(s, val * 1);
390 test_less(s * 1, val * 1);
391 test_less(s * 1, 20);
392 test_less(s + 2, val * 2);
394 test_equal(val, val);
397 test_equal(val + 0, val);
398 test_equal(val, val * 1);
399 test_equal(val * 1, val * 1);
400 test_equal(val * 1, 20);
401 test_equal(val * 20, val * 20);
403 if (std::numeric_limits<T>::has_quiet_NaN)
405 s = std::numeric_limits<T>::quiet_NaN();
406 test_unordered(s, val);
407 test_unordered(s, 20);
408 test_unordered(s + 0, val);
409 test_unordered(s, val * 1);
410 test_unordered(s * 1, val * 1);
411 test_unordered(s * 1, 20);
412 test_unordered(s + 2, val * 2);
413 if (std::numeric_limits<double>::has_quiet_NaN)
415 double n = std::numeric_limits<double>::quiet_NaN();
416 test_unordered(n, val);
420 T tol = 8 * std::numeric_limits<T>::epsilon();
422 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
423 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
424 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
425 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
426 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
427 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
428 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
429 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
430 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
431 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
432 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
434 BOOST_CHECK_CLOSE_FRACTION(lgamma(val), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
435 BOOST_CHECK_CLOSE_FRACTION(lgamma(val + 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
437 BOOST_CHECK_EQUAL(lrint(val), 20);
438 BOOST_CHECK_EQUAL(lrint(val * 2), 40);
439 BOOST_CHECK_EQUAL(llrint(val), 20);
440 BOOST_CHECK_EQUAL(llrint(val * 2), 40);
443 BOOST_CHECK_CLOSE_FRACTION(log1p(val), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
444 BOOST_CHECK_CLOSE_FRACTION(log1p(val + 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
446 BOOST_CHECK_CLOSE_FRACTION(T(log2(val)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
447 BOOST_CHECK_CLOSE_FRACTION(T(log2(val + 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
449 BOOST_CHECK_EQUAL(T(nearbyint(val)), 20);
450 BOOST_CHECK_EQUAL(T(nearbyint(val + 0.25)), 20);
451 BOOST_CHECK_EQUAL(T(rint(val)), 20);
452 BOOST_CHECK_EQUAL(T(rint(val + 0.25)), 20);
454 BOOST_CHECK_GT(nextafter(val, T(200)), val);
455 BOOST_CHECK_GT(nextafter(val + 0, T(200)), val);
456 BOOST_CHECK_GT(nextafter(val + 0, T(200) + 1), val);
457 BOOST_CHECK_GT(nextafter(val, T(200) + 1), val);
459 BOOST_CHECK_GT(nexttoward(val, T(200)), val);
460 BOOST_CHECK_GT(nexttoward(val + 0, T(200)), val);
461 BOOST_CHECK_GT(nexttoward(val + 0, T(200) + 1), val);
462 BOOST_CHECK_GT(nexttoward(val, T(200) + 1), val);
466 BOOST_CHECK_EQUAL(T(remainder(val, s)), 1);
467 BOOST_CHECK_EQUAL(T(remainder(val, 5)), 1);
468 BOOST_CHECK_EQUAL(T(remainder(21, s)), 1);
469 BOOST_CHECK_EQUAL(T(remainder(val * 1, s)), 1);
470 BOOST_CHECK_EQUAL(T(remainder(val * 1, s * 1)), 1);
471 BOOST_CHECK_EQUAL(T(remainder(val, s * 1)), 1);
472 BOOST_CHECK_EQUAL(T(remainder(val * 1, 5)), 1);
473 BOOST_CHECK_EQUAL(T(remainder(21, s * 1)), 1);
475 BOOST_CHECK_EQUAL(T(remquo(val, s, &i)), 1);
476 BOOST_CHECK_EQUAL(i, 4);
478 BOOST_CHECK_EQUAL(T(remquo(val, 5, &i)), 1);
479 BOOST_CHECK_EQUAL(i, 4);
481 BOOST_CHECK_EQUAL(T(remquo(21, s, &i)), 1);
482 BOOST_CHECK_EQUAL(i, 4);
484 BOOST_CHECK_EQUAL(T(remquo(val * 1, s, &i)), 1);
485 BOOST_CHECK_EQUAL(i, 4);
487 BOOST_CHECK_EQUAL(T(remquo(val * 1, s * 1, &i)), 1);
488 BOOST_CHECK_EQUAL(i, 4);
490 BOOST_CHECK_EQUAL(T(remquo(val, s * 1, &i)), 1);
491 BOOST_CHECK_EQUAL(i, 4);
493 BOOST_CHECK_EQUAL(T(remquo(val * 1, 5, &i)), 1);
494 BOOST_CHECK_EQUAL(i, 4);
496 BOOST_CHECK_EQUAL(T(remquo(21, s * 1, &i)), 1);
497 BOOST_CHECK_EQUAL(i, 4);
501 BOOST_CHECK_CLOSE_FRACTION(tgamma(val), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol);
502 BOOST_CHECK_CLOSE_FRACTION(tgamma(val + 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol);
504 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol);
505 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol);
507 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T(32768uL), tol);
508 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T(65536uL), tol);
510 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);
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);
586 result += (min)(a, b);
587 result += (max)(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) + isfinite(a) + isinf(a) + islessgreater(a, b) + isnormal(a) + signbit(a) + isgreater(a, b) + isless(a, b);
597 bool type_sets_errno(const T&)
602 template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
603 bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>&)
609 bool type_sets_errno(const boost::multiprecision::float128&)
616 typename boost::enable_if_c<std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
618 if (std::numeric_limits<T>::has_quiet_NaN)
620 BOOST_CHECK(isnan(val));
624 BOOST_CHECK_EQUAL(val, 0);
626 if (type_sets_errno(val))
627 BOOST_CHECK_EQUAL(errno, EDOM);
632 typename boost::disable_if_c<std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
634 check_invalid(static_cast<typename T::result_type>(val));
638 void check_erange(const T& val)
640 if (type_sets_errno(val))
641 BOOST_CHECK_EQUAL(errno, ERANGE);
646 void test_c99_appendix_F()
649 // Tests conformance to non-normative appendix F.9.1 of C99, basically how to handle
650 // special cases, infinities and NaN's.
653 T tol = std::numeric_limits<T>::epsilon();
657 BOOST_CHECK_EQUAL(val, 0);
658 BOOST_CHECK(signbit(val) == 0);
660 check_invalid(acos(arg));
662 check_invalid(acos(arg));
663 if (std::numeric_limits<T>::has_infinity)
665 arg = std::numeric_limits<T>::infinity();
666 check_invalid(acos(arg));
667 arg = -std::numeric_limits<T>::infinity();
668 check_invalid(acos(arg));
670 if (std::numeric_limits<T>::has_quiet_NaN)
672 arg = std::numeric_limits<T>::quiet_NaN();
673 check_invalid(acos(arg));
674 arg = -std::numeric_limits<T>::quiet_NaN();
675 check_invalid(acos(arg));
680 BOOST_CHECK_EQUAL(val, 0);
681 BOOST_CHECK(signbit(val) == 0);
686 BOOST_CHECK_EQUAL(val, 0);
687 BOOST_CHECK(signbit(val));
690 check_invalid(asin(arg));
692 check_invalid(asin(arg));
693 if (std::numeric_limits<T>::has_infinity)
695 arg = std::numeric_limits<T>::infinity();
696 check_invalid(asin(arg));
697 arg = -std::numeric_limits<T>::infinity();
698 check_invalid(asin(arg));
700 if (std::numeric_limits<T>::has_quiet_NaN)
702 arg = std::numeric_limits<T>::quiet_NaN();
703 check_invalid(asin(arg));
704 arg = -std::numeric_limits<T>::quiet_NaN();
705 check_invalid(asin(arg));
710 BOOST_CHECK_EQUAL(val, 0);
711 BOOST_CHECK(signbit(val) == 0);
716 BOOST_CHECK_EQUAL(val, 0);
717 BOOST_CHECK(signbit(val));
719 if (std::numeric_limits<T>::has_infinity)
721 arg = std::numeric_limits<T>::infinity();
723 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
724 arg = -std::numeric_limits<T>::infinity();
726 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
728 if (std::numeric_limits<T>::has_quiet_NaN)
730 arg = std::numeric_limits<T>::quiet_NaN();
731 check_invalid(asin(arg));
732 arg = -std::numeric_limits<T>::quiet_NaN();
733 check_invalid(asin(arg));
738 val = atan2(arg, arg2);
739 BOOST_CHECK_EQUAL(val, 0);
740 BOOST_CHECK(signbit(val) == 0);
744 val = atan2(arg, arg2);
745 BOOST_CHECK_EQUAL(val, 0);
746 BOOST_CHECK(signbit(val));
752 val = atan2(arg, arg2);
753 BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
754 BOOST_CHECK(signbit(val) == 0);
756 val = atan2(arg, arg2);
757 BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
758 BOOST_CHECK(signbit(val));
762 val = atan2(arg, arg2);
763 BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
767 val = atan2(arg, arg2);
768 BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
772 val = atan2(arg, arg2);
773 BOOST_CHECK_EQUAL(val, 0);
774 BOOST_CHECK(signbit(val) == 0);
778 val = atan2(arg, arg2);
779 BOOST_CHECK_EQUAL(val, 0);
780 BOOST_CHECK(signbit(val));
784 val = atan2(arg, arg2);
785 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
789 val = atan2(arg, arg2);
790 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
794 val = atan2(arg, arg2);
795 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
799 val = atan2(arg, arg2);
800 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
802 if (std::numeric_limits<T>::has_infinity)
805 arg2 = -std::numeric_limits<T>::infinity();
806 val = atan2(arg, arg2);
807 BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
809 val = atan2(arg, arg2);
810 BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
812 arg2 = std::numeric_limits<T>::infinity();
813 val = atan2(arg, arg2);
814 BOOST_CHECK_EQUAL(val, 0);
815 BOOST_CHECK(signbit(val) == 0);
819 val = atan2(arg, arg2);
820 BOOST_CHECK_EQUAL(val, 0);
821 BOOST_CHECK(signbit(val));
823 arg = std::numeric_limits<T>::infinity();
825 val = atan2(arg, arg2);
826 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
828 val = atan2(arg, arg2);
829 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
830 arg = std::numeric_limits<T>::infinity();
832 val = atan2(arg, arg2);
833 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
835 val = atan2(arg, arg2);
836 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
837 arg = std::numeric_limits<T>::infinity();
838 arg2 = -std::numeric_limits<T>::infinity();
839 val = atan2(arg, arg2);
840 BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::three_quarters_pi<T>(), tol);
842 val = atan2(arg, arg2);
843 BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::three_quarters_pi<T>(), tol);
844 arg = std::numeric_limits<T>::infinity();
845 arg2 = std::numeric_limits<T>::infinity();
846 val = atan2(arg, arg2);
847 BOOST_CHECK_CLOSE_FRACTION(val, ldexp(boost::math::constants::pi<T>(), -2), tol);
849 val = atan2(arg, arg2);
850 BOOST_CHECK_CLOSE_FRACTION(val, -ldexp(boost::math::constants::pi<T>(), -2), tol);
851 if (std::numeric_limits<T>::has_quiet_NaN)
853 arg = std::numeric_limits<T>::quiet_NaN();
855 check_invalid(atan2(arg, arg2));
856 std::swap(arg, arg2);
857 check_invalid(atan2(arg, arg2));
858 arg = std::numeric_limits<T>::quiet_NaN();
859 check_invalid(atan2(arg, arg2));
865 BOOST_CHECK_EQUAL(val, 1);
867 BOOST_CHECK_EQUAL(val, 1);
868 if (std::numeric_limits<T>::has_infinity)
870 arg = std::numeric_limits<T>::infinity();
871 check_invalid(cos(arg));
872 arg = -std::numeric_limits<T>::infinity();
873 check_invalid(cos(arg));
875 if (std::numeric_limits<T>::has_quiet_NaN)
877 arg = std::numeric_limits<T>::quiet_NaN();
878 check_invalid(cos(arg));
879 arg = -std::numeric_limits<T>::quiet_NaN();
880 check_invalid(cos(arg));
885 BOOST_CHECK_EQUAL(val, 0);
886 BOOST_CHECK(signbit(val) == 0);
891 BOOST_CHECK_EQUAL(val, 0);
892 BOOST_CHECK(signbit(val));
894 if (std::numeric_limits<T>::has_infinity)
896 arg = std::numeric_limits<T>::infinity();
897 check_invalid(sin(arg));
898 arg = -std::numeric_limits<T>::infinity();
899 check_invalid(sin(arg));
901 if (std::numeric_limits<T>::has_quiet_NaN)
903 arg = std::numeric_limits<T>::quiet_NaN();
904 check_invalid(sin(arg));
905 arg = -std::numeric_limits<T>::quiet_NaN();
906 check_invalid(sin(arg));
911 BOOST_CHECK_EQUAL(val, 0);
912 BOOST_CHECK(signbit(val) == 0);
917 BOOST_CHECK_EQUAL(val, 0);
918 BOOST_CHECK(signbit(val));
920 if (std::numeric_limits<T>::has_infinity)
922 arg = std::numeric_limits<T>::infinity();
923 check_invalid(tan(arg));
924 arg = -std::numeric_limits<T>::infinity();
925 check_invalid(tan(arg));
927 if (std::numeric_limits<T>::has_quiet_NaN)
929 arg = std::numeric_limits<T>::quiet_NaN();
930 check_invalid(tan(arg));
931 arg = -std::numeric_limits<T>::quiet_NaN();
932 check_invalid(tan(arg));
937 BOOST_CHECK_EQUAL(val, 0);
938 BOOST_CHECK(signbit(val) == 0);
940 check_invalid(acosh(arg));
941 if (std::numeric_limits<T>::has_infinity)
943 arg = std::numeric_limits<T>::infinity();
945 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
947 arg = -std::numeric_limits<T>::infinity();
948 check_invalid(acosh(arg));
950 if (std::numeric_limits<T>::has_quiet_NaN)
952 arg = std::numeric_limits<T>::quiet_NaN();
953 check_invalid(acosh(arg));
954 arg = -std::numeric_limits<T>::quiet_NaN();
955 check_invalid(acosh(arg));
960 BOOST_CHECK_EQUAL(val, 0);
961 BOOST_CHECK(signbit(val) == 0);
966 BOOST_CHECK_EQUAL(val, 0);
967 BOOST_CHECK(signbit(val));
969 if (std::numeric_limits<T>::has_infinity)
971 arg = std::numeric_limits<T>::infinity();
973 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
975 arg = -std::numeric_limits<T>::infinity();
977 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
979 if (std::numeric_limits<T>::has_quiet_NaN)
981 arg = std::numeric_limits<T>::quiet_NaN();
982 check_invalid(asinh(arg));
983 arg = -std::numeric_limits<T>::quiet_NaN();
984 check_invalid(asinh(arg));
989 BOOST_CHECK_EQUAL(val, 0);
990 BOOST_CHECK(signbit(val) == 0);
995 BOOST_CHECK_EQUAL(val, 0);
996 BOOST_CHECK(signbit(val));
999 check_invalid(atanh(arg));
1001 check_invalid(atanh(arg));
1003 if (std::numeric_limits<T>::has_infinity)
1007 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1008 BOOST_CHECK(signbit(val) == 0);
1012 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1013 BOOST_CHECK(signbit(val));
1016 arg = std::numeric_limits<T>::infinity();
1017 check_invalid(atanh(arg));
1018 arg = -std::numeric_limits<T>::infinity();
1019 check_invalid(atanh(arg));
1021 if (std::numeric_limits<T>::has_quiet_NaN)
1023 arg = std::numeric_limits<T>::quiet_NaN();
1024 check_invalid(atanh(arg));
1025 arg = -std::numeric_limits<T>::quiet_NaN();
1026 check_invalid(atanh(arg));
1031 BOOST_CHECK_EQUAL(val, 1);
1036 BOOST_CHECK_EQUAL(val, 1);
1038 if (std::numeric_limits<T>::has_infinity)
1040 arg = (std::numeric_limits<T>::max)();
1042 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1045 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1046 arg = std::numeric_limits<T>::infinity();
1048 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1051 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1053 if (std::numeric_limits<T>::has_quiet_NaN)
1055 arg = std::numeric_limits<T>::quiet_NaN();
1056 check_invalid(cosh(arg));
1057 arg = -std::numeric_limits<T>::quiet_NaN();
1058 check_invalid(cosh(arg));
1063 BOOST_CHECK_EQUAL(val, 0);
1064 BOOST_CHECK(signbit(val) == 0);
1069 BOOST_CHECK_EQUAL(val, 0);
1070 BOOST_CHECK(signbit(val));
1072 if (std::numeric_limits<T>::has_infinity)
1074 arg = (std::numeric_limits<T>::max)();
1076 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1079 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1080 arg = std::numeric_limits<T>::infinity();
1082 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1085 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1087 if (std::numeric_limits<T>::has_quiet_NaN)
1089 arg = std::numeric_limits<T>::quiet_NaN();
1090 check_invalid(sinh(arg));
1091 arg = -std::numeric_limits<T>::quiet_NaN();
1092 check_invalid(sinh(arg));
1097 BOOST_CHECK_EQUAL(val, 0);
1098 BOOST_CHECK(signbit(val) == 0);
1103 BOOST_CHECK_EQUAL(val, 0);
1104 BOOST_CHECK(signbit(val));
1106 arg = (std::numeric_limits<T>::max)();
1108 BOOST_CHECK_EQUAL(val, 1);
1111 BOOST_CHECK_EQUAL(val, -1);
1112 if (std::numeric_limits<T>::has_infinity)
1114 arg = std::numeric_limits<T>::infinity();
1116 BOOST_CHECK_EQUAL(val, 1);
1119 BOOST_CHECK_EQUAL(val, -1);
1121 if (std::numeric_limits<T>::has_quiet_NaN)
1123 arg = std::numeric_limits<T>::quiet_NaN();
1124 check_invalid(tanh(arg));
1125 arg = -std::numeric_limits<T>::quiet_NaN();
1126 check_invalid(tanh(arg));
1131 BOOST_CHECK_EQUAL(val, 1);
1136 BOOST_CHECK_EQUAL(val, 1);
1138 if (std::numeric_limits<T>::has_infinity)
1140 arg = std::numeric_limits<T>::infinity();
1142 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1145 BOOST_CHECK_EQUAL(val, 0);
1146 BOOST_CHECK(signbit(val) == 0);
1147 arg = (std::numeric_limits<T>::max)();
1149 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1152 BOOST_CHECK_EQUAL(val, 0);
1153 BOOST_CHECK(signbit(val) == 0);
1155 if (std::numeric_limits<T>::has_quiet_NaN)
1157 arg = std::numeric_limits<T>::quiet_NaN();
1158 check_invalid(exp(arg));
1159 arg = -std::numeric_limits<T>::quiet_NaN();
1160 check_invalid(exp(arg));
1165 BOOST_CHECK_EQUAL(val, 1);
1170 BOOST_CHECK_EQUAL(val, 1);
1172 if (std::numeric_limits<T>::has_infinity)
1174 arg = std::numeric_limits<T>::infinity();
1176 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1179 BOOST_CHECK_EQUAL(val, 0);
1180 BOOST_CHECK(signbit(val) == 0);
1181 arg = (std::numeric_limits<T>::max)();
1183 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1186 BOOST_CHECK_EQUAL(val, 0);
1187 BOOST_CHECK(signbit(val) == 0);
1189 if (std::numeric_limits<T>::has_quiet_NaN)
1191 arg = std::numeric_limits<T>::quiet_NaN();
1192 check_invalid(exp2(arg));
1193 arg = -std::numeric_limits<T>::quiet_NaN();
1194 check_invalid(exp2(arg));
1199 BOOST_CHECK_EQUAL(val, 0);
1200 BOOST_CHECK(signbit(val) == 0);
1205 BOOST_CHECK_EQUAL(val, 0);
1206 BOOST_CHECK(signbit(val));
1208 if (std::numeric_limits<T>::has_infinity)
1210 arg = std::numeric_limits<T>::infinity();
1212 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1215 BOOST_CHECK_EQUAL(val, -1);
1216 arg = (std::numeric_limits<T>::max)();
1218 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1221 BOOST_CHECK_EQUAL(val, -1);
1223 if (std::numeric_limits<T>::has_quiet_NaN)
1225 arg = std::numeric_limits<T>::quiet_NaN();
1226 check_invalid(expm1(arg));
1227 arg = -std::numeric_limits<T>::quiet_NaN();
1228 check_invalid(expm1(arg));
1233 val = frexp(arg, &ival);
1234 BOOST_CHECK_EQUAL(val, 0);
1235 BOOST_CHECK_EQUAL(ival, 0);
1236 BOOST_CHECK(signbit(val) == 0);
1240 val = frexp(arg, &ival);
1241 BOOST_CHECK_EQUAL(val, 0);
1242 BOOST_CHECK(signbit(val));
1243 BOOST_CHECK(signbit(val));
1245 if (std::numeric_limits<T>::has_infinity)
1247 arg = std::numeric_limits<T>::infinity();
1248 val = frexp(arg, &ival);
1249 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1251 val = frexp(arg, &ival);
1252 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1254 if (std::numeric_limits<T>::has_quiet_NaN)
1256 arg = std::numeric_limits<T>::quiet_NaN();
1257 val = frexp(arg, &ival);
1258 BOOST_CHECK(isnan(val));
1261 typename T::backend_type::exponent_type eval;
1262 typename T::backend_type::exponent_type fp_ilogb0 = (std::numeric_limits<typename T::backend_type::exponent_type>::min)();
1263 typename T::backend_type::exponent_type fp_ilogbnan =
1265 FP_ILOGBNAN < 0 ? (std::numeric_limits<typename T::backend_type::exponent_type>::min)() : (std::numeric_limits<typename T::backend_type::exponent_type>::max)();
1272 BOOST_CHECK_EQUAL(eval, fp_ilogb0);
1273 if (std::numeric_limits<T>::has_infinity)
1275 arg = std::numeric_limits<T>::infinity();
1277 BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
1280 BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
1282 if (std::numeric_limits<T>::has_quiet_NaN)
1284 arg = std::numeric_limits<T>::quiet_NaN();
1286 BOOST_CHECK_EQUAL(eval, fp_ilogbnan);
1291 BOOST_CHECK_EQUAL(val, 0);
1292 BOOST_CHECK(signbit(val) == 0);
1293 if (std::numeric_limits<T>::has_infinity)
1297 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1303 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1307 check_invalid(log(arg));
1308 arg = -std::numeric_limits<T>::infinity();
1309 check_invalid(log(arg));
1310 arg = std::numeric_limits<T>::infinity();
1312 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1314 if (std::numeric_limits<T>::has_quiet_NaN)
1316 arg = std::numeric_limits<T>::quiet_NaN();
1317 check_invalid(log(arg));
1318 arg = -std::numeric_limits<T>::quiet_NaN();
1319 check_invalid(log(arg));
1324 BOOST_CHECK_EQUAL(val, 0);
1325 BOOST_CHECK(signbit(val) == 0);
1326 if (std::numeric_limits<T>::has_infinity)
1330 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1336 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1340 check_invalid(log10(arg));
1341 arg = -std::numeric_limits<T>::infinity();
1342 check_invalid(log10(arg));
1343 arg = std::numeric_limits<T>::infinity();
1345 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1347 if (std::numeric_limits<T>::has_quiet_NaN)
1349 arg = std::numeric_limits<T>::quiet_NaN();
1350 check_invalid(log10(arg));
1351 arg = -std::numeric_limits<T>::quiet_NaN();
1352 check_invalid(log10(arg));
1357 BOOST_CHECK_EQUAL(val, 0);
1358 BOOST_CHECK(signbit(val) == 0);
1363 BOOST_CHECK_EQUAL(val, 0);
1364 BOOST_CHECK(signbit(val));
1366 if (std::numeric_limits<T>::has_infinity)
1370 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1373 check_invalid(log1p(arg));
1374 arg = -std::numeric_limits<T>::infinity();
1375 check_invalid(log1p(arg));
1376 arg = std::numeric_limits<T>::infinity();
1378 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1380 if (std::numeric_limits<T>::has_quiet_NaN)
1382 arg = std::numeric_limits<T>::quiet_NaN();
1383 check_invalid(log1p(arg));
1384 arg = -std::numeric_limits<T>::quiet_NaN();
1385 check_invalid(log1p(arg));
1390 BOOST_CHECK_EQUAL(val, 0);
1391 BOOST_CHECK(signbit(val) == 0);
1392 if (std::numeric_limits<T>::has_infinity)
1396 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1402 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1406 check_invalid(log2(arg));
1407 arg = -std::numeric_limits<T>::infinity();
1408 check_invalid(log2(arg));
1409 arg = std::numeric_limits<T>::infinity();
1411 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1413 if (std::numeric_limits<T>::has_quiet_NaN)
1415 arg = std::numeric_limits<T>::quiet_NaN();
1416 check_invalid(log2(arg));
1417 arg = -std::numeric_limits<T>::quiet_NaN();
1418 check_invalid(log2(arg));
1421 if (std::numeric_limits<T>::has_infinity)
1425 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1431 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1434 arg = std::numeric_limits<T>::infinity();
1436 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1437 arg = -std::numeric_limits<T>::infinity();
1439 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1441 if (std::numeric_limits<T>::has_quiet_NaN)
1443 arg = std::numeric_limits<T>::quiet_NaN();
1444 check_invalid(logb(arg));
1445 arg = -std::numeric_limits<T>::quiet_NaN();
1446 check_invalid(logb(arg));
1450 val = scalbn(arg, 2);
1451 BOOST_CHECK_EQUAL(val, 0);
1452 BOOST_CHECK(signbit(val) == 0);
1456 val = scalbn(arg, 2);
1457 BOOST_CHECK_EQUAL(val, 0);
1458 BOOST_CHECK(signbit(val));
1460 if (std::numeric_limits<T>::has_infinity)
1462 arg = std::numeric_limits<T>::infinity();
1463 val = scalbn(arg, -100);
1464 BOOST_CHECK_EQUAL(val, arg);
1466 val = scalbn(arg, -100);
1467 BOOST_CHECK_EQUAL(val, arg);
1472 BOOST_CHECK_EQUAL(val, 0);
1473 BOOST_CHECK(signbit(val) == 0);
1478 BOOST_CHECK_EQUAL(val, 0);
1479 BOOST_CHECK(signbit(val));
1481 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1483 // This test fails with early implementations of libquadmath - not our issue!
1485 if (std::numeric_limits<T>::has_infinity)
1487 arg = std::numeric_limits<T>::infinity();
1489 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1490 arg = -std::numeric_limits<T>::infinity();
1492 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1495 if (std::numeric_limits<T>::has_quiet_NaN)
1497 arg = std::numeric_limits<T>::quiet_NaN();
1498 check_invalid(cbrt(arg));
1499 arg = -std::numeric_limits<T>::quiet_NaN();
1500 check_invalid(cbrt(arg));
1505 BOOST_CHECK_EQUAL(val, 0);
1506 BOOST_CHECK(signbit(val) == 0);
1511 BOOST_CHECK_EQUAL(val, 0);
1512 BOOST_CHECK(signbit(val) == 0);
1514 if (std::numeric_limits<T>::has_infinity)
1516 arg = std::numeric_limits<T>::infinity();
1518 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1519 arg = -std::numeric_limits<T>::infinity();
1521 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1526 val = hypot(arg, arg2);
1527 BOOST_CHECK_EQUAL(val, arg);
1529 val = hypot(arg, arg2);
1530 BOOST_CHECK_EQUAL(val, arg);
1531 if (std::numeric_limits<T>::has_infinity)
1533 arg = std::numeric_limits<T>::infinity();
1535 val = hypot(arg, arg2);
1536 BOOST_CHECK_EQUAL(val, arg);
1538 val = hypot(arg, arg2);
1539 BOOST_CHECK_EQUAL(val, -arg);
1540 arg2 = std::numeric_limits<T>::quiet_NaN();
1541 val = hypot(arg, arg2);
1542 BOOST_CHECK_EQUAL(val, -arg);
1544 val = hypot(arg, arg2);
1545 BOOST_CHECK_EQUAL(val, arg);
1548 if (std::numeric_limits<T>::has_infinity)
1552 val = pow(arg, arg2);
1553 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1558 val = pow(arg, arg2);
1559 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1564 val = pow(arg, arg2);
1565 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1570 val = pow(arg, arg2);
1571 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1576 val = pow(arg, arg2);
1577 BOOST_CHECK_EQUAL(val, 0);
1578 BOOST_CHECK(signbit(val) == 0);
1582 val = pow(arg, arg2);
1583 BOOST_CHECK_EQUAL(val, 0);
1584 BOOST_CHECK(signbit(val));
1588 val = pow(arg, arg2);
1589 BOOST_CHECK_EQUAL(val, 0);
1590 BOOST_CHECK(signbit(val) == 0);
1594 val = pow(arg, arg2);
1595 BOOST_CHECK_EQUAL(val, 0);
1596 BOOST_CHECK(signbit(val) == 0);
1599 arg2 = std::numeric_limits<T>::infinity();
1600 val = pow(arg, arg2);
1601 BOOST_CHECK_EQUAL(val, 1);
1602 arg2 = -std::numeric_limits<T>::infinity();
1603 val = pow(arg, arg2);
1604 BOOST_CHECK_EQUAL(val, 1);
1607 val = pow(arg, arg2);
1608 BOOST_CHECK_EQUAL(val, 1);
1609 arg2 = std::numeric_limits<T>::infinity();
1610 val = pow(arg, arg2);
1611 BOOST_CHECK_EQUAL(val, 1);
1612 arg2 = -std::numeric_limits<T>::infinity();
1613 val = pow(arg, arg2);
1614 BOOST_CHECK_EQUAL(val, 1);
1615 arg2 = std::numeric_limits<T>::quiet_NaN();
1616 val = pow(arg, arg2);
1617 BOOST_CHECK_EQUAL(val, 1);
1620 val = pow(arg, arg2);
1621 BOOST_CHECK_EQUAL(val, 1);
1623 val = pow(arg, arg2);
1624 BOOST_CHECK_EQUAL(val, 1);
1625 arg = std::numeric_limits<T>::infinity();
1626 val = pow(arg, arg2);
1627 BOOST_CHECK_EQUAL(val, 1);
1629 val = pow(arg, arg2);
1630 BOOST_CHECK_EQUAL(val, 1);
1631 arg = std::numeric_limits<T>::quiet_NaN();
1632 val = pow(arg, arg2);
1633 BOOST_CHECK_EQUAL(val, 1);
1635 val = pow(arg, arg2);
1636 BOOST_CHECK_EQUAL(val, 1);
1638 if (std::numeric_limits<T>::has_quiet_NaN)
1642 check_invalid(pow(arg, arg2));
1644 if (std::numeric_limits<T>::has_infinity)
1647 arg2 = -std::numeric_limits<T>::infinity();
1648 val = pow(arg, arg2);
1649 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1651 val = pow(arg, arg2);
1652 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1654 arg2 = -std::numeric_limits<T>::infinity();
1655 val = pow(arg, arg2);
1656 BOOST_CHECK_EQUAL(val, 0);
1658 val = pow(arg, arg2);
1659 BOOST_CHECK_EQUAL(val, 0);
1661 arg2 = std::numeric_limits<T>::infinity();
1662 val = pow(arg, arg2);
1663 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1665 val = pow(arg, arg2);
1666 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1667 arg = -std::numeric_limits<T>::infinity();
1669 val = pow(arg, arg2);
1670 BOOST_CHECK_EQUAL(val, 0);
1672 BOOST_CHECK(signbit(val));
1674 val = pow(arg, arg2);
1675 BOOST_CHECK_EQUAL(val, 0);
1676 BOOST_CHECK(signbit(val) == 0);
1678 val = pow(arg, arg2);
1679 BOOST_CHECK_EQUAL(val, 0);
1680 BOOST_CHECK(signbit(val) == 0);
1682 val = pow(arg, arg2);
1683 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1685 val = pow(arg, arg2);
1686 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1688 val = pow(arg, arg2);
1689 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1692 val = pow(arg, arg2);
1693 BOOST_CHECK_EQUAL(val, 0);
1694 BOOST_CHECK(signbit(val) == 0);
1696 val = pow(arg, arg2);
1697 BOOST_CHECK_EQUAL(val, 0);
1698 BOOST_CHECK(signbit(val) == 0);
1700 val = pow(arg, arg2);
1701 BOOST_CHECK_EQUAL(val, 0);
1702 BOOST_CHECK(signbit(val) == 0);
1704 val = pow(arg, arg2);
1705 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1707 val = pow(arg, arg2);
1708 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1710 val = pow(arg, arg2);
1711 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1716 BOOST_CHECK_EQUAL(val, 0);
1717 BOOST_CHECK(signbit(val) == 0);
1722 BOOST_CHECK_EQUAL(val, 0);
1723 BOOST_CHECK(signbit(val));
1725 #if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1727 // This test fails with early implementations of libquadmath - not our issue!
1729 if (std::numeric_limits<T>::has_infinity)
1731 arg = std::numeric_limits<T>::infinity();
1733 BOOST_CHECK_EQUAL(val, arg);
1735 check_invalid(sqrt(arg));
1738 if (std::numeric_limits<T>::has_quiet_NaN)
1740 arg = std::numeric_limits<T>::quiet_NaN();
1741 check_invalid(sqrt(arg));
1746 BOOST_CHECK_EQUAL(val, 0);
1747 BOOST_CHECK(signbit(val) == 0);
1752 BOOST_CHECK_EQUAL(val, 0);
1753 BOOST_CHECK(signbit(val));
1755 if (std::numeric_limits<T>::has_infinity)
1757 arg = std::numeric_limits<T>::infinity();
1759 BOOST_CHECK_EQUAL(val, 1);
1762 BOOST_CHECK_EQUAL(val, -1);
1764 if (std::numeric_limits<T>::has_quiet_NaN)
1766 arg = std::numeric_limits<T>::quiet_NaN();
1767 check_invalid(erf(arg));
1770 if (std::numeric_limits<T>::has_infinity)
1772 arg = std::numeric_limits<T>::infinity();
1774 BOOST_CHECK_EQUAL(val, 0);
1775 BOOST_CHECK(signbit(val) == 0);
1778 BOOST_CHECK_EQUAL(val, 2);
1780 if (std::numeric_limits<T>::has_quiet_NaN)
1782 arg = std::numeric_limits<T>::quiet_NaN();
1783 check_invalid(erfc(arg));
1788 BOOST_CHECK_EQUAL(val, 0);
1789 BOOST_CHECK(signbit(val) == 0);
1792 BOOST_CHECK_EQUAL(val, 0);
1793 BOOST_CHECK(signbit(val) == 0);
1794 #if !defined(BOOST_MPFR_VERSION) || (BOOST_MPFR_VERSION > 30103)
1797 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1801 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1805 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1807 arg = -std::numeric_limits<T>::infinity();
1809 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1811 arg = std::numeric_limits<T>::infinity();
1813 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1814 if (std::numeric_limits<T>::has_quiet_NaN)
1816 arg = std::numeric_limits<T>::quiet_NaN();
1817 check_invalid(lgamma(arg));
1820 if (std::numeric_limits<T>::has_infinity)
1824 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1830 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1834 check_invalid(tgamma(arg));
1835 arg = -std::numeric_limits<T>::infinity();
1836 check_invalid(tgamma(arg));
1837 arg = std::numeric_limits<T>::infinity();
1839 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1841 if (std::numeric_limits<T>::has_quiet_NaN)
1843 arg = std::numeric_limits<T>::quiet_NaN();
1844 check_invalid(tgamma(arg));
1849 BOOST_CHECK_EQUAL(val, 0);
1850 BOOST_CHECK(signbit(val) == 0);
1855 BOOST_CHECK_EQUAL(val, 0);
1856 BOOST_CHECK(signbit(val));
1858 if (std::numeric_limits<T>::has_infinity)
1860 arg = std::numeric_limits<T>::infinity();
1862 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1865 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1867 if (std::numeric_limits<T>::has_quiet_NaN)
1869 arg = std::numeric_limits<T>::quiet_NaN();
1870 check_invalid(ceil(arg));
1875 BOOST_CHECK_EQUAL(val, 0);
1876 BOOST_CHECK(signbit(val) == 0);
1881 BOOST_CHECK_EQUAL(val, 0);
1882 BOOST_CHECK(signbit(val));
1884 if (std::numeric_limits<T>::has_infinity)
1886 arg = std::numeric_limits<T>::infinity();
1888 BOOST_CHECK_EQUAL(val, 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(floor(arg));
1900 val = nearbyint(arg);
1901 BOOST_CHECK_EQUAL(val, 0);
1902 BOOST_CHECK(signbit(val) == 0);
1906 val = nearbyint(arg);
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();
1913 val = nearbyint(arg);
1914 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1916 val = nearbyint(arg);
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(nearbyint(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(rint(arg));
1953 BOOST_CHECK_EQUAL(val, 0);
1954 BOOST_CHECK(signbit(val) == 0);
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();
1966 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
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(round(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(trunc(arg));
2005 val = fmod(arg, arg2);
2006 BOOST_CHECK_EQUAL(val, 0);
2007 BOOST_CHECK(signbit(val) == 0);
2011 val = fmod(arg, arg2);
2012 BOOST_CHECK_EQUAL(val, 0);
2013 BOOST_CHECK(signbit(val));
2015 if (std::numeric_limits<T>::has_infinity)
2017 arg = std::numeric_limits<T>::infinity();
2018 check_invalid(fmod(arg, arg2));
2020 check_invalid(fmod(arg, arg2));
2023 check_invalid(fmod(arg, arg2));
2024 check_invalid(fmod(arg, -arg2));
2026 if (std::numeric_limits<T>::has_quiet_NaN)
2028 arg = std::numeric_limits<T>::quiet_NaN();
2030 check_invalid(fmod(arg, arg2));
2032 check_invalid(fmod(arg, arg2));
2033 check_invalid(fmod(arg2, arg2));
2039 boost::math::lgamma(T(0.000001), &sign);
2040 BOOST_CHECK_EQUAL(sign, 1);
2042 boost::math::lgamma(T(0.5), &sign);
2043 BOOST_CHECK_EQUAL(sign, 1);
2045 boost::math::lgamma(T(0.9), &sign);
2046 BOOST_CHECK_EQUAL(sign, 1);
2048 boost::math::lgamma(T(1.1), &sign);
2049 BOOST_CHECK_EQUAL(sign, 1);
2051 boost::math::lgamma(T(1.9), &sign);
2052 BOOST_CHECK_EQUAL(sign, 1);
2054 boost::math::lgamma(T(2.1), &sign);
2055 BOOST_CHECK_EQUAL(sign, 1);
2057 boost::math::lgamma(T(20), &sign);
2058 BOOST_CHECK_EQUAL(sign, 1);
2060 boost::math::lgamma(T(-0.0000000000001), &sign);
2061 BOOST_CHECK_EQUAL(sign, -1);
2063 boost::math::lgamma(T(-0.5), &sign);
2064 BOOST_CHECK_EQUAL(sign, -1);
2066 boost::math::lgamma(T(-1.5), &sign);
2067 BOOST_CHECK_EQUAL(sign, 1);
2069 boost::math::lgamma(T(-2.5), &sign);
2070 BOOST_CHECK_EQUAL(sign, -1);
2072 boost::math::lgamma(T(-3.5), &sign);
2073 BOOST_CHECK_EQUAL(sign, 1);
2078 test_poison<float>();
2079 test_poison<double>();
2081 test<boost::multiprecision::mpf_float_50>();
2082 test<boost::multiprecision::mpf_float_100>();
2085 std::cout << "Testing MPFR: " << MPFR_VERSION_STRING << std::endl;
2086 test<boost::multiprecision::mpfr_float_50>();
2087 test<boost::multiprecision::mpfr_float_100>();
2088 test_c99_appendix_F<boost::multiprecision::mpfr_float_50>();
2091 test<boost::multiprecision::mpfi_float_50>();
2092 test<boost::multiprecision::mpfi_float_100>();
2094 #ifdef TEST_CPP_DEC_FLOAT
2095 test<boost::multiprecision::cpp_dec_float_50>();
2096 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2097 test<boost::multiprecision::cpp_dec_float_100>();
2099 test_c99_appendix_F<boost::multiprecision::cpp_dec_float_50>();
2101 #ifdef TEST_CPP_DEC_FLOAT_2
2102 // Some "peculiar" digit counts which stress our code:
2103 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
2104 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2105 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
2108 #ifdef TEST_CPP_DEC_FLOAT_3
2109 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
2110 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2111 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
2114 #ifdef TEST_CPP_DEC_FLOAT_4
2115 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
2116 #if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
2117 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
2120 #ifdef TEST_CPP_DEC_FLOAT_5
2121 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
2123 #ifdef TEST_CPP_DEC_FLOAT_6
2124 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
2126 #ifdef TEST_CPP_BIN_FLOAT
2127 test<boost::multiprecision::cpp_bin_float_50>();
2128 test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
2130 #ifdef TEST_CPP_BIN_FLOAT_2
2131 test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, boost::long_long_type> > >();
2133 #ifdef TEST_CPP_BIN_FLOAT_3
2134 test_c99_appendix_F<boost::multiprecision::cpp_bin_float_50>();
2135 test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
2137 #ifdef TEST_FLOAT128
2138 test<boost::multiprecision::float128>();
2139 test_c99_appendix_F<boost::multiprecision::float128>();
2142 return boost::report_errors();