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