C++23 Floats

include/boost/math/distributions/beta.hpp

@@ -2,6 +2,7 @@
 
 // Copyright John Maddock 2006.
 // Copyright Paul A. Bristow 2006.
+// Copyright Matt Borland 2023.
 
 // Use, modification and distribution are subject to the
 // Boost Software License, Version 1.0.
@@ -241,7 +242,7 @@ namespace boost
         {
           return result;
         }
-        return ibeta_inva(beta, x, probability, Policy());
+        return static_cast<RealType>(ibeta_inva(beta, x, probability, Policy()));
       } // RealType find_alpha(beta, a, probability)
 
       static RealType find_beta(
@@ -264,7 +265,7 @@ namespace boost
         {
           return result;
         }
-        return ibeta_invb(alpha, x, probability, Policy());
+        return static_cast<RealType>(ibeta_invb(alpha, x, probability, Policy()));
       } //  RealType find_beta(alpha, x, probability)
 
     private:
@@ -396,7 +397,7 @@ namespace boost
       {
         if (a == 1)
         {
-          return 1 / beta(a, b);
+          return static_cast<RealType>(1 / beta(a, b));
         }
         else if (a < 1)
         {
@@ -411,7 +412,7 @@ namespace boost
       {
         if (b == 1)
         {
-          return 1 / beta(a, b);
+          return static_cast<RealType>(1 / beta(a, b));
         }
         else if (b < 1)
         {
@@ -423,7 +424,7 @@ namespace boost
         }
       }
 
-      return ibeta_derivative(a, b, x, Policy());
+      return static_cast<RealType>(ibeta_derivative(a, b, x, Policy()));
     } // pdf
 
     template <class RealType, class Policy>
@@ -454,7 +455,7 @@ namespace boost
       {
         return 1;
       }
-      return ibeta(a, b, x, Policy());
+      return static_cast<RealType>(ibeta(a, b, x, Policy()));
     } // beta cdf
 
     template <class RealType, class Policy>
@@ -481,16 +482,16 @@ namespace boost
       }
       if (x == 0)
       {
-        return 1;
+        return RealType(1);
       }
       else if (x == 1)
       {
-        return 0;
+        return RealType(0);
       }
       // Calculate cdf beta using the incomplete beta function.
       // Use of ibeta here prevents cancellation errors in calculating
       // 1 - x if x is very small, perhaps smaller than machine epsilon.
-      return ibetac(a, b, x, Policy());
+      return static_cast<RealType>(ibetac(a, b, x, Policy()));
     } // beta cdf
 
     template <class RealType, class Policy>
@@ -519,13 +520,13 @@ namespace boost
       // Special cases:
       if (p == 0)
       {
-        return 0;
+        return RealType(0);
       }
       if (p == 1)
       {
-        return 1;
+        return RealType(1);
       }
-      return ibeta_inv(a, b, p, static_cast<RealType*>(nullptr), Policy());
+      return static_cast<RealType>(ibeta_inv(a, b, p, static_cast<RealType*>(nullptr), Policy()));
     } // quantile
 
     template <class RealType, class Policy>
@@ -555,14 +556,14 @@ namespace boost
       // Special cases:
       if(q == 1)
       {
-        return 0;
+        return RealType(0);
       }
       if(q == 0)
       {
-        return 1;
+        return RealType(1);
       }
 
-      return ibetac_inv(a, b, q, static_cast<RealType*>(nullptr), Policy());
+      return static_cast<RealType>(ibetac_inv(a, b, q, static_cast<RealType*>(nullptr), Policy()));
     } // Quantile Complement
 
   } // namespace math

include/boost/math/special_functions/beta.hpp

@@ -1501,8 +1501,9 @@ template <class RT1, class RT2, class A>
 inline typename tools::promote_args<RT1, RT2, A>::type
    beta(RT1 a, RT2 b, A arg)
 {
-   typedef typename policies::is_policy<A>::type tag;
-   return boost::math::detail::beta(a, b, arg, static_cast<tag*>(nullptr));
+   using tag = typename policies::is_policy<A>::type;
+   using ReturnType = tools::promote_args_t<RT1, RT2, A>;
+   return static_cast<ReturnType>(boost::math::detail::beta(a, b, arg, static_cast<tag*>(nullptr)));
 }
 
 template <class RT1, class RT2>

