Merge pull request #1246 from boostorg/develop

Merge for 1.88

Author: mborland

doc/background/special_tut.qbk

@@ -373,7 +373,7 @@ Now we just need to write the test driver program, at it's most basic it looks s
       std::cout << "<note>The long double tests have been disabled on this platform "
          "either because the long double overloads of the usual math functions are "
          "not available at all, or because they are too inaccurate for these tests "
-         "to pass.</note>" << std::cout;
+         "to pass.</note>" << std::endl;
    #endif
    }
 

doc/distributions/cauchy.qbk

@@ -105,28 +105,23 @@ In the following table __x0 is the location parameter of the distribution,
 
 [table
 [[Function][Implementation Notes]]
-[[pdf][Using the relation: ['pdf = 1 / ([pi] * [gamma] * (1 + ((x - __x0) / [gamma])[super 2]) ]]]
+[[pdf][Using the relation: ['pdf = 1 / ([pi] * [gamma] * (1 + ((x - __x0) / [gamma])[super 2])) ]]]
 [[cdf and its complement][
 The cdf is normally given by:
 
 [expression p = 0.5 + atan(x)/[pi]]
 
 But that suffers from cancellation error as x -> -[infin].
-So recall that for `x < 0`:
 
-[expression atan(x) = -[pi]/2 - atan(1/x)]
+Instead, the mathematically equivalent expression based on the function atan2
+is used:
 
-Substituting into the above we get:
+[expression p = atan2(1, -x)/[pi]]
 
-[expression p = -atan(1/x) / [pi]  ; x < 0]
+By symmetry, the complement is
 
-So the procedure is to calculate the cdf for -fabs(x)
-using the above formula.  Note that to factor in the location and scale
-parameters you must substitute (x - __x0) / [gamma] for x in the above.
+[expression q = atan2(1, x)/[pi]]
 
-This procedure yields the smaller of /p/ and /q/, so the result
-may need subtracting from 1 depending on whether we want the complement
-or not, and whether /x/ is less than __x0 or not.
 ]]
 [[quantile][The same procedure is used irrespective of whether we're starting
             from the probability or its complement.  First the argument /p/ is

include/boost/math/ccmath/floor.hpp

@@ -33,7 +33,7 @@ inline constexpr T floor_pos_impl(T arg) noexcept
 
     T result = 1;
 
-    if(result < arg)
+    if(result <= arg)
     {
         while(result < arg)
         {

include/boost/math/ccmath/isinf.hpp

@@ -23,8 +23,13 @@ constexpr bool isinf BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x) noexcept
         if constexpr (std::numeric_limits<T>::is_signed)
         {
 #if defined(__clang_major__) && __clang_major__ >= 6
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wtautological-constant-compare"
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wtautological-constant-compare"
+#  if defined(__has_warning)
+#    if __has_warning("-Wnan-infinity-disabled")
+#      pragma clang diagnostic ignored "-Wnan-infinity-disabled"
+#    endif
+#  endif
 #endif
             return x == std::numeric_limits<T>::infinity() || -x == std::numeric_limits<T>::infinity();
 #if defined(__clang_major__) && __clang_major__ >= 6

include/boost/math/distributions/cauchy.hpp

@@ -45,23 +45,11 @@ BOOST_MATH_GPU_ENABLED RealType cdf_imp(const cauchy_distribution<RealType, Poli
    //
    // This calculates the cdf of the Cauchy distribution and/or its complement.
    //
-   // The usual formula for the Cauchy cdf is:
+   // This implementation uses the formula
    //
-   // cdf = 0.5 + atan(x)/pi
+   //     cdf = atan2(1, -x)/pi
    //
-   // But that suffers from cancellation error as x -> -INF.
-   //
-   // Recall that for x < 0:
-   //
-   // atan(x) = -pi/2 - atan(1/x)
-   //
-   // Substituting into the above we get:
-   //
-   // CDF = -atan(1/x)/pi  ; x < 0
-   //
-   // So the procedure is to calculate the cdf for -fabs(x)
-   // using the above formula, and then subtract from 1 when required
-   // to get the result.
+   // where x is the standardized (i.e. shifted and scaled) domain variable.
    //
    BOOST_MATH_STD_USING // for ADL of std functions
    constexpr auto function = "boost::math::cdf(cauchy<%1%>&, %1%)";
@@ -99,13 +87,8 @@ BOOST_MATH_GPU_ENABLED RealType cdf_imp(const cauchy_distribution<RealType, Poli
    { // Catches x == NaN
       return result;
    }
-   RealType mx = -fabs((x - location) / scale); // scale is > 0
-   if(mx > -tools::epsilon<RealType>() / 8)
-   {  // special case first: x extremely close to location.
-      return static_cast<RealType>(0.5f);
-   }
-   result = -atan(1 / mx) / constants::pi<RealType>();
-   return (((x > location) != complement) ? 1 - result : result);
+   RealType x_std = static_cast<RealType>((complement) ? 1 : -1)*(x - location) / scale;
+   return atan2(static_cast<RealType>(1), x_std) / constants::pi<RealType>();
 } // cdf
 
 template <class RealType, class Policy>

include/boost/math/distributions/fwd.hpp

@@ -11,8 +11,6 @@
 #ifndef BOOST_MATH_DISTRIBUTIONS_FWD_HPP
 #define BOOST_MATH_DISTRIBUTIONS_FWD_HPP
 
-// 33 distributions at Boost 1.9.1 after adding hyperexpon and arcsine
-
 namespace boost{ namespace math{
 
 template <class RealType, class Policy>

include/boost/math/distributions/skew_normal.hpp

@@ -13,7 +13,7 @@
 // Azzalini, A. (1985). "A class of distributions which includes the normal ones".
 // Scand. J. Statist. 12: 171-178.
 
-#include <boost/math/distributions/fwd.hpp> // TODO add skew_normal distribution to fwd.hpp!
+#include <boost/math/distributions/fwd.hpp>
 #include <boost/math/special_functions/owens_t.hpp> // Owen's T function
 #include <boost/math/distributions/complement.hpp>
 #include <boost/math/distributions/normal.hpp>

include/boost/math/special_functions/bessel.hpp

@@ -96,7 +96,7 @@ BOOST_MATH_GPU_ENABLED inline T sph_bessel_j_small_z_series(unsigned v, T x, con
 }
 
 template <class T, class Policy>
-BOOST_MATH_GPU_ENABLED T cyl_bessel_j_imp_final(T v, T x, const bessel_no_int_tag& t, const Policy& pol)
+BOOST_MATH_GPU_ENABLED T cyl_bessel_j_imp_final(T v, T x, const bessel_no_int_tag&, const Policy& pol)
 {
    BOOST_MATH_STD_USING
 
@@ -264,7 +264,7 @@ BOOST_MATH_GPU_ENABLED T cyl_bessel_i_imp(T v, T x, const Policy& pol)
 }
 
 template <class T, class Policy>
-BOOST_MATH_GPU_ENABLED inline T cyl_bessel_k_imp(T v, T x, const bessel_no_int_tag& /* t */, const Policy& pol)
+BOOST_MATH_GPU_ENABLED inline T cyl_bessel_k_imp(T v, T x, const bessel_no_int_tag&, const Policy& pol)
 {
    constexpr auto function = "boost::math::cyl_bessel_k<%1%>(%1%,%1%)";
    BOOST_MATH_STD_USING

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

@@ -470,7 +470,7 @@ BOOST_MATH_GPU_ENABLED T bessel_k0_imp(const T& x, const boost::math::integral_c
             BOOST_MATH_BIG_CONSTANT(T, 113, 8.370574966987293592457152146806662562e+03),
             BOOST_MATH_BIG_CONSTANT(T, 113, 4.871254714311063594080644835895740323e+01)
          };
-         if(x < tools::log_max_value<T>())
+         if(-x > tools::log_min_value<T>())
             return  ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
          else
          {

include/boost/math/special_functions/gamma.hpp

@@ -111,11 +111,13 @@ BOOST_MATH_GPU_ENABLED T sinpx(T z)
 // tgamma(z), with Lanczos support:
 //
 template <class T, class Policy, class Lanczos>
-BOOST_MATH_GPU_ENABLED T gamma_imp_final(T z, const Policy& pol, const Lanczos&)
+BOOST_MATH_GPU_ENABLED T gamma_imp_final(T z, const Policy& pol, const Lanczos& l)
 {
    BOOST_MATH_STD_USING
+   
+   (void)l; // Suppresses unused variable warning when BOOST_MATH_INSTRUMENT is not defined
 
-   T result = 1;
+   T result = 1;  
 
 #ifdef BOOST_MATH_INSTRUMENT
    static bool b = false;