@lakutata/math 0.0.0-stage → 3.1.5

package/vendor/boost/math/include/boost/math/special_functions/detail/hypergeometric_1F1_recurrence.hpp

@@ -0,0 +1,522 @@
+
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2014 Anton Bikineev
+//  Copyright 2014 Christopher Kormanyos
+//  Copyright 2014 John Maddock
+//  Copyright 2014 Paul Bristow
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_HYPERGEOMETRIC_1F1_RECURRENCE_HPP_
+#define BOOST_HYPERGEOMETRIC_1F1_RECURRENCE_HPP_
+
+#include <boost/math/special_functions/modf.hpp>
+#include <boost/math/special_functions/next.hpp>
+
+#include <boost/math/tools/recurrence.hpp>
+#include <boost/math/special_functions/detail/hypergeometric_pFq_checked_series.hpp>
+
+  namespace boost { namespace math { namespace detail {
+
+  // forward declaration for initial values
+  template <class T, class Policy>
+  inline T hypergeometric_1F1_imp(const T& a, const T& b, const T& z, const Policy& pol);
+
+  template <class T, class Policy>
+  inline T hypergeometric_1F1_imp(const T& a, const T& b, const T& z, const Policy& pol, long long& log_scaling);
+
+  template <class T>
+  struct hypergeometric_1F1_recurrence_a_coefficients
+  {
+    using result_type = boost::math::tuple<T, T, T>;
+
+    hypergeometric_1F1_recurrence_a_coefficients(const T& a, const T& b, const T& z):
+    a(a), b(b), z(z)
+    {
+    }
+
+    hypergeometric_1F1_recurrence_a_coefficients(const hypergeometric_1F1_recurrence_a_coefficients&) = default;
+
+    hypergeometric_1F1_recurrence_a_coefficients operator=(const hypergeometric_1F1_recurrence_a_coefficients&) = delete;
+
+    result_type operator()(std::intmax_t i) const
+    {
+      const T ai = a + i;
+
+      const T an = b - ai;
+      const T bn = (2 * ai - b + z);
+      const T cn = -ai;
+
+      return boost::math::make_tuple(an, bn, cn);
+    }
+
+  private:
+    const T a;
+    const T b;
+    const T z;
+  };
+
+  template <class T>
+  struct hypergeometric_1F1_recurrence_b_coefficients
+  {
+    using result_type = boost::math::tuple<T, T, T>;
+
+    hypergeometric_1F1_recurrence_b_coefficients(const T& a, const T& b, const T& z):
+    a(a), b(b), z(z)
+    {
+    }
+
+    hypergeometric_1F1_recurrence_b_coefficients(const hypergeometric_1F1_recurrence_b_coefficients&) = default;
+
+    hypergeometric_1F1_recurrence_b_coefficients& operator=(const hypergeometric_1F1_recurrence_b_coefficients&) = delete;
+
+    result_type operator()(std::intmax_t i) const
+    {
+      const T bi = b + i;
+
+      const T an = bi * (bi - 1);
+      const T bn = bi * (1 - bi - z);
+      const T cn = z * (bi - a);
+
+      return boost::math::make_tuple(an, bn, cn);
+    }
+
+  private:
+    const T a;
+    const T b;
+    const T z;
+  };
+  //
+  // for use when we're recursing to a small b:
+  //
+  template <class T>
+  struct hypergeometric_1F1_recurrence_small_b_coefficients
+  {
+     using result_type = boost::math::tuple<T, T, T>;
+
+     hypergeometric_1F1_recurrence_small_b_coefficients(const T& a, const T& b, const T& z, int N) :
+        a(a), b(b), z(z), N(N)
+     {
+     }
+
+     hypergeometric_1F1_recurrence_small_b_coefficients(const hypergeometric_1F1_recurrence_small_b_coefficients&) = default;
+
+     hypergeometric_1F1_recurrence_small_b_coefficients operator=(const hypergeometric_1F1_recurrence_small_b_coefficients&) = delete;
+
+     result_type operator()(std::intmax_t i) const
+     {
+        const T bi = b + (i + N);
+        const T bi_minus_1 = b + (i + N - 1);
+
+        const T an = bi * bi_minus_1;
+        const T bn = bi * (-bi_minus_1 - z);
+        const T cn = z * (bi - a);
+
+        return boost::math::make_tuple(an, bn, cn);
+     }
+
+  private:
+     const T a;
+     const T b;
+     const T z;
+     int N;
+  };
+
+  template <class T>
+  struct hypergeometric_1F1_recurrence_a_and_b_coefficients
+  {
+    using result_type = boost::math::tuple<T, T, T>;
+
+    hypergeometric_1F1_recurrence_a_and_b_coefficients(const T& a, const T& b, const T& z, int offset = 0):
+    a(a), b(b), z(z), offset(offset)
+    {
+    }
+
+    hypergeometric_1F1_recurrence_a_and_b_coefficients(const hypergeometric_1F1_recurrence_a_and_b_coefficients&) = default;
+
+    hypergeometric_1F1_recurrence_a_and_b_coefficients operator=(const hypergeometric_1F1_recurrence_a_and_b_coefficients&) = delete;
+
+    result_type operator()(std::intmax_t i) const
+    {
+      const T ai = a + (offset + i);
+      const T bi = b + (offset + i);
+
+      const T an = bi * (b + (offset + i - 1));
+      const T bn = bi * (z - (b + (offset + i - 1)));
+      const T cn = -ai * z;
+
+      return boost::math::make_tuple(an, bn, cn);
+    }
+
+  private:
+    const T a;
+    const T b;
+    const T z;
+    int offset;
+  };
+#if 0
+  //
+  // These next few recurrence relations are archived for future reference, some of them are novel, though all
+  // are trivially derived from the existing well known relations:
+  //
+  // Recurrence relation for double-stepping on both a and b:
+  // - b(b-1)(b-2) / (2-b+z) M(a-2,b-2,z) + [b(a-1)z / (2-b+z) + b(1-b+z) + abz(b+1) /(b+1)(z-b)] M(a,b,z) - a(a+1)z^2 / (b+1)(z-b) M(a+2,b+2,z)
+  //
+  template <class T>
+  struct hypergeometric_1F1_recurrence_2a_and_2b_coefficients
+  {
+     typedef boost::math::tuple<T, T, T> result_type;
+
+     hypergeometric_1F1_recurrence_2a_and_2b_coefficients(const T& a, const T& b, const T& z, int offset = 0) :
+        a(a), b(b), z(z), offset(offset)
+     {
+     }
+
+     result_type operator()(std::intmax_t i) const
+     {
+        i *= 2;
+        const T ai = a + (offset + i);
+        const T bi = b + (offset + i);
+
+        const T an = -bi * (b + (offset + i - 1)) * (b + (offset + i - 2)) / (-(b + (offset + i - 2)) + z);
+        const T bn = bi * (a + (offset + i - 1)) * z / (z - (b + (offset + i - 2)))
+           + bi * (z - (b + (offset + i - 1)))
+           + ai * bi * z * (b + (offset + i + 1)) / ((b + (offset + i + 1)) * (z - bi));
+        const T cn = -ai * (a + (offset + i + 1)) * z * z / ((b + (offset + i + 1)) * (z - bi));
+
+        return boost::math::make_tuple(an, bn, cn);
+     }
+
+  private:
+     const T a, b, z;
+     int offset;
+     hypergeometric_1F1_recurrence_2a_and_2b_coefficients operator=(const hypergeometric_1F1_recurrence_2a_and_2b_coefficients&);
+  };
+
+  //
+  // Recurrence relation for double-stepping on a:
+  // -(b-a)(1 + b - a)/(2a-2-b+z)M(a-2,b,z)  + [(b-a)(a-1)/(2a-2-b+z) + (2a-b+z) + a(b-a-1)/(2a+2-b+z)]M(a,b,z)   -a(a+1)/(2a+2-b+z)M(a+2,b,z)
+  //
+  template <class T>
+  struct hypergeometric_1F1_recurrence_2a_coefficients
+  {
+     typedef boost::math::tuple<T, T, T> result_type;
+
+     hypergeometric_1F1_recurrence_2a_coefficients(const T& a, const T& b, const T& z, int offset = 0) :
+        a(a), b(b), z(z), offset(offset)
+     {
+     }
+
+     result_type operator()(std::intmax_t i) const
+     {
+        i *= 2;
+        const T ai = a + (offset + i);
+        // -(b-a)(1 + b - a)/(2a-2-b+z)
+        const T an = -(b - ai) * (b - (a + (offset + i - 1))) / (2 * (a + (offset + i - 1)) - b + z);
+        const T bn = (b - ai) * (a + (offset + i - 1)) / (2 * (a + (offset + i - 1)) - b + z) + (2 * ai - b + z) + ai * (b - (a + (offset + i + 1))) / (2 * (a + (offset + i + 1)) - b + z);
+        const T cn = -ai * (a + (offset + i + 1)) / (2 * (a + (offset + i + 1)) - b + z);
+
+        return boost::math::make_tuple(an, bn, cn);
+     }
+
+  private:
+     const T a, b, z;
+     int offset;
+     hypergeometric_1F1_recurrence_2a_coefficients operator=(const hypergeometric_1F1_recurrence_2a_coefficients&);
+  };
+
+  //
+  // Recurrence relation for double-stepping on b:
+  // b(b-1)^2(b-2)/((1-b)(2-b-z)) M(a,b-2,z)  + [zb(b-1)(b-1-a)/((1-b)(2-b-z)) + b(1-b-z) + z(b-a)(b+1)b/((b+1)(b+z)) ] M(a,b,z) + z^2(b-a)(b+1-a)/((b+1)(b+z)) M(a,b+2,z)
+  //
+  template <class T>
+  struct hypergeometric_1F1_recurrence_2b_coefficients
+  {
+     typedef boost::math::tuple<T, T, T> result_type;
+
+     hypergeometric_1F1_recurrence_2b_coefficients(const T& a, const T& b, const T& z, int offset = 0) :
+        a(a), b(b), z(z), offset(offset)
+     {
+     }
+
+     result_type operator()(std::intmax_t i) const
+     {
+        i *= 2;
+        const T bi = b + (offset + i);
+        const T bi_m1 = b + (offset + i - 1);
+        const T bi_p1 = b + (offset + i + 1);
+        const T bi_m2 = b + (offset + i - 2);
+
+        const T an = bi * (bi_m1) * (bi_m1) * (bi_m2) / (-bi_m1 * (-bi_m2 - z));
+        const T bn = z * bi * bi_m1 * (bi_m1 - a) / (-bi_m1 * (-bi_m2 - z)) + bi * (-bi_m1 - z) + z * (bi - a) * bi_p1 * bi / (bi_p1 * (bi + z));
+        const T cn = z * z * (bi - a) * (bi_p1 - a) / (bi_p1 * (bi + z));
+
+        return boost::math::make_tuple(an, bn, cn);
+     }
+
+  private:
+     const T a, b, z;
+     int offset;
+     hypergeometric_1F1_recurrence_2b_coefficients operator=(const hypergeometric_1F1_recurrence_2b_coefficients&);
+  };
+
+  //
+  // Recurrence relation for a+ b-:
+  // -z(b-a)(a-1-b)/(b(a-1+z)) M(a-1,b+1,z) + [(b-a)(a-1)b/(b(a-1+z)) + (2a-b+z) + a(b-a-1)/(a+z)] M(a,b,z) + a(1-b)/(a+z) M(a+1,b-1,z)
+  //
+  // This is potentially the most useful of these novel recurrences.
+  //              -                                      -                  +        -                           +
+  template <class T>
+  struct hypergeometric_1F1_recurrence_a_plus_b_minus_coefficients
+  {
+     typedef boost::math::tuple<T, T, T> result_type;
+
+     hypergeometric_1F1_recurrence_a_plus_b_minus_coefficients(const T& a, const T& b, const T& z, int offset = 0) :
+        a(a), b(b), z(z), offset(offset)
+     {
+     }
+
+     result_type operator()(std::intmax_t i) const
+     {
+        const T ai = a + (offset + i);
+        const T bi = b - (offset + i);
+
+        const T an = -z * (bi - ai) * (ai - 1 - bi) / (bi * (ai - 1 + z));
+        const T bn = z * ((-1 / (ai + z) - 1 / (ai + z - 1)) * (bi + z - 1) + 3) + bi - 1;
+        const T cn = ai * (1 - bi) / (ai + z);
+
+        return boost::math::make_tuple(an, bn, cn);
+     }
+
+  private:
+     const T a, b, z;
+     int offset;
+     hypergeometric_1F1_recurrence_a_plus_b_minus_coefficients operator=(const hypergeometric_1F1_recurrence_a_plus_b_minus_coefficients&);
+  };
+#endif
+
+  template <class T, class Policy>
+  inline T hypergeometric_1F1_backward_recurrence_for_negative_a(const T& a, const T& b, const T& z, const Policy& pol, const char* function, long long& log_scaling)
+  {
+    BOOST_MATH_STD_USING // modf, frexp, fabs, pow
+
+    std::intmax_t integer_part = 0;
+    T ak = modf(a, &integer_part);
+    //
+    // We need ak-1 positive to avoid infinite recursion below:
+    //
+    if (0 != ak)
+    {
+       ak += 2;
+       integer_part -= 2;
+    }
+    if (ak - 1 == b)
+    {
+       // When ak - 1 == b are recursion coefficients disappear to zero and
+       // we end up with a NaN result.  Reduce the recursion steps by 1 to
+       // avoid this.  We rely on |b| small and therefore no infinite recursion.
+       ak -= 1;
+       integer_part += 1;
+    }
+
+    if (-integer_part > static_cast<std::intmax_t>(policies::get_max_series_iterations<Policy>()))
+       return policies::raise_evaluation_error<T>(function, "1F1 arguments sit in a range with a so negative that we have no evaluation method, got a = %1%", std::numeric_limits<T>::quiet_NaN(), pol);
+
+    T first {};
+    T second {};
+    if(ak == 0)
+    { 
+       first = 1;
+       ak -= 1;
+       second = 1 - z / b;
+       if (fabs(second) < 0.5)
+          second = (b - z) / b;  // cancellation avoidance
+    }
+    else
+    {
+       long long scaling1 {};
+       long long scaling2 {};
+       first = detail::hypergeometric_1F1_imp(ak, b, z, pol, scaling1);
+       ak -= 1;
+       second = detail::hypergeometric_1F1_imp(ak, b, z, pol, scaling2);
+       if (scaling1 != scaling2)
+       {
+          second *= exp(T(scaling2 - scaling1));
+       }
+       log_scaling += scaling1;
+    }
+    ++integer_part;
+
+    detail::hypergeometric_1F1_recurrence_a_coefficients<T> s(ak, b, z);
+
+    return tools::apply_recurrence_relation_backward(s,
+                                                     static_cast<unsigned int>(std::abs(integer_part)),
+                                                     first,
+                                                     second, &log_scaling);
+  }
+
+
+  template <class T, class Policy>
+  T hypergeometric_1F1_backwards_recursion_on_b_for_negative_a(const T& a, const T& b, const T& z, const Policy& pol, const char*, long long& log_scaling)
+  {
+     using std::swap;
+     BOOST_MATH_STD_USING // modf, frexp, fabs, pow
+     //
+     // We compute 
+     //
+     // M[a + a_shift, b + b_shift; z] 
+     //
+     // and recurse backwards on a and b down to
+     //
+     // M[a, b, z]
+     //
+     // With a + a_shift > 1 and b + b_shift > z
+     // 
+     // There are 3 distinct regions to ensure stability during the recursions:
+     //
+     // a > 0         :  stable for backwards on a
+     // a < 0, b > 0  :  stable for backwards on a and b
+     // a < 0, b < 0  :  stable for backwards on b (as long as |b| is small). 
+     // 
+     // We could simplify things by ignoring the middle region, but it's more efficient
+     // to recurse on a and b together when we can.
+     //
+
+     BOOST_MATH_ASSERT(a < -1); // Not tested nor taken for -1 < a < 0
+
+     int b_shift = itrunc(z - b) + 2;
+
+     int a_shift = itrunc(-a);
+     if (a + a_shift != 0)
+     {
+        a_shift += 2;
+     }
+     //
+     // If the shifts are so large that we would throw an evaluation_error, try the series instead,
+     // even though this will almost certainly throw as well:
+     //
+     if (b_shift > static_cast<std::intmax_t>(boost::math::policies::get_max_series_iterations<Policy>()))
+        return hypergeometric_1F1_checked_series_impl(a, b, z, pol, log_scaling);
+
+     if (a_shift > static_cast<std::intmax_t>(boost::math::policies::get_max_series_iterations<Policy>()))
+        return hypergeometric_1F1_checked_series_impl(a, b, z, pol, log_scaling);
+
+     int a_b_shift = b < 0 ? itrunc(b + b_shift) : b_shift;   // The max we can shift on a and b together
+     int leading_a_shift = (std::min)(3, a_shift);        // Just enough to make a negative
+     if (a_b_shift > a_shift - 3)
+     {
+        a_b_shift = a_shift < 3 ? 0 : a_shift - 3;
+     }
+     else
+     {
+        // Need to ensure that leading_a_shift is large enough that a will reach it's target
+        // after the first 2 phases (-,0) and (-,-) are over:
+        leading_a_shift = a_shift - a_b_shift;
+     }
+     int trailing_b_shift = b_shift - a_b_shift;
+     if (a_b_shift < 5)
+     {
+        // Might as well do things in two steps rather than 3:
+        if (a_b_shift > 0)
+        {
+           leading_a_shift += a_b_shift;
+           trailing_b_shift += a_b_shift;
+        }
+        a_b_shift = 0;
+        --leading_a_shift;
+     }
+
+     BOOST_MATH_ASSERT(leading_a_shift > 1);
+     BOOST_MATH_ASSERT(a_b_shift + leading_a_shift + (a_b_shift == 0 ? 1 : 0) == a_shift);
+     BOOST_MATH_ASSERT(a_b_shift + trailing_b_shift == b_shift);
+
+     if ((trailing_b_shift == 0) && (fabs(b) < 0.5) && a_b_shift)
+     {
+        // Better to have the final recursion on b alone, otherwise we lose precision when b is very small:
+        int diff = (std::min)(a_b_shift, 3);
+        a_b_shift -= diff;
+        leading_a_shift += diff;
+        trailing_b_shift += diff;
+     }
+
+     T first {};
+     T second {};
+     long long scale1 {};
+     long long scale2 {};
+     first = boost::math::detail::hypergeometric_1F1_imp(T(a + a_shift), T(b + b_shift), z, pol, scale1);
+     //
+     // It would be good to compute "second" from first and the ratio - unfortunately we are right on the cusp
+     // recursion on a switching from stable backwards to stable forwards behaviour and so this is not possible here.
+     //
+     second = boost::math::detail::hypergeometric_1F1_imp(T(a + a_shift - 1), T(b + b_shift), z, pol, scale2);
+     if (scale1 != scale2)
+        second *= exp(T(scale2 - scale1));
+     log_scaling += scale1;
+
+     //
+     // Now we have [a + a_shift, b + b_shift, z] and [a + a_shift - 1, b + b_shift, z]
+     // and want to recurse until [a + a_shift - leading_a_shift, b + b_shift, z] and [a + a_shift - leadng_a_shift - 1, b + b_shift, z]
+     // which is leading_a_shift -1 steps.
+     //
+     second = boost::math::tools::apply_recurrence_relation_backward(
+        hypergeometric_1F1_recurrence_a_coefficients<T>(a + a_shift - 1, b + b_shift, z), 
+        leading_a_shift, first, second, &log_scaling, &first);
+
+     if (a_b_shift)
+     {
+        //
+        // Now we need to switch to an a+b shift so that we have:
+        // [a + a_shift - leading_a_shift, b + b_shift, z] and [a + a_shift - leadng_a_shift - 1, b + b_shift - 1, z]
+        // A&S 13.4.3 gives us what we need:
+        //
+        {
+           // local a's and b's:
+           T la = a + a_shift - leading_a_shift - 1;
+           T lb = b + b_shift;
+           second = ((1 + la - lb) * second - la * first) / (1 - lb);
+        }
+        //
+        // Now apply a_b_shift - 1 recursions to get down to
+        // [a + 1, b + trailing_b_shift + 1, z] and [a, b + trailing_b_shift, z]
+        //
+        second = boost::math::tools::apply_recurrence_relation_backward(
+           hypergeometric_1F1_recurrence_a_and_b_coefficients<T>(a, b + b_shift - a_b_shift, z, a_b_shift - 1),
+           a_b_shift - 1, first, second, &log_scaling, &first);
+        //
+        // Now we need to switch to a b shift, a different application of A&S 13.4.3
+        // will get us there, we leave "second" where it is, and move "first" sideways:
+        //
+        {
+           T lb = b + trailing_b_shift + 1;
+           first = (second * (lb - 1) - a * first) / -(1 + a - lb);
+        }
+     }
+     else
+     {
+        //
+        // We have M[a+1, b+b_shift, z] and M[a, b+b_shift, z] and need M[a, b+b_shift-1, z] for
+        // recursion on b: A&S 13.4.3 gives us what we need.
+        //
+        T third = -(second * (1 + a - b - b_shift) - first * a) / (b + b_shift - 1);
+        swap(first, second);
+        swap(second, third);
+        --trailing_b_shift;
+     }
+     //
+     // Finish off by applying trailing_b_shift recursions:
+     //
+     if (trailing_b_shift)
+     {
+        second = boost::math::tools::apply_recurrence_relation_backward(
+           hypergeometric_1F1_recurrence_small_b_coefficients<T>(a, b, z, trailing_b_shift), 
+           trailing_b_shift, first, second, &log_scaling);
+     }
+     return second;
+  }
+
+
+
+  } } } // namespaces
+
+#endif // BOOST_HYPERGEOMETRIC_1F1_RECURRENCE_HPP_

