Merge remote-tracking branch 'origin' into mydevelop

Author: cohomology

include/boost/math/constants/info.hpp

@@ -13,7 +13,9 @@
 #include <boost/math/constants/constants.hpp>
 #include <iostream>
 #include <iomanip>
+#ifndef BOOST_MATH_NO_RTTI
 #include <typeinfo>
+#endif
 
 namespace boost{ namespace math{ namespace constants{
 
@@ -22,7 +24,11 @@ namespace boost{ namespace math{ namespace constants{
       template <class T>
       const char* nameof(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T))
       {
+         #ifndef BOOST_MATH_NO_RTTI
          return typeid(T).name();
+         #else
+         return "unknown";
+         #endif
       }
       template <>
       const char* nameof<float>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(float))

include/boost/math/distributions/landau.hpp

@@ -3382,7 +3382,7 @@ BOOST_MATH_GPU_ENABLED inline RealType landau_quantile_lower_imp_prec(const Real
 
         // Rational Approximation
         // Maximum Relative Error: 5.3064e-35
-        //LCOV_EXCL_START
+        // LCOV_EXCL_START
         BOOST_MATH_STATIC const RealType P[14] = {
             BOOST_MATH_BIG_CONSTANT(RealType, 113, -5.09971143249822249471944441552701756051e0),
             BOOST_MATH_BIG_CONSTANT(RealType, 113, -3.00154235169065403254826962372636417554e-2),

include/boost/math/policies/error_handling.hpp

@@ -8,29 +8,32 @@
 #ifndef BOOST_MATH_POLICY_ERROR_HANDLING_HPP
 #define BOOST_MATH_POLICY_ERROR_HANDLING_HPP
 
+#include <boost/math/policies/policy.hpp>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/tools/numeric_limits.hpp>
-#include <boost/math/tools/type_traits.hpp>
-#include <boost/math/tools/cstdint.hpp>
-#include <boost/math/tools/tuple.hpp>
-#include <boost/math/policies/policy.hpp>
 #include <boost/math/tools/precision.hpp>
+#include <boost/math/tools/tuple.hpp>
+#include <boost/math/tools/type_traits.hpp>
 
 #ifndef BOOST_MATH_HAS_NVRTC
 
-#include <iomanip>
-#include <string>
-#include <cstring>
-#ifndef BOOST_MATH_NO_RTTI
-#include <typeinfo>
+#ifndef BOOST_MATH_NO_EXCEPTIONS
+#include <boost/math/tools/throw_exception.hpp>
 #endif
+
 #include <cerrno>
-#include <complex>
 #include <cmath>
+#include <complex>
 #include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <sstream>
 #ifndef BOOST_MATH_NO_EXCEPTIONS
 #include <stdexcept>
-#include <boost/math/tools/throw_exception.hpp>
+#endif
+#include <string>
+#ifndef BOOST_MATH_NO_RTTI
+#include <typeinfo>
 #endif
 
 #ifdef _MSC_VER
@@ -43,7 +46,6 @@
 // Note that this only occurs when the compiler can deduce code is unreachable,
 // for example when policy macros are used to ignore errors rather than throw.
 #endif
-#include <sstream>
 
 namespace boost{ namespace math{
 
@@ -91,15 +93,20 @@ namespace detail
 template <class T>
 inline std::string prec_format(const T& val)
 {
-   typedef typename boost::math::policies::precision<T, boost::math::policies::policy<> >::type prec_type;
-   std::stringstream ss;
+   using prec_type = typename boost::math::policies::precision<T, boost::math::policies::policy<> >::type;
+
+   std::stringstream strm { };
+
    if(prec_type::value)
    {
-      int prec = 2 + (prec_type::value * 30103UL) / 100000UL;
-      ss << std::setprecision(prec);
+      const std::streamsize prec { static_cast<std::streamsize>(2UL + (prec_type::value * 30103UL) / 100000UL) };
+
+      strm << std::setprecision(prec);
    }
-   ss << val;
-   return ss.str();
+
+   strm << val;
+
+   return strm.str();
 }
 
 #ifdef BOOST_MATH_USE_CHARCONV_FOR_CONVERSION

include/boost/math/policies/policy.hpp

@@ -132,7 +132,7 @@ namespace policies{
 
 #define BOOST_MATH_META_INT(Type, name, Default)                                                \
    template <Type N = Default>                                                                  \
-   class name : public boost::math::integral_constant<int, N>{};                                \
+   class name : public boost::math::integral_constant<Type, N> { };                             \
                                                                                                 \
    namespace detail{                                                                            \
    template <Type N>                                                                            \

include/boost/math/special_functions/bessel.hpp

@@ -524,7 +524,7 @@ BOOST_MATH_GPU_ENABLED inline T cyl_neumann_zero_imp(T v, int m, const Policy& p
 
    if(number_of_iterations >= policies::get_max_root_iterations<Policy>())
    {
-      return policies::raise_evaluation_error<T>(function, "Unable to locate root in a reasonable time: Current best guess is %1%", yvm, Policy()); //LCOV_EXCL_LINE
+      return policies::raise_evaluation_error<T>(function, "Unable to locate root in a reasonable time: Current best guess is %1%", yvm, Policy()); // LCOV_EXCL_LINE
    }
 
    return yvm;

include/boost/math/special_functions/beta.hpp

@@ -683,7 +683,15 @@ BOOST_MATH_GPU_ENABLED T ibeta_series(T a, T b, T x, T s0, const Lanczos&, bool
       if ((a < tools::min_value<T>()) || (b < tools::min_value<T>()))
          result = 0;  // denorms cause overflow in the Lanzos series, result will be zero anyway
       else
-         result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b));
+      {
+         T l1 = Lanczos::lanczos_sum_expG_scaled(c);
+         T l2 = Lanczos::lanczos_sum_expG_scaled(a);
+         T l3 = Lanczos::lanczos_sum_expG_scaled(b);
+         if ((l2 > 1) && (l3 > 1) && (tools::max_value<T>() / l2 < l3))
+            result = (l1 / l2) / l3;
+         else
+         result = l1 / (l2 * l3);
+      }
 
       if (!(boost::math::isfinite)(result))
          result = 0;  // LCOV_EXCL_LINE we can probably never get here, covered already above?

include/boost/math/special_functions/detail/bernoulli_details.hpp

@@ -108,7 +108,7 @@ inline std::size_t find_bernoulli_overflow_limit(const std::false_type&)
    // Set a limit on how large the result can ever be:
    static const auto max_result = static_cast<double>((std::numeric_limits<std::size_t>::max)() - 1000u);
 
-   unsigned long long t = lltrunc(boost::math::tools::log_max_value<T>());
+   unsigned long long t = static_cast<unsigned long long>(lltrunc(boost::math::tools::log_max_value<T>()));
    max_bernoulli_root_functor fun(t);
    boost::math::tools::equal_floor tol;
    std::uintmax_t max_iter = boost::math::policies::get_max_root_iterations<Policy>();
@@ -372,7 +372,7 @@ class bernoulli_numbers_cache
          {
             for(; n; ++start, --n)
             {
-               *out = b2n_asymptotic<T, Policy>(static_cast<typename container_type::size_type>(start * 2U));
+               *out = b2n_asymptotic<T, Policy>(static_cast<int>(start * 2U));
                ++out;
             }
          }

include/boost/math/special_functions/detail/bessel_ik.hpp

@@ -416,7 +416,7 @@ BOOST_MATH_GPU_ENABLED int bessel_ik(T v, T x, T* result_I, T* result_K, int kin
        else
           Iv = boost::math::numeric_limits<T>::quiet_NaN(); // any value will do
     }
-    if (reflect)
+    if (reflect && (kind & need_i))
     {
         BOOST_MATH_ASSERT(fabs(v - n - u) < tools::forth_root_epsilon<T>());
         T z = (u + n % 2);

include/boost/math/special_functions/detail/bessel_j1.hpp

@@ -32,41 +32,9 @@
 
 namespace boost { namespace math{  namespace detail{
 
-template <typename T>
-BOOST_MATH_GPU_ENABLED T bessel_j1(T x);
-
-template <class T>
-struct bessel_j1_initializer
-{
-   struct init
-   {
-      BOOST_MATH_GPU_ENABLED init()
-      {
-         do_init();
-      }
-      BOOST_MATH_GPU_ENABLED static void do_init()
-      {
-         bessel_j1(T(1));
-      }
-      BOOST_MATH_GPU_ENABLED void force_instantiate()const{}
-   };
-   BOOST_MATH_STATIC const init initializer;
-   BOOST_MATH_GPU_ENABLED static void force_instantiate()
-   {
-      #ifndef BOOST_MATH_HAS_GPU_SUPPORT
-      initializer.force_instantiate();
-      #endif
-   }
-};
-
-template <class T>
-const typename bessel_j1_initializer<T>::init bessel_j1_initializer<T>::initializer;
-
 template <typename T>
 BOOST_MATH_GPU_ENABLED T bessel_j1(T x)
 {
-    bessel_j1_initializer<T>::force_instantiate();
-
     BOOST_MATH_STATIC const T P1[] = {
          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4258509801366645672e+11)),
          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 6.6781041261492395835e+09)),

include/boost/math/special_functions/detail/bessel_jn.hpp

@@ -76,7 +76,7 @@ BOOST_MATH_GPU_ENABLED T bessel_jn(int n, T x, const Policy& pol)
     {
         prev = bessel_j0(x);
         current = bessel_j1(x);
-        policies::check_series_iterations<T>("boost::math::bessel_j_n<%1%>(%1%,%1%)", n, pol);
+        policies::check_series_iterations<T>("boost::math::bessel_j_n<%1%>(%1%,%1%)", static_cast<unsigned>(n), pol);
         for (int k = 1; k < n; k++)
         {
             value = (2 * k * current / x) - prev;
@@ -96,7 +96,7 @@ BOOST_MATH_GPU_ENABLED T bessel_jn(int n, T x, const Policy& pol)
         prev = fn;
         current = 1;
         // Check recursion won't go on too far:
-        policies::check_series_iterations<T>("boost::math::bessel_j_n<%1%>(%1%,%1%)", n, pol);
+        policies::check_series_iterations<T>("boost::math::bessel_j_n<%1%>(%1%,%1%)", static_cast<unsigned>(n), pol);
         for (int k = n; k > 0; k--)
         {
             T fact = 2 * k / x;