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