First draft of promotion

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;