boostorg · jzmaddock · Jan 11, 2023 · Dec 28, 2022 · Dec 28, 2022 · Dec 28, 2022
diff --git a/.drone.star b/.drone.star
@@ -52,6 +52,8 @@ def main(ctx):
       result.append(linux_cxx("Ubuntu g++-11 " + cxx + " " + suite, "g++-11", packages="g++-11", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-11', 'CXXSTD': cxx, 'TEST_SUITE': suite, }, globalenv=globalenv))
     for cxx in clang_10_stds:
       result.append(linux_cxx("Ubuntu clang++-10 " + cxx + " " + suite, "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': cxx, 'TEST_SUITE': suite, }, globalenv=globalenv))
+    for cxx in gnu_9_stds:
+      result.append(linux_cxx("Ubuntu g++ s390s " + cxx + " " + suite, "g++", packages="g++", buildtype="boost", image="cppalliance/droneubuntu2204:multiarch", arch="s390x", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++', 'CXXSTD': cxx, 'TEST_SUITE': suite, }, globalenv=globalenv))
 
   return result
 

diff --git a/.drone/boost.sh b/.drone/boost.sh
@@ -40,7 +40,7 @@ echo '==================================> BEFORE_SCRIPT'
 echo '==================================> SCRIPT'
 
 echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD $OPTIONS ;" > ~/user-config.jam
-(cd libs/config/test && ../../../b2 config_info_travis_install toolset=$TOOLSET && ./config_info_travis)
+(cd libs/config/test && ../../../b2 print_config_info print_math_info toolset=$TOOLSET)
 (cd libs/math/test && ../../../b2 -j3 toolset=$TOOLSET $TEST_SUITE)
 
 echo '==================================> AFTER_SUCCESS'

diff --git a/include/boost/math/interpolators/detail/whittaker_shannon_detail.hpp b/include/boost/math/interpolators/detail/whittaker_shannon_detail.hpp
@@ -30,6 +30,7 @@ class whittaker_shannon_detail {
         using boost::math::constants::pi;
         using std::isfinite;
         using std::floor;
+        using std::ceil;
         Real y = 0;
         Real x = (t - m_t0)/m_h;
         Real z = x;
@@ -61,6 +62,7 @@ class whittaker_shannon_detail {
         using boost::math::constants::pi;
         using std::isfinite;
         using std::floor;
+        using std::ceil;
 
         Real x = (t - m_t0)/m_h;
         if (ceil(x) == x) {

diff --git a/include/boost/math/special_functions/detail/bessel_jy.hpp b/include/boost/math/special_functions/detail/bessel_jy.hpp
@@ -465,6 +465,13 @@ namespace boost { namespace math {
                for (k = n; k > 0; k--)             // backward recurrence for J
                {
                   next = 2 * (u + k) * current / x - prev;
+                  //
+                  // We can't allow next to completely cancel out or the subsequent logic breaks.
+                  // Pretend that one bit did not cancel:
+                  if (next == 0)
+                  {
+                     next = prev * tools::epsilon<T>() / 2;
+                  }
                   prev = current;
                   current = next;
                }

diff --git a/test/adaptive_gauss_kronrod_quadrature_test.cpp b/test/adaptive_gauss_kronrod_quadrature_test.cpp
@@ -259,6 +259,7 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_left_limit_infinite<double, 17>();
 #endif
 #ifdef TEST1A
+#if LDBL_MANT_DIG < 100 // If we have too many digits in a long double, we get build errors due to a constexpr issue.
     std::cout << "Testing with 21 point Gauss-Kronrod rule:\n";
     test_linear<cpp_bin_float_quad, 21>();
     test_quadratic<cpp_bin_float_quad, 21>();
@@ -277,7 +278,9 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 31>();
     test_left_limit_infinite<cpp_bin_float_quad, 31>();
 #endif
+#endif
 #ifdef TEST2
+#if LDBL_MANT_DIG < 100 // If we have too many digits in a long double, we get build errors due to a constexpr issue.
     std::cout << "Testing with 41 point Gauss-Kronrod rule:\n";
     test_linear<cpp_bin_float_quad, 41>();
     test_quadratic<cpp_bin_float_quad, 41>();
@@ -296,7 +299,9 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 51>();
     test_left_limit_infinite<cpp_bin_float_quad, 51>();
 #endif
+#endif
 #ifdef TEST3
+#if LDBL_MANT_DIG < 100 // If we have too many digits in a long double, we get build errors due to a constexpr issue.
     std::cout << "Testing with 61 point Gauss-Kronrod rule:\n";
     test_linear<cpp_bin_float_quad, 61>();
     test_quadratic<cpp_bin_float_quad, 61>();
@@ -306,6 +311,7 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 61>();
     test_left_limit_infinite<cpp_bin_float_quad, 61>();
 #endif
+#endif
 }
 
 #else

diff --git a/test/bessel_i_prime_data.ipp b/test/bessel_i_prime_data.ipp
diff --git a/test/cardinal_cubic_b_spline_test.cpp b/test/cardinal_cubic_b_spline_test.cpp
@@ -247,7 +247,9 @@ void test_circ_conic_function()
 
     boost::math::interpolators::cardinal_cubic_b_spline<Real> spline(v.data(), v.size(), -w, step);
 
-    const Real tol = 100 * sqrt(std::numeric_limits<Real>::epsilon());
+    Real tol = 100 * sqrt(std::numeric_limits<Real>::epsilon());
+    if ((std::numeric_limits<Real>::digits > 100) || !std::numeric_limits<Real>::digits)
+       tol *= 500000;
     // First check derivatives exactly at end points
     BOOST_CHECK_CLOSE(spline.prime(-w), df(-w), tol);
     BOOST_CHECK_CLOSE(spline.prime(w), df(w), tol);

diff --git a/test/cardinal_quadratic_b_spline_test.cpp b/test/cardinal_quadratic_b_spline_test.cpp
@@ -25,7 +25,7 @@ void test_constant()
     while (i < n) {
       Real t = t0 + i*h;
       CHECK_ULP_CLOSE(c, qbs(t), 2);
-      CHECK_MOLLIFIED_CLOSE(0, qbs.prime(t), 100*std::numeric_limits<Real>::epsilon());
+      CHECK_MOLLIFIED_CLOSE(0, qbs.prime(t), (std::numeric_limits<Real>::digits > 100 ? 200 : 100) * std::numeric_limits<Real>::epsilon());
       ++i;
     }
 
@@ -36,7 +36,7 @@ void test_constant()
       CHECK_MOLLIFIED_CLOSE(0, qbs.prime(t), 300*std::numeric_limits<Real>::epsilon());
       t = t0 + i*h + h/4;
       CHECK_ULP_CLOSE(c, qbs(t), 2);
-      CHECK_MOLLIFIED_CLOSE(0, qbs.prime(t), 150*std::numeric_limits<Real>::epsilon());
+      CHECK_MOLLIFIED_CLOSE(0, qbs.prime(t), (std::numeric_limits<Real>::digits > 100 ? 300 : 150) * std::numeric_limits<Real>::epsilon());
       ++i;
     }
 }

diff --git a/test/ccmath_abs_test.cpp b/test/ccmath_abs_test.cpp
@@ -36,7 +36,7 @@ void gpp_test()
 
     constexpr T sin_1 = boost::math::ccmath::abs(std::sin(T(-1)));
     static_assert(sin_1 > 0);
-    static_assert(sin_1 == T(0.8414709848078965066525l));
+    static_assert(sin_1 == T(0.841470984807896506652502321630298999622563060798371065672751709L));
 }
 
 template <typename T>
@@ -76,7 +76,9 @@ int main()
 
     // Types that are convertible to int
     test<short>();
+#if CHAR_MIN != 0
     test<char>();
+#endif
 
     // fabs
     fabs_test<float>();

diff --git a/test/ccmath_sqrt_test.cpp b/test/ccmath_sqrt_test.cpp
@@ -46,7 +46,7 @@ void test_float_sqrt()
     constexpr Real tol = 2*std::numeric_limits<Real>::epsilon();
 
     constexpr Real test_val = boost::math::ccmath::sqrt(Real(2));
-    constexpr Real sqrt2 = Real(1.4142135623730950488016887l);
+    constexpr Real sqrt2 = Real(1.4142135623730950488016887242096980785696718753769480731766797379L);
     constexpr Real abs_test_error = (test_val - sqrt2) > 0 ? (test_val - sqrt2) : (sqrt2 - test_val);
     static_assert(abs_test_error < tol, "Out of tolerance");
 

diff --git a/test/cohen_acceleration_test.cpp b/test/cohen_acceleration_test.cpp
@@ -67,7 +67,7 @@ void test_divergent()
 {
     auto g = Divergent<Real>();
     Real x = -cohen_acceleration(g);
-    CHECK_ULP_CLOSE(log(pi<Real>()/2)/2, x, 135);
+    CHECK_ULP_CLOSE(log(pi<Real>()/2)/2, x, (std::numeric_limits<Real>::digits > 100 ? 350 : 135));
 }
 
 int main()

diff --git a/test/cubic_roots_test.cpp b/test/cubic_roots_test.cpp
@@ -8,6 +8,8 @@
 #include "math_unit_test.hpp"
 #include <boost/math/tools/cubic_roots.hpp>
 #include <random>
+#include <cmath>
+#include <cfloat>
 #ifdef BOOST_HAS_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 using boost::multiprecision::float128;
@@ -17,6 +19,7 @@ using boost::math::tools::cubic_root_condition_number;
 using boost::math::tools::cubic_root_residual;
 using boost::math::tools::cubic_roots;
 using std::cbrt;
+using std::abs;
 
 template <class Real> void test_zero_coefficients() {
     Real a = 0;
@@ -96,7 +99,7 @@ template <class Real> void test_zero_coefficients() {
 
         auto roots = cubic_roots(a, b, c, d);
         // I could check the condition number here, but this is fine right?
-        if (!CHECK_ULP_CLOSE(r[0], roots[0], 25)) {
+        if (!CHECK_ULP_CLOSE(r[0], roots[0], (std::numeric_limits<Real>::digits > 100 ? 120 : 25))) {
             std::cerr << "  Polynomial x^3 + " << b << "x^2 + " << c << "x + "
                       << d << " has roots {";
             std::cerr << r[0] << ", " << r[1] << ", " << r[2]
@@ -105,7 +108,7 @@ template <class Real> void test_zero_coefficients() {
                       << "}\n";
         }
         CHECK_ULP_CLOSE(r[1], roots[1], 25);
-        CHECK_ULP_CLOSE(r[2], roots[2], 25);
+        CHECK_ULP_CLOSE(r[2], roots[2], (std::numeric_limits<Real>::digits > 100 ? 120 : 25));
         for (auto root : roots) {
             auto res = cubic_root_residual(a, b, c, d, root);
             CHECK_LE(abs(res[0]), res[1]);

diff --git a/test/daubechies_scaling_test.cpp b/test/daubechies_scaling_test.cpp
@@ -33,6 +33,8 @@ using std::sqrt;
 template<class Real, unsigned p>
 void test_daubechies_filters()
 {
+    using std::sqrt;
+
     std::cout << "Testing Daubechies filters with " << p << " vanishing moments on type " << boost::core::demangle(typeid(Real).name()) << "\n";
     Real tol = 3*std::numeric_limits<Real>::epsilon();
     using boost::math::filters::daubechies_scaling_filter;
@@ -287,6 +289,9 @@ void test_dyadic_grid()
 // "Direct algorithm for computation of derivatives of the Daubechies basis functions"
 void test_first_derivative()
 {
+#if LDBL_MANT_DIG > 64
+   // Limited precision test data means we can't test long double here...
+#else
     auto phi1_3 = boost::math::detail::daubechies_scaling_integer_grid<long double, 3, 1>();
     std::array<long double, 6> lin_3{0.0L, 1.638452340884085725014976L, -2.232758190463137395017742L,
                                      0.5501593582740176149905562L, 0.04414649130503405501220997L, 0.0L};
@@ -320,6 +325,7 @@ void test_first_derivative()
             std::cerr << "  Index " << i << " is incorrect\n";
         }
     }
+#endif
 }
 
 template<typename Real, int p>

diff --git a/test/exp_sinh_quadrature_test.cpp b/test/exp_sinh_quadrature_test.cpp
@@ -192,8 +192,8 @@ void test_right_limit_infinite()
     Q_expected = root_pi<Real>();
     Real tol_mult = 1;
     // Multiprecision type have higher error rates, probably evaluation of f() is less accurate:
-    if (std::numeric_limits<Real>::digits10 > std::numeric_limits<long double>::digits10)
-       tol_mult = 12;
+    if (!std::numeric_limits<Real>::digits10 || (std::numeric_limits<Real>::digits10 > 25))
+       tol_mult = 1200;
     else if (std::numeric_limits<Real>::digits10 > std::numeric_limits<double>::digits10)
        tol_mult = 5;
     BOOST_CHECK_CLOSE_FRACTION(Q, Q_expected, tol * tol_mult);
@@ -322,10 +322,8 @@ void test_nr_examples()
     Q = integrator.integrate(f2, get_convergence_tolerance<Real>(), &error, &L1);
     Q_expected = half<Real>()*boost::math::tgamma((Real) 5/ (Real) 14);
     tol_mul = 1;
-    if (std::numeric_limits<Real>::is_specialized == false)
-       tol_mul = 6;
-    else if (std::numeric_limits<Real>::digits10 > 40)
-       tol_mul = 100;
+    if ((std::numeric_limits<Real>::is_specialized == false) || (std::numeric_limits<Real>::digits10 > 40))
+       tol_mul = 500;
     else
        tol_mul = 3;
     BOOST_CHECK_CLOSE_FRACTION(Q, Q_expected, tol_mul * tol);
@@ -425,7 +423,7 @@ void test_crc()
        Q = integrator.integrate(f3, get_convergence_tolerance<Real>(), &error, &L1);
        Q_expected = s/(a*a+s*s);
        if (std::numeric_limits<Real>::digits10 > std::numeric_limits<double>::digits10)
-          tol_mult = 5000; // we should really investigate this more??
+          tol_mult = 500000; // we should really investigate this more??
        BOOST_CHECK_CLOSE_FRACTION(Q, Q_expected, tol_mult*tol);
     }
 
@@ -448,8 +446,8 @@ void test_crc()
        Q_expected = 1 / sqrt(1 + s*s);
        tol_mult = 3;
        // Multiprecision type have higher error rates, probably evaluation of f() is less accurate:
-       if (std::numeric_limits<Real>::digits10 > std::numeric_limits<long double>::digits10)
-          tol_mult = 750;
+       if ((std::numeric_limits<Real>::digits10 > std::numeric_limits<long double>::digits10) || (std::numeric_limits<Real>::digits > 100) || !std::numeric_limits<Real>::digits)
+          tol_mult = 50000;
        BOOST_CHECK_CLOSE_FRACTION(Q, Q_expected, tol_mult * tol);
     }
     auto f6 = [](const Real& t)->Real { return t > boost::math::tools::log_max_value<Real>() ? Real(0) : Real(exp(-t*t)*log(t));};

diff --git a/test/float128/test_factorials.cpp b/test/float128/test_factorials.cpp
@@ -24,6 +24,8 @@
   using std::cout;
   using std::endl;
 
+#if LDBL_MANT_DIG != 113
+
 template <class T>
 T naive_falling_factorial(T x, unsigned n)
 {
@@ -284,12 +286,15 @@ void test_spots(T)
       i += 10;
    }
 } // template <class T> void test_spots(T)
+#endif
 
 BOOST_AUTO_TEST_CASE( test_main )
 {
    BOOST_MATH_CONTROL_FP;
+#if LDBL_MANT_DIG != 113
    test_spots(0.0Q);
    cout << "max factorial for __float128"  << boost::math::max_factorial<boost::floatmax_t>::value  << endl;
+#endif
 }
 
 

diff --git a/test/float128/test_std_lib.cpp b/test/float128/test_std_lib.cpp
@@ -261,11 +261,11 @@ BOOST_AUTO_TEST_CASE( test_main )
    BOOST_CHECK_CLOSE_FRACTION(imag(exp(cm)), BOOST_FLOATMAX_C(-4.27341455284486523762268047763120025488336663280501044879428), tol);
    BOOST_CHECK_CLOSE_FRACTION(real(log(cm)), BOOST_FLOATMAX_C(1.45888536604213956747543177478663529791228872640369045476212), tol);
    BOOST_CHECK_CLOSE_FRACTION(imag(log(cm)), BOOST_FLOATMAX_C(0.95054684081207514789478913546381917504767901030880427426177), tol);
-   BOOST_CHECK_CLOSE_FRACTION(real(pow(cm, cm)), BOOST_FLOATMAX_C(0.500085941796692509786065254311643761781309406813392318413211), 3 * tol);
+   BOOST_CHECK_CLOSE_FRACTION(real(pow(cm, cm)), BOOST_FLOATMAX_C(0.500085941796692509786065254311643761781309406813392318413211), 5 * tol);
    BOOST_CHECK_CLOSE_FRACTION(imag(pow(cm, cm)), BOOST_FLOATMAX_C(1.2835619023632800631240903890826362708871896445947786884), tol);
    BOOST_CHECK_CLOSE_FRACTION(real(pow(cm, 45)), BOOST_FLOATMAX_C(1.15295630001810518909457669488131135702133178710937500000000e28), tol);
    BOOST_CHECK_CLOSE_FRACTION(imag(pow(cm, 45)), BOOST_FLOATMAX_C(-3.03446103291767290317331113291188915967941284179687500000000e28), tol);
-   BOOST_CHECK_CLOSE_FRACTION(real(pow(cm, BOOST_FLOATMAX_C(-6.25))), BOOST_FLOATMAX_C(0.0001033088262386741675929555572265687059620746178809486273109638), tol);
+   BOOST_CHECK_CLOSE_FRACTION(real(pow(cm, BOOST_FLOATMAX_C(-6.25))), BOOST_FLOATMAX_C(0.0001033088262386741675929555572265687059620746178809486273109638), tol * 2);
    BOOST_CHECK_CLOSE_FRACTION(imag(pow(cm, BOOST_FLOATMAX_C(-6.25))), BOOST_FLOATMAX_C(0.000036807924520680371147635577932953977554657684086220380643819), 10*tol);
 
    // N[(25/10)^((25/10)+((35/10) I)), 64]

diff --git a/test/gauss_kronrod_quadrature_test.cpp b/test/gauss_kronrod_quadrature_test.cpp
@@ -476,6 +476,7 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_complex_lambert_w<std::complex<long double>>();
 #endif
 #ifdef TEST1A
+#if LDBL_MANT_DIG < 100 // If we have too many digits in a long double, we get build errors due to a constexpr issue.
     std::cout << "Testing 21 point approximation:\n";
     test_linear<cpp_bin_float_quad, 21>();
     test_quadratic<cpp_bin_float_quad, 21>();
@@ -494,7 +495,9 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 31>();
     test_left_limit_infinite<cpp_bin_float_quad, 31>();
 #endif
+#endif
 #ifdef TEST2
+#if LDBL_MANT_DIG < 100 // If we have too many digits in a long double, we get build errors due to a constexpr issue.
     std::cout << "Testing 41 point approximation:\n";
     test_linear<cpp_bin_float_quad, 41>();
     test_quadratic<cpp_bin_float_quad, 41>();
@@ -513,6 +516,7 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 51>();
     test_left_limit_infinite<cpp_bin_float_quad, 51>();
 #endif
+#endif
 #ifdef TEST3
     // Need at least one set of tests with expression templates turned on:
     std::cout << "Testing 61 point approximation:\n";
@@ -524,9 +528,11 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_dec_float_50, 61>();
     test_left_limit_infinite<cpp_dec_float_50, 61>();
 #ifdef BOOST_HAS_FLOAT128
+#if LDBL_MANT_DIG < 100 // If we have too many digits in a long double, we get build errors due to a constexpr issue.
     test_complex_lambert_w<boost::multiprecision::complex128>();
 #endif
 #endif
+#endif
 }
 
 #else

diff --git a/test/gauss_quadrature_test.cpp b/test/gauss_quadrature_test.cpp
@@ -460,6 +460,7 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<double, 9>();
     test_left_limit_infinite<double, 9>();
 
+#if LDBL_MANT_DIG < 100
     test_linear<cpp_bin_float_quad, 10>();
     test_quadratic<cpp_bin_float_quad, 10>();
     test_ca<cpp_bin_float_quad, 10>();
@@ -468,7 +469,9 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 10>();
     test_left_limit_infinite<cpp_bin_float_quad, 10>();
 #endif
+#endif
 #ifdef TEST2
+#if LDBL_MANT_DIG < 100
     test_linear<cpp_bin_float_quad, 15>();
     test_quadratic<cpp_bin_float_quad, 15>();
     test_ca<cpp_bin_float_quad, 15>();
@@ -501,18 +504,22 @@ BOOST_AUTO_TEST_CASE(gauss_quadrature_test)
     test_right_limit_infinite<cpp_bin_float_quad, 30>();
     test_left_limit_infinite<cpp_bin_float_quad, 30>();
 
-
+#endif
 #endif
 #ifdef TEST3
+#if LDBL_MANT_DIG < 100
     test_left_limit_infinite<cpp_bin_float_quad, 30>();
+#endif
     test_complex_lambert_w<std::complex<double>>();
     test_complex_lambert_w<std::complex<long double>>();
 #ifdef BOOST_HAS_FLOAT128
     test_left_limit_infinite<boost::multiprecision::float128, 30>();
     test_complex_lambert_w<boost::multiprecision::complex128>();
 #endif
+#if LDBL_MANT_DIG < 100
     test_complex_lambert_w<boost::multiprecision::cpp_complex_quad>();
 #endif
+#endif
 }
 
 #else