libs/math/test/test_igamma.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_2(const T& data, const char* type_name, const char* test_name)
  30 {
  31    typedef Real                   value_type;
  32
  33    typedef value_type (*pg)(value_type, value_type);
  34    pg funcp;
  35
  36    boost::math::tools::test_result<value_type> result;
  37
  38 #if !(defined(ERROR_REPORTING_MODE) && !defined(IGAMMA_FUNCTION_TO_TEST))
  39
  40 #ifdef IGAMMA_FUNCTION_TO_TEST
  41    funcp = IGAMMA_FUNCTION_TO_TEST;
  42 #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
  43    funcp = boost::math::tgamma<value_type, value_type>;
  44 #else
  45    funcp = boost::math::tgamma;
  46 #endif
  47
  48    std::cout << "Testing " << test_name << " with type " << type_name
  49       << "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
  50
  51    //
  52    // test tgamma(T, T) against data:
  53    //
  54    if(Real(data[0][2]) > 0)
  55    {
  56       result = boost::math::tools::test_hetero<Real>(
  57          data,
  58          bind_func<Real>(funcp, 0, 1),
  59          extract_result<Real>(2));
  60       handle_test_result(result, data[result.worst()], result.worst(), type_name, "tgamma (incomplete)", test_name);
  61       //
  62       // test tgamma_lower(T, T) against data:
  63       //
  64 #ifdef IGAMMAL_FUNCTION_TO_TEST
  65       funcp = IGAMMAL_FUNCTION_TO_TEST;
  66 #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
  67       funcp = boost::math::tgamma_lower<value_type, value_type>;
  68 #else
  69       funcp = boost::math::tgamma_lower;
  70 #endif
  71       result = boost::math::tools::test_hetero<Real>(
  72          data,
  73          bind_func<Real>(funcp, 0, 1),
  74          extract_result<Real>(4));
  75       handle_test_result(result, data[result.worst()], result.worst(), type_name, "tgamma_lower", test_name);
  76    }
  77 #endif
  78 #if !(defined(ERROR_REPORTING_MODE) && !defined(GAMMAQ_FUNCTION_TO_TEST))
  79    //
  80    // test gamma_q(T, T) against data:
  81    //
  82 #ifdef GAMMAQ_FUNCTION_TO_TEST
  83    funcp = GAMMAQ_FUNCTION_TO_TEST;
  84 #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
  85    funcp = boost::math::gamma_q<value_type, value_type>;
  86 #else
  87    funcp = boost::math::gamma_q;
  88 #endif
  89    result = boost::math::tools::test_hetero<Real>(
  90       data,
  91       bind_func<Real>(funcp, 0, 1),
  92       extract_result<Real>(3));
  93    handle_test_result(result, data[result.worst()], result.worst(), type_name, "gamma_q", test_name);
  94    //
  95    // test gamma_p(T, T) against data:
  96    //
  97 #ifdef GAMMAP_FUNCTION_TO_TEST
  98    funcp = GAMMAP_FUNCTION_TO_TEST;
  99 #elif defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
 100    funcp = boost::math::gamma_p<value_type, value_type>;
 101 #else
 102    funcp = boost::math::gamma_p;
 103 #endif
 104    result = boost::math::tools::test_hetero<Real>(
 105       data,
 106       bind_func<Real>(funcp, 0, 1),
 107       extract_result<Real>(5));
 108    handle_test_result(result, data[result.worst()], result.worst(), type_name, "gamma_p", test_name);
 109    std::cout << std::endl;
 110 #endif
 111 }
 112
 113 template <class T>
 114 void test_gamma(T, const char* name)
 115 {
 116    //
 117    // The actual test data is rather verbose, so it's in a separate file
 118    //
 119    // First the data for the incomplete gamma function, each
 120    // row has the following 6 entries:
 121    // Parameter a, parameter z,
 122    // Expected tgamma(a, z), Expected gamma_q(a, z)
 123    // Expected tgamma_lower(a, z), Expected gamma_p(a, z)
 124    //
 125 #  include "igamma_med_data.ipp"
 126
 127    do_test_gamma_2<T>(igamma_med_data, name, "tgamma(a, z) medium values");
 128
 129 #  include "igamma_small_data.ipp"
 130
 131    do_test_gamma_2<T>(igamma_small_data, name, "tgamma(a, z) small values");
 132
 133 #  include "igamma_big_data.ipp"
 134
 135    do_test_gamma_2<T>(igamma_big_data, name, "tgamma(a, z) large values");
 136
 137 #  include "igamma_int_data.ipp"
 138
 139    do_test_gamma_2<T>(igamma_int_data, name, "tgamma(a, z) integer and half integer values");
 140 }
 141
 142 template <class T>
 143 void test_spots(T)
 144 {
 145    //
 146    // basic sanity checks, tolerance is 10 epsilon expressed as a percentage:
 147    //
 148    T tolerance = boost::math::tools::epsilon<T>() * 1000;
 149 #if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
 150    tolerance *= 10;
 151 #endif
 152    // An extra fudge factor for real_concept which has a less accurate tgamma:
 153    T tolerance_tgamma_extra = std::numeric_limits<T>::is_specialized ? 1 : 10;
 154
 155    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(5), static_cast<T>(1)), static_cast<T>(23.912163676143750903709045060494956383977723517065L), tolerance);
 156    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(5), static_cast<T>(5)), static_cast<T>(10.571838841565097874621959975919877646444998907920L), tolerance);
 157    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(5), static_cast<T>(10)), static_cast<T>(0.70206451384706574414638719662835463671916532623256L), tolerance);
 158    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(5), static_cast<T>(100)), static_cast<T>(3.8734332808745531496973774140085644548465762343719e-36L), tolerance);
 159    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(0.5), static_cast<T>(0.5)), static_cast<T>(0.56241823159440712427949495730204306902676756479651L), tolerance * tolerance_tgamma_extra);
 160    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(0.5), static_cast<T>(9)/10), static_cast<T>(0.31853210360412109873859360390443790076576777747449L), tolerance*10);
 161    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(0.5), static_cast<T>(5)), static_cast<T>(0.0027746032604128093194908357272603294120210079791437L), tolerance * tolerance_tgamma_extra);
 162    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(0.5), static_cast<T>(100)), static_cast<T>(3.7017478604082789202535664481339075721362102520338e-45L), tolerance * tolerance_tgamma_extra);
 163
 164    BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(5), static_cast<T>(1)), static_cast<T>(0.087836323856249096290954939505043616022276482935091L), tolerance);
 165    BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(5), static_cast<T>(5)), static_cast<T>(13.428161158434902125378040024080122353555001092080L), tolerance);
 166    BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(5), static_cast<T>(10)), static_cast<T>(23.297935486152934255853612803371645363280834673767L), tolerance);
 167    BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(5), static_cast<T>(100)), static_cast<T>(23.999999999999999999999999999999999996126566719125L), tolerance);
 168
 169    BOOST_CHECK_CLOSE(::boost::math::gamma_q(static_cast<T>(5), static_cast<T>(1)), static_cast<T>(0.99634015317265628765454354418728984933240514654437L), tolerance);
 170    BOOST_CHECK_CLOSE(::boost::math::gamma_q(static_cast<T>(5), static_cast<T>(5)), static_cast<T>(0.44049328506521241144258166566332823526854162116334L), tolerance);
 171    BOOST_CHECK_CLOSE(::boost::math::gamma_q(static_cast<T>(5), static_cast<T>(10)), static_cast<T>(0.029252688076961072672766133192848109863298555259690L), tolerance);
 172    BOOST_CHECK_CLOSE(::boost::math::gamma_q(static_cast<T>(5), static_cast<T>(100)), static_cast<T>(1.6139305336977304790405739225035685228527400976549e-37L), tolerance);
 173    BOOST_CHECK_CLOSE(::boost::math::gamma_q(static_cast<T>(1.5), static_cast<T>(2)), static_cast<T>(0.26146412994911062220282207597592120190281060919079L), tolerance);
 174    BOOST_CHECK_CLOSE(::boost::math::gamma_q(static_cast<T>(20.5), static_cast<T>(22)), static_cast<T>(0.34575332043467326814971590879658406632570278929072L), tolerance);
 175
 176    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(5), static_cast<T>(1)), static_cast<T>(0.0036598468273437123454564558127101506675948534556288L), tolerance);
 177    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(5), static_cast<T>(5)), static_cast<T>(0.55950671493478758855741833433667176473145837883666L), tolerance);
 178    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(5), static_cast<T>(10)), static_cast<T>(0.97074731192303892732723386680715189013670144474031L), tolerance);
 179    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(5), static_cast<T>(100)), static_cast<T>(0.9999999999999999999999999999999999998386069466302L), tolerance);
 180    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(1.5), static_cast<T>(2)), static_cast<T>(0.73853587005088937779717792402407879809718939080921L), tolerance);
 181    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(20.5), static_cast<T>(22)), static_cast<T>(0.65424667956532673185028409120341593367429721070928L), tolerance);
 182
 183    // naive check on derivative function:
 184    using namespace std;  // For ADL of std functions
 185    tolerance = boost::math::tools::epsilon<T>() * 5000; // 50 eps
 186    BOOST_CHECK_CLOSE(::boost::math::gamma_p_derivative(static_cast<T>(20.5), static_cast<T>(22)),
 187       exp(static_cast<T>(-22)) * pow(static_cast<T>(22), static_cast<T>(19.5)) / boost::math::tgamma(static_cast<T>(20.5)), tolerance);
 188
 189    // Bug reports from Rocco Romeo:
 190    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(20), ldexp(T(1), -40)), static_cast<T>(1.21645100408832000000e17L), tolerance);
 191    BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(20), ldexp(T(1), -40)), static_cast<T>(7.498484069471659696438206828760307317022658816757448882e-243L), tolerance);
 192    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(20), ldexp(T(1), -40)), static_cast<T>(6.164230243774976473534975936127139110276824507876192062e-260L), tolerance);
 193
 194    BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(30), ldexp(T(1), -30)), static_cast<T>(8.841761993739701954543616000000e30L), tolerance);
 195    BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(30), ldexp(T(1), -30)), static_cast<T>(3.943507283668378474979245322638092813837393749566146974e-273L), tolerance);
 196 #ifdef __SUNPRO_CC
 197    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(30), ldexp(T(1), -30)), static_cast<T>(4.460092102072560946444018923090222645613009128135650652e-304L), tolerance * 8);
 198 #else
 199    BOOST_CHECK_CLOSE(::boost::math::gamma_p(static_cast<T>(30), ldexp(T(1), -30)), static_cast<T>(4.460092102072560946444018923090222645613009128135650652e-304L), tolerance);
 200 #endif
 201    BOOST_CHECK_CLOSE(::boost::math::gamma_p_derivative(static_cast<T>(2), ldexp(T(1), -575)), static_cast<T>(8.08634922390438981326119906687585206568664784377654648227177e-174L), tolerance);
 202
 203    //typedef boost::math::policies::policy<boost::math::policies::overflow_error<boost::math::policies::throw_on_error> > throw_policy;
 204
 205    if(std::numeric_limits<T>::max_exponent <= 1024 && std::numeric_limits<T>::has_infinity)
 206    {
 207       BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(176), static_cast<T>(100)), std::numeric_limits<T>::infinity());
 208       //BOOST_MATH_CHECK_THROW(::boost::math::tgamma(static_cast<T>(176), static_cast<T>(100), throw_policy()), std::overflow_error);
 209       BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(530), static_cast<T>(2000)), std::numeric_limits<T>::infinity());
 210       BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(740), static_cast<T>(2500)), std::numeric_limits<T>::infinity());
 211       BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(530.5), static_cast<T>(2000)), std::numeric_limits<T>::infinity());
 212       BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(740.5), static_cast<T>(2500)), std::numeric_limits<T>::infinity());
 213       BOOST_CHECK_EQUAL(::boost::math::tgamma_lower(static_cast<T>(10000.0f), static_cast<T>(10000.0f / 4)), std::numeric_limits<T>::infinity());
 214    }
 215    if(std::numeric_limits<T>::max_exponent >= 1024)
 216    {
 217       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(170), static_cast<T>(165)), static_cast<T>(2.737338337642022829223832094019477918166996032112404370e304L), tolerance);
 218       BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(170), static_cast<T>(165)), static_cast<T>(1.531729671362682445715419794880088619901822603944331733e304L), tolerance);
 219       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(170), static_cast<T>(170)), static_cast<T>(2.090991698081449410761040647015858316167077909285580375e304L), 10 * tolerance);
 220       BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(170), static_cast<T>(170)), static_cast<T>(2.178076310923255864178211241883708221901740726771155728e304L), 10 * tolerance);
 221       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(170), static_cast<T>(190)), static_cast<T>(2.8359275512790301602903689596273175148895758522893941392e303L), 10 * tolerance);
 222       BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(170), static_cast<T>(190)), static_cast<T>(3.985475253876802258910214992936834786579861050827796689e304L), 10 * tolerance);
 223       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(170), static_cast<T>(1000)), static_cast<T>(6.1067635957780723069200425769800190368662985052038980542e72L), 10 * tolerance);
 224
 225       BOOST_CHECK_CLOSE(::boost::math::tgamma_lower(static_cast<T>(185), static_cast<T>(1)), static_cast<T>(0.001999286058955490074702037576083582139834300307968257924836L), tolerance);
 226       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(185), static_cast<T>(1500)), static_cast<T>(1.037189524841404054867100938934493979112615962865368623e-67L), tolerance * 10);
 227
 228       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(36), ldexp(static_cast<T>(1), -26)), static_cast<T>(1.03331479663861449296666513375232000000e40L), tolerance * 10);
 229       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(50.5), ldexp(static_cast<T>(1), -17)), static_cast<T>(4.2904629123519598109157551960589377e63L), tolerance * 10);
 230       BOOST_CHECK_CLOSE(::boost::math::tgamma(static_cast<T>(164.5), static_cast<T>(0.125)), static_cast<T>(2.5649307433687542701168405519538910e292L), tolerance * 10);
 231    }
 232    //
 233    // Check very large parameters, see: https://github.com/boostorg/math/issues/168
 234    //
 235    T max_val = boost::math::tools::max_value<T>();
 236    T large_val = max_val * 0.99f;
 237    BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(22.25), max_val), 0);
 238    BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(22.25), large_val), 0);
 239    BOOST_CHECK_EQUAL(::boost::math::tgamma_lower(static_cast<T>(22.25), max_val), boost::math::tgamma(static_cast<T>(22.25)));
 240    BOOST_CHECK_EQUAL(::boost::math::tgamma_lower(static_cast<T>(22.25), large_val), boost::math::tgamma(static_cast<T>(22.25)));
 241    BOOST_CHECK_EQUAL(::boost::math::gamma_q(static_cast<T>(22.25), max_val), 0);
 242    BOOST_CHECK_EQUAL(::boost::math::gamma_q(static_cast<T>(22.25), large_val), 0);
 243    BOOST_CHECK_EQUAL(::boost::math::gamma_p(static_cast<T>(22.25), max_val), 1);
 244    BOOST_CHECK_EQUAL(::boost::math::gamma_p(static_cast<T>(22.25), large_val), 1);
 245    if (std::numeric_limits<T>::has_infinity)
 246    {
 247       BOOST_CHECK_EQUAL(::boost::math::tgamma(static_cast<T>(22.25), std::numeric_limits<T>::infinity()), 0);
 248       BOOST_CHECK_EQUAL(::boost::math::tgamma_lower(static_cast<T>(22.25), std::numeric_limits<T>::infinity()), boost::math::tgamma(static_cast<T>(22.25)));
 249       BOOST_CHECK_EQUAL(::boost::math::gamma_q(static_cast<T>(22.25), std::numeric_limits<T>::infinity()), 0);
 250       BOOST_CHECK_EQUAL(::boost::math::gamma_p(static_cast<T>(22.25), std::numeric_limits<T>::infinity()), 1);
 251    }
 252 }
 253