include/boost/math/special_functions/log1p.hpp

@@ -136,24 +136,24 @@ T log1p_imp(T const& x, const Policy& pol, const std::integral_constant<int, 53>
    // Maximum Relative Change in Control Points:   8.138e-004
    // Max Error found at double precision =        3.250766e-016
    static const T P[] = {
-       0.15141069795941984e-16L,
-       0.35495104378055055e-15L,
-       0.33333333333332835L,
-       0.99249063543365859L,
-       1.1143969784156509L,
-       0.58052937949269651L,
-       0.13703234928513215L,
-       0.011294864812099712L
+       static_cast<T>(0.15141069795941984e-16L),
+       static_cast<T>(0.35495104378055055e-15L),
+       static_cast<T>(0.33333333333332835L),
+       static_cast<T>(0.99249063543365859L),
+       static_cast<T>(1.1143969784156509L),
+       static_cast<T>(0.58052937949269651L),
+       static_cast<T>(0.13703234928513215L),
+       static_cast<T>(0.011294864812099712L)
      };
    static const T Q[] = {
-       1L,
-       3.7274719063011499L,
-       5.5387948649720334L,
-       4.159201143419005L,
-       1.6423855110312755L,
-       0.31706251443180914L,
-       0.022665554431410243L,
-       -0.29252538135177773e-5L
+       static_cast<T>(1L),
+       static_cast<T>(3.7274719063011499L),
+       static_cast<T>(5.5387948649720334L),
+       static_cast<T>(4.159201143419005L),
+       static_cast<T>(1.6423855110312755L),
+       static_cast<T>(0.31706251443180914L),
+       static_cast<T>(0.022665554431410243L),
+       static_cast<T>(-0.29252538135177773e-5L)
      };
 
    T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x);

include/boost/math/tools/promotion.hpp

@@ -2,6 +2,7 @@
 
 // Copyright John Maddock 2006.
 // Copyright Paul A. Bristow 2006.
+// Copyright Matt Borland 2023.
 
 // Use, modification and distribution are subject to the
 // Boost Software License, Version 1.0.
@@ -25,6 +26,10 @@
 #include <boost/math/tools/config.hpp>
 #include <type_traits>
 