package/vendor/boost/math/include/boost/math/special_functions/detail/hypergeometric_1F1_scaled_series.hpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2017 John Maddock
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_MATH_HYPERGEOMETRIC_1F1_SCALED_SERIES_HPP
+#define BOOST_MATH_HYPERGEOMETRIC_1F1_SCALED_SERIES_HPP
+
+#include <array>
+#include <cstdint>
+
+  namespace boost{ namespace math{ namespace detail{
+
+     template <class T, class Policy>
+     T hypergeometric_1F1_scaled_series(const T& a, const T& b, T z, const Policy& pol, const char* function)
+     {
+        BOOST_MATH_STD_USING
+        //
+        // Result is returned scaled by e^-z.
+        // Whenever the terms start becoming too large, we scale by some factor e^-n
+        // and keep track of the integer scaling factor n.  At the end we can perform
+        // an exact subtraction of n from z and scale the result:
+        //
+        T sum(0), term(1), upper_limit(sqrt(boost::math::tools::max_value<T>())), diff;
+        unsigned n = 0;
+        long long log_scaling_factor = 1 - lltrunc(boost::math::tools::log_max_value<T>());
+        T scaling_factor = exp(T(log_scaling_factor));
+        std::intmax_t current_scaling = 0;
+
+        do
+        {
+           sum += term;
+           if (sum >= upper_limit)
+           {
+              sum *= scaling_factor;
+              term *= scaling_factor;
+              current_scaling += log_scaling_factor;
+           }
+           term *= (((a + n) / ((b + n) * (n + 1))) * z);
+           if (n > boost::math::policies::get_max_series_iterations<Policy>())
+              return boost::math::policies::raise_evaluation_error(function, "Series did not converge, best value is %1%", sum, pol);
+           ++n;
+           diff = fabs(term / sum);
+        } while (diff > boost::math::policies::get_epsilon<T, Policy>());
+
+        z = -z - current_scaling;
+        while (z < log_scaling_factor)
+        {
+           z -= log_scaling_factor;
+           sum *= scaling_factor;
+        }
+        return sum * exp(z);
+     }
+
+
+
+  } } } // namespaces
+
+#endif // BOOST_MATH_HYPERGEOMETRIC_1F1_SCALED_SERIES_HPP

