]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/multiprecision/test/test_sf_import_c99.cpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update ceph source to reef 18.1.2
[ceph.git] / ceph / src / boost / libs / multiprecision / test / test_sf_import_c99.cpp
CommitLineData
7c673cae
FG		 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)
5
6#ifdef _MSC_VER
92f5a8d4 7#pragma warning(disable : 4127) // conditional expression is constant
7c673cae
FG		 8#endif
9
1e59de90
TL		 10#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) \
11 && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) \
12 && !defined(TEST_CPP_DEC_FLOAT_2) && !defined(TEST_CPP_DEC_FLOAT_3) && !defined(TEST_CPP_DEC_FLOAT_4) \
13 && !defined(TEST_CPP_DEC_FLOAT_5) && !defined(TEST_CPP_DEC_FLOAT_6) && !defined(TEST_CPP_BIN_FLOAT_2) && !defined(TEST_CPP_BIN_FLOAT_3)\
14 && !defined(TEST_MPFI_DEBUG_ADAPTOR) && !defined(TEST_MPFR_DEBUG_ADAPTOR) && !defined(TEST_MPFI_LOGGED_ADAPTOR) && !defined(TEST_MPFR_LOGGED_ADAPTOR)
92f5a8d4
TL		 15#define TEST_MPF_50
16#define TEST_MPFR_50
17#define TEST_MPFI_50
18#define TEST_CPP_DEC_FLOAT
19#define TEST_CPP_DEC_FLOAT_2
20#define TEST_CPP_DEC_FLOAT_3
21#define TEST_CPP_DEC_FLOAT_4
22#define TEST_CPP_DEC_FLOAT_5
23#define TEST_CPP_DEC_FLOAT_6
24#define TEST_FLOAT128
25#define TEST_CPP_BIN_FLOAT
26#define TEST_CPP_BIN_FLOAT_2
27#define TEST_CPP_BIN_FLOAT_3
1e59de90
TL		 28#define TEST_MPFI_DEBUG_ADAPTOR
29#define TEST_MPFR_DEBUG_ADAPTOR
30#define TEST_MPFI_LOGGED_ADAPTOR
31#define TEST_MPFR_LOGGED_ADAPTOR
7c673cae
FG		 32
33#ifdef _MSC_VER
34#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
35#endif
36#ifdef __GNUC__
37#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
38#endif
39
40#endif
41
42#if defined(TEST_MPF_50)
43#include <boost/multiprecision/gmp.hpp>
44#endif
45#ifdef TEST_MPFR_50
46#include <boost/multiprecision/mpfr.hpp>
47#endif
48#ifdef TEST_MPFI_50
49#include <boost/multiprecision/mpfi.hpp>
50#endif
92f5a8d4 51#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_2) || defined(TEST_CPP_DEC_FLOAT_3) || defined(TEST_CPP_DEC_FLOAT_4) || defined(TEST_CPP_DEC_FLOAT_5) || defined(TEST_CPP_DEC_FLOAT_6)
7c673cae
FG		 52#include <boost/multiprecision/cpp_dec_float.hpp>
53#endif
92f5a8d4 54#if defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_BIN_FLOAT_2) || defined(TEST_CPP_BIN_FLOAT_3)
7c673cae 55#include <boost/multiprecision/cpp_bin_float.hpp>
b32b8144 56#include <boost/multiprecision/debug_adaptor.hpp>
7c673cae
FG		 57#endif
58#ifdef TEST_FLOAT128
59#include <boost/multiprecision/float128.hpp>
60#endif
1e59de90
TL		 61#ifdef TEST_MPFI_DEBUG_ADAPTOR
62# include <boost/multiprecision/mpfi.hpp>
63# include <boost/multiprecision/debug_adaptor.hpp>
64#endif
65#ifdef TEST_MPFR_DEBUG_ADAPTOR
66# include <boost/multiprecision/mpfr.hpp>
67# include <boost/multiprecision/debug_adaptor.hpp>
68#endif
69#ifdef TEST_MPFI_LOGGED_ADAPTOR
70# include <boost/multiprecision/mpfi.hpp>
71# include <boost/multiprecision/logged_adaptor.hpp>
72#endif
73#ifdef TEST_MPFR_LOGGED_ADAPTOR
74# include <boost/multiprecision/mpfr.hpp>
75# include <boost/multiprecision/logged_adaptor.hpp>
76#endif
7c673cae 77
b32b8144 78#include <boost/math/constants/constants.hpp>
92f5a8d4 79#include <boost/math/special_functions/gamma.hpp>
7c673cae
FG		 80#include "test.hpp"
81
82#ifdef signbit
83#undef signbit
84#endif
85#ifdef sign
86#undef sign
87#endif
88#ifdef changesign
89#undef changesign
90#endif
91#ifdef copysign
92#undef copysign
93#endif
94#ifdef fpclassify
95#undef fpclassify
96#endif
97#ifdef isinf
98#undef isinf
99#endif
100#ifdef isnan
101#undef isnan
102#endif
103#ifdef isnormal
104#undef isnormal
105#endif
106
b32b8144
FG		 107#ifdef MPFR_VERSION_MAJOR
108#define BOOST_MPFR_VERSION MPFR_VERSION_MAJOR * 10000 + MPFR_VERSION_MINOR * 100 + MPFR_VERSION_PATCHLEVEL
109#endif
110
7c673cae
FG		 111template <class T, class U>
112void test_less(T a, U b)
113{
114 BOOST_CHECK(a < b);
115 BOOST_CHECK(a <= b);
116 BOOST_CHECK(!(a > b));
117 BOOST_CHECK(!(a >= b));
118 BOOST_CHECK(!(a == b));
119 BOOST_CHECK((a != b));
120
121 BOOST_CHECK(b > a);
122 BOOST_CHECK(b >= a);
123 BOOST_CHECK(!(b < a));
124 BOOST_CHECK(!(b <= a));
125 BOOST_CHECK(!(b == a));
126 BOOST_CHECK((b != a));
127
128 BOOST_CHECK(isless(a, b));
129 BOOST_CHECK(islessequal(a, b));
130 BOOST_CHECK(!isgreater(a, b));
131 BOOST_CHECK(!isgreaterequal(a, b));
132 BOOST_CHECK(islessgreater(a, b));
133
134 BOOST_CHECK(!isless(b, a));
135 BOOST_CHECK(!islessequal(b, a));
136 BOOST_CHECK(isgreater(b, a));
137 BOOST_CHECK(isgreaterequal(b, a));
138 BOOST_CHECK(islessgreater(b, a));
139}
140template <class T, class U>
141void test_equal(T a, U b)
142{
143 BOOST_CHECK(!(a < b));
144 BOOST_CHECK(a <= b);
145 BOOST_CHECK(!(a > b));
146 BOOST_CHECK((a >= b));
147 BOOST_CHECK((a == b));
148 BOOST_CHECK(!(a != b));
149
150 BOOST_CHECK(!(b > a));
151 BOOST_CHECK(b >= a);
152 BOOST_CHECK(!(b < a));
153 BOOST_CHECK((b <= a));
154 BOOST_CHECK((b == a));
155 BOOST_CHECK(!(b != a));
156
157 BOOST_CHECK(!isless(a, b));
158 BOOST_CHECK(islessequal(a, b));
159 BOOST_CHECK(!isgreater(a, b));
160 BOOST_CHECK(isgreaterequal(a, b));
161 BOOST_CHECK(!islessgreater(a, b));
162
163 BOOST_CHECK(!isless(b, a));
164 BOOST_CHECK(islessequal(b, a));
165 BOOST_CHECK(!isgreater(b, a));
166 BOOST_CHECK(isgreaterequal(b, a));
167 BOOST_CHECK(!islessgreater(b, a));
168}
169template <class T, class U>
170void test_unordered(T a, U b)
171{
172 BOOST_CHECK(!(a < b));
173 BOOST_CHECK(!(a <= b));
174 BOOST_CHECK(!(a > b));
175 BOOST_CHECK(!(a >= b));
176 BOOST_CHECK(!(a == b));
177 BOOST_CHECK((a != b));
178
179 BOOST_CHECK(!(b > a));
180 BOOST_CHECK(!(b >= a));
181 BOOST_CHECK(!(b < a));
182 BOOST_CHECK(!(b <= a));
183 BOOST_CHECK(!(b == a));
184 BOOST_CHECK((b != a));
185
186 BOOST_CHECK(!isless(a, b));
187 BOOST_CHECK(!islessequal(a, b));
188 BOOST_CHECK(!isgreater(a, b));
189 BOOST_CHECK(!isgreaterequal(a, b));
190 BOOST_CHECK(!islessgreater(a, b));
191
192 BOOST_CHECK(!isless(b, a));
193 BOOST_CHECK(!islessequal(b, a));
194 BOOST_CHECK(!isgreater(b, a));
195 BOOST_CHECK(!isgreaterequal(b, a));
196 BOOST_CHECK(!islessgreater(b, a));
197}
198
199template <class T>
200void test()
201{
202 //
203 // Basic sanity checks for C99 functions which are just imported versions
204 // from Boost.Math. These should still be found via ADL so no using declarations here...
205 //
206 T val = 2;
207 BOOST_CHECK(signbit(val) == 0);
208 BOOST_CHECK(signbit(val + 2) == 0);
209 val = -val;
210 BOOST_CHECK(signbit(val));
211 BOOST_CHECK(signbit(val * 2));
212
213 val = 2;
214 BOOST_CHECK_EQUAL(sign(val), 1);
215 BOOST_CHECK_EQUAL(sign(val + 2), 1);
216 val = -val;
217 BOOST_CHECK_EQUAL(sign(val), -1);
218 BOOST_CHECK_EQUAL(sign(val * 2), -1);
219 val = 0;
220 BOOST_CHECK_EQUAL(sign(val), 0);
221 BOOST_CHECK_EQUAL(sign(val * 2), 0);
222
223 val = 2;
224 BOOST_CHECK_EQUAL(changesign(val), -2);
225 BOOST_CHECK_EQUAL(changesign(val * 2), -4);
226 val = -2;
227 BOOST_CHECK_EQUAL(changesign(val), 2);
228 BOOST_CHECK_EQUAL(changesign(val * 2), 4);
229 val = 0;
230 BOOST_CHECK_EQUAL(changesign(val), 0);
231 BOOST_CHECK_EQUAL(changesign(val * 2), 0);
232 // Things involving signed zero, need to detect it first:
233 T neg_zero_test = -(std::numeric_limits<T>::min)();
234 neg_zero_test /= (std::numeric_limits<T>::max)();
92f5a8d4 235 T one(1);
7c673cae 236 bool test_signed_zero = !boost::multiprecision::is_interval_number<T>::value && std::numeric_limits<T>::has_infinity && (one / neg_zero_test < 0);
92f5a8d4 237 if (test_signed_zero)
7c673cae
FG		 238 {
239 BOOST_CHECK(signbit(changesign(val)));
240 BOOST_CHECK(signbit(changesign(val * 2)));
241 }
242
243 T s = 2;
244 val = 3;
245 BOOST_CHECK_EQUAL(copysign(val, s), 3);
246 BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
247 BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
248 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
249 s = -2;
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);
254 val = -3;
255 BOOST_CHECK_EQUAL(copysign(val, s), -3);
256 BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
257 BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
258 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
259 s = 0;
260 BOOST_CHECK_EQUAL(copysign(val, s), 3);
261 // Things involving signed zero, need to detect it first:
92f5a8d4 262 if (test_signed_zero)
7c673cae
FG		 263 {
264 BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
265 }
266 BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
267 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
268 // Things involving signed zero, need to detect it first:
92f5a8d4 269 if (test_signed_zero)
7c673cae
FG		 270 {
271 s = changesign(s);
92f5a8d4 272 if (signbit(s))
7c673cae
FG		 273 {
274 BOOST_CHECK_EQUAL(copysign(val, s), -3);
275 BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
276 BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
277 BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
278 }
279 }
280
281 val = 3;
282 BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
283 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
284 BOOST_CHECK(!isinf(val));
285 BOOST_CHECK(!isinf(val + 2));
286 BOOST_CHECK(!isnan(val));
287 BOOST_CHECK(!isnan(val + 2));
288 BOOST_CHECK(isnormal(val));
289 BOOST_CHECK(isnormal(val + 2));
290 val = -3;
291 BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
292 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
293 BOOST_CHECK(!isinf(val));
294 BOOST_CHECK(!isinf(val + 2));
295 BOOST_CHECK(!isnan(val));
296 BOOST_CHECK(!isnan(val + 2));
297 BOOST_CHECK(isnormal(val));
298 BOOST_CHECK(isnormal(val + 2));
299 val = 0;
300 BOOST_CHECK_EQUAL(fpclassify(val), FP_ZERO);
301 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_ZERO);
302 BOOST_CHECK(!isinf(val));
303 BOOST_CHECK(!isinf(val + 2));
304 BOOST_CHECK(!isnan(val));
305 BOOST_CHECK(!isnan(val + 2));
306 BOOST_CHECK(!isnormal(val));
307 BOOST_CHECK(!isnormal(val * 2));
308 BOOST_CHECK(!isnormal(val * -2));
92f5a8d4 309 if (std::numeric_limits<T>::has_infinity)
7c673cae
FG		 310 {
311 val = std::numeric_limits<T>::infinity();
312 BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
313 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
314 BOOST_CHECK(isinf(val));
315 BOOST_CHECK(isinf(val + 2));
316 BOOST_CHECK(!isnan(val));
317 BOOST_CHECK(!isnan(val + 2));
318 BOOST_CHECK(!isnormal(val));
319 BOOST_CHECK(!isnormal(val + 2));
320 val = -val;
321 BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
322 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
323 BOOST_CHECK(isinf(val));
324 BOOST_CHECK(isinf(val + 2));
325 BOOST_CHECK(!isnan(val));
326 BOOST_CHECK(!isnan(val + 2));
327 BOOST_CHECK(!isnormal(val));
328 BOOST_CHECK(!isnormal(val + 2));
329 }
92f5a8d4 330 if (std::numeric_limits<T>::has_quiet_NaN)
7c673cae 331 {
92f5a8d4 332 val = std::numeric_limits<T>::quiet_NaN();
7c673cae
FG		 333 BOOST_CHECK_EQUAL(fpclassify(val), FP_NAN);
334 BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NAN);
335 BOOST_CHECK(!isinf(val));
336 BOOST_CHECK(!isinf(val + 2));
337 BOOST_CHECK(isnan(val));
338 BOOST_CHECK(isnan(val + 2));
339 BOOST_CHECK(!isnormal(val));
340 BOOST_CHECK(!isnormal(val + 2));
341 }
92f5a8d4 342 s = 8 * std::numeric_limits<T>::epsilon();
7c673cae
FG		 343 val = 2.5;
344 BOOST_CHECK_CLOSE_FRACTION(asinh(val), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
345 BOOST_CHECK_CLOSE_FRACTION(asinh(val + T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
346 BOOST_CHECK_CLOSE_FRACTION(acosh(val), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
347 BOOST_CHECK_CLOSE_FRACTION(acosh(val + T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
348 val = 0.5;
349 BOOST_CHECK_CLOSE_FRACTION(atanh(val), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
350 BOOST_CHECK_CLOSE_FRACTION(atanh(val + T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
351 val = 55.25;
352 BOOST_CHECK_CLOSE_FRACTION(cbrt(val), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
353 BOOST_CHECK_CLOSE_FRACTION(cbrt(val + T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
92f5a8d4 354 if (!boost::multiprecision::is_interval_number<T>::value)
7c673cae
FG		 355 {
356 val = 2.75;
357 BOOST_CHECK_CLOSE_FRACTION(erf(val), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
358 BOOST_CHECK_CLOSE_FRACTION(erf(val + T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
359 BOOST_CHECK_CLOSE_FRACTION(erfc(val), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
360 BOOST_CHECK_CLOSE_FRACTION(erfc(val + T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
361 }
362 val = 0.125;
363 BOOST_CHECK_CLOSE_FRACTION(expm1(val), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
364 BOOST_CHECK_CLOSE_FRACTION(expm1(val + T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
365
366 val = 20;
92f5a8d4 367 s = 2;
7c673cae
FG		 368 BOOST_CHECK_EQUAL(fdim(val, s), 18);
369 BOOST_CHECK_EQUAL(fdim(s, val), 0);
370 BOOST_CHECK_EQUAL(fdim(val, s * 2), 16);
371 BOOST_CHECK_EQUAL(fdim(s * 2, val), 0);
372 BOOST_CHECK_EQUAL(fdim(val, 2), 18);
373 BOOST_CHECK_EQUAL(fdim(2, val), 0);
374
375 BOOST_CHECK_EQUAL(fmax(val, s), val);
376 BOOST_CHECK_EQUAL(fmax(s, val), val);
377 BOOST_CHECK_EQUAL(fmax(val * 2, s), val * 2);
378 BOOST_CHECK_EQUAL(fmax(val, s * 2), val);
379 BOOST_CHECK_EQUAL(fmax(val * 2, s * 2), val * 2);
380 BOOST_CHECK_EQUAL(fmin(val, s), s);
381 BOOST_CHECK_EQUAL(fmin(s, val), s);
382 BOOST_CHECK_EQUAL(fmin(val * 2, s), s);
383 BOOST_CHECK_EQUAL(fmin(val, s * 2), s * 2);
384 BOOST_CHECK_EQUAL(fmin(val * 2, s * 2), s * 2);
385
386 BOOST_CHECK_EQUAL(fmax(val, 2), val);
387 BOOST_CHECK_EQUAL(fmax(val, 2.0), val);
388 BOOST_CHECK_EQUAL(fmax(20, s), val);
389 BOOST_CHECK_EQUAL(fmax(20.0, s), val);
390 BOOST_CHECK_EQUAL(fmin(val, 2), s);
391 BOOST_CHECK_EQUAL(fmin(val, 2.0), s);
392 BOOST_CHECK_EQUAL(fmin(20, s), s);
393 BOOST_CHECK_EQUAL(fmin(20.0, s), s);
92f5a8d4 394 if (std::numeric_limits<T>::has_quiet_NaN)
7c673cae
FG		 395 {
396 BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<T>::quiet_NaN()), val);
397 BOOST_CHECK_EQUAL(fmax(std::numeric_limits<T>::quiet_NaN(), val), val);
398 BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<T>::quiet_NaN()), val);
399 BOOST_CHECK_EQUAL(fmin(std::numeric_limits<T>::quiet_NaN(), val), val);
400 }
92f5a8d4 401 if (std::numeric_limits<double>::has_quiet_NaN)
7c673cae
FG		 402 {
403 BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<double>::quiet_NaN()), val);
404 BOOST_CHECK_EQUAL(fmax(std::numeric_limits<double>::quiet_NaN(), val), val);
405 BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<double>::quiet_NaN()), val);
406 BOOST_CHECK_EQUAL(fmin(std::numeric_limits<double>::quiet_NaN(), val), val);
407 }
408
409 test_less(s, val);
410 test_less(2, val);
411 test_less(s, 20);
412 test_less(s + 0, val);
413 test_less(s, val * 1);
414 test_less(s * 1, val * 1);
415 test_less(s * 1, 20);
416 test_less(s + 2, val * 2);
417
418 test_equal(val, val);
419 test_equal(20, val);
420 test_equal(val, 20);
421 test_equal(val + 0, val);
422 test_equal(val, val * 1);
423 test_equal(val * 1, val * 1);
424 test_equal(val * 1, 20);
425 test_equal(val * 20, val * 20);
426
92f5a8d4 427 if (std::numeric_limits<T>::has_quiet_NaN)
7c673cae
FG		 428 {
429 s = std::numeric_limits<T>::quiet_NaN();
430 test_unordered(s, val);
431 test_unordered(s, 20);
432 test_unordered(s + 0, val);
433 test_unordered(s, val * 1);
434 test_unordered(s * 1, val * 1);
435 test_unordered(s * 1, 20);
436 test_unordered(s + 2, val * 2);
92f5a8d4 437 if (std::numeric_limits<double>::has_quiet_NaN)
7c673cae
FG		 438 {
439 double n = std::numeric_limits<double>::quiet_NaN();
440 test_unordered(n, val);
441 }
442 }
443
444 T tol = 8 * std::numeric_limits<T>::epsilon();
92f5a8d4 445 s = 2;
7c673cae
FG		 446 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
447 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
448 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
449 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
450 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
451 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
452 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
453 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
454 BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
455 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
456 BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
457
458 BOOST_CHECK_CLOSE_FRACTION(lgamma(val), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
459 BOOST_CHECK_CLOSE_FRACTION(lgamma(val + 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
460
461 BOOST_CHECK_EQUAL(lrint(val), 20);
462 BOOST_CHECK_EQUAL(lrint(val * 2), 40);
463 BOOST_CHECK_EQUAL(llrint(val), 20);
464 BOOST_CHECK_EQUAL(llrint(val * 2), 40);
465
466 val = 0.125;
467 BOOST_CHECK_CLOSE_FRACTION(log1p(val), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
468 BOOST_CHECK_CLOSE_FRACTION(log1p(val + 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
469 val = 20;
470 BOOST_CHECK_CLOSE_FRACTION(T(log2(val)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
471 BOOST_CHECK_CLOSE_FRACTION(T(log2(val + 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
472
473 BOOST_CHECK_EQUAL(T(nearbyint(val)), 20);
474 BOOST_CHECK_EQUAL(T(nearbyint(val + 0.25)), 20);
475 BOOST_CHECK_EQUAL(T(rint(val)), 20);
476 BOOST_CHECK_EQUAL(T(rint(val + 0.25)), 20);
477
478 BOOST_CHECK_GT(nextafter(val, T(200)), val);
479 BOOST_CHECK_GT(nextafter(val + 0, T(200)), val);
480 BOOST_CHECK_GT(nextafter(val + 0, T(200) + 1), val);
481 BOOST_CHECK_GT(nextafter(val, T(200) + 1), val);
482
483 BOOST_CHECK_GT(nexttoward(val, T(200)), val);
484 BOOST_CHECK_GT(nexttoward(val + 0, T(200)), val);
485 BOOST_CHECK_GT(nexttoward(val + 0, T(200) + 1), val);
486 BOOST_CHECK_GT(nexttoward(val, T(200) + 1), val);
487
488 val = 21;
92f5a8d4 489 s = 5;
7c673cae
FG		 490 BOOST_CHECK_EQUAL(T(remainder(val, s)), 1);
491 BOOST_CHECK_EQUAL(T(remainder(val, 5)), 1);
492 BOOST_CHECK_EQUAL(T(remainder(21, s)), 1);
493 BOOST_CHECK_EQUAL(T(remainder(val * 1, s)), 1);
494 BOOST_CHECK_EQUAL(T(remainder(val * 1, s * 1)), 1);
495 BOOST_CHECK_EQUAL(T(remainder(val, s * 1)), 1);
496 BOOST_CHECK_EQUAL(T(remainder(val * 1, 5)), 1);
497 BOOST_CHECK_EQUAL(T(remainder(21, s * 1)), 1);
498 int i(0);
499 BOOST_CHECK_EQUAL(T(remquo(val, s, &i)), 1);
500 BOOST_CHECK_EQUAL(i, 4);
501 i = 0;
502 BOOST_CHECK_EQUAL(T(remquo(val, 5, &i)), 1);
503 BOOST_CHECK_EQUAL(i, 4);
504 i = 0;
505 BOOST_CHECK_EQUAL(T(remquo(21, s, &i)), 1);
506 BOOST_CHECK_EQUAL(i, 4);
507 i = 0;
508 BOOST_CHECK_EQUAL(T(remquo(val * 1, s, &i)), 1);
509 BOOST_CHECK_EQUAL(i, 4);
510 i = 0;
511 BOOST_CHECK_EQUAL(T(remquo(val * 1, s * 1, &i)), 1);
512 BOOST_CHECK_EQUAL(i, 4);
513 i = 0;
514 BOOST_CHECK_EQUAL(T(remquo(val, s * 1, &i)), 1);
515 BOOST_CHECK_EQUAL(i, 4);
516 i = 0;
517 BOOST_CHECK_EQUAL(T(remquo(val * 1, 5, &i)), 1);
518 BOOST_CHECK_EQUAL(i, 4);
519 i = 0;
520 BOOST_CHECK_EQUAL(T(remquo(21, s * 1, &i)), 1);
521 BOOST_CHECK_EQUAL(i, 4);
92f5a8d4 522 i = 0;
7c673cae
FG		 523 val = 5.25;
524 tol = 3000;
525 BOOST_CHECK_CLOSE_FRACTION(tgamma(val), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol);
526 BOOST_CHECK_CLOSE_FRACTION(tgamma(val + 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol);
527
528 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol);
529 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol);
530 val = 15;
531 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T(32768uL), tol);
532 BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T(65536uL), tol);
533
92f5a8d4 534 i = fpclassify(val) + isgreaterequal(val, s) + islessequal(val, s) + isnan(val) + isunordered(val, s) + isfinite(val) + isinf(val) + islessgreater(val, s) + isnormal(val) + signbit(val) + isgreater(val, s) + isless(val, s);
7c673cae
FG		 535}
536
537template <class T>
538void test_poison()
539{
540 // use these macros as proxies for determining C99 support:
541#if defined(FP_ILOGB0) && defined(FP_INFINITE)
542 //
543 // These tests verify that our function overloads for Boost.Multiprecision
544 // don't do anything nasty to the std:: overloads for built in types:
545 //
546 using namespace std;
547 using namespace boost::multiprecision;
548 //using namespace boost::math;
549
92f5a8d4 550 T a(2), b(0.3f), c(4), result(0);
7c673cae
FG		 551 int i;
552
553 result += abs(a);
554 result += cosh(a);
555 result += fmod(a, b);
556 result += logb(a);
557 result += remquo(a, b, &i);
558 result += acos(b);
559 result += erf(a);
560 result += frexp(a, &i);
561 result += lrint(a);
562 result += rint(a);
563 result += acosh(b);
564 result += erfc(b);
565 result += hypot(a, b);
566 result += lround(c);
567 result += round(c);
568 result += asin(b);
569 result += exp2(a);
570 result += ilogb(b);
571 result += modf(a, &b);
572 result += scalbln(a, i);
573 result += asinh(b);
574 result += exp(b);
575 result += ldexp(a, i);
576 result += scalbn(a, i);
577 result += atan(b);
578 result += expm1(a);
579 result += lgamma(a);
580 result += sin(b);
581 result += atan2(a, c);
582 result += fabs(a);
583 result += llrint(a);
584 result += sinh(b);
585 result += atanh(b);
586 result += fdim(a, b);
587 result += llround(a);
588 result += nearbyint(a);
589 result += sqrt(b);
590 result += cbrt(a);
591 result += floor(b);
592 result += log(a);
593 result += nextafter(a, b);
594 result += tan(b);
595 result += ceil(b);
596 result += fma(a, b, c);
597 result += log10(a);
598 result += nexttoward(a, b);
599 result += tanh(a);
600 result += copysign(a, b);
601 result += fmax(a, b);
602 result += log1p(a);
603 result += pow(a, b);
604 result += tgamma(a);
605 result += cos(b);
606 result += fmin(a, b);
607 result += log2(a);
608 result += remainder(a, b);
609 result += trunc(b);
92f5a8d4
TL		 610 result += (min)(a, b);
611 result += (max)(a, b);
7c673cae
FG		 612
613#if !BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 60000)
614
92f5a8d4 615 i = fpclassify(a) + isgreaterequal(a, b) + islessequal(a, b) + isnan(a) + isunordered(a, b) + isfinite(a) + isinf(a) + islessgreater(a, b) + isnormal(a) + signbit(a) + isgreater(a, b) + isless(a, b);
7c673cae
FG		 616#endif
617#endif
618}
619
b32b8144
FG		 620template <class T>
621bool type_sets_errno(const T&)
622{
623 return true;
624}
625#ifdef TEST_MPFR_50
92f5a8d4
TL		 626template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
627bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>&)
b32b8144
FG		 628{
629 return false;
630}
631#endif
1e59de90
TL		 632#ifdef TEST_MPFR_DEBUG_ADAPTOR
633template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
634bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>&)
635{
636 return false;
637}
638#endif
639#ifdef TEST_MPFI_DEBUG_ADAPTOR
640template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
641bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>&)
642{
643 return false;
644}
645#endif
646#ifdef TEST_MPFR_LOGGED_ADAPTOR
647template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
648bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>&)
649{
650 return false;
651}
652#endif
653#ifdef TEST_MPFI_LOGGED_ADAPTOR
654template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
655bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>&)
656{
657 return false;
658}
659#endif
b32b8144 660#ifdef TEST_FLOAT128
92f5a8d4 661bool type_sets_errno(const boost::multiprecision::float128&)
b32b8144
FG		 662{
663 return false;
664}
665#endif
666
667template <class T>
1e59de90 668typename std::enable_if<std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
b32b8144 669{
92f5a8d4 670 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 671 {
672 BOOST_CHECK(isnan(val));
673 }
674 else
675 {
676 BOOST_CHECK_EQUAL(val, 0);
677 }
92f5a8d4 678 if (type_sets_errno(val))
b32b8144
FG		 679 BOOST_CHECK_EQUAL(errno, EDOM);
680 errno = 0;
681}
682
683template <class T>
1e59de90 684typename std::enable_if<!std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
b32b8144
FG		 685{
686 check_invalid(static_cast<typename T::result_type>(val));
687}
688
689template <class T>
690void check_erange(const T& val)
691{
92f5a8d4 692 if (type_sets_errno(val))
b32b8144
FG		 693 BOOST_CHECK_EQUAL(errno, ERANGE);
694 errno = 0;
695}
696
697template <class T>
698void test_c99_appendix_F()
699{
700 //
701 // Tests conformance to non-normative appendix F.9.1 of C99, basically how to handle
702 // special cases, infinities and NaN's.
703 //
704 errno = 0;
705 T tol = std::numeric_limits<T>::epsilon();
706 // F.9.1.1:
707 T arg = 1;
708 T val = acos(arg);
709 BOOST_CHECK_EQUAL(val, 0);
710 BOOST_CHECK(signbit(val) == 0);
711 arg = 2;
712 check_invalid(acos(arg));
713 arg = -2;
714 check_invalid(acos(arg));
92f5a8d4 715 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 716 {
717 arg = std::numeric_limits<T>::infinity();
718 check_invalid(acos(arg));
719 arg = -std::numeric_limits<T>::infinity();
720 check_invalid(acos(arg));
721 }
92f5a8d4 722 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 723 {
724 arg = std::numeric_limits<T>::quiet_NaN();
725 check_invalid(acos(arg));
726 arg = -std::numeric_limits<T>::quiet_NaN();
727 check_invalid(acos(arg));
728 }
729 // F.9.1.2:
730 arg = 0;
731 val = asin(arg);
732 BOOST_CHECK_EQUAL(val, 0);
733 BOOST_CHECK(signbit(val) == 0);
734 arg = -arg;
92f5a8d4 735 if (signbit(arg))
b32b8144
FG		 736 {
737 val = asin(arg);
738 BOOST_CHECK_EQUAL(val, 0);
739 BOOST_CHECK(signbit(val));
740 }
741 arg = 2;
742 check_invalid(asin(arg));
743 arg = -2;
744 check_invalid(asin(arg));
92f5a8d4 745 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 746 {
747 arg = std::numeric_limits<T>::infinity();
748 check_invalid(asin(arg));
749 arg = -std::numeric_limits<T>::infinity();
750 check_invalid(asin(arg));
751 }
92f5a8d4 752 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 753 {
754 arg = std::numeric_limits<T>::quiet_NaN();
755 check_invalid(asin(arg));
756 arg = -std::numeric_limits<T>::quiet_NaN();
757 check_invalid(asin(arg));
758 }
759 // F.9.1.3:
760 arg = 0;
761 val = atan(arg);
762 BOOST_CHECK_EQUAL(val, 0);
763 BOOST_CHECK(signbit(val) == 0);
764 arg = -arg;
92f5a8d4 765 if (signbit(arg))
b32b8144
FG		 766 {
767 val = atan(arg);
768 BOOST_CHECK_EQUAL(val, 0);
769 BOOST_CHECK(signbit(val));
770 }
92f5a8d4 771 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 772 {
773 arg = std::numeric_limits<T>::infinity();
774 val = atan(arg);
775 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
776 arg = -std::numeric_limits<T>::infinity();
777 val = atan(arg);
778 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
779 }
92f5a8d4 780 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 781 {
782 arg = std::numeric_limits<T>::quiet_NaN();
783 check_invalid(asin(arg));
784 arg = -std::numeric_limits<T>::quiet_NaN();
785 check_invalid(asin(arg));
786 }
787 // F.9.1.4:
92f5a8d4 788 arg = 0;
b32b8144 789 T arg2 = 0;
92f5a8d4 790 val = atan2(arg, arg2);
b32b8144
FG		 791 BOOST_CHECK_EQUAL(val, 0);
792 BOOST_CHECK(signbit(val) == 0);
793 arg = -arg;
92f5a8d4 794 if (signbit(arg))
b32b8144
FG		 795 {
796 val = atan2(arg, arg2);
797 BOOST_CHECK_EQUAL(val, 0);
798 BOOST_CHECK(signbit(val));
799 }
800 arg2 = -arg2;
92f5a8d4 801 if (signbit(arg2))
b32b8144
FG		 802 {
803 arg = 0;
804 val = atan2(arg, arg2);
805 BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
806 BOOST_CHECK(signbit(val) == 0);
807 arg = -arg;
808 val = atan2(arg, arg2);
809 BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
810 BOOST_CHECK(signbit(val));
811 }
92f5a8d4 812 arg = 0;
b32b8144 813 arg2 = -2;
92f5a8d4 814 val = atan2(arg, arg2);
b32b8144
FG		 815 BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
816 arg = -arg;
92f5a8d4 817 if (signbit(arg))
b32b8144
FG		 818 {
819 val = atan2(arg, arg2);
820 BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
821 }
92f5a8d4 822 arg = 0;
b32b8144 823 arg2 = 2;
92f5a8d4 824 val = atan2(arg, arg2);
b32b8144
FG		 825 BOOST_CHECK_EQUAL(val, 0);
826 BOOST_CHECK(signbit(val) == 0);
827 arg = -arg;
92f5a8d4 828 if (signbit(arg))
b32b8144
FG		 829 {
830 val = atan2(arg, arg2);
831 BOOST_CHECK_EQUAL(val, 0);
832 BOOST_CHECK(signbit(val));
833 }
92f5a8d4 834 arg = -2;
b32b8144 835 arg2 = 0;
92f5a8d4 836 val = atan2(arg, arg2);
b32b8144
FG		 837 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
838 arg2 = -arg2;
92f5a8d4 839 if (signbit(arg2))
b32b8144
FG		 840 {
841 val = atan2(arg, arg2);
842 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
843 }
92f5a8d4 844 arg = 2;
b32b8144 845 arg2 = 0;
92f5a8d4 846 val = atan2(arg, arg2);
b32b8144
FG		 847 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
848 arg2 = -arg2;
92f5a8d4 849 if (signbit(arg2))
b32b8144
FG		 850 {
851 val = atan2(arg, arg2);
852 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
853 }
92f5a8d4 854 if (std::numeric_limits<T>::has_infinity)
b32b8144 855 {
92f5a8d4 856 arg = 2;
b32b8144 857 arg2 = -std::numeric_limits<T>::infinity();
92f5a8d4 858 val = atan2(arg, arg2);
b32b8144
FG		 859 BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
860 arg = -arg;
861 val = atan2(arg, arg2);
862 BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
92f5a8d4 863 arg = 2;
b32b8144 864 arg2 = std::numeric_limits<T>::infinity();
92f5a8d4 865 val = atan2(arg, arg2);
b32b8144
FG		 866 BOOST_CHECK_EQUAL(val, 0);
867 BOOST_CHECK(signbit(val) == 0);
868 arg = -arg;
92f5a8d4 869 if (signbit(-T(0)))
b32b8144
FG		 870 {
871 val = atan2(arg, arg2);
872 BOOST_CHECK_EQUAL(val, 0);
873 BOOST_CHECK(signbit(val));
874 }
92f5a8d4 875 arg = std::numeric_limits<T>::infinity();
b32b8144 876 arg2 = 2;
92f5a8d4 877 val = atan2(arg, arg2);
b32b8144
FG		 878 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
879 arg = -arg;
880 val = atan2(arg, arg2);
881 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
92f5a8d4 882 arg = std::numeric_limits<T>::infinity();
b32b8144 883 arg2 = -2;
92f5a8d4 884 val = atan2(arg, arg2);
b32b8144
FG		 885 BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
886 arg = -arg;
887 val = atan2(arg, arg2);
888 BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
92f5a8d4 889 arg = std::numeric_limits<T>::infinity();
b32b8144 890 arg2 = -std::numeric_limits<T>::infinity();
92f5a8d4 891 val = atan2(arg, arg2);
b32b8144
FG		 892 BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::three_quarters_pi<T>(), tol);
893 arg = -arg;
894 val = atan2(arg, arg2);
895 BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::three_quarters_pi<T>(), tol);
92f5a8d4 896 arg = std::numeric_limits<T>::infinity();
b32b8144 897 arg2 = std::numeric_limits<T>::infinity();
92f5a8d4 898 val = atan2(arg, arg2);
b32b8144
FG		 899 BOOST_CHECK_CLOSE_FRACTION(val, ldexp(boost::math::constants::pi<T>(), -2), tol);
900 arg = -arg;
901 val = atan2(arg, arg2);
902 BOOST_CHECK_CLOSE_FRACTION(val, -ldexp(boost::math::constants::pi<T>(), -2), tol);
92f5a8d4 903 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144 904 {
92f5a8d4 905 arg = std::numeric_limits<T>::quiet_NaN();
b32b8144
FG		 906 arg2 = 2;
907 check_invalid(atan2(arg, arg2));
908 std::swap(arg, arg2);
909 check_invalid(atan2(arg, arg2));
910 arg = std::numeric_limits<T>::quiet_NaN();
911 check_invalid(atan2(arg, arg2));
912 }
913 }
914 // F.9.1.5:
915 arg = 0;
916 val = cos(arg);
917 BOOST_CHECK_EQUAL(val, 1);
918 arg = -arg;
919 BOOST_CHECK_EQUAL(val, 1);
92f5a8d4 920 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 921 {
922 arg = std::numeric_limits<T>::infinity();
923 check_invalid(cos(arg));
924 arg = -std::numeric_limits<T>::infinity();
925 check_invalid(cos(arg));
926 }
92f5a8d4 927 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 928 {
929 arg = std::numeric_limits<T>::quiet_NaN();
930 check_invalid(cos(arg));
931 arg = -std::numeric_limits<T>::quiet_NaN();
932 check_invalid(cos(arg));
933 }
934 // F.9.1.6:
935 arg = 0;
936 val = sin(arg);
937 BOOST_CHECK_EQUAL(val, 0);
938 BOOST_CHECK(signbit(val) == 0);
939 arg = -arg;
92f5a8d4 940 if (signbit(arg))
b32b8144
FG		 941 {
942 val = sin(arg);
943 BOOST_CHECK_EQUAL(val, 0);
944 BOOST_CHECK(signbit(val));
945 }
92f5a8d4 946 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 947 {
948 arg = std::numeric_limits<T>::infinity();
949 check_invalid(sin(arg));
950 arg = -std::numeric_limits<T>::infinity();
951 check_invalid(sin(arg));
952 }
92f5a8d4 953 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 954 {
955 arg = std::numeric_limits<T>::quiet_NaN();
956 check_invalid(sin(arg));
957 arg = -std::numeric_limits<T>::quiet_NaN();
958 check_invalid(sin(arg));
959 }
960 // F.9.1.7:
961 arg = 0;
962 val = tan(arg);
963 BOOST_CHECK_EQUAL(val, 0);
964 BOOST_CHECK(signbit(val) == 0);
965 arg = -arg;
92f5a8d4 966 if (signbit(arg))
b32b8144
FG		 967 {
968 val = tan(arg);
969 BOOST_CHECK_EQUAL(val, 0);
970 BOOST_CHECK(signbit(val));
971 }
92f5a8d4 972 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 973 {
974 arg = std::numeric_limits<T>::infinity();
975 check_invalid(tan(arg));
976 arg = -std::numeric_limits<T>::infinity();
977 check_invalid(tan(arg));
978 }
92f5a8d4 979 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 980 {
981 arg = std::numeric_limits<T>::quiet_NaN();
982 check_invalid(tan(arg));
983 arg = -std::numeric_limits<T>::quiet_NaN();
984 check_invalid(tan(arg));
985 }
986 // F.9.2.1:
987 arg = 1;
988 val = acosh(arg);
989 BOOST_CHECK_EQUAL(val, 0);
990 BOOST_CHECK(signbit(val) == 0);
991 arg = -arg;
992 check_invalid(acosh(arg));
92f5a8d4 993 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 994 {
995 arg = std::numeric_limits<T>::infinity();
996 val = acosh(arg);
997 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
998
999 arg = -std::numeric_limits<T>::infinity();
1000 check_invalid(acosh(arg));
1001 }
92f5a8d4 1002 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1003 {
1004 arg = std::numeric_limits<T>::quiet_NaN();
1005 check_invalid(acosh(arg));
1006 arg = -std::numeric_limits<T>::quiet_NaN();
1007 check_invalid(acosh(arg));
1008 }
1009 // F.9.2.2:
1010 arg = 0;
1011 val = asinh(arg);
1012 BOOST_CHECK_EQUAL(val, 0);
1013 BOOST_CHECK(signbit(val) == 0);
1014 arg = -arg;
92f5a8d4 1015 if (signbit(arg))
b32b8144
FG		 1016 {
1017 val = asinh(arg);
1018 BOOST_CHECK_EQUAL(val, 0);
1019 BOOST_CHECK(signbit(val));
1020 }
92f5a8d4 1021 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1022 {
1023 arg = std::numeric_limits<T>::infinity();
1024 val = asinh(arg);
1025 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1026
1027 arg = -std::numeric_limits<T>::infinity();
1028 val = asinh(arg);
1029 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1030 }
92f5a8d4 1031 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1032 {
1033 arg = std::numeric_limits<T>::quiet_NaN();
1034 check_invalid(asinh(arg));
1035 arg = -std::numeric_limits<T>::quiet_NaN();
1036 check_invalid(asinh(arg));
1037 }
1038 // F.9.2.3:
1039 arg = 0;
1040 val = atanh(arg);
1041 BOOST_CHECK_EQUAL(val, 0);
1042 BOOST_CHECK(signbit(val) == 0);
1043 arg = -arg;
92f5a8d4 1044 if (signbit(arg))
b32b8144
FG		 1045 {
1046 val = atanh(arg);
1047 BOOST_CHECK_EQUAL(val, 0);
1048 BOOST_CHECK(signbit(val));
1049 }
1050 arg = 2;
1051 check_invalid(atanh(arg));
1052 arg = -3;
1053 check_invalid(atanh(arg));
1054
92f5a8d4 1055 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1056 {
1057 arg = 1;
1058 val = atanh(arg);
1059 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1060 BOOST_CHECK(signbit(val) == 0);
1061 check_erange(val);
1062 arg = -arg;
1063 val = atanh(arg);
1064 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1065 BOOST_CHECK(signbit(val));
1066 check_erange(val);
1067
1068 arg = std::numeric_limits<T>::infinity();
1069 check_invalid(atanh(arg));
1070 arg = -std::numeric_limits<T>::infinity();
1071 check_invalid(atanh(arg));
1072 }
92f5a8d4 1073 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1074 {
1075 arg = std::numeric_limits<T>::quiet_NaN();
1076 check_invalid(atanh(arg));
1077 arg = -std::numeric_limits<T>::quiet_NaN();
1078 check_invalid(atanh(arg));
1079 }
1080 // F.9.2.4:
1081 arg = 0;
1082 val = cosh(arg);
1083 BOOST_CHECK_EQUAL(val, 1);
1084 arg = -arg;
92f5a8d4 1085 if (signbit(arg))
b32b8144
FG		 1086 {
1087 val = cosh(arg);
1088 BOOST_CHECK_EQUAL(val, 1);
1089 }
92f5a8d4 1090 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1091 {
1092 arg = (std::numeric_limits<T>::max)();
1093 val = cosh(arg);
1094 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1095 arg = -arg;
1096 val = cosh(arg);
1097 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1098 arg = std::numeric_limits<T>::infinity();
1099 val = cosh(arg);
1100 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1101 arg = -arg;
1102 val = cosh(arg);
1103 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1104 }
92f5a8d4 1105 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1106 {
1107 arg = std::numeric_limits<T>::quiet_NaN();
1108 check_invalid(cosh(arg));
1109 arg = -std::numeric_limits<T>::quiet_NaN();
1110 check_invalid(cosh(arg));
1111 }
1112 // F.9.2.5:
1113 arg = 0;
1114 val = sinh(arg);
1115 BOOST_CHECK_EQUAL(val, 0);
1116 BOOST_CHECK(signbit(val) == 0);
1117 arg = -arg;
92f5a8d4 1118 if (signbit(arg))
b32b8144
FG		 1119 {
1120 val = sinh(arg);
1121 BOOST_CHECK_EQUAL(val, 0);
1122 BOOST_CHECK(signbit(val));
1123 }
92f5a8d4 1124 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1125 {
1126 arg = (std::numeric_limits<T>::max)();
1127 val = sinh(arg);
1128 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1129 arg = -arg;
1130 val = sinh(arg);
1131 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1132 arg = std::numeric_limits<T>::infinity();
1133 val = sinh(arg);
1134 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1135 arg = -arg;
1136 val = sinh(arg);
1137 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1138 }
92f5a8d4 1139 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1140 {
1141 arg = std::numeric_limits<T>::quiet_NaN();
1142 check_invalid(sinh(arg));
1143 arg = -std::numeric_limits<T>::quiet_NaN();
1144 check_invalid(sinh(arg));
1145 }
1146 // F.9.2.6:
1147 arg = 0;
1148 val = tanh(arg);
1149 BOOST_CHECK_EQUAL(val, 0);
1150 BOOST_CHECK(signbit(val) == 0);
1151 arg = -arg;
92f5a8d4 1152 if (signbit(arg))
b32b8144
FG		 1153 {
1154 val = tanh(arg);
1155 BOOST_CHECK_EQUAL(val, 0);
1156 BOOST_CHECK(signbit(val));
1157 }
1158 arg = (std::numeric_limits<T>::max)();
1159 val = tanh(arg);
1160 BOOST_CHECK_EQUAL(val, 1);
1161 arg = -arg;
1162 val = tanh(arg);
1163 BOOST_CHECK_EQUAL(val, -1);
92f5a8d4 1164 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1165 {
1166 arg = std::numeric_limits<T>::infinity();
1167 val = tanh(arg);
1168 BOOST_CHECK_EQUAL(val, 1);
1169 arg = -arg;
1170 val = tanh(arg);
1171 BOOST_CHECK_EQUAL(val, -1);
1172 }
92f5a8d4 1173 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1174 {
1175 arg = std::numeric_limits<T>::quiet_NaN();
1176 check_invalid(tanh(arg));
1177 arg = -std::numeric_limits<T>::quiet_NaN();
1178 check_invalid(tanh(arg));
1179 }
1180 // F.9.3.1:
1181 arg = 0;
1182 val = exp(arg);
1183 BOOST_CHECK_EQUAL(val, 1);
1184 arg = -arg;
92f5a8d4 1185 if (signbit(arg))
b32b8144
FG		 1186 {
1187 val = exp(arg);
1188 BOOST_CHECK_EQUAL(val, 1);
1189 }
92f5a8d4 1190 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1191 {
1192 arg = std::numeric_limits<T>::infinity();
1193 val = exp(arg);
1194 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1195 arg = -arg;
1196 val = exp(arg);
1197 BOOST_CHECK_EQUAL(val, 0);
1198 BOOST_CHECK(signbit(val) == 0);
1199 arg = (std::numeric_limits<T>::max)();
1200 val = exp(arg);
1201 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1202 arg = -arg;
1203 val = exp(arg);
1204 BOOST_CHECK_EQUAL(val, 0);
1205 BOOST_CHECK(signbit(val) == 0);
1206 }
92f5a8d4 1207 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1208 {
1209 arg = std::numeric_limits<T>::quiet_NaN();
1210 check_invalid(exp(arg));
1211 arg = -std::numeric_limits<T>::quiet_NaN();
1212 check_invalid(exp(arg));
1213 }
1214 // F.9.3.2:
1215 arg = 0;
1216 val = exp2(arg);
1217 BOOST_CHECK_EQUAL(val, 1);
1218 arg = -arg;
92f5a8d4 1219 if (signbit(arg))
b32b8144
FG		 1220 {
1221 val = exp2(arg);
1222 BOOST_CHECK_EQUAL(val, 1);
1223 }
92f5a8d4 1224 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1225 {
1226 arg = std::numeric_limits<T>::infinity();
1227 val = exp2(arg);
1228 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1229 arg = -arg;
1230 val = exp2(arg);
1231 BOOST_CHECK_EQUAL(val, 0);
1232 BOOST_CHECK(signbit(val) == 0);
1233 arg = (std::numeric_limits<T>::max)();
1234 val = exp2(arg);
1235 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1236 arg = -arg;
1237 val = exp2(arg);
1238 BOOST_CHECK_EQUAL(val, 0);
1239 BOOST_CHECK(signbit(val) == 0);
1240 }
92f5a8d4 1241 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1242 {
1243 arg = std::numeric_limits<T>::quiet_NaN();
1244 check_invalid(exp2(arg));
1245 arg = -std::numeric_limits<T>::quiet_NaN();
1246 check_invalid(exp2(arg));
1247 }
1248 // F.9.3.3:
1249 arg = 0;
1250 val = expm1(arg);
1251 BOOST_CHECK_EQUAL(val, 0);
1252 BOOST_CHECK(signbit(val) == 0);
1253 arg = -arg;
92f5a8d4 1254 if (signbit(arg))
b32b8144
FG		 1255 {
1256 val = expm1(arg);
1257 BOOST_CHECK_EQUAL(val, 0);
1258 BOOST_CHECK(signbit(val));
1259 }
92f5a8d4 1260 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1261 {
1262 arg = std::numeric_limits<T>::infinity();
1263 val = expm1(arg);
1264 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1265 arg = -arg;
1266 val = expm1(arg);
1267 BOOST_CHECK_EQUAL(val, -1);
1268 arg = (std::numeric_limits<T>::max)();
1269 val = expm1(arg);
1270 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1271 arg = -arg;
1272 val = expm1(arg);
1273 BOOST_CHECK_EQUAL(val, -1);
1274 }
92f5a8d4 1275 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1276 {
1277 arg = std::numeric_limits<T>::quiet_NaN();
1278 check_invalid(expm1(arg));
1279 arg = -std::numeric_limits<T>::quiet_NaN();
1280 check_invalid(expm1(arg));
1281 }
1282 // F.9.3.4:
1283 arg = 0;
1284 int ival;
1285 val = frexp(arg, &ival);
1286 BOOST_CHECK_EQUAL(val, 0);
1287 BOOST_CHECK_EQUAL(ival, 0);
1288 BOOST_CHECK(signbit(val) == 0);
1289 arg = -arg;
92f5a8d4 1290 if (signbit(arg))
b32b8144
FG		 1291 {
1292 val = frexp(arg, &ival);
1293 BOOST_CHECK_EQUAL(val, 0);
1294 BOOST_CHECK(signbit(val));
1295 BOOST_CHECK(signbit(val));
1296 }
92f5a8d4 1297 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1298 {
1299 arg = std::numeric_limits<T>::infinity();
1300 val = frexp(arg, &ival);
1301 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1302 arg = -arg;
1303 val = frexp(arg, &ival);
1304 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1305 }
92f5a8d4 1306 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1307 {
1308 arg = std::numeric_limits<T>::quiet_NaN();
1309 val = frexp(arg, &ival);
1310 BOOST_CHECK(isnan(val));
1311 }
1312 // F.9.3.5:
1313 typename T::backend_type::exponent_type eval;
1314 typename T::backend_type::exponent_type fp_ilogb0 = (std::numeric_limits<typename T::backend_type::exponent_type>::min)();
1315 typename T::backend_type::exponent_type fp_ilogbnan =
1316#ifdef FP_ILOGBNAN
92f5a8d4 1317 FP_ILOGBNAN < 0 ? (std::numeric_limits<typename T::backend_type::exponent_type>::min)() : (std::numeric_limits<typename T::backend_type::exponent_type>::max)();
b32b8144 1318#else
92f5a8d4 1319 INT_MAX;
b32b8144
FG		 1320#endif
1321
92f5a8d4 1322 arg = 0;
b32b8144
FG		 1323 eval = ilogb(arg);
1324 BOOST_CHECK_EQUAL(eval, fp_ilogb0);
92f5a8d4 1325 if (std::numeric_limits<T>::has_infinity)
b32b8144 1326 {
92f5a8d4 1327 arg = std::numeric_limits<T>::infinity();
b32b8144
FG		 1328 eval = ilogb(arg);
1329 BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
92f5a8d4 1330 arg = -arg;
b32b8144
FG		 1331 eval = ilogb(arg);
1332 BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
1333 }
92f5a8d4 1334 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144 1335 {
92f5a8d4 1336 arg = std::numeric_limits<T>::quiet_NaN();
b32b8144
FG		 1337 eval = ilogb(arg);
1338 BOOST_CHECK_EQUAL(eval, fp_ilogbnan);
1339 }
1340 // F.9.3.7:
1341 arg = 1;
1342 val = log(arg);
1343 BOOST_CHECK_EQUAL(val, 0);
1344 BOOST_CHECK(signbit(val) == 0);
92f5a8d4 1345 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1346 {
1347 arg = 0;
1348 val = log(arg);
1349 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1350 check_erange(val);
1351 arg = -arg;
92f5a8d4 1352 if (signbit(arg))
b32b8144
FG		 1353 {
1354 val = log(arg);
1355 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1356 check_erange(val);
1357 }
1358 arg = -1;
1359 check_invalid(log(arg));
1360 arg = -std::numeric_limits<T>::infinity();
1361 check_invalid(log(arg));
1362 arg = std::numeric_limits<T>::infinity();
1363 val = log(arg);
1364 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1365 }
92f5a8d4 1366 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1367 {
1368 arg = std::numeric_limits<T>::quiet_NaN();
1369 check_invalid(log(arg));
1370 arg = -std::numeric_limits<T>::quiet_NaN();
1371 check_invalid(log(arg));
1372 }
1373 // F.9.3.8:
1374 arg = 1;
1375 val = log10(arg);
1376 BOOST_CHECK_EQUAL(val, 0);
1377 BOOST_CHECK(signbit(val) == 0);
92f5a8d4 1378 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1379 {
1380 arg = 0;
1381 val = log10(arg);
1382 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1383 check_erange(val);
1384 arg = -arg;
92f5a8d4 1385 if (signbit(arg))
b32b8144
FG		 1386 {
1387 val = log10(arg);
1388 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1389 check_erange(val);
1390 }
1391 arg = -1;
1392 check_invalid(log10(arg));
1393 arg = -std::numeric_limits<T>::infinity();
1394 check_invalid(log10(arg));
1395 arg = std::numeric_limits<T>::infinity();
1396 val = log10(arg);
1397 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1398 }
92f5a8d4 1399 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1400 {
1401 arg = std::numeric_limits<T>::quiet_NaN();
1402 check_invalid(log10(arg));
1403 arg = -std::numeric_limits<T>::quiet_NaN();
1404 check_invalid(log10(arg));
1405 }
1406 // F.9.3.9:
1407 arg = 0;
1408 val = log1p(arg);
1409 BOOST_CHECK_EQUAL(val, 0);
1410 BOOST_CHECK(signbit(val) == 0);
1411 arg = -arg;
92f5a8d4 1412 if (signbit(arg))
b32b8144
FG		 1413 {
1414 val = log1p(arg);
1415 BOOST_CHECK_EQUAL(val, 0);
1416 BOOST_CHECK(signbit(val));
1417 }
92f5a8d4 1418 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1419 {
1420 arg = -1;
1421 val = log1p(arg);
1422 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1423 check_erange(val);
1424 arg = -2;
1425 check_invalid(log1p(arg));
1426 arg = -std::numeric_limits<T>::infinity();
1427 check_invalid(log1p(arg));
1428 arg = std::numeric_limits<T>::infinity();
1429 val = log1p(arg);
1430 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1431 }
92f5a8d4 1432 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1433 {
1434 arg = std::numeric_limits<T>::quiet_NaN();
1435 check_invalid(log1p(arg));
1436 arg = -std::numeric_limits<T>::quiet_NaN();
1437 check_invalid(log1p(arg));
1438 }
1439 // F.9.3.10:
1440 arg = 1;
1441 val = log2(arg);
1442 BOOST_CHECK_EQUAL(val, 0);
1443 BOOST_CHECK(signbit(val) == 0);
92f5a8d4 1444 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1445 {
1446 arg = 0;
1447 val = log2(arg);
1448 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1449 check_erange(val);
1450 arg = -arg;
92f5a8d4 1451 if (signbit(arg))
b32b8144
FG		 1452 {
1453 val = log2(arg);
1454 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1455 check_erange(val);
1456 }
1457 arg = -1;
1458 check_invalid(log2(arg));
1459 arg = -std::numeric_limits<T>::infinity();
1460 check_invalid(log2(arg));
1461 arg = std::numeric_limits<T>::infinity();
1462 val = log2(arg);
1463 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1464 }
92f5a8d4 1465 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1466 {
1467 arg = std::numeric_limits<T>::quiet_NaN();
1468 check_invalid(log2(arg));
1469 arg = -std::numeric_limits<T>::quiet_NaN();
1470 check_invalid(log2(arg));
1471 }
1472 // F.9.3.11:
92f5a8d4 1473 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1474 {
1475 arg = 0;
1476 val = logb(arg);
1477 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1478 check_erange(val);
1479 arg = -arg;
92f5a8d4 1480 if (signbit(arg))
b32b8144
FG		 1481 {
1482 val = logb(arg);
1483 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1484 check_erange(val);
1485 }
1486 arg = std::numeric_limits<T>::infinity();
1487 val = logb(arg);
1488 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1489 arg = -std::numeric_limits<T>::infinity();
1490 val = logb(arg);
1491 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1492 }
92f5a8d4 1493 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1494 {
1495 arg = std::numeric_limits<T>::quiet_NaN();
1496 check_invalid(logb(arg));
1497 arg = -std::numeric_limits<T>::quiet_NaN();
1498 check_invalid(logb(arg));
1499 }
1500 // F.9.3.13:
1501 arg = 0;
1502 val = scalbn(arg, 2);
1503 BOOST_CHECK_EQUAL(val, 0);
1504 BOOST_CHECK(signbit(val) == 0);
1505 arg = -arg;
92f5a8d4 1506 if (signbit(arg))
b32b8144
FG		 1507 {
1508 val = scalbn(arg, 2);
1509 BOOST_CHECK_EQUAL(val, 0);
1510 BOOST_CHECK(signbit(val));
1511 }
92f5a8d4 1512 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1513 {
1514 arg = std::numeric_limits<T>::infinity();
1515 val = scalbn(arg, -100);
1516 BOOST_CHECK_EQUAL(val, arg);
1517 arg = -arg;
1518 val = scalbn(arg, -100);
1519 BOOST_CHECK_EQUAL(val, arg);
1520 }
1521 // F.9.4.1:
1522 arg = 0;
1523 val = cbrt(arg);
1524 BOOST_CHECK_EQUAL(val, 0);
1525 BOOST_CHECK(signbit(val) == 0);
1526 arg = -arg;
92f5a8d4 1527 if (signbit(arg))
b32b8144
FG		 1528 {
1529 val = cbrt(arg);
1530 BOOST_CHECK_EQUAL(val, 0);
1531 BOOST_CHECK(signbit(val));
1532 }
1533#if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1534 //
1535 // This test fails with early implementations of libquadmath - not our issue!
1536 //
92f5a8d4 1537 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1538 {
1539 arg = std::numeric_limits<T>::infinity();
1540 val = cbrt(arg);
1541 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1542 arg = -std::numeric_limits<T>::infinity();
1543 val = cbrt(arg);
1544 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1545 }
1546#endif
92f5a8d4 1547 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1548 {
1549 arg = std::numeric_limits<T>::quiet_NaN();
1550 check_invalid(cbrt(arg));
1551 arg = -std::numeric_limits<T>::quiet_NaN();
1552 check_invalid(cbrt(arg));
1553 }
1554 // F.9.4.2:
1555 arg = 0;
1556 val = fabs(arg);
1557 BOOST_CHECK_EQUAL(val, 0);
1558 BOOST_CHECK(signbit(val) == 0);
1559 arg = -arg;
92f5a8d4 1560 if (signbit(arg))
b32b8144
FG		 1561 {
1562 val = fabs(arg);
1563 BOOST_CHECK_EQUAL(val, 0);
1564 BOOST_CHECK(signbit(val) == 0);
1565 }
92f5a8d4 1566 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1567 {
1568 arg = std::numeric_limits<T>::infinity();
1569 val = fabs(arg);
1570 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1571 arg = -std::numeric_limits<T>::infinity();
1572 val = fabs(arg);
1573 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1574 }
1575 // F.9.4.3:
92f5a8d4 1576 arg = 2;
b32b8144 1577 arg2 = 0;
92f5a8d4 1578 val = hypot(arg, arg2);
b32b8144
FG		 1579 BOOST_CHECK_EQUAL(val, arg);
1580 arg2 = -arg2;
92f5a8d4 1581 val = hypot(arg, arg2);
b32b8144 1582 BOOST_CHECK_EQUAL(val, arg);
92f5a8d4 1583 if (std::numeric_limits<T>::has_infinity)
b32b8144 1584 {
92f5a8d4 1585 arg = std::numeric_limits<T>::infinity();
b32b8144 1586 arg2 = 2;
92f5a8d4 1587 val = hypot(arg, arg2);
b32b8144
FG		 1588 BOOST_CHECK_EQUAL(val, arg);
1589 arg = -arg;
1590 val = hypot(arg, arg2);
1591 BOOST_CHECK_EQUAL(val, -arg);
1592 arg2 = std::numeric_limits<T>::quiet_NaN();
92f5a8d4 1593 val = hypot(arg, arg2);
b32b8144
FG		 1594 BOOST_CHECK_EQUAL(val, -arg);
1595 arg = -arg;
1596 val = hypot(arg, arg2);
1597 BOOST_CHECK_EQUAL(val, arg);
1598 }
1599 // F.9.4.4:
92f5a8d4 1600 if (std::numeric_limits<T>::has_infinity)
b32b8144 1601 {
92f5a8d4 1602 arg = 0;
b32b8144 1603 arg2 = -3;
92f5a8d4 1604 val = pow(arg, arg2);
b32b8144
FG		 1605 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1606 check_erange(val);
1607 arg = -arg;
92f5a8d4 1608 if (signbit(arg))
b32b8144
FG		 1609 {
1610 val = pow(arg, arg2);
1611 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1612 check_erange(val);
1613 }
92f5a8d4 1614 arg = 0;
b32b8144 1615 arg2 = -2;
92f5a8d4 1616 val = pow(arg, arg2);
b32b8144
FG		 1617 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1618 check_erange(val);
1619 arg = -arg;
92f5a8d4 1620 if (signbit(arg))
b32b8144
FG		 1621 {
1622 val = pow(arg, arg2);
1623 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1624 check_erange(val);
1625 }
92f5a8d4 1626 arg = 0;
b32b8144 1627 arg2 = 3;
92f5a8d4 1628 val = pow(arg, arg2);
b32b8144
FG		 1629 BOOST_CHECK_EQUAL(val, 0);
1630 BOOST_CHECK(signbit(val) == 0);
1631 arg = -arg;
92f5a8d4 1632 if (signbit(arg))
b32b8144
FG		 1633 {
1634 val = pow(arg, arg2);
1635 BOOST_CHECK_EQUAL(val, 0);
1636 BOOST_CHECK(signbit(val));
1637 }
92f5a8d4 1638 arg = 0;
b32b8144 1639 arg2 = 2;
92f5a8d4 1640 val = pow(arg, arg2);
b32b8144
FG		 1641 BOOST_CHECK_EQUAL(val, 0);
1642 BOOST_CHECK(signbit(val) == 0);
1643 arg = -arg;
92f5a8d4 1644 if (signbit(arg))
b32b8144
FG		 1645 {
1646 val = pow(arg, arg2);
1647 BOOST_CHECK_EQUAL(val, 0);
1648 BOOST_CHECK(signbit(val) == 0);
1649 }
92f5a8d4 1650 arg = -1;
b32b8144 1651 arg2 = std::numeric_limits<T>::infinity();
92f5a8d4 1652 val = pow(arg, arg2);
b32b8144
FG		 1653 BOOST_CHECK_EQUAL(val, 1);
1654 arg2 = -std::numeric_limits<T>::infinity();
92f5a8d4 1655 val = pow(arg, arg2);
b32b8144 1656 BOOST_CHECK_EQUAL(val, 1);
92f5a8d4 1657 arg = 1;
b32b8144 1658 arg2 = 0;
92f5a8d4 1659 val = pow(arg, arg2);
b32b8144
FG		 1660 BOOST_CHECK_EQUAL(val, 1);
1661 arg2 = std::numeric_limits<T>::infinity();
92f5a8d4 1662 val = pow(arg, arg2);
b32b8144
FG		 1663 BOOST_CHECK_EQUAL(val, 1);
1664 arg2 = -std::numeric_limits<T>::infinity();
92f5a8d4 1665 val = pow(arg, arg2);
b32b8144
FG		 1666 BOOST_CHECK_EQUAL(val, 1);
1667 arg2 = std::numeric_limits<T>::quiet_NaN();
92f5a8d4 1668 val = pow(arg, arg2);
b32b8144 1669 BOOST_CHECK_EQUAL(val, 1);
92f5a8d4 1670 arg = 0;
b32b8144 1671 arg2 = 0;
92f5a8d4 1672 val = pow(arg, arg2);
b32b8144
FG		 1673 BOOST_CHECK_EQUAL(val, 1);
1674 arg2 = -arg2;
92f5a8d4 1675 val = pow(arg, arg2);
b32b8144
FG		 1676 BOOST_CHECK_EQUAL(val, 1);
1677 arg = std::numeric_limits<T>::infinity();
1678 val = pow(arg, arg2);
1679 BOOST_CHECK_EQUAL(val, 1);
1680 arg2 = -arg2;
92f5a8d4 1681 val = pow(arg, arg2);
b32b8144
FG		 1682 BOOST_CHECK_EQUAL(val, 1);
1683 arg = std::numeric_limits<T>::quiet_NaN();
1684 val = pow(arg, arg2);
1685 BOOST_CHECK_EQUAL(val, 1);
1686 arg2 = -arg2;
92f5a8d4 1687 val = pow(arg, arg2);
b32b8144
FG		 1688 BOOST_CHECK_EQUAL(val, 1);
1689 }
92f5a8d4 1690 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144 1691 {
92f5a8d4 1692 arg = -2.5;
b32b8144
FG		 1693 arg2 = 2.5;
1694 check_invalid(pow(arg, arg2));
1695 }
92f5a8d4 1696 if (std::numeric_limits<T>::has_infinity)
b32b8144 1697 {
92f5a8d4 1698 arg = 0.5;
b32b8144 1699 arg2 = -std::numeric_limits<T>::infinity();
92f5a8d4 1700 val = pow(arg, arg2);
b32b8144
FG		 1701 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1702 arg = -0.25;
1703 val = pow(arg, arg2);
1704 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
92f5a8d4 1705 arg = 2.5;
b32b8144 1706 arg2 = -std::numeric_limits<T>::infinity();
92f5a8d4 1707 val = pow(arg, arg2);
b32b8144
FG		 1708 BOOST_CHECK_EQUAL(val, 0);
1709 arg = -arg;
1710 val = pow(arg, arg2);
1711 BOOST_CHECK_EQUAL(val, 0);
92f5a8d4 1712 arg = 2.5;
b32b8144 1713 arg2 = std::numeric_limits<T>::infinity();
92f5a8d4 1714 val = pow(arg, arg2);
b32b8144
FG		 1715 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1716 arg = -arg;
1717 val = pow(arg, arg2);
1718 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
92f5a8d4 1719 arg = -std::numeric_limits<T>::infinity();
b32b8144 1720 arg2 = -3;
92f5a8d4 1721 val = pow(arg, arg2);
b32b8144 1722 BOOST_CHECK_EQUAL(val, 0);
92f5a8d4 1723 if (signbit(-T(0)))
b32b8144
FG		 1724 BOOST_CHECK(signbit(val));
1725 arg2 = -2;
92f5a8d4 1726 val = pow(arg, arg2);
b32b8144
FG		 1727 BOOST_CHECK_EQUAL(val, 0);
1728 BOOST_CHECK(signbit(val) == 0);
1729 arg2 = -2.5;
92f5a8d4 1730 val = pow(arg, arg2);
b32b8144
FG		 1731 BOOST_CHECK_EQUAL(val, 0);
1732 BOOST_CHECK(signbit(val) == 0);
1733 arg2 = 3;
92f5a8d4 1734 val = pow(arg, arg2);
b32b8144
FG		 1735 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1736 arg2 = 2;
92f5a8d4 1737 val = pow(arg, arg2);
b32b8144
FG		 1738 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1739 arg2 = 2.5;
92f5a8d4 1740 val = pow(arg, arg2);
b32b8144 1741 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
92f5a8d4 1742 arg = -arg; // +INF
b32b8144 1743 arg2 = -2;
92f5a8d4 1744 val = pow(arg, arg2);
b32b8144
FG		 1745 BOOST_CHECK_EQUAL(val, 0);
1746 BOOST_CHECK(signbit(val) == 0);
1747 arg2 = -3;
92f5a8d4 1748 val = pow(arg, arg2);
b32b8144
FG		 1749 BOOST_CHECK_EQUAL(val, 0);
1750 BOOST_CHECK(signbit(val) == 0);
1751 arg2 = -3.5;
92f5a8d4 1752 val = pow(arg, arg2);
b32b8144
FG		 1753 BOOST_CHECK_EQUAL(val, 0);
1754 BOOST_CHECK(signbit(val) == 0);
1755 arg2 = 2;
92f5a8d4 1756 val = pow(arg, arg2);
b32b8144
FG		 1757 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1758 arg2 = 3;
92f5a8d4 1759 val = pow(arg, arg2);
b32b8144
FG		 1760 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1761 arg2 = 3.5;
92f5a8d4 1762 val = pow(arg, arg2);
b32b8144
FG		 1763 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1764 }
1765 // F.9.4.5:
1766 arg = 0;
1767 val = sqrt(arg);
1768 BOOST_CHECK_EQUAL(val, 0);
1769 BOOST_CHECK(signbit(val) == 0);
1770 arg = -arg;
92f5a8d4 1771 if (signbit(arg))
b32b8144
FG		 1772 {
1773 val = sqrt(arg);
1774 BOOST_CHECK_EQUAL(val, 0);
1775 BOOST_CHECK(signbit(val));
1776 }
1777#if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
1778 //
1779 // This test fails with early implementations of libquadmath - not our issue!
1780 //
92f5a8d4 1781 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1782 {
1783 arg = std::numeric_limits<T>::infinity();
1784 val = sqrt(arg);
1785 BOOST_CHECK_EQUAL(val, arg);
1786 arg = -arg;
1787 check_invalid(sqrt(arg));
1788 }
1789#endif
92f5a8d4 1790 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1791 {
1792 arg = std::numeric_limits<T>::quiet_NaN();
1793 check_invalid(sqrt(arg));
1794 }
1795 // F.9.5.1:
1796 arg = 0;
1797 val = erf(arg);
1798 BOOST_CHECK_EQUAL(val, 0);
1799 BOOST_CHECK(signbit(val) == 0);
1800 arg = -arg;
92f5a8d4 1801 if (signbit(arg))
b32b8144
FG		 1802 {
1803 val = erf(arg);
1804 BOOST_CHECK_EQUAL(val, 0);
1805 BOOST_CHECK(signbit(val));
1806 }
92f5a8d4 1807 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1808 {
1809 arg = std::numeric_limits<T>::infinity();
1810 val = erf(arg);
1811 BOOST_CHECK_EQUAL(val, 1);
1812 arg = -arg;
1813 val = erf(arg);
1814 BOOST_CHECK_EQUAL(val, -1);
1815 }
92f5a8d4 1816 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1817 {
1818 arg = std::numeric_limits<T>::quiet_NaN();
1819 check_invalid(erf(arg));
1820 }
1821 // F.9.5.2:
92f5a8d4 1822 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1823 {
1824 arg = std::numeric_limits<T>::infinity();
1825 val = erfc(arg);
1826 BOOST_CHECK_EQUAL(val, 0);
1827 BOOST_CHECK(signbit(val) == 0);
1828 arg = -arg;
1829 val = erfc(arg);
1830 BOOST_CHECK_EQUAL(val, 2);
1831 }
92f5a8d4 1832 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1833 {
1834 arg = std::numeric_limits<T>::quiet_NaN();
1835 check_invalid(erfc(arg));
1836 }
1837 // F.9.5.3:
1838 arg = 1;
1839 val = lgamma(arg);
1840 BOOST_CHECK_EQUAL(val, 0);
1841 BOOST_CHECK(signbit(val) == 0);
1842 arg = 2;
1843 val = lgamma(arg);
1844 BOOST_CHECK_EQUAL(val, 0);
1845 BOOST_CHECK(signbit(val) == 0);
1846#if !defined(BOOST_MPFR_VERSION) || (BOOST_MPFR_VERSION > 30103)
1847 arg = 0;
1848 val = lgamma(arg);
1849 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1850 check_erange(val);
1851 arg = -1;
1852 val = lgamma(arg);
1853 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1854 check_erange(val);
1855 arg = -2;
1856 val = lgamma(arg);
1857 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1858 check_erange(val);
1859 arg = -std::numeric_limits<T>::infinity();
1860 val = lgamma(arg);
1861 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1862#endif
1863 arg = std::numeric_limits<T>::infinity();
1864 val = lgamma(arg);
1865 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
92f5a8d4 1866 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1867 {
1868 arg = std::numeric_limits<T>::quiet_NaN();
1869 check_invalid(lgamma(arg));
1870 }
1871 // F.9.5.4:
92f5a8d4 1872 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1873 {
1874 arg = 0;
1875 val = tgamma(arg);
1876 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1877 check_erange(val);
1878 arg = -arg;
92f5a8d4 1879 if (signbit(arg))
b32b8144
FG		 1880 {
1881 val = tgamma(arg);
1882 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1883 check_erange(val);
1884 }
1885 arg = -1;
1886 check_invalid(tgamma(arg));
1887 arg = -std::numeric_limits<T>::infinity();
1888 check_invalid(tgamma(arg));
1889 arg = std::numeric_limits<T>::infinity();
1890 val = tgamma(arg);
1891 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1892 }
92f5a8d4 1893 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1894 {
1895 arg = std::numeric_limits<T>::quiet_NaN();
1896 check_invalid(tgamma(arg));
1897 }
1898 // F.9.6.1:
1899 arg = 0;
1900 val = ceil(arg);
1901 BOOST_CHECK_EQUAL(val, 0);
1902 BOOST_CHECK(signbit(val) == 0);
1903 arg = -arg;
92f5a8d4 1904 if (signbit(arg))
b32b8144
FG		 1905 {
1906 val = ceil(arg);
1907 BOOST_CHECK_EQUAL(val, 0);
1908 BOOST_CHECK(signbit(val));
1909 }
92f5a8d4 1910 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1911 {
1912 arg = std::numeric_limits<T>::infinity();
1913 val = ceil(arg);
1914 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1915 arg = -arg;
1916 val = ceil(arg);
1917 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1918 }
92f5a8d4 1919 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1920 {
1921 arg = std::numeric_limits<T>::quiet_NaN();
1922 check_invalid(ceil(arg));
1923 }
1924 // F.9.6.2:
1925 arg = 0;
1926 val = floor(arg);
1927 BOOST_CHECK_EQUAL(val, 0);
1928 BOOST_CHECK(signbit(val) == 0);
1929 arg = -arg;
92f5a8d4 1930 if (signbit(arg))
b32b8144
FG		 1931 {
1932 val = floor(arg);
1933 BOOST_CHECK_EQUAL(val, 0);
1934 BOOST_CHECK(signbit(val));
1935 }
92f5a8d4 1936 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1937 {
1938 arg = std::numeric_limits<T>::infinity();
1939 val = floor(arg);
1940 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1941 arg = -arg;
1942 val = floor(arg);
1943 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1944 }
92f5a8d4 1945 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1946 {
1947 arg = std::numeric_limits<T>::quiet_NaN();
1948 check_invalid(floor(arg));
1949 }
1950 // F.9.6.3:
1951 arg = 0;
1952 val = nearbyint(arg);
1953 BOOST_CHECK_EQUAL(val, 0);
1954 BOOST_CHECK(signbit(val) == 0);
1955 arg = -arg;
92f5a8d4 1956 if (signbit(arg))
b32b8144
FG		 1957 {
1958 val = nearbyint(arg);
1959 BOOST_CHECK_EQUAL(val, 0);
1960 BOOST_CHECK(signbit(val));
1961 }
92f5a8d4 1962 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1963 {
1964 arg = std::numeric_limits<T>::infinity();
1965 val = nearbyint(arg);
1966 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1967 arg = -arg;
1968 val = nearbyint(arg);
1969 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1970 }
92f5a8d4 1971 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1972 {
1973 arg = std::numeric_limits<T>::quiet_NaN();
1974 check_invalid(nearbyint(arg));
1975 }
1976 // F.9.6.4:
1977 arg = 0;
1978 val = rint(arg);
1979 BOOST_CHECK_EQUAL(val, 0);
1980 BOOST_CHECK(signbit(val) == 0);
1981 arg = -arg;
92f5a8d4 1982 if (signbit(arg))
b32b8144
FG		 1983 {
1984 val = rint(arg);
1985 BOOST_CHECK_EQUAL(val, 0);
1986 BOOST_CHECK(signbit(val));
1987 }
92f5a8d4 1988 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 1989 {
1990 arg = std::numeric_limits<T>::infinity();
1991 val = rint(arg);
1992 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
1993 arg = -arg;
1994 val = rint(arg);
1995 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
1996 }
92f5a8d4 1997 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 1998 {
1999 arg = std::numeric_limits<T>::quiet_NaN();
2000 check_invalid(rint(arg));
2001 }
2002 // F.9.6.6:
2003 arg = 0;
2004 val = round(arg);
2005 BOOST_CHECK_EQUAL(val, 0);
2006 BOOST_CHECK(signbit(val) == 0);
2007 arg = -arg;
92f5a8d4 2008 if (signbit(arg))
b32b8144
FG		 2009 {
2010 val = round(arg);
2011 BOOST_CHECK_EQUAL(val, 0);
2012 BOOST_CHECK(signbit(val));
2013 }
92f5a8d4 2014 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 2015 {
2016 arg = std::numeric_limits<T>::infinity();
2017 val = round(arg);
2018 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
2019 arg = -arg;
2020 val = round(arg);
2021 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
2022 }
92f5a8d4 2023 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 2024 {
2025 arg = std::numeric_limits<T>::quiet_NaN();
2026 check_invalid(round(arg));
2027 }
2028 // F.9.6.8:
2029 arg = 0;
2030 val = trunc(arg);
2031 BOOST_CHECK_EQUAL(val, 0);
2032 BOOST_CHECK(signbit(val) == 0);
2033 arg = -arg;
92f5a8d4 2034 if (signbit(arg))
b32b8144
FG		 2035 {
2036 val = trunc(arg);
2037 BOOST_CHECK_EQUAL(val, 0);
2038 BOOST_CHECK(signbit(val));
2039 }
92f5a8d4 2040 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 2041 {
2042 arg = std::numeric_limits<T>::infinity();
2043 val = trunc(arg);
2044 BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
2045 arg = -arg;
2046 val = trunc(arg);
2047 BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
2048 }
92f5a8d4 2049 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144
FG		 2050 {
2051 arg = std::numeric_limits<T>::quiet_NaN();
2052 check_invalid(trunc(arg));
2053 }
2054 // F.9.7.1:
92f5a8d4 2055 arg = 0;
b32b8144 2056 arg2 = 2;
92f5a8d4 2057 val = fmod(arg, arg2);
b32b8144
FG		 2058 BOOST_CHECK_EQUAL(val, 0);
2059 BOOST_CHECK(signbit(val) == 0);
2060 arg = -arg;
92f5a8d4 2061 if (signbit(arg))
b32b8144
FG		 2062 {
2063 val = fmod(arg, arg2);
2064 BOOST_CHECK_EQUAL(val, 0);
2065 BOOST_CHECK(signbit(val));
2066 }
92f5a8d4 2067 if (std::numeric_limits<T>::has_infinity)
b32b8144
FG		 2068 {
2069 arg = std::numeric_limits<T>::infinity();
2070 check_invalid(fmod(arg, arg2));
2071 arg = -arg;
2072 check_invalid(fmod(arg, arg2));
92f5a8d4 2073 arg = 2;
b32b8144
FG		 2074 arg2 = 0;
2075 check_invalid(fmod(arg, arg2));
2076 check_invalid(fmod(arg, -arg2));
2077 }
92f5a8d4 2078 if (std::numeric_limits<T>::has_quiet_NaN)
b32b8144 2079 {
92f5a8d4 2080 arg = std::numeric_limits<T>::quiet_NaN();
b32b8144
FG		 2081 arg2 = 2;
2082 check_invalid(fmod(arg, arg2));
2083 swap(arg, arg2);
2084 check_invalid(fmod(arg, arg2));
2085 check_invalid(fmod(arg2, arg2));
2086 }
92f5a8d4
TL		 2087 //
2088 // Bugs:
2089 //
2090 int sign = 0;
2091 boost::math::lgamma(T(0.000001), &sign);
2092 BOOST_CHECK_EQUAL(sign, 1);
2093 sign = 0;
2094 boost::math::lgamma(T(0.5), &sign);
2095 BOOST_CHECK_EQUAL(sign, 1);
2096 sign = 0;
2097 boost::math::lgamma(T(0.9), &sign);
2098 BOOST_CHECK_EQUAL(sign, 1);
2099 sign = 0;
2100 boost::math::lgamma(T(1.1), &sign);
2101 BOOST_CHECK_EQUAL(sign, 1);
2102 sign = 0;
2103 boost::math::lgamma(T(1.9), &sign);
2104 BOOST_CHECK_EQUAL(sign, 1);
2105 sign = 0;
2106 boost::math::lgamma(T(2.1), &sign);
2107 BOOST_CHECK_EQUAL(sign, 1);
2108 sign = 0;
2109 boost::math::lgamma(T(20), &sign);
2110 BOOST_CHECK_EQUAL(sign, 1);
2111 sign = 0;
2112 boost::math::lgamma(T(-0.0000000000001), &sign);
2113 BOOST_CHECK_EQUAL(sign, -1);
2114 sign = 0;
2115 boost::math::lgamma(T(-0.5), &sign);
2116 BOOST_CHECK_EQUAL(sign, -1);
2117 sign = 0;
2118 boost::math::lgamma(T(-1.5), &sign);
2119 BOOST_CHECK_EQUAL(sign, 1);
2120 sign = 0;
2121 boost::math::lgamma(T(-2.5), &sign);
2122 BOOST_CHECK_EQUAL(sign, -1);
2123 sign = 0;
2124 boost::math::lgamma(T(-3.5), &sign);
2125 BOOST_CHECK_EQUAL(sign, 1);
b32b8144
FG		 2126}
2127
f67539c2
TL		 2128template <class T>
2129void test_c99_appendix_F_tgammaq_addon_for_float128()
2130{
2131#if defined(TEST_FLOAT128)
2132 // Special tests of tgamma for positive and negative
2133 // real values in the neighborhood of the origin.
2134
2135 // At Wolfram Alpha: N[Gamma[1/3], 201]
2136 const T tgamma_third
2137 (
2138 "2."
2139 "67893853470774763365569294097467764412868937795730"
2140 "11009504283275904176101677438195409828890411887894"
2141 "19159049200072263335719084569504472259977713367708"
2142 "46976816728982305000321834255032224715694181755545"
2143 );
2144
2145 // Create a string such as "1e-84", where 84 exemplifies (digits10*5 + 5)/6
2146 // and the exponent varies depending on the value of digits10 for the type.
2147 // Consider, for instance digits10=100. In this case n_exp=(100*5 + 5)/6 = 84.
2148
2149 const int n_exp =(std::max)(((std::numeric_limits<T>::digits10 * 5) + 5) / 6, 1);
2150
2151 const T tgamma_tol("1e-" + boost::lexical_cast<std::string>(n_exp));
2152
2153 // Check tgamma(1/3 - n) for n in 0...24.
2154 for(int n = 0; n < 25; ++n)
2155 {
2156 const T tgamma_val = tgamma(T((T(1) / T(3)) - T(n)));
2157
2158 T tgamma_control(tgamma_third);
2159
2160 for(unsigned int k = 0U; k < static_cast<unsigned int>(n); ++k)
2161 {
2162 tgamma_control *= -3;
2163 tgamma_control /= ((3U * (k + 1U)) - 1U);
2164 }
2165
2166 BOOST_CHECK_CLOSE_FRACTION(tgamma_val, tgamma_control, tgamma_tol);
2167 }
2168
2169 // Check tgamma(1/3 + n) for n in 0...24.
2170 for(unsigned int n = 0U; n < 25U; ++n)
2171 {
2172 const T tgamma_val = tgamma(T((T(1) / T(3)) + T(n)));
2173
2174 T tgamma_control(tgamma_third);
2175
2176 for(unsigned int k = 0U; k < n; ++k)
2177 {
2178 tgamma_control /= 3;
2179 tgamma_control *= ((3U * (k + 1U)) - 2U);
2180 }
2181
2182 BOOST_CHECK_CLOSE_FRACTION(tgamma_val, tgamma_control, tgamma_tol);
2183 }
2184#endif
2185}
2186
7c673cae
FG		 2187int main()
2188{
2189 test_poison<float>();
2190 test_poison<double>();
2191#ifdef TEST_MPF_50
2192 test<boost::multiprecision::mpf_float_50>();
2193 test<boost::multiprecision::mpf_float_100>();
2194#endif
2195#ifdef TEST_MPFR_50
b32b8144 2196 std::cout << "Testing MPFR: " << MPFR_VERSION_STRING << std::endl;
7c673cae
FG		 2197 test<boost::multiprecision::mpfr_float_50>();
2198 test<boost::multiprecision::mpfr_float_100>();
b32b8144 2199 test_c99_appendix_F<boost::multiprecision::mpfr_float_50>();
7c673cae
FG		 2200#endif
2201#ifdef TEST_MPFI_50
2202 test<boost::multiprecision::mpfi_float_50>();
2203 test<boost::multiprecision::mpfi_float_100>();
2204#endif
2205#ifdef TEST_CPP_DEC_FLOAT
2206 test<boost::multiprecision::cpp_dec_float_50>();
11fdf7f2 2207#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
7c673cae 2208 test<boost::multiprecision::cpp_dec_float_100>();
b32b8144
FG		 2209#endif
2210 test_c99_appendix_F<boost::multiprecision::cpp_dec_float_50>();
2211#endif
2212#ifdef TEST_CPP_DEC_FLOAT_2
7c673cae
FG		 2213 // Some "peculiar" digit counts which stress our code:
2214 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
11fdf7f2 2215#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
7c673cae 2216 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
b32b8144
FG		 2217#endif
2218#endif
2219#ifdef TEST_CPP_DEC_FLOAT_3
7c673cae 2220 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
11fdf7f2 2221#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
7c673cae 2222 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
b32b8144
FG		 2223#endif
2224#endif
2225#ifdef TEST_CPP_DEC_FLOAT_4
7c673cae 2226 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
11fdf7f2 2227#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
7c673cae 2228 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
b32b8144
FG		 2229#endif
2230#endif
2231#ifdef TEST_CPP_DEC_FLOAT_5
1e59de90
TL		 2232 #if defined(__MINGW32__) || defined(__MINGW64__) // Weak workaround just to, let's say, get green
2233 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long > > >();
2234 #else
11fdf7f2 2235 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
1e59de90 2236 #endif
7c673cae 2237#endif
92f5a8d4 2238#ifdef TEST_CPP_DEC_FLOAT_6
1e59de90
TL		 2239 #if defined(__MINGW32__) || defined(__MINGW64__) // Weak workaround just to, let's say, get green
2240 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long > > >();
2241 #else
92f5a8d4 2242 test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
1e59de90 2243 #endif
7c673cae
FG		 2244#endif
2245#ifdef TEST_CPP_BIN_FLOAT
2246 test<boost::multiprecision::cpp_bin_float_50>();
2247 test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
11fdf7f2
TL		 2248#endif
2249#ifdef TEST_CPP_BIN_FLOAT_2
1e59de90 2250 test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
11fdf7f2
TL		 2251#endif
2252#ifdef TEST_CPP_BIN_FLOAT_3
b32b8144
FG		 2253 test_c99_appendix_F<boost::multiprecision::cpp_bin_float_50>();
2254 test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
7c673cae
FG		 2255#endif
2256#ifdef TEST_FLOAT128
2257 test<boost::multiprecision::float128>();
b32b8144 2258 test_c99_appendix_F<boost::multiprecision::float128>();
f67539c2 2259 test_c99_appendix_F_tgammaq_addon_for_float128<boost::multiprecision::float128>();
7c673cae 2260#endif
1e59de90
TL		 2261#ifdef TEST_MPFI_DEBUG_ADAPTOR
2262 test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
2263 //test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
2264#endif
2265#ifdef TEST_MPFR_DEBUG_ADAPTOR
2266 test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
2267 test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
2268#endif
2269#ifdef TEST_MPFI_LOGGED_ADAPTOR
2270 test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
2271 //test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
2272#endif
2273#ifdef TEST_MPFR_LOGGED_ADAPTOR
2274 test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
2275 test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
2276#endif
7c673cae
FG		 2277
2278 return boost::report_errors();
2279}
Ceph