+#if __has_include(<stdfloat>)
+#  include <stdfloat>
+#endif
+
 namespace boost
 {
   namespace math
@@ -63,6 +68,19 @@ namespace boost
       template <> struct promote_arg<long double> { using type = long double; };
       template <> struct promote_arg<int> {  using type = double; };
 
+      #ifdef __STDCPP_FLOAT16_T__
+      template <> struct promote_arg<std::float16_t> { using type = std::float16_t; };
+      #endif
+      #ifdef __STDCPP_FLOAT32_T__
+      template <> struct promote_arg<std::float32_t> { using type = std::float32_t; };
+      #endif
+      #ifdef __STDCPP_FLOAT64_T__
+      template <> struct promote_arg<std::float64_t> { using type = std::float64_t; };
+      #endif
+      #ifdef __STDCPP_FLOAT128_T__
+      template <> struct promote_arg<std::float128_t> { using type = std::float128_t; };
+      #endif
+
       template <typename T>
       using promote_arg_t = typename promote_arg<T>::type;
 
@@ -78,14 +96,35 @@ namespace boost
 #ifdef BOOST_MATH_USE_FLOAT128
            typename std::conditional<std::is_same<__float128, T1P>::value || std::is_same<__float128, T2P>::value, // either long double?
             __float128,
-#endif
+#endif 
+#ifdef __STDCPP_FLOAT128_T__
+           typename std::conditional<std::is_same<std::float128_t, T1P>::value || std::is_same<std::float128_t, T2P>::value, // either long double?
+            std::float128_t,
+#endif 
              typename std::conditional<std::is_same<long double, T1P>::value || std::is_same<long double, T2P>::value, // either long double?
                long double, // then result type is long double.
+#ifdef __STDCPP_FLOAT64_T__
+             typename std::conditional<std::is_same<std::float64_t, T1P>::value || std::is_same<std::float64_t, T2P>::value, // either float64?
+               std::float64_t, // then result type is float64_t.
+#endif
                typename std::conditional<std::is_same<double, T1P>::value || std::is_same<double, T2P>::value, // either double?
                   double, // result type is double.
+#ifdef __STDCPP_FLOAT32_T__
+             typename std::conditional<std::is_same<std::float32_t, T1P>::value || std::is_same<std::float32_t, T2P>::value, // either float32?
+               std::float32_t, // then result type is float32_t.
+#endif
                   float // else result type is float.
              >::type
 #ifdef BOOST_MATH_USE_FLOAT128
+             >::type,
+#endif
+#ifdef __STDCPP_FLOAT128_T__
+             >::type
+#endif
+#ifdef __STDCPP_FLOAT64_T__
+             >::type
+#endif
+#ifdef __STDCPP_FLOAT32_T__
              >::type
 #endif
              >::type,
@@ -111,6 +150,88 @@ namespace boost
       template <> struct promote_args_2<double, long double> {  using type = long double; };
       template <> struct promote_args_2<long double, double> {  using type = long double; };
 
+      #ifdef __STDCPP_FLOAT128_T__
+      template <> struct promote_args_2<int, std::float128_t> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float128_t, int> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float128_t, float> { using type = std::float128_t; };
+      template <> struct promote_args_2<float, std::float128_t> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float128_t, double> { using type = std::float128_t; };
+      template <> struct promote_args_2<double, std::float128_t> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float128_t, long double> { using type = std::float128_t; };
+      template <> struct promote_args_2<long double, std::float128_t> { using type = std::float128_t; };
+
+      #ifdef __STDCPP_FLOAT16_T__
+      template <> struct promote_args_2<std::float128_t, std::float16_t> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float16_t, std::float128_t> { using type = std::float128_t; };
+      #endif
+
+      #ifdef __STDCPP_FLOAT32_T__
+      template <> struct promote_args_2<std::float128_t, std::float32_t> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float32_t, std::float128_t> { using type = std::float128_t; };
+      #endif
+
+      #ifdef __STDCPP_FLOAT64_T__
+      template <> struct promote_args_2<std::float128_t, std::float64_t> { using type = std::float128_t; };
+      template <> struct promote_args_2<std::float64_t, std::float128_t> { using type = std::float128_t; };
+      #endif
+
+      template <> struct promote_args_2<std::float128_t, std::float128_t> { using type = std::float128_t; };
+      #endif
+
+      #ifdef __STDCPP_FLOAT64_T__
+      template <> struct promote_args_2<int, std::float64_t> { using type = std::float64_t; };
+      template <> struct promote_args_2<std::float64_t, int> { using type = std::float64_t; };
+      template <> struct promote_args_2<std::float64_t, float> { using type = std::float64_t; };
+      template <> struct promote_args_2<float, std::float64_t> { using type = std::float64_t; };
+      template <> struct promote_args_2<std::float64_t, double> { using type = std::float64_t; };
+      template <> struct promote_args_2<double, std::float64_t> { using type = std::float64_t; };
+      template <> struct promote_args_2<std::float64_t, long double> { using type = long double; };
+      template <> struct promote_args_2<long double, std::float64_t> { using type = long double; };
+
+      #ifdef __STDCPP_FLOAT16_T__
+      template <> struct promote_args_2<std::float64_t, std::float16_t> { using type = std::float64_t; };
+      template <> struct promote_args_2<std::float16_t, std::float64_t> { using type = std::float64_t; };
+      #endif
+
+      #ifdef __STDCPP_FLOAT32_T__
+      template <> struct promote_args_2<std::float64_t, std::float32_t> { using type = std::float64_t; };
+      template <> struct promote_args_2<std::float32_t, std::float64_t> { using type = std::float64_t; };
+      #endif
+
+      template <> struct promote_args_2<std::float64_t, std::float64_t> { using type = std::float64_t; };
+      #endif
+
+      #ifdef __STDCPP_FLOAT32_T__
+      template <> struct promote_args_2<int, std::float32_t> { using type = std::float32_t; };
+      template <> struct promote_args_2<std::float32_t, int> { using type = std::float32_t; };
+      template <> struct promote_args_2<std::float32_t, float> { using type = std::float32_t; };
+      template <> struct promote_args_2<float, std::float32_t> { using type = std::float32_t; };
+      template <> struct promote_args_2<std::float32_t, double> { using type = double; };
+      template <> struct promote_args_2<double, std::float32_t> { using type = double; };
+      template <> struct promote_args_2<std::float32_t, long double> { using type = long double; };
+      template <> struct promote_args_2<long double, std::float32_t> { using type = long double; };
+
+      #ifdef __STDCPP_FLOAT16_T__
+      template <> struct promote_args_2<std::float32_t, std::float16_t> { using type = std::float32_t; };
+      template <> struct promote_args_2<std::float16_t, std::float32_t> { using type = std::float32_t; };
+      #endif
+
+      template <> struct promote_args_2<std::float32_t, std::float32_t> { using type = std::float64_t; };
+      #endif
+
+      #ifdef __STDCPP_FLOAT16_T__
+      template <> struct promote_args_2<int, std::float16_t> { using type = std::float16_t; };
+      template <> struct promote_args_2<std::float16_t, int> { using type = std::float16_t; };
+      template <> struct promote_args_2<std::float16_t, float> { using type = float; };
+      template <> struct promote_args_2<float, std::float16_t> { using type = float; };
+      template <> struct promote_args_2<std::float16_t, double> { using type = double; };
+      template <> struct promote_args_2<double, std::float16_t> { using type = double; };
+      template <> struct promote_args_2<std::float16_t, long double> { using type = long double; };
+      template <> struct promote_args_2<long double, std::float16_t> { using type = long double; };
+
+      template <> struct promote_args_2<std::float16_t, std::float16_t> { using type = std::float16_t; };
+      #endif
+
       template <typename T, typename U>
       using promote_args_2_t = typename promote_args_2<T, U>::type;
 

test/test_beta_dist.cpp

@@ -52,6 +52,10 @@ using std::endl;
 #include <limits>
 using std::numeric_limits;
 
+#if __has_include(<stdfloat>)
+# include <stdfloat>
+#endif
+
 template <class RealType>
 void test_spot(
      RealType a,    // alpha a
@@ -135,6 +139,14 @@ void test_spots(RealType)
    cout << "epsilon = " << tolerance;
 
    tolerance *= 100000; // Note: NO * 100 because is fraction, NOT %.
+
+   #ifdef __STDCPP_FLOAT16_T__
+   if constexpr (std::is_same_v<RealType, std::float16_t>)
+   {
+      tolerance *= 100;
+   }
+   #endif
+
    cout  << ", Tolerance = " << tolerance * 100 << "%." << endl;
 
   // RealType teneps = boost::math::tools::epsilon<RealType>() * 10;
@@ -527,7 +539,14 @@ void test_spots(RealType)
    } // has_infinity
 
    // Error handling checks:
+   #ifdef __STDCPP_FLOAT16_T__
+   if constexpr (!std::is_same_v<std::float16_t, RealType>)
+   {
+      check_out_of_range<boost::math::beta_distribution<RealType> >(1, 1); // (All) valid constructor parameter values.
+   }
+   #else
    check_out_of_range<boost::math::beta_distribution<RealType> >(1, 1); // (All) valid constructor parameter values.
+   #endif
    // and range and non-finite.
 
    // Not needed??????
@@ -631,6 +650,17 @@ BOOST_AUTO_TEST_CASE( test_main )
    test_spots(boost::math::concepts::real_concept(0.)); // Test real concept.
 #endif
 #endif
+
+#ifdef __STDCPP_FLOAT64_T__
+   test_spots(0.0F64);
+#endif
+#ifdef __STDCPP_FLOAT32_T__
+   test_spots(0.0F32);
+#endif
+#ifdef __STDCPP_FLOAT16_T__
+   test_spots(0.0F16);
+#endif
+
 } // BOOST_AUTO_TEST_CASE( test_main )
 
 /*