package/vendor/boost/math/include/boost/math/special_functions/detail/hypergeometric_1F1_small_a_negative_b_by_ratio.hpp

@@ -0,0 +1,70 @@
+
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2018 John Maddock
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_MATH_HYPERGEOMETRIC_1F1_SMALL_A_NEG_B_HPP
+#define BOOST_MATH_HYPERGEOMETRIC_1F1_SMALL_A_NEG_B_HPP
+
+#include <algorithm>
+#include <boost/math/tools/recurrence.hpp>
+
+  namespace boost { namespace math { namespace detail {
+
+     // forward declaration for initial values
+     template <class T, class Policy>
+     inline T hypergeometric_1F1_imp(const T& a, const T& b, const T& z, const Policy& pol);
+
+     template <class T, class Policy>
+     inline T hypergeometric_1F1_imp(const T& a, const T& b, const T& z, const Policy& pol, long long& log_scaling);
+
+      template <class T>
+      T max_b_for_1F1_small_a_negative_b_by_ratio(const T& z)
+      {
+         if (z < -998)
+            return (z * 2) / 3;
+         float max_b[][2] = 
+         {
+            { 0.0f, -47.3046f }, {-6.7275f, -52.0351f }, { -8.9543f, -57.2386f }, {-11.9182f, -62.9625f }, {-14.421f, -69.2587f }, {-19.1943f, -76.1846f }, {-23.2252f, -83.803f }, {-28.1024f, -92.1833f }, {-34.0039f, -101.402f }, {-37.4043f, -111.542f }, {-45.2593f, -122.696f }, {-54.7637f, -134.966f }, {-60.2401f, -148.462f }, {-72.8905f, -163.308f }, {-88.1975f, -179.639f }, {-88.1975f, -197.603f }, {-106.719f, -217.363f }, {-129.13f, -239.1f }, {-142.043f, -263.01f }, {-156.247f, -289.311f }, {-189.059f, -318.242f }, {-207.965f, -350.066f }, {-228.762f, -385.073f }, {-276.801f, -423.58f }, {-304.482f, -465.938f }, {-334.93f, -512.532f }, {-368.423f, -563.785f }, {-405.265f, -620.163f }, {-445.792f, -682.18f }, {-539.408f, -750.398f }, {-593.349f, -825.437f }, {-652.683f, -907.981f }, {-717.952f, -998.779f }
+         };
+         auto p = std::lower_bound(max_b, max_b + sizeof(max_b) / sizeof(max_b[0]), z, [](const float (&a)[2], const T& z) { return a[1] > z; });
+         T b = p - max_b ? (*--p)[0] : 0;
+         //
+         // We need approximately an extra 10 recurrences per 50 binary digits precision above that of double:
+         //
+         b += (std::max)(0, boost::math::tools::digits<T>() - 53) / 5;
+         return b;
+      }
+
+      template <class T, class Policy>
+      T hypergeometric_1F1_small_a_negative_b_by_ratio(const T& a, const T& b, const T& z, const Policy& pol, long long& log_scaling)
+      {
+         BOOST_MATH_STD_USING
+         //
+         // We grab the ratio for M[a, b, z] / M[a, b+1, z] and use it to seed 2 initial values,
+         // then recurse until b > 0, compute a reference value and normalize (Millers method).
+         //
+         int iterations = itrunc(-b, pol);
+         std::uintmax_t max_iter = boost::math::policies::get_max_series_iterations<Policy>();
+         T ratio = boost::math::tools::function_ratio_from_forwards_recurrence(boost::math::detail::hypergeometric_1F1_recurrence_b_coefficients<T>(a, b, z), boost::math::tools::epsilon<T>(), max_iter);
+         boost::math::policies::check_series_iterations<T>("boost::math::hypergeometric_1F1_small_a_negative_b_by_ratio<%1%>(%1%,%1%,%1%)", max_iter, pol);
+         T first = 1;
+         T second = 1 / ratio;
+         long long scaling1 = 0;
+         BOOST_MATH_ASSERT(b + iterations != a);
+         second = boost::math::tools::apply_recurrence_relation_forward(boost::math::detail::hypergeometric_1F1_recurrence_b_coefficients<T>(a, b + 1, z), iterations, first, second, &scaling1);
+         long long scaling2 = 0;
+         first = hypergeometric_1F1_imp(a, T(b + iterations + 1), z, pol, scaling2);
+         //
+         // Result is now first/second * e^(scaling2 - scaling1)
+         //
+         log_scaling += scaling2 - scaling1;
+         return first / second;
+      }
+
+
+  } } } // namespaces
+
+#endif // BOOST_MATH_HYPERGEOMETRIC_1F1_SMALL_A_NEG_B_HPP