]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright John Maddock 2006. |
2 | // Copyright Paul A. Bristow 2007, 2009 | |
3 | // Use, modification and distribution are subject to the | |
4 | // Boost Software License, Version 1.0. (See accompanying file | |
5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
6 | ||
7 | #define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error | |
8 | ||
9 | #include <boost/math/concepts/real_concept.hpp> | |
10 | #include <boost/math/special_functions/math_fwd.hpp> | |
11 | #define BOOST_TEST_MAIN | |
12 | #include <boost/test/unit_test.hpp> | |
92f5a8d4 | 13 | #include <boost/test/tools/floating_point_comparison.hpp> |
7c673cae FG |
14 | #include <boost/math/tools/stats.hpp> |
15 | #include <boost/math/tools/test.hpp> | |
16 | #include <boost/math/constants/constants.hpp> | |
17 | #include <boost/type_traits/is_floating_point.hpp> | |
18 | #include <boost/array.hpp> | |
19 | #include "functor.hpp" | |
20 | ||
21 | #include "handle_test_result.hpp" | |
22 | #include "table_type.hpp" | |
23 | ||
24 | #ifndef SC_ | |
25 | #define SC_(x) static_cast<typename table_type<T>::type>(BOOST_JOIN(x, L)) | |
26 | #endif | |
27 | ||
28 | template <class Real, class T> | |
29 | void do_test_gamma(const T& data, const char* type_name, const char* test_name) | |
30 | { | |
31 | #if !(defined(ERROR_REPORTING_MODE) && (!defined(TGAMMA_FUNCTION_TO_TEST) || !defined(LGAMMA_FUNCTION_TO_TEST))) | |
32 | typedef Real value_type; | |
33 | ||
34 | typedef value_type (*pg)(value_type); | |
35 | #ifdef TGAMMA_FUNCTION_TO_TEST | |
36 | pg funcp = TGAMMA_FUNCTION_TO_TEST; | |
37 | #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS) | |
38 | pg funcp = boost::math::tgamma<value_type>; | |
39 | #else | |
40 | pg funcp = boost::math::tgamma; | |
41 | #endif | |
42 | ||
43 | boost::math::tools::test_result<value_type> result; | |
44 | ||
45 | std::cout << "Testing " << test_name << " with type " << type_name | |
46 | << "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"; | |
47 | ||
48 | // | |
49 | // test tgamma against data: | |
50 | // | |
51 | result = boost::math::tools::test_hetero<Real>( | |
52 | data, | |
53 | bind_func<Real>(funcp, 0), | |
54 | extract_result<Real>(1)); | |
55 | handle_test_result(result, data[result.worst()], result.worst(), type_name, "tgamma", test_name); | |
56 | // | |
57 | // test lgamma against data: | |
58 | // | |
59 | #ifdef LGAMMA_FUNCTION_TO_TEST | |
60 | funcp = LGAMMA_FUNCTION_TO_TEST; | |
61 | #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS) | |
62 | funcp = boost::math::lgamma<value_type>; | |
63 | #else | |
64 | funcp = boost::math::lgamma; | |
65 | #endif | |
66 | result = boost::math::tools::test_hetero<Real>( | |
67 | data, | |
68 | bind_func<Real>(funcp, 0), | |
69 | extract_result<Real>(2)); | |
70 | handle_test_result(result, data[result.worst()], result.worst(), type_name, "lgamma", test_name); | |
71 | ||
72 | std::cout << std::endl; | |
73 | #endif | |
74 | } | |
75 | ||
76 | template <class Real, class T> | |
77 | void do_test_gammap1m1(const T& data, const char* type_name, const char* test_name) | |
78 | { | |
79 | #if !(defined(ERROR_REPORTING_MODE) && !defined(TGAMMA1PM1_FUNCTION_TO_TEST)) | |
80 | typedef Real value_type; | |
81 | ||
82 | typedef value_type (*pg)(value_type); | |
83 | #ifdef TGAMMA1PM1_FUNCTION_TO_TEST | |
84 | pg funcp = TGAMMA1PM1_FUNCTION_TO_TEST; | |
85 | #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS) | |
86 | pg funcp = boost::math::tgamma1pm1<value_type>; | |
87 | #else | |
88 | pg funcp = boost::math::tgamma1pm1; | |
89 | #endif | |
90 | ||
91 | boost::math::tools::test_result<value_type> result; | |
92 | ||
93 | std::cout << "Testing " << test_name << " with type " << type_name | |
94 | << "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"; | |
95 | ||
96 | // | |
97 | // test tgamma1pm1 against data: | |
98 | // | |
99 | result = boost::math::tools::test_hetero<Real>( | |
100 | data, | |
101 | bind_func<Real>(funcp, 0), | |
102 | extract_result<Real>(1)); | |
103 | handle_test_result(result, data[result.worst()], result.worst(), type_name, "tgamma1pm1", test_name); | |
104 | std::cout << std::endl; | |
105 | #endif | |
106 | } | |
107 | ||
108 | template <class T> | |
109 | void test_gamma(T, const char* name) | |
110 | { | |
111 | // | |
112 | // The actual test data is rather verbose, so it's in a separate file | |
113 | // | |
114 | // The contents are as follows, each row of data contains | |
115 | // three items, input value, gamma and lgamma: | |
116 | // | |
117 | // gamma and lgamma at integer and half integer values: | |
118 | // boost::array<boost::array<T, 3>, N> factorials; | |
119 | // | |
120 | // gamma and lgamma for z near 0: | |
121 | // boost::array<boost::array<T, 3>, N> near_0; | |
122 | // | |
123 | // gamma and lgamma for z near 1: | |
124 | // boost::array<boost::array<T, 3>, N> near_1; | |
125 | // | |
126 | // gamma and lgamma for z near 2: | |
127 | // boost::array<boost::array<T, 3>, N> near_2; | |
128 | // | |
129 | // gamma and lgamma for z near -10: | |
130 | // boost::array<boost::array<T, 3>, N> near_m10; | |
131 | // | |
132 | // gamma and lgamma for z near -55: | |
133 | // boost::array<boost::array<T, 3>, N> near_m55; | |
134 | // | |
135 | // The last two cases are chosen more or less at random, | |
136 | // except that one is even and the other odd, and both are | |
137 | // at negative poles. The data near zero also tests near | |
138 | // a pole, the data near 1 and 2 are to probe lgamma as | |
139 | // the result -> 0. | |
140 | // | |
141 | # include "test_gamma_data.ipp" | |
142 | ||
143 | do_test_gamma<T>(factorials, name, "factorials"); | |
144 | do_test_gamma<T>(near_0, name, "near 0"); | |
145 | do_test_gamma<T>(near_1, name, "near 1"); | |
146 | do_test_gamma<T>(near_2, name, "near 2"); | |
147 | do_test_gamma<T>(near_m10, name, "near -10"); | |
148 | do_test_gamma<T>(near_m55, name, "near -55"); | |
149 | ||
150 | // | |
151 | // And now tgamma1pm1 which computes gamma(1+dz)-1: | |
152 | // | |
153 | do_test_gammap1m1<T>(gammap1m1_data, name, "tgamma1pm1(dz)"); | |
154 | } | |
155 | ||
156 | template <class T> | |
157 | void test_spots(T, const char* name) | |
158 | { | |
159 | BOOST_MATH_STD_USING | |
160 | ||
161 | std::cout << "Testing type " << name << std::endl; | |
162 | // | |
163 | // basic sanity checks, tolerance is 50 epsilon expressed as a percentage: | |
164 | // | |
165 | T tolerance = boost::math::tools::epsilon<T>() * 5000; | |
166 | // | |
167 | // Extra tolerance for real_concept checks which use less accurate code: | |
168 | // | |
169 | T extra_tol = boost::is_floating_point<T>::value ? 1 : 20; | |
170 | ||
171 | BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(3.5)), static_cast<T>(3.3233509704478425511840640312646472177454052302295L), tolerance); | |
172 | BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(0.125)), static_cast<T>(7.5339415987976119046992298412151336246104195881491L), tolerance); | |
173 | BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(-0.125)), static_cast<T>(-8.7172188593831756100190140408231437691829605421405L), tolerance); | |
174 | BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(-3.125)), static_cast<T>(1.1668538708507675587790157356605097019141636072094L), tolerance); | |
175 | // Lower tolerance on this one, is only really needed on Linux x86 systems, result is mostly down to std lib accuracy: | |
176 | BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(-53249.0 / 1024)), static_cast<T>(-1.2646559519067605488251406578743995122462767733517e-65L), tolerance * 3); | |
177 | ||
178 | // Very small values, from a bug report by Rocco Romeo: | |
179 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -12)), static_cast<T>(4095.42302574977164107280305038926932586783813167844235368772L), tolerance); | |
180 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -14)), static_cast<T>(16383.4228446989052821887834066513143241996925504706815681204L), tolerance * 2); | |
181 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -25)), static_cast<T>(3.35544314227843645746319656372890833248893111091576093784981e7L), tolerance); | |
182 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -27)), static_cast<T>(1.34217727422784342467508497080056807355928046680073490038257e8L), tolerance); | |
183 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -29)), static_cast<T>(5.36870911422784336940727488260481582524683632281496706906706e8L), tolerance); | |
184 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -35)), static_cast<T>(3.43597383674227843351272524573929605605651956475300480712955e10L), tolerance); | |
185 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -54)), static_cast<T>(1.80143985094819834227843350984671942971248427509141008005685e16L), tolerance); | |
186 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -64)), static_cast<T>(1.84467440737095516154227843350984671394471047428598176073616e19L), tolerance); | |
187 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -66)), static_cast<T>(7.37869762948382064634227843350984671394068921181531525785592922800e19L), tolerance); | |
188 | BOOST_CHECK_CLOSE(::boost::math::tgamma(ldexp(static_cast<T>(1), -33)), static_cast<T>(8.58993459142278433521360841138215453639282914047157884932317481977e9L), tolerance); | |
189 | BOOST_CHECK_CLOSE(::boost::math::tgamma(4 / boost::math::tools::max_value<T>()), boost::math::tools::max_value<T>() / 4, tolerance); | |
190 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -12)), static_cast<T>(-4096.57745718775464971331294488248972086965434176847741450728L), tolerance); | |
191 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -14)), static_cast<T>(-16384.5772760354695939336148831283410381037202353359487504624L), tolerance * 2); | |
192 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -25)), static_cast<T>(-3.35544325772156943776992988569766723938420508937071533029983e7L), tolerance); | |
193 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -27)), static_cast<T>(-1.34217728577215672270574319043497450577151370942651414968627e8L), tolerance); | |
194 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -29)), static_cast<T>(-5.36870912577215666743793215770406791630514293641886249382012e8L), tolerance); | |
195 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -34)), static_cast<T>(-1.71798691845772156649591034966100693794360502123447124928244e10L), tolerance); | |
196 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -54)), static_cast<T>(-1.80143985094819845772156649015329155101490229157245556564920e16L), tolerance); | |
197 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -64)), static_cast<T>(-1.84467440737095516165772156649015328606601289230246224694513e19L), tolerance); | |
198 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -66)), static_cast<T>(-7.37869762948382064645772156649015328606199162983179574406439e19L), tolerance); | |
199 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-ldexp(static_cast<T>(1), -33)), static_cast<T>(-8.58993459257721566501667413261977598620193488449233402857632e9L), tolerance); | |
200 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 / boost::math::tools::max_value<T>()), -boost::math::tools::max_value<T>() / 4, tolerance); | |
201 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-1 + ldexp(static_cast<T>(1), -22)), static_cast<T>(-4.19430442278467170746130758391572421252211886167956799318843e6L), tolerance); | |
202 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-1 - ldexp(static_cast<T>(1), -22)), static_cast<T>(4.19430357721600151046968956086404748206205391186399889108944e6L), tolerance); | |
203 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 + ldexp(static_cast<T>(1), -20)), static_cast<T>(43690.7294216755534842491085530510391932288379640970386378756L), tolerance * extra_tol); | |
204 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 - ldexp(static_cast<T>(1), -20)), static_cast<T>(-43690.6039118698506165317137699180871126338425941292693705533L), tolerance * extra_tol); | |
205 | if(boost::math::tools::digits<T>() > 50) | |
206 | { | |
207 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-1 + ldexp(static_cast<T>(1), -44)), static_cast<T>(-1.75921860444164227843350985473932247549232492467032584051825e13L), tolerance); | |
208 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-1 - ldexp(static_cast<T>(1), -44)), static_cast<T>(1.75921860444155772156649016131144377791001546933519242218430e13L), tolerance); | |
209 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 + ldexp(static_cast<T>(1), -44)), static_cast<T>(7.33007751850729421569517998006564998020333048893618664936994e11L), tolerance * extra_tol); | |
210 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 - ldexp(static_cast<T>(1), -44)), static_cast<T>(-7.33007751850603911763815347967171096249288790373790093559568e11L), tolerance * extra_tol); | |
211 | } | |
212 | if(boost::math::tools::digits<T>() > 60) | |
213 | { | |
214 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-1 + ldexp(static_cast<T>(1), -55)), static_cast<T>(-3.60287970189639684227843350984671785799289582631555600561524e16L), tolerance); | |
215 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-1 - ldexp(static_cast<T>(1), -55)), static_cast<T>(3.60287970189639675772156649015328997929531384279596450489170e16L), tolerance * 3); | |
216 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 + ldexp(static_cast<T>(1), -55)), static_cast<T>(1.50119987579016539608823618465835611632004877549994080474627e15L), tolerance * extra_tol); | |
217 | BOOST_CHECK_CLOSE(::boost::math::tgamma(-4 - ldexp(static_cast<T>(1), -55)), static_cast<T>(-1.50119987579016527057843048200831672241827850458884790004313e15L), tolerance * extra_tol); | |
218 | } | |
219 | ||
220 | #ifdef BOOST_MSVC | |
221 | #pragma warning(push) | |
222 | #pragma warning(disable:4127) | |
223 | #endif | |
224 | // Test bug fixes in tgamma: | |
225 | if(std::numeric_limits<T>::max_exponent10 > 244) | |
226 | { | |
227 | BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(142.75)), static_cast<T>(7.8029496083318133344429227511387928576820621466e244L), tolerance * 4); | |
228 | } | |
229 | #ifdef BOOST_MSVC | |
230 | #pragma warning(pop) | |
231 | #endif | |
232 | // An extra fudge factor for real_concept which has a less accurate tgamma: | |
233 | T tolerance_tgamma_extra = std::numeric_limits<T>::is_specialized ? 1 : 10; | |
234 | ||
235 | int sign = 1; | |
236 | BOOST_CHECK_CLOSE(::boost::math::lgamma(static_cast<T>(3.5), &sign), static_cast<T>(1.2009736023470742248160218814507129957702389154682L), tolerance); | |
237 | BOOST_CHECK(sign == 1); | |
238 | BOOST_CHECK_CLOSE(::boost::math::lgamma(static_cast<T>(0.125), &sign), static_cast<T>(2.0194183575537963453202905211670995899482809521344L), tolerance); | |
239 | BOOST_CHECK(sign == 1); | |
240 | BOOST_CHECK_CLOSE(::boost::math::lgamma(static_cast<T>(-0.125), &sign), static_cast<T>(2.1653002489051702517540619481440174064962195287626L), tolerance); | |
241 | BOOST_CHECK(sign == -1); | |
242 | BOOST_CHECK_CLOSE(::boost::math::lgamma(static_cast<T>(-3.125), &sign), static_cast<T>(0.1543111276840418242676072830970532952413339012367L), tolerance * tolerance_tgamma_extra); | |
243 | BOOST_CHECK(sign == 1); | |
244 | BOOST_CHECK_CLOSE(::boost::math::lgamma(static_cast<T>(-53249.0 / 1024), &sign), static_cast<T>(-149.43323093420259741100038126078721302600128285894L), tolerance); | |
245 | BOOST_CHECK(sign == -1); | |
246 | // Very small values, from a bug report by Rocco Romeo: | |
247 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -12), &sign), log(static_cast<T>(4095.42302574977164107280305038926932586783813167844235368772L)), tolerance); | |
248 | BOOST_CHECK(sign == 1); | |
249 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -14), &sign), log(static_cast<T>(16383.4228446989052821887834066513143241996925504706815681204L)), tolerance); | |
250 | BOOST_CHECK(sign == 1); | |
251 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -25), &sign), log(static_cast<T>(3.35544314227843645746319656372890833248893111091576093784981e7L)), tolerance); | |
252 | BOOST_CHECK(sign == 1); | |
253 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -27), &sign), log(static_cast<T>(1.34217727422784342467508497080056807355928046680073490038257e8L)), tolerance); | |
254 | BOOST_CHECK(sign == 1); | |
255 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -29), &sign), log(static_cast<T>(5.36870911422784336940727488260481582524683632281496706906706e8L)), tolerance); | |
256 | BOOST_CHECK(sign == 1); | |
257 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -35), &sign), log(static_cast<T>(3.43597383674227843351272524573929605605651956475300480712955e10L)), tolerance); | |
258 | BOOST_CHECK(sign == 1); | |
259 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -54), &sign), log(static_cast<T>(1.80143985094819834227843350984671942971248427509141008005685e16L)), tolerance); | |
260 | BOOST_CHECK(sign == 1); | |
261 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -64), &sign), log(static_cast<T>(1.84467440737095516154227843350984671394471047428598176073616e19L)), tolerance); | |
262 | BOOST_CHECK(sign == 1); | |
263 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -66), &sign), log(static_cast<T>(7.37869762948382064634227843350984671394068921181531525785592922800e19L)), tolerance); | |
264 | BOOST_CHECK(sign == 1); | |
265 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(1), -33), &sign), log(static_cast<T>(8.58993459142278433521360841138215453639282914047157884932317481977e9L)), tolerance); | |
266 | BOOST_CHECK(sign == 1); | |
267 | BOOST_CHECK_CLOSE(::boost::math::lgamma(4 / boost::math::tools::max_value<T>(), &sign), log(boost::math::tools::max_value<T>() / 4), tolerance); | |
268 | BOOST_CHECK(sign == 1); | |
269 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -12), &sign), log(-static_cast<T>(-4096.57745718775464971331294488248972086965434176847741450728L)), tolerance); | |
270 | BOOST_CHECK(sign == -1); | |
271 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -14), &sign), log(-static_cast<T>(-16384.5772760354695939336148831283410381037202353359487504624L)), tolerance); | |
272 | BOOST_CHECK(sign == -1); | |
273 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -25), &sign), log(-static_cast<T>(-3.35544325772156943776992988569766723938420508937071533029983e7L)), tolerance); | |
274 | BOOST_CHECK(sign == -1); | |
275 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -27), &sign), log(-static_cast<T>(-1.34217728577215672270574319043497450577151370942651414968627e8L)), tolerance); | |
276 | BOOST_CHECK(sign == -1); | |
277 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -29), &sign), log(-static_cast<T>(-5.36870912577215666743793215770406791630514293641886249382012e8L)), tolerance); | |
278 | BOOST_CHECK(sign == -1); | |
279 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -34), &sign), log(-static_cast<T>(-1.71798691845772156649591034966100693794360502123447124928244e10L)), tolerance); | |
280 | BOOST_CHECK(sign == -1); | |
281 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -54), &sign), log(-static_cast<T>(-1.80143985094819845772156649015329155101490229157245556564920e16L)), tolerance); | |
282 | BOOST_CHECK(sign == -1); | |
283 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -64), &sign), log(-static_cast<T>(-1.84467440737095516165772156649015328606601289230246224694513e19L)), tolerance); | |
284 | BOOST_CHECK(sign == -1); | |
285 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -66), &sign), log(-static_cast<T>(-7.37869762948382064645772156649015328606199162983179574406439e19L)), tolerance); | |
286 | BOOST_CHECK(sign == -1); | |
287 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-ldexp(static_cast<T>(1), -33), &sign), log(-static_cast<T>(-8.58993459257721566501667413261977598620193488449233402857632e9L)), tolerance); | |
288 | BOOST_CHECK(sign == -1); | |
289 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 / boost::math::tools::max_value<T>(), &sign), log(boost::math::tools::max_value<T>() / 4), tolerance); | |
290 | BOOST_CHECK(sign == -1); | |
291 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-1 + ldexp(static_cast<T>(1), -22), &sign), log(static_cast<T>(4.19430442278467170746130758391572421252211886167956799318843e6L)), tolerance); | |
292 | BOOST_CHECK(sign == -1); | |
293 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-1 - ldexp(static_cast<T>(1), -22), &sign), log(static_cast<T>(4.19430357721600151046968956086404748206205391186399889108944e6L)), tolerance); | |
294 | BOOST_CHECK(sign == 1); | |
295 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 + ldexp(static_cast<T>(1), -20), &sign), log(static_cast<T>(43690.7294216755534842491085530510391932288379640970386378756L)), tolerance * extra_tol); | |
296 | BOOST_CHECK(sign == 1); | |
297 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 - ldexp(static_cast<T>(1), -20), &sign), log(static_cast<T>(43690.6039118698506165317137699180871126338425941292693705533L)), tolerance * extra_tol); | |
298 | BOOST_CHECK(sign == -1); | |
299 | if(boost::math::tools::digits<T>() > 50) | |
300 | { | |
301 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-1 + ldexp(static_cast<T>(1), -44), &sign), log(static_cast<T>(1.75921860444164227843350985473932247549232492467032584051825e13L)), tolerance); | |
302 | BOOST_CHECK(sign == -1); | |
303 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-1 - ldexp(static_cast<T>(1), -44), &sign), log(static_cast<T>(1.75921860444155772156649016131144377791001546933519242218430e13L)), tolerance); | |
304 | BOOST_CHECK(sign == 1); | |
305 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 + ldexp(static_cast<T>(1), -44), &sign), log(static_cast<T>(7.33007751850729421569517998006564998020333048893618664936994e11L)), tolerance * extra_tol); | |
306 | BOOST_CHECK(sign == 1); | |
307 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 - ldexp(static_cast<T>(1), -44), &sign), log(static_cast<T>(7.33007751850603911763815347967171096249288790373790093559568e11L)), tolerance * extra_tol); | |
308 | BOOST_CHECK(sign == -1); | |
309 | } | |
310 | if(boost::math::tools::digits<T>() > 60) | |
311 | { | |
312 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-1 + ldexp(static_cast<T>(1), -55), &sign), log(static_cast<T>(3.60287970189639684227843350984671785799289582631555600561524e16L)), tolerance); | |
313 | BOOST_CHECK(sign == -1); | |
314 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-1 - ldexp(static_cast<T>(1), -55), &sign), log(static_cast<T>(3.60287970189639675772156649015328997929531384279596450489170e16L)), tolerance); | |
315 | BOOST_CHECK(sign == 1); | |
316 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 + ldexp(static_cast<T>(1), -55), &sign), log(static_cast<T>(1.50119987579016539608823618465835611632004877549994080474627e15L)), tolerance * extra_tol); | |
317 | BOOST_CHECK(sign == 1); | |
318 | BOOST_CHECK_CLOSE(::boost::math::lgamma(-4 - ldexp(static_cast<T>(1), -55), &sign), log(static_cast<T>(1.50119987579016527057843048200831672241827850458884790004313e15L)), tolerance * extra_tol); | |
319 | BOOST_CHECK(sign == -1); | |
320 | } | |
321 | ||
322 | if(std::numeric_limits<T>::has_denorm && std::numeric_limits<T>::has_infinity && (boost::math::isinf)(1 / std::numeric_limits<T>::denorm_min())) | |
323 | { | |
324 | BOOST_CHECK_EQUAL(boost::math::tgamma(-std::numeric_limits<T>::denorm_min()), -std::numeric_limits<T>::infinity()); | |
325 | BOOST_CHECK_EQUAL(boost::math::tgamma(std::numeric_limits<T>::denorm_min()), std::numeric_limits<T>::infinity()); | |
326 | } | |
92f5a8d4 TL |
327 | // |
328 | // Extra large values for lgamma, see https://github.com/boostorg/math/issues/242 | |
329 | // | |
330 | if (boost::math::tools::digits<T>() >= std::numeric_limits<double>::digits) | |
331 | { | |
332 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(11103367432951928LL), 32)), static_cast<T>(2.7719825960021351251696385101478518546793793286704974382373670822285114741208958e27L), tolerance); | |
333 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(11103367432951928LL), 62)), static_cast<T>(4.0411767712186990905102512019058204792570873633363159e36L), tolerance); | |
334 | BOOST_CHECK_CLOSE(::boost::math::lgamma(ldexp(static_cast<T>(11103367432951928LL), 326)), static_cast<T>(3.9754720509185529233002820161357111676582583112671658e116L), tolerance); | |
335 | } | |
20effc67 TL |
336 | // |
337 | // Super small values may cause spurious overflow: | |
338 | // | |
339 | if (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::has_denorm) | |
340 | { | |
341 | T value = (std::numeric_limits<T>::min)(); | |
342 | while (value != 0) | |
343 | { | |
344 | BOOST_CHECK((boost::math::isfinite)(boost::math::lgamma(value))); | |
345 | value /= 2; | |
346 | } | |
347 | } | |
7c673cae FG |
348 | } |
349 |