Chris@16: //  Copyright John Maddock 2008.
Chris@16: //  Use, modification and distribution are subject to the
Chris@16: //  Boost Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: // Wrapper that works with mpfr_class defined in gmpfrxx.h
Chris@16: // See http://math.berkeley.edu/~wilken/code/gmpfrxx/
Chris@16: // Also requires the gmp and mpfr libraries.
Chris@16: //
Chris@16: 
Chris@16: #ifndef BOOST_MATH_MPLFR_BINDINGS_HPP
Chris@16: #define BOOST_MATH_MPLFR_BINDINGS_HPP
Chris@16: 
Chris@16: #include <boost/config.hpp>
Chris@16: #include <boost/lexical_cast.hpp>
Chris@16: 
Chris@16: #ifdef BOOST_MSVC
Chris@16: //
Chris@16: // We get a lot of warnings from the gmp, mpfr and gmpfrxx headers, 
Chris@16: // disable them here, so we only see warnings from *our* code:
Chris@16: //
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable: 4127 4800 4512)
Chris@16: #endif
Chris@16: 
Chris@16: #include <gmpfrxx.h>
Chris@16: 
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: 
Chris@16: #include <boost/math/tools/precision.hpp>
Chris@16: #include <boost/math/tools/real_cast.hpp>
Chris@16: #include <boost/math/policies/policy.hpp>
Chris@16: #include <boost/math/distributions/fwd.hpp>
Chris@16: #include <boost/math/special_functions/math_fwd.hpp>
Chris@16: #include <boost/math/bindings/detail/big_digamma.hpp>
Chris@16: #include <boost/math/bindings/detail/big_lanczos.hpp>
Chris@101: #include <boost/math/tools/big_constant.hpp>
Chris@16: 
Chris@16: inline mpfr_class fabs(const mpfr_class& v)
Chris@16: {
Chris@16:    return abs(v);
Chris@16: }
Chris@16: template <class T, class U>
Chris@16: inline mpfr_class fabs(const __gmp_expr<T,U>& v)
Chris@16: {
Chris@16:    return abs(static_cast<mpfr_class>(v));
Chris@16: }
Chris@16: 
Chris@16: inline mpfr_class pow(const mpfr_class& b, const mpfr_class& e)
Chris@16: {
Chris@16:    mpfr_class result;
Chris@16:    mpfr_pow(result.__get_mp(), b.__get_mp(), e.__get_mp(), GMP_RNDN);
Chris@16:    return result;
Chris@16: }
Chris@16: /*
Chris@16: template <class T, class U, class V, class W>
Chris@16: inline mpfr_class pow(const __gmp_expr<T,U>& b, const __gmp_expr<V,W>& e)
Chris@16: {
Chris@16:    return pow(static_cast<mpfr_class>(b), static_cast<mpfr_class>(e));
Chris@16: }
Chris@16: */
Chris@16: inline mpfr_class ldexp(const mpfr_class& v, int e)
Chris@16: {
Chris@16:    //int e = mpfr_get_exp(*v.__get_mp());
Chris@16:    mpfr_class result(v);
Chris@16:    mpfr_set_exp(result.__get_mp(), e);
Chris@16:    return result;
Chris@16: }
Chris@16: template <class T, class U>
Chris@16: inline mpfr_class ldexp(const __gmp_expr<T,U>& v, int e)
Chris@16: {
Chris@16:    return ldexp(static_cast<mpfr_class>(v), e);
Chris@16: }
Chris@16: 
Chris@16: inline mpfr_class frexp(const mpfr_class& v, int* expon)
Chris@16: {
Chris@16:    int e = mpfr_get_exp(v.__get_mp());
Chris@16:    mpfr_class result(v);
Chris@16:    mpfr_set_exp(result.__get_mp(), 0);
Chris@16:    *expon = e;
Chris@16:    return result;
Chris@16: }
Chris@16: template <class T, class U>
Chris@16: inline mpfr_class frexp(const __gmp_expr<T,U>& v, int* expon)
Chris@16: {
Chris@16:    return frexp(static_cast<mpfr_class>(v), expon);
Chris@16: }
Chris@16: 
Chris@16: inline mpfr_class fmod(const mpfr_class& v1, const mpfr_class& v2)
Chris@16: {
Chris@16:    mpfr_class n;
Chris@16:    if(v1 < 0)
Chris@16:       n = ceil(v1 / v2);
Chris@16:    else
Chris@16:       n = floor(v1 / v2);
Chris@16:    return v1 - n * v2;
Chris@16: }
Chris@16: template <class T, class U, class V, class W>
Chris@16: inline mpfr_class fmod(const __gmp_expr<T,U>& v1, const __gmp_expr<V,W>& v2)
Chris@16: {
Chris@16:    return fmod(static_cast<mpfr_class>(v1), static_cast<mpfr_class>(v2));
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline mpfr_class modf(const mpfr_class& v, long long* ipart, const Policy& pol)
Chris@16: {
Chris@16:    *ipart = lltrunc(v, pol);
Chris@16:    return v - boost::math::tools::real_cast<mpfr_class>(*ipart);
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline mpfr_class modf(const __gmp_expr<T,U>& v, long long* ipart, const Policy& pol)
Chris@16: {
Chris@16:    return modf(static_cast<mpfr_class>(v), ipart, pol);
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline int iround(mpfr_class const& x, const Policy&)
Chris@16: {
Chris@16:    return boost::math::tools::real_cast<int>(boost::math::round(x, typename boost::math::policies::normalise<Policy, boost::math::policies::rounding_error< boost::math::policies::throw_on_error> >::type()));
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline int iround(__gmp_expr<T,U> const& x, const Policy& pol)
Chris@16: {
Chris@16:    return iround(static_cast<mpfr_class>(x), pol);
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline long lround(mpfr_class const& x, const Policy&)
Chris@16: {
Chris@16:    return boost::math::tools::real_cast<long>(boost::math::round(x, typename boost::math::policies::normalise<Policy, boost::math::policies::rounding_error< boost::math::policies::throw_on_error> >::type()));
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline long lround(__gmp_expr<T,U> const& x, const Policy& pol)
Chris@16: {
Chris@16:    return lround(static_cast<mpfr_class>(x), pol);
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline long long llround(mpfr_class const& x, const Policy&)
Chris@16: {
Chris@16:    return boost::math::tools::real_cast<long long>(boost::math::round(x, typename boost::math::policies::normalise<Policy, boost::math::policies::rounding_error< boost::math::policies::throw_on_error> >::type()));
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline long long llround(__gmp_expr<T,U> const& x, const Policy& pol)
Chris@16: {
Chris@16:    return llround(static_cast<mpfr_class>(x), pol);
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline int itrunc(mpfr_class const& x, const Policy&)
Chris@16: {
Chris@16:    return boost::math::tools::real_cast<int>(boost::math::trunc(x, typename boost::math::policies::normalise<Policy, boost::math::policies::rounding_error< boost::math::policies::throw_on_error> >::type()));
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline int itrunc(__gmp_expr<T,U> const& x, const Policy& pol)
Chris@16: {
Chris@16:    return itrunc(static_cast<mpfr_class>(x), pol);
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline long ltrunc(mpfr_class const& x, const Policy&)
Chris@16: {
Chris@16:    return boost::math::tools::real_cast<long>(boost::math::trunc(x, typename boost::math::policies::normalise<Policy, boost::math::policies::rounding_error< boost::math::policies::throw_on_error> >::type()));
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline long ltrunc(__gmp_expr<T,U> const& x, const Policy& pol)
Chris@16: {
Chris@16:    return ltrunc(static_cast<mpfr_class>(x), pol);
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline long long lltrunc(mpfr_class const& x, const Policy&)
Chris@16: {
Chris@16:    return boost::math::tools::real_cast<long long>(boost::math::trunc(x, typename boost::math::policies::normalise<Policy, boost::math::policies::rounding_error< boost::math::policies::throw_on_error> >::type()));
Chris@16: }
Chris@16: template <class T, class U, class Policy>
Chris@16: inline long long lltrunc(__gmp_expr<T,U> const& x, const Policy& pol)
Chris@16: {
Chris@16:    return lltrunc(static_cast<mpfr_class>(x), pol);
Chris@16: }
Chris@16: 
Chris@101: namespace boost{ 
Chris@101: 
Chris@101: #ifdef BOOST_MATH_USE_FLOAT128
Chris@101:    template<> struct is_convertible<BOOST_MATH_FLOAT128_TYPE, mpfr_class> : public boost::integral_constant<bool, false>{};
Chris@101: #endif
Chris@101:    template<> struct is_convertible<long long, mpfr_class> : public boost::integral_constant<bool, false>{};
Chris@101: 
Chris@101: namespace math{
Chris@16: 
Chris@16: #if defined(__GNUC__) && (__GNUC__ < 4)
Chris@16:    using ::iround;
Chris@16:    using ::lround;
Chris@16:    using ::llround;
Chris@16:    using ::itrunc;
Chris@16:    using ::ltrunc;
Chris@16:    using ::lltrunc;
Chris@16:    using ::modf;
Chris@16: #endif
Chris@16: 
Chris@16: namespace lanczos{
Chris@16: 
Chris@16: struct mpfr_lanczos
Chris@16: {
Chris@16:    static mpfr_class lanczos_sum(const mpfr_class& z)
Chris@16:    {
Chris@16:       unsigned long p = z.get_dprec();
Chris@16:       if(p <= 72)
Chris@16:          return lanczos13UDT::lanczos_sum(z);
Chris@16:       else if(p <= 120)
Chris@16:          return lanczos22UDT::lanczos_sum(z);
Chris@16:       else if(p <= 170)
Chris@16:          return lanczos31UDT::lanczos_sum(z);
Chris@16:       else //if(p <= 370) approx 100 digit precision:
Chris@16:          return lanczos61UDT::lanczos_sum(z);
Chris@16:    }
Chris@16:    static mpfr_class lanczos_sum_expG_scaled(const mpfr_class& z)
Chris@16:    {
Chris@16:       unsigned long p = z.get_dprec();
Chris@16:       if(p <= 72)
Chris@16:          return lanczos13UDT::lanczos_sum_expG_scaled(z);
Chris@16:       else if(p <= 120)
Chris@16:          return lanczos22UDT::lanczos_sum_expG_scaled(z);
Chris@16:       else if(p <= 170)
Chris@16:          return lanczos31UDT::lanczos_sum_expG_scaled(z);
Chris@16:       else //if(p <= 370) approx 100 digit precision:
Chris@16:          return lanczos61UDT::lanczos_sum_expG_scaled(z);
Chris@16:    }
Chris@16:    static mpfr_class lanczos_sum_near_1(const mpfr_class& z)
Chris@16:    {
Chris@16:       unsigned long p = z.get_dprec();
Chris@16:       if(p <= 72)
Chris@16:          return lanczos13UDT::lanczos_sum_near_1(z);
Chris@16:       else if(p <= 120)
Chris@16:          return lanczos22UDT::lanczos_sum_near_1(z);
Chris@16:       else if(p <= 170)
Chris@16:          return lanczos31UDT::lanczos_sum_near_1(z);
Chris@16:       else //if(p <= 370) approx 100 digit precision:
Chris@16:          return lanczos61UDT::lanczos_sum_near_1(z);
Chris@16:    }
Chris@16:    static mpfr_class lanczos_sum_near_2(const mpfr_class& z)
Chris@16:    {
Chris@16:       unsigned long p = z.get_dprec();
Chris@16:       if(p <= 72)
Chris@16:          return lanczos13UDT::lanczos_sum_near_2(z);
Chris@16:       else if(p <= 120)
Chris@16:          return lanczos22UDT::lanczos_sum_near_2(z);
Chris@16:       else if(p <= 170)
Chris@16:          return lanczos31UDT::lanczos_sum_near_2(z);
Chris@16:       else //if(p <= 370) approx 100 digit precision:
Chris@16:          return lanczos61UDT::lanczos_sum_near_2(z);
Chris@16:    }
Chris@16:    static mpfr_class g()
Chris@16:    { 
Chris@16:       unsigned long p = mpfr_class::get_dprec();
Chris@16:       if(p <= 72)
Chris@16:          return lanczos13UDT::g();
Chris@16:       else if(p <= 120)
Chris@16:          return lanczos22UDT::g();
Chris@16:       else if(p <= 170)
Chris@16:          return lanczos31UDT::g();
Chris@16:       else //if(p <= 370) approx 100 digit precision:
Chris@16:          return lanczos61UDT::g();
Chris@16:    }
Chris@16: };
Chris@16: 
Chris@16: template<class Policy>
Chris@16: struct lanczos<mpfr_class, Policy>
Chris@16: {
Chris@16:    typedef mpfr_lanczos type;
Chris@16: };
Chris@16: 
Chris@16: } // namespace lanczos
Chris@16: 
Chris@16: namespace constants{
Chris@16: 
Chris@16: template <class Real, class Policy>
Chris@16: struct construction_traits;
Chris@16: 
Chris@16: template <class Policy>
Chris@16: struct construction_traits<mpfr_class, Policy>
Chris@16: {
Chris@16:    typedef mpl::int_<0> type;
Chris@16: };
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: namespace tools
Chris@16: {
Chris@16: 
Chris@16: template <class T, class U>
Chris@16: struct promote_arg<__gmp_expr<T,U> >
Chris@16: { // If T is integral type, then promote to double.
Chris@16:   typedef mpfr_class type;
Chris@16: };
Chris@16: 
Chris@16: template<>
Chris@16: inline int digits<mpfr_class>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpfr_class))
Chris@16: {
Chris@16:    return mpfr_class::get_dprec();
Chris@16: }
Chris@16: 
Chris@16: namespace detail{
Chris@16: 
Chris@16: template<class I>
Chris@16: void convert_to_long_result(mpfr_class const& r, I& result)
Chris@16: {
Chris@16:    result = 0;
Chris@16:    I last_result(0);
Chris@16:    mpfr_class t(r);
Chris@16:    double term;
Chris@16:    do
Chris@16:    {
Chris@16:       term = real_cast<double>(t);
Chris@16:       last_result = result;
Chris@16:       result += static_cast<I>(term);
Chris@16:       t -= term;
Chris@16:    }while(result != last_result);
Chris@16: }
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: template <>
Chris@16: inline mpfr_class real_cast<mpfr_class, long long>(long long t)
Chris@16: {
Chris@16:    mpfr_class result;
Chris@16:    int expon = 0;
Chris@16:    int sign = 1;
Chris@16:    if(t < 0)
Chris@16:    {
Chris@16:       sign = -1;
Chris@16:       t = -t;
Chris@16:    }
Chris@16:    while(t)
Chris@16:    {
Chris@16:       result += ldexp((double)(t & 0xffffL), expon);
Chris@16:       expon += 32;
Chris@16:       t >>= 32;
Chris@16:    }
Chris@16:    return result * sign;
Chris@16: }
Chris@16: template <>
Chris@16: inline unsigned real_cast<unsigned, mpfr_class>(mpfr_class t)
Chris@16: {
Chris@16:    return t.get_ui();
Chris@16: }
Chris@16: template <>
Chris@16: inline int real_cast<int, mpfr_class>(mpfr_class t)
Chris@16: {
Chris@16:    return t.get_si();
Chris@16: }
Chris@16: template <>
Chris@16: inline double real_cast<double, mpfr_class>(mpfr_class t)
Chris@16: {
Chris@16:    return t.get_d();
Chris@16: }
Chris@16: template <>
Chris@16: inline float real_cast<float, mpfr_class>(mpfr_class t)
Chris@16: {
Chris@16:    return static_cast<float>(t.get_d());
Chris@16: }
Chris@16: template <>
Chris@16: inline long real_cast<long, mpfr_class>(mpfr_class t)
Chris@16: {
Chris@16:    long result;
Chris@16:    detail::convert_to_long_result(t, result);
Chris@16:    return result;
Chris@16: }
Chris@16: template <>
Chris@16: inline long long real_cast<long long, mpfr_class>(mpfr_class t)
Chris@16: {
Chris@16:    long long result;
Chris@16:    detail::convert_to_long_result(t, result);
Chris@16:    return result;
Chris@16: }
Chris@16: 
Chris@16: template <>
Chris@16: inline mpfr_class max_value<mpfr_class>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpfr_class))
Chris@16: {
Chris@16:    static bool has_init = false;
Chris@16:    static mpfr_class val;
Chris@16:    if(!has_init)
Chris@16:    {
Chris@16:       val = 0.5;
Chris@16:       mpfr_set_exp(val.__get_mp(), mpfr_get_emax());
Chris@16:       has_init = true;
Chris@16:    }
Chris@16:    return val;
Chris@16: }
Chris@16: 
Chris@16: template <>
Chris@16: inline mpfr_class min_value<mpfr_class>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpfr_class))
Chris@16: {
Chris@16:    static bool has_init = false;
Chris@16:    static mpfr_class val;
Chris@16:    if(!has_init)
Chris@16:    {
Chris@16:       val = 0.5;
Chris@16:       mpfr_set_exp(val.__get_mp(), mpfr_get_emin());
Chris@16:       has_init = true;
Chris@16:    }
Chris@16:    return val;
Chris@16: }
Chris@16: 
Chris@16: template <>
Chris@16: inline mpfr_class log_max_value<mpfr_class>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpfr_class))
Chris@16: {
Chris@16:    static bool has_init = false;
Chris@16:    static mpfr_class val = max_value<mpfr_class>();
Chris@16:    if(!has_init)
Chris@16:    {
Chris@16:       val = log(val);
Chris@16:       has_init = true;
Chris@16:    }
Chris@16:    return val;
Chris@16: }
Chris@16: 
Chris@16: template <>
Chris@16: inline mpfr_class log_min_value<mpfr_class>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpfr_class))
Chris@16: {
Chris@16:    static bool has_init = false;
Chris@16:    static mpfr_class val = max_value<mpfr_class>();
Chris@16:    if(!has_init)
Chris@16:    {
Chris@16:       val = log(val);
Chris@16:       has_init = true;
Chris@16:    }
Chris@16:    return val;
Chris@16: }
Chris@16: 
Chris@16: template <>
Chris@16: inline mpfr_class epsilon<mpfr_class>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpfr_class))
Chris@16: {
Chris@16:    return ldexp(mpfr_class(1), 1-boost::math::policies::digits<mpfr_class, boost::math::policies::policy<> >());
Chris@16: }
Chris@16: 
Chris@16: } // namespace tools
Chris@16: 
Chris@16: namespace policies{
Chris@16: 
Chris@16: template <class T, class U, class Policy>
Chris@16: struct evaluation<__gmp_expr<T, U>, Policy>
Chris@16: {
Chris@16:    typedef mpfr_class type;
Chris@16: };
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline mpfr_class skewness(const extreme_value_distribution<mpfr_class, Policy>& /*dist*/)
Chris@16: {
Chris@16:    //
Chris@16:    // This is 12 * sqrt(6) * zeta(3) / pi^3:
Chris@16:    // See http://mathworld.wolfram.com/ExtremeValueDistribution.html
Chris@16:    //
Chris@16:    return boost::lexical_cast<mpfr_class>("1.1395470994046486574927930193898461120875997958366");
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline mpfr_class skewness(const rayleigh_distribution<mpfr_class, Policy>& /*dist*/)
Chris@16: {
Chris@16:   // using namespace boost::math::constants;
Chris@16:   return boost::lexical_cast<mpfr_class>("0.63111065781893713819189935154422777984404221106391");
Chris@16:   // Computed using NTL at 150 bit, about 50 decimal digits.
Chris@16:   // return 2 * root_pi<RealType>() * pi_minus_three<RealType>() / pow23_four_minus_pi<RealType>();
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline mpfr_class kurtosis(const rayleigh_distribution<mpfr_class, Policy>& /*dist*/)
Chris@16: {
Chris@16:   // using namespace boost::math::constants;
Chris@16:   return boost::lexical_cast<mpfr_class>("3.2450893006876380628486604106197544154170667057995");
Chris@16:   // Computed using NTL at 150 bit, about 50 decimal digits.
Chris@16:   // return 3 - (6 * pi<RealType>() * pi<RealType>() - 24 * pi<RealType>() + 16) /
Chris@16:   // (four_minus_pi<RealType>() * four_minus_pi<RealType>());
Chris@16: }
Chris@16: 
Chris@16: template <class Policy>
Chris@16: inline mpfr_class kurtosis_excess(const rayleigh_distribution<mpfr_class, Policy>& /*dist*/)
Chris@16: {
Chris@16:   //using namespace boost::math::constants;
Chris@16:   // Computed using NTL at 150 bit, about 50 decimal digits.
Chris@16:   return boost::lexical_cast<mpfr_class>("0.2450893006876380628486604106197544154170667057995");
Chris@16:   // return -(6 * pi<RealType>() * pi<RealType>() - 24 * pi<RealType>() + 16) /
Chris@16:   //   (four_minus_pi<RealType>() * four_minus_pi<RealType>());
Chris@16: } // kurtosis
Chris@16: 
Chris@16: namespace detail{
Chris@16: 
Chris@16: //
Chris@16: // Version of Digamma accurate to ~100 decimal digits.
Chris@16: //
Chris@16: template <class Policy>
Chris@16: mpfr_class digamma_imp(mpfr_class x, const mpl::int_<0>* , const Policy& pol)
Chris@16: {
Chris@16:    //
Chris@16:    // This handles reflection of negative arguments, and all our
Chris@16:    // empfr_classor handling, then forwards to the T-specific approximation.
Chris@16:    //
Chris@16:    BOOST_MATH_STD_USING // ADL of std functions.
Chris@16: 
Chris@16:    mpfr_class result = 0;
Chris@16:    //
Chris@16:    // Check for negative arguments and use reflection:
Chris@16:    //
Chris@16:    if(x < 0)
Chris@16:    {
Chris@16:       // Reflect:
Chris@16:       x = 1 - x;
Chris@16:       // Argument reduction for tan:
Chris@16:       mpfr_class remainder = x - floor(x);
Chris@16:       // Shift to negative if > 0.5:
Chris@16:       if(remainder > 0.5)
Chris@16:       {
Chris@16:          remainder -= 1;
Chris@16:       }
Chris@16:       //
Chris@16:       // check for evaluation at a negative pole:
Chris@16:       //
Chris@16:       if(remainder == 0)
Chris@16:       {
Chris@16:          return policies::raise_pole_error<mpfr_class>("boost::math::digamma<%1%>(%1%)", 0, (1-x), pol);
Chris@16:       }
Chris@16:       result = constants::pi<mpfr_class>() / tan(constants::pi<mpfr_class>() * remainder);
Chris@16:    }
Chris@16:    result += big_digamma(x);
Chris@16:    return result;
Chris@16: }
Chris@16: //
Chris@16: // Specialisations of this function provides the initial
Chris@16: // starting guess for Halley iteration:
Chris@16: //
Chris@16: template <class Policy>
Chris@16: inline mpfr_class erf_inv_imp(const mpfr_class& p, const mpfr_class& q, const Policy&, const boost::mpl::int_<64>*)
Chris@16: {
Chris@16:    BOOST_MATH_STD_USING // for ADL of std names.
Chris@16: 
Chris@16:    mpfr_class result = 0;
Chris@16:    
Chris@16:    if(p <= 0.5)
Chris@16:    {
Chris@16:       //
Chris@16:       // Evaluate inverse erf using the rational approximation:
Chris@16:       //
Chris@16:       // x = p(p+10)(Y+R(p))
Chris@16:       //
Chris@16:       // Where Y is a constant, and R(p) is optimised for a low
Chris@16:       // absolute empfr_classor compared to |Y|.
Chris@16:       //
Chris@16:       // double: Max empfr_classor found: 2.001849e-18
Chris@16:       // long double: Max empfr_classor found: 1.017064e-20
Chris@16:       // Maximum Deviation Found (actual empfr_classor term at infinite precision) 8.030e-21
Chris@16:       //
Chris@16:       static const float Y = 0.0891314744949340820313f;
Chris@16:       static const mpfr_class P[] = {    
Chris@16:          -0.000508781949658280665617,
Chris@16:          -0.00836874819741736770379,
Chris@16:          0.0334806625409744615033,
Chris@16:          -0.0126926147662974029034,
Chris@16:          -0.0365637971411762664006,
Chris@16:          0.0219878681111168899165,
Chris@16:          0.00822687874676915743155,
Chris@16:          -0.00538772965071242932965
Chris@16:       };
Chris@16:       static const mpfr_class Q[] = {    
Chris@16:          1,
Chris@16:          -0.970005043303290640362,
Chris@16:          -1.56574558234175846809,
Chris@16:          1.56221558398423026363,
Chris@16:          0.662328840472002992063,
Chris@16:          -0.71228902341542847553,
Chris@16:          -0.0527396382340099713954,
Chris@16:          0.0795283687341571680018,
Chris@16:          -0.00233393759374190016776,
Chris@16:          0.000886216390456424707504
Chris@16:       };
Chris@16:       mpfr_class g = p * (p + 10);
Chris@16:       mpfr_class r = tools::evaluate_polynomial(P, p) / tools::evaluate_polynomial(Q, p);
Chris@16:       result = g * Y + g * r;
Chris@16:    }
Chris@16:    else if(q >= 0.25)
Chris@16:    {
Chris@16:       //
Chris@16:       // Rational approximation for 0.5 > q >= 0.25
Chris@16:       //
Chris@16:       // x = sqrt(-2*log(q)) / (Y + R(q))
Chris@16:       //
Chris@16:       // Where Y is a constant, and R(q) is optimised for a low
Chris@16:       // absolute empfr_classor compared to Y.
Chris@16:       //
Chris@16:       // double : Max empfr_classor found: 7.403372e-17
Chris@16:       // long double : Max empfr_classor found: 6.084616e-20
Chris@16:       // Maximum Deviation Found (empfr_classor term) 4.811e-20
Chris@16:       //
Chris@16:       static const float Y = 2.249481201171875f;
Chris@16:       static const mpfr_class P[] = {    
Chris@16:          -0.202433508355938759655,
Chris@16:          0.105264680699391713268,
Chris@16:          8.37050328343119927838,
Chris@16:          17.6447298408374015486,
Chris@16:          -18.8510648058714251895,
Chris@16:          -44.6382324441786960818,
Chris@16:          17.445385985570866523,
Chris@16:          21.1294655448340526258,
Chris@16:          -3.67192254707729348546
Chris@16:       };
Chris@16:       static const mpfr_class Q[] = {    
Chris@16:          1,
Chris@16:          6.24264124854247537712,
Chris@16:          3.9713437953343869095,
Chris@16:          -28.6608180499800029974,
Chris@16:          -20.1432634680485188801,
Chris@16:          48.5609213108739935468,
Chris@16:          10.8268667355460159008,
Chris@16:          -22.6436933413139721736,
Chris@16:          1.72114765761200282724
Chris@16:       };
Chris@16:       mpfr_class g = sqrt(-2 * log(q));
Chris@16:       mpfr_class xs = q - 0.25;
Chris@16:       mpfr_class r = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
Chris@16:       result = g / (Y + r);
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       //
Chris@16:       // For q < 0.25 we have a series of rational approximations all
Chris@16:       // of the general form:
Chris@16:       //
Chris@16:       // let: x = sqrt(-log(q))
Chris@16:       //
Chris@16:       // Then the result is given by:
Chris@16:       //
Chris@16:       // x(Y+R(x-B))
Chris@16:       //
Chris@16:       // where Y is a constant, B is the lowest value of x for which 
Chris@16:       // the approximation is valid, and R(x-B) is optimised for a low
Chris@16:       // absolute empfr_classor compared to Y.
Chris@16:       //
Chris@16:       // Note that almost all code will really go through the first
Chris@16:       // or maybe second approximation.  After than we're dealing with very
Chris@16:       // small input values indeed: 80 and 128 bit long double's go all the
Chris@16:       // way down to ~ 1e-5000 so the "tail" is rather long...
Chris@16:       //
Chris@16:       mpfr_class x = sqrt(-log(q));
Chris@16:       if(x < 3)
Chris@16:       {
Chris@16:          // Max empfr_classor found: 1.089051e-20
Chris@16:          static const float Y = 0.807220458984375f;
Chris@16:          static const mpfr_class P[] = {    
Chris@16:             -0.131102781679951906451,
Chris@16:             -0.163794047193317060787,
Chris@16:             0.117030156341995252019,
Chris@16:             0.387079738972604337464,
Chris@16:             0.337785538912035898924,
Chris@16:             0.142869534408157156766,
Chris@16:             0.0290157910005329060432,
Chris@16:             0.00214558995388805277169,
Chris@16:             -0.679465575181126350155e-6,
Chris@16:             0.285225331782217055858e-7,
Chris@16:             -0.681149956853776992068e-9
Chris@16:          };
Chris@16:          static const mpfr_class Q[] = {    
Chris@16:             1,
Chris@16:             3.46625407242567245975,
Chris@16:             5.38168345707006855425,
Chris@16:             4.77846592945843778382,
Chris@16:             2.59301921623620271374,
Chris@16:             0.848854343457902036425,
Chris@16:             0.152264338295331783612,
Chris@16:             0.01105924229346489121
Chris@16:          };
Chris@16:          mpfr_class xs = x - 1.125;
Chris@16:          mpfr_class R = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
Chris@16:          result = Y * x + R * x;
Chris@16:       }
Chris@16:       else if(x < 6)
Chris@16:       {
Chris@16:          // Max empfr_classor found: 8.389174e-21
Chris@16:          static const float Y = 0.93995571136474609375f;
Chris@16:          static const mpfr_class P[] = {    
Chris@16:             -0.0350353787183177984712,
Chris@16:             -0.00222426529213447927281,
Chris@16:             0.0185573306514231072324,
Chris@16:             0.00950804701325919603619,
Chris@16:             0.00187123492819559223345,
Chris@16:             0.000157544617424960554631,
Chris@16:             0.460469890584317994083e-5,
Chris@16:             -0.230404776911882601748e-9,
Chris@16:             0.266339227425782031962e-11
Chris@16:          };
Chris@16:          static const mpfr_class Q[] = {    
Chris@16:             1,
Chris@16:             1.3653349817554063097,
Chris@16:             0.762059164553623404043,
Chris@16:             0.220091105764131249824,
Chris@16:             0.0341589143670947727934,
Chris@16:             0.00263861676657015992959,
Chris@16:             0.764675292302794483503e-4
Chris@16:          };
Chris@16:          mpfr_class xs = x - 3;
Chris@16:          mpfr_class R = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
Chris@16:          result = Y * x + R * x;
Chris@16:       }
Chris@16:       else if(x < 18)
Chris@16:       {
Chris@16:          // Max empfr_classor found: 1.481312e-19
Chris@16:          static const float Y = 0.98362827301025390625f;
Chris@16:          static const mpfr_class P[] = {    
Chris@16:             -0.0167431005076633737133,
Chris@16:             -0.00112951438745580278863,
Chris@16:             0.00105628862152492910091,
Chris@16:             0.000209386317487588078668,
Chris@16:             0.149624783758342370182e-4,
Chris@16:             0.449696789927706453732e-6,
Chris@16:             0.462596163522878599135e-8,
Chris@16:             -0.281128735628831791805e-13,
Chris@16:             0.99055709973310326855e-16
Chris@16:          };
Chris@16:          static const mpfr_class Q[] = {    
Chris@16:             1,
Chris@16:             0.591429344886417493481,
Chris@16:             0.138151865749083321638,
Chris@16:             0.0160746087093676504695,
Chris@16:             0.000964011807005165528527,
Chris@16:             0.275335474764726041141e-4,
Chris@16:             0.282243172016108031869e-6
Chris@16:          };
Chris@16:          mpfr_class xs = x - 6;
Chris@16:          mpfr_class R = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
Chris@16:          result = Y * x + R * x;
Chris@16:       }
Chris@16:       else if(x < 44)
Chris@16:       {
Chris@16:          // Max empfr_classor found: 5.697761e-20
Chris@16:          static const float Y = 0.99714565277099609375f;
Chris@16:          static const mpfr_class P[] = {    
Chris@16:             -0.0024978212791898131227,
Chris@16:             -0.779190719229053954292e-5,
Chris@16:             0.254723037413027451751e-4,
Chris@16:             0.162397777342510920873e-5,
Chris@16:             0.396341011304801168516e-7,
Chris@16:             0.411632831190944208473e-9,
Chris@16:             0.145596286718675035587e-11,
Chris@16:             -0.116765012397184275695e-17
Chris@16:          };
Chris@16:          static const mpfr_class Q[] = {    
Chris@16:             1,
Chris@16:             0.207123112214422517181,
Chris@16:             0.0169410838120975906478,
Chris@16:             0.000690538265622684595676,
Chris@16:             0.145007359818232637924e-4,
Chris@16:             0.144437756628144157666e-6,
Chris@16:             0.509761276599778486139e-9
Chris@16:          };
Chris@16:          mpfr_class xs = x - 18;
Chris@16:          mpfr_class R = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
Chris@16:          result = Y * x + R * x;
Chris@16:       }
Chris@16:       else
Chris@16:       {
Chris@16:          // Max empfr_classor found: 1.279746e-20
Chris@16:          static const float Y = 0.99941349029541015625f;
Chris@16:          static const mpfr_class P[] = {    
Chris@16:             -0.000539042911019078575891,
Chris@16:             -0.28398759004727721098e-6,
Chris@16:             0.899465114892291446442e-6,
Chris@16:             0.229345859265920864296e-7,
Chris@16:             0.225561444863500149219e-9,
Chris@16:             0.947846627503022684216e-12,
Chris@16:             0.135880130108924861008e-14,
Chris@16:             -0.348890393399948882918e-21
Chris@16:          };
Chris@16:          static const mpfr_class Q[] = {    
Chris@16:             1,
Chris@16:             0.0845746234001899436914,
Chris@16:             0.00282092984726264681981,
Chris@16:             0.468292921940894236786e-4,
Chris@16:             0.399968812193862100054e-6,
Chris@16:             0.161809290887904476097e-8,
Chris@16:             0.231558608310259605225e-11
Chris@16:          };
Chris@16:          mpfr_class xs = x - 44;
Chris@16:          mpfr_class R = tools::evaluate_polynomial(P, xs) / tools::evaluate_polynomial(Q, xs);
Chris@16:          result = Y * x + R * x;
Chris@16:       }
Chris@16:    }
Chris@16:    return result;
Chris@16: }
Chris@16: 
Chris@16: inline mpfr_class bessel_i0(mpfr_class x)
Chris@16: {
Chris@16:     static const mpfr_class P1[] = {
Chris@16:         boost::lexical_cast<mpfr_class>("-2.2335582639474375249e+15"),
Chris@16:         boost::lexical_cast<mpfr_class>("-5.5050369673018427753e+14"),
Chris@16:         boost::lexical_cast<mpfr_class>("-3.2940087627407749166e+13"),
Chris@16:         boost::lexical_cast<mpfr_class>("-8.4925101247114157499e+11"),
Chris@16:         boost::lexical_cast<mpfr_class>("-1.1912746104985237192e+10"),
Chris@16:         boost::lexical_cast<mpfr_class>("-1.0313066708737980747e+08"),
Chris@16:         boost::lexical_cast<mpfr_class>("-5.9545626019847898221e+05"),
Chris@16:         boost::lexical_cast<mpfr_class>("-2.4125195876041896775e+03"),
Chris@16:         boost::lexical_cast<mpfr_class>("-7.0935347449210549190e+00"),
Chris@16:         boost::lexical_cast<mpfr_class>("-1.5453977791786851041e-02"),
Chris@16:         boost::lexical_cast<mpfr_class>("-2.5172644670688975051e-05"),
Chris@16:         boost::lexical_cast<mpfr_class>("-3.0517226450451067446e-08"),
Chris@16:         boost::lexical_cast<mpfr_class>("-2.6843448573468483278e-11"),
Chris@16:         boost::lexical_cast<mpfr_class>("-1.5982226675653184646e-14"),
Chris@16:         boost::lexical_cast<mpfr_class>("-5.2487866627945699800e-18"),
Chris@16:     };
Chris@16:     static const mpfr_class Q1[] = {
Chris@16:         boost::lexical_cast<mpfr_class>("-2.2335582639474375245e+15"),
Chris@16:         boost::lexical_cast<mpfr_class>("7.8858692566751002988e+12"),
Chris@16:         boost::lexical_cast<mpfr_class>("-1.2207067397808979846e+10"),
Chris@16:         boost::lexical_cast<mpfr_class>("1.0377081058062166144e+07"),
Chris@16:         boost::lexical_cast<mpfr_class>("-4.8527560179962773045e+03"),
Chris@16:         boost::lexical_cast<mpfr_class>("1.0"),
Chris@16:     };
Chris@16:     static const mpfr_class P2[] = {
Chris@16:         boost::lexical_cast<mpfr_class>("-2.2210262233306573296e-04"),
Chris@16:         boost::lexical_cast<mpfr_class>("1.3067392038106924055e-02"),
Chris@16:         boost::lexical_cast<mpfr_class>("-4.4700805721174453923e-01"),
Chris@16:         boost::lexical_cast<mpfr_class>("5.5674518371240761397e+00"),
Chris@16:         boost::lexical_cast<mpfr_class>("-2.3517945679239481621e+01"),
Chris@16:         boost::lexical_cast<mpfr_class>("3.1611322818701131207e+01"),
Chris@16:         boost::lexical_cast<mpfr_class>("-9.6090021968656180000e+00"),
Chris@16:     };
Chris@16:     static const mpfr_class Q2[] = {
Chris@16:         boost::lexical_cast<mpfr_class>("-5.5194330231005480228e-04"),
Chris@16:         boost::lexical_cast<mpfr_class>("3.2547697594819615062e-02"),
Chris@16:         boost::lexical_cast<mpfr_class>("-1.1151759188741312645e+00"),
Chris@16:         boost::lexical_cast<mpfr_class>("1.3982595353892851542e+01"),
Chris@16:         boost::lexical_cast<mpfr_class>("-6.0228002066743340583e+01"),
Chris@16:         boost::lexical_cast<mpfr_class>("8.5539563258012929600e+01"),
Chris@16:         boost::lexical_cast<mpfr_class>("-3.1446690275135491500e+01"),
Chris@16:         boost::lexical_cast<mpfr_class>("1.0"),
Chris@16:     };
Chris@16:     mpfr_class value, factor, r;
Chris@16: 
Chris@16:     BOOST_MATH_STD_USING
Chris@16:     using namespace boost::math::tools;
Chris@16: 
Chris@16:     if (x < 0)
Chris@16:     {
Chris@16:         x = -x;                         // even function
Chris@16:     }
Chris@16:     if (x == 0)
Chris@16:     {
Chris@16:         return static_cast<mpfr_class>(1);
Chris@16:     }
Chris@16:     if (x <= 15)                        // x in (0, 15]
Chris@16:     {
Chris@16:         mpfr_class y = x * x;
Chris@16:         value = evaluate_polynomial(P1, y) / evaluate_polynomial(Q1, y);
Chris@16:     }
Chris@16:     else                                // x in (15, \infty)
Chris@16:     {
Chris@16:         mpfr_class y = 1 / x - mpfr_class(1) / 15;
Chris@16:         r = evaluate_polynomial(P2, y) / evaluate_polynomial(Q2, y);
Chris@16:         factor = exp(x) / sqrt(x);
Chris@16:         value = factor * r;
Chris@16:     }
Chris@16: 
Chris@16:     return value;
Chris@16: }
Chris@16: 
Chris@16: inline mpfr_class bessel_i1(mpfr_class x)
Chris@16: {
Chris@16:     static const mpfr_class P1[] = {
Chris@16:         static_cast<mpfr_class>("-1.4577180278143463643e+15"),
Chris@16:         static_cast<mpfr_class>("-1.7732037840791591320e+14"),
Chris@16:         static_cast<mpfr_class>("-6.9876779648010090070e+12"),
Chris@16:         static_cast<mpfr_class>("-1.3357437682275493024e+11"),
Chris@16:         static_cast<mpfr_class>("-1.4828267606612366099e+09"),
Chris@16:         static_cast<mpfr_class>("-1.0588550724769347106e+07"),
Chris@16:         static_cast<mpfr_class>("-5.1894091982308017540e+04"),
Chris@16:         static_cast<mpfr_class>("-1.8225946631657315931e+02"),
Chris@16:         static_cast<mpfr_class>("-4.7207090827310162436e-01"),
Chris@16:         static_cast<mpfr_class>("-9.1746443287817501309e-04"),
Chris@16:         static_cast<mpfr_class>("-1.3466829827635152875e-06"),
Chris@16:         static_cast<mpfr_class>("-1.4831904935994647675e-09"),
Chris@16:         static_cast<mpfr_class>("-1.1928788903603238754e-12"),
Chris@16:         static_cast<mpfr_class>("-6.5245515583151902910e-16"),
Chris@16:         static_cast<mpfr_class>("-1.9705291802535139930e-19"),
Chris@16:     };
Chris@16:     static const mpfr_class Q1[] = {
Chris@16:         static_cast<mpfr_class>("-2.9154360556286927285e+15"),
Chris@16:         static_cast<mpfr_class>("9.7887501377547640438e+12"),
Chris@16:         static_cast<mpfr_class>("-1.4386907088588283434e+10"),
Chris@16:         static_cast<mpfr_class>("1.1594225856856884006e+07"),
Chris@16:         static_cast<mpfr_class>("-5.1326864679904189920e+03"),
Chris@16:         static_cast<mpfr_class>("1.0"),
Chris@16:     };
Chris@16:     static const mpfr_class P2[] = {
Chris@16:         static_cast<mpfr_class>("1.4582087408985668208e-05"),
Chris@16:         static_cast<mpfr_class>("-8.9359825138577646443e-04"),
Chris@16:         static_cast<mpfr_class>("2.9204895411257790122e-02"),
Chris@16:         static_cast<mpfr_class>("-3.4198728018058047439e-01"),
Chris@16:         static_cast<mpfr_class>("1.3960118277609544334e+00"),
Chris@16:         static_cast<mpfr_class>("-1.9746376087200685843e+00"),
Chris@16:         static_cast<mpfr_class>("8.5591872901933459000e-01"),
Chris@16:         static_cast<mpfr_class>("-6.0437159056137599999e-02"),
Chris@16:     };
Chris@16:     static const mpfr_class Q2[] = {
Chris@16:         static_cast<mpfr_class>("3.7510433111922824643e-05"),
Chris@16:         static_cast<mpfr_class>("-2.2835624489492512649e-03"),
Chris@16:         static_cast<mpfr_class>("7.4212010813186530069e-02"),
Chris@16:         static_cast<mpfr_class>("-8.5017476463217924408e-01"),
Chris@16:         static_cast<mpfr_class>("3.2593714889036996297e+00"),
Chris@16:         static_cast<mpfr_class>("-3.8806586721556593450e+00"),
Chris@16:         static_cast<mpfr_class>("1.0"),
Chris@16:     };
Chris@16:     mpfr_class value, factor, r, w;
Chris@16: 
Chris@16:     BOOST_MATH_STD_USING
Chris@16:     using namespace boost::math::tools;
Chris@16: 
Chris@16:     w = abs(x);
Chris@16:     if (x == 0)
Chris@16:     {
Chris@16:         return static_cast<mpfr_class>(0);
Chris@16:     }
Chris@16:     if (w <= 15)                        // w in (0, 15]
Chris@16:     {
Chris@16:         mpfr_class y = x * x;
Chris@16:         r = evaluate_polynomial(P1, y) / evaluate_polynomial(Q1, y);
Chris@16:         factor = w;
Chris@16:         value = factor * r;
Chris@16:     }
Chris@16:     else                                // w in (15, \infty)
Chris@16:     {
Chris@16:         mpfr_class y = 1 / w - mpfr_class(1) / 15;
Chris@16:         r = evaluate_polynomial(P2, y) / evaluate_polynomial(Q2, y);
Chris@16:         factor = exp(w) / sqrt(w);
Chris@16:         value = factor * r;
Chris@16:     }
Chris@16: 
Chris@16:     if (x < 0)
Chris@16:     {
Chris@16:         value *= -value;                 // odd function
Chris@16:     }
Chris@16:     return value;
Chris@16: }
Chris@16: 
Chris@16: } // namespace detail
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: template<> struct is_convertible<long double, mpfr_class> : public mpl::false_{};
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: #endif // BOOST_MATH_MPLFR_BINDINGS_HPP
Chris@16: