libs/math/test/test_gamma.hpp

   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>
  13 #include <boost/test/tools/floating_point_comparison.hpp>
  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    }
 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    }
 336 }
 337