Update contrib/restricted/boost/math to 1.83.0

5 files changed, 530 insertions, 390 deletions

diff --git a/contrib/restricted/boost/math/README.md b/contrib/restricted/boost/math/README.md
index 6363e01527..07c6c4604b 100644
--- a/contrib/restricted/boost/math/README.md
+++ b/contrib/restricted/boost/math/README.md
@@ -2,8 +2,7 @@ Boost Math Library
 [![Build Status](https://drone.cpp.al/api/badges/boostorg/math/status.svg)](https://drone.cpp.al/boostorg/math)[![Build Status](https://github.com/boostorg/math/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/math/actions)
 ==================
 
->ANNOUNCEMENT: Support for C++11 will be deprecated in this library starting in July 2023 (Boost 1.82).  
->New features will require *at least* C++14, as will existing features starting with the deprecation release.
+>ANNOUNCEMENT: This library now requires a compliant C++14 compiler.
 
 This library is divided into several interconnected parts:
 
diff --git a/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp b/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp
index 6f9d739e1e..7b99651402 100644
--- a/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp
@@ -39,111 +39,111 @@ namespace boost
 
    // Beta functions.
    template <class RT1, class RT2>
-   typename tools::promote_args<RT1, RT2>::type
+   tools::promote_args_t<RT1, RT2>
          beta(RT1 a, RT2 b); // Beta function (2 arguments).
 
    template <class RT1, class RT2, class A>
-   typename tools::promote_args<RT1, RT2, A>::type
+   tools::promote_args_t<RT1, RT2, A>
          beta(RT1 a, RT2 b, A x); // Beta function (3 arguments).
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          beta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Beta function (3 arguments).
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          betac(RT1 a, RT2 b, RT3 x);
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          betac(RT1 a, RT2 b, RT3 x, const Policy& pol);
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta(RT1 a, RT2 b, RT3 x); // Incomplete beta function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta function.
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac(RT1 a, RT2 b, RT3 x); // Incomplete beta complement function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta complement function.
 
    template <class T1, class T2, class T3, class T4>
-   typename tools::promote_args<T1, T2, T3, T4>::type
+   tools::promote_args_t<T1, T2, T3, T4>
          ibeta_inv(T1 a, T2 b, T3 p, T4* py);
 
    template <class T1, class T2, class T3, class T4, class Policy>
-   typename tools::promote_args<T1, T2, T3, T4>::type
+   tools::promote_args_t<T1, T2, T3, T4>
          ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol);
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_inv(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_inva(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_invb(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
 
    template <class T1, class T2, class T3, class T4>
-   typename tools::promote_args<T1, T2, T3, T4>::type
+   tools::promote_args_t<T1, T2, T3, T4>
          ibetac_inv(T1 a, T2 b, T3 q, T4* py);
 
    template <class T1, class T2, class T3, class T4, class Policy>
-   typename tools::promote_args<T1, T2, T3, T4>::type
+   tools::promote_args_t<T1, T2, T3, T4>
          ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol);
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac_inv(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac_inva(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac_invb(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
 
    template <class RT1, class RT2, class RT3>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_derivative(RT1 a, RT2 b, RT3 x);  // derivative of incomplete beta
 
    template <class RT1, class RT2, class RT3, class Policy>
-   typename tools::promote_args<RT1, RT2, RT3>::type
+   tools::promote_args_t<RT1, RT2, RT3>
          ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol);  // derivative of incomplete beta
 
    // Binomial:
@@ -154,35 +154,35 @@ namespace boost
 
    // erf & erfc error functions.
    template <class RT> // Error function.
-   typename tools::promote_args<RT>::type erf(RT z);
+   tools::promote_args_t<RT> erf(RT z);
    template <class RT, class Policy> // Error function.
-   typename tools::promote_args<RT>::type erf(RT z, const Policy&);
+   tools::promote_args_t<RT> erf(RT z, const Policy&);
 
    template <class RT>// Error function complement.
-   typename tools::promote_args<RT>::type erfc(RT z);
+   tools::promote_args_t<RT> erfc(RT z);
    template <class RT, class Policy>// Error function complement.
-   typename tools::promote_args<RT>::type erfc(RT z, const Policy&);
+   tools::promote_args_t<RT> erfc(RT z, const Policy&);
 
    template <class RT>// Error function inverse.
-   typename tools::promote_args<RT>::type erf_inv(RT z);
+   tools::promote_args_t<RT> erf_inv(RT z);
    template <class RT, class Policy>// Error function inverse.
-   typename tools::promote_args<RT>::type erf_inv(RT z, const Policy& pol);
+   tools::promote_args_t<RT> erf_inv(RT z, const Policy& pol);
 
    template <class RT>// Error function complement inverse.
-   typename tools::promote_args<RT>::type erfc_inv(RT z);
+   tools::promote_args_t<RT> erfc_inv(RT z);
    template <class RT, class Policy>// Error function complement inverse.
-   typename tools::promote_args<RT>::type erfc_inv(RT z, const Policy& pol);
+   tools::promote_args_t<RT> erfc_inv(RT z, const Policy& pol);
 
    // Polynomials:
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1);
 
    template <class T>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
          legendre_p(int l, T x);
    template <class T>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
           legendre_p_prime(int l, T x);
 
 
@@ -193,46 +193,46 @@ namespace boost
    inline std::vector<T> legendre_p_zeros(int l);
 
    template <class T, class Policy>
-   typename std::enable_if<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
+   typename std::enable_if<policies::is_policy<Policy>::value, tools::promote_args_t<T>>::type
          legendre_p(int l, T x, const Policy& pol);
    template <class T, class Policy>
-   inline typename std::enable_if<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
+   inline typename std::enable_if<policies::is_policy<Policy>::value, tools::promote_args_t<T>>::type
       legendre_p_prime(int l, T x, const Policy& pol);
 
    template <class T>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
          legendre_q(unsigned l, T x);
 
    template <class T, class Policy>
-   typename std::enable_if<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
+   typename std::enable_if<policies::is_policy<Policy>::value, tools::promote_args_t<T>>::type
          legendre_q(unsigned l, T x, const Policy& pol);
 
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);
 
    template <class T>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
          legendre_p(int l, int m, T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
          legendre_p(int l, int m, T x, const Policy& pol);
 
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1);
 
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
       laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1);
 
    template <class T>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
       laguerre(unsigned n, T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
       laguerre(unsigned n, unsigned m, T x, const Policy& pol);
 
    template <class T1, class T2>
@@ -250,144 +250,144 @@ namespace boost
       laguerre(unsigned n, T1 m, T2 x);
 
    template <class T>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
       hermite(unsigned n, T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type
+   tools::promote_args_t<T>
       hermite(unsigned n, T x, const Policy& pol);
 
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
       hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);
 
    template<class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type chebyshev_next(T1 const & x, T2 const & Tn, T3 const & Tn_1);
+   tools::promote_args_t<T1, T2, T3> chebyshev_next(T1 const & x, T2 const & Tn, T3 const & Tn_1);
 
    template <class Real, class Policy>
-   typename tools::promote_args<Real>::type
+   tools::promote_args_t<Real>
       chebyshev_t(unsigned n, Real const & x, const Policy&);
    template<class Real>
-   typename tools::promote_args<Real>::type chebyshev_t(unsigned n, Real const & x);
+   tools::promote_args_t<Real> chebyshev_t(unsigned n, Real const & x);
    
    template <class Real, class Policy>
-   typename tools::promote_args<Real>::type
+   tools::promote_args_t<Real>
       chebyshev_u(unsigned n, Real const & x, const Policy&);
    template<class Real>
-   typename tools::promote_args<Real>::type chebyshev_u(unsigned n, Real const & x);
+   tools::promote_args_t<Real> chebyshev_u(unsigned n, Real const & x);
 
    template <class Real, class Policy>
-   typename tools::promote_args<Real>::type
+   tools::promote_args_t<Real>
       chebyshev_t_prime(unsigned n, Real const & x, const Policy&);
    template<class Real>
-   typename tools::promote_args<Real>::type chebyshev_t_prime(unsigned n, Real const & x);
+   tools::promote_args_t<Real> chebyshev_t_prime(unsigned n, Real const & x);
 
    template<class Real, class T2>
    Real chebyshev_clenshaw_recurrence(const Real* const c, size_t length, const T2& x);
 
    template <class T1, class T2>
-   std::complex<typename tools::promote_args<T1, T2>::type>
+   std::complex<tools::promote_args_t<T1, T2>>
          spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);
 
    template <class T1, class T2, class Policy>
-   std::complex<typename tools::promote_args<T1, T2>::type>
+   std::complex<tools::promote_args_t<T1, T2>>
       spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
       spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
       spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
 
    // Elliptic integrals:
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          ellint_rf(T1 x, T2 y, T3 z);
 
    template <class T1, class T2, class T3, class Policy>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          ellint_rf(T1 x, T2 y, T3 z, const Policy& pol);
 
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          ellint_rd(T1 x, T2 y, T3 z);
 
    template <class T1, class T2, class T3, class Policy>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
          ellint_rd(T1 x, T2 y, T3 z, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          ellint_rc(T1 x, T2 y);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          ellint_rc(T1 x, T2 y, const Policy& pol);
 
    template <class T1, class T2, class T3, class T4>
-   typename tools::promote_args<T1, T2, T3, T4>::type
+   tools::promote_args_t<T1, T2, T3, T4>
          ellint_rj(T1 x, T2 y, T3 z, T4 p);
 
    template <class T1, class T2, class T3, class T4, class Policy>
-   typename tools::promote_args<T1, T2, T3, T4>::type
+   tools::promote_args_t<T1, T2, T3, T4>
          ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);
 
    template <class T1, class T2, class T3>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
       ellint_rg(T1 x, T2 y, T3 z);
 
    template <class T1, class T2, class T3, class Policy>
-   typename tools::promote_args<T1, T2, T3>::type
+   tools::promote_args_t<T1, T2, T3>
       ellint_rg(T1 x, T2 y, T3 z, const Policy& pol);
 
    template <typename T>
-   typename tools::promote_args<T>::type ellint_2(T k);
+   tools::promote_args_t<T> ellint_2(T k);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi);
+   tools::promote_args_t<T1, T2> ellint_2(T1 k, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol);
+   tools::promote_args_t<T1, T2> ellint_2(T1 k, T2 phi, const Policy& pol);
 
    template <typename T>
-   typename tools::promote_args<T>::type ellint_1(T k);
+   tools::promote_args_t<T> ellint_1(T k);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi);
+   tools::promote_args_t<T1, T2> ellint_1(T1 k, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi, const Policy& pol);
+   tools::promote_args_t<T1, T2> ellint_1(T1 k, T2 phi, const Policy& pol);
 
    template <typename T>
-   typename tools::promote_args<T>::type ellint_d(T k);
+   tools::promote_args_t<T> ellint_d(T k);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi);
+   tools::promote_args_t<T1, T2> ellint_d(T1 k, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi, const Policy& pol);
+   tools::promote_args_t<T1, T2> ellint_d(T1 k, T2 phi, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi);
+   tools::promote_args_t<T1, T2> jacobi_zeta(T1 k, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi, const Policy& pol);
+   tools::promote_args_t<T1, T2> jacobi_zeta(T1 k, T2 phi, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi);
+   tools::promote_args_t<T1, T2> heuman_lambda(T1 k, T2 phi);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi, const Policy& pol);
+   tools::promote_args_t<T1, T2> heuman_lambda(T1 k, T2 phi, const Policy& pol);
 
    namespace detail{
 
@@ -396,8 +396,8 @@ namespace boost
    {
       using type = typename std::conditional<
          policies::is_policy<V>::value,
-         typename tools::promote_args<T, U>::type,
-         typename tools::promote_args<T, U, V>::type
+         tools::promote_args_t<T, U>,
+         tools::promote_args_t<T, U, V>
       >::type;
    };
 
@@ -408,10 +408,10 @@ namespace boost
    typename detail::ellint_3_result<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi);
 
    template <class T1, class T2, class T3, class Policy>
-   typename tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);
+   tools::promote_args_t<T1, T2, T3> ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v);
+   tools::promote_args_t<T1, T2> ellint_3(T1 k, T2 v);
 
    // Factorial functions.
    // Note: not for integral types, at present.
@@ -429,211 +429,211 @@ namespace boost
    RT double_factorial(unsigned i, const Policy& pol);
 
    template <class RT>
-   typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n);
+   tools::promote_args_t<RT> falling_factorial(RT x, unsigned n);
 
    template <class RT, class Policy>
-   typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n, const Policy& pol);
+   tools::promote_args_t<RT> falling_factorial(RT x, unsigned n, const Policy& pol);
 
    template <class RT>
-   typename tools::promote_args<RT>::type rising_factorial(RT x, int n);
+   tools::promote_args_t<RT> rising_factorial(RT x, int n);
 
    template <class RT, class Policy>
-   typename tools::promote_args<RT>::type rising_factorial(RT x, int n, const Policy& pol);
+   tools::promote_args_t<RT> rising_factorial(RT x, int n, const Policy& pol);
 
    // Gamma functions.
    template <class RT>
-   typename tools::promote_args<RT>::type tgamma(RT z);
+   tools::promote_args_t<RT> tgamma(RT z);
 
    template <class RT>
-   typename tools::promote_args<RT>::type tgamma1pm1(RT z);
+   tools::promote_args_t<RT> tgamma1pm1(RT z);
 
    template <class RT, class Policy>
-   typename tools::promote_args<RT>::type tgamma1pm1(RT z, const Policy& pol);
+   tools::promote_args_t<RT> tgamma1pm1(RT z, const Policy& pol);
 
    template <class RT1, class RT2>
-   typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z);
+   tools::promote_args_t<RT1, RT2> tgamma(RT1 a, RT2 z);
 
    template <class RT1, class RT2, class Policy>
-   typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z, const Policy& pol);
+   tools::promote_args_t<RT1, RT2> tgamma(RT1 a, RT2 z, const Policy& pol);
 
    template <class RT>
-   typename tools::promote_args<RT>::type lgamma(RT z, int* sign);
+   tools::promote_args_t<RT> lgamma(RT z, int* sign);
 
    template <class RT, class Policy>
-   typename tools::promote_args<RT>::type lgamma(RT z, int* sign, const Policy& pol);
+   tools::promote_args_t<RT> lgamma(RT z, int* sign, const Policy& pol);
 
    template <class RT>
-   typename tools::promote_args<RT>::type lgamma(RT x);
+   tools::promote_args_t<RT> lgamma(RT x);
 
    template <class RT, class Policy>
-   typename tools::promote_args<RT>::type lgamma(RT x, const Policy& pol);
+   tools::promote_args_t<RT> lgamma(RT x, const Policy& pol);
 
    template <class RT1, class RT2>
-   typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z);
+   tools::promote_args_t<RT1, RT2> tgamma_lower(RT1 a, RT2 z);
 
    template <class RT1, class RT2, class Policy>
-   typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z, const Policy&);
+   tools::promote_args_t<RT1, RT2> tgamma_lower(RT1 a, RT2 z, const Policy&);
 
    template <class RT1, class RT2>
-   typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z);
+   tools::promote_args_t<RT1, RT2> gamma_q(RT1 a, RT2 z);
 
    template <class RT1, class RT2, class Policy>
-   typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z, const Policy&);
+   tools::promote_args_t<RT1, RT2> gamma_q(RT1 a, RT2 z, const Policy&);
 
    template <class RT1, class RT2>
-   typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z);
+   tools::promote_args_t<RT1, RT2> gamma_p(RT1 a, RT2 z);
 
    template <class RT1, class RT2, class Policy>
-   typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z, const Policy&);
+   tools::promote_args_t<RT1, RT2> gamma_p(RT1 a, RT2 z, const Policy&);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta);
+   tools::promote_args_t<T1, T2> tgamma_delta_ratio(T1 z, T2 delta);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta, const Policy&);
+   tools::promote_args_t<T1, T2> tgamma_delta_ratio(T1 z, T2 delta, const Policy&);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b);
+   tools::promote_args_t<T1, T2> tgamma_ratio(T1 a, T2 b);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b, const Policy&);
+   tools::promote_args_t<T1, T2> tgamma_ratio(T1 a, T2 b, const Policy&);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x);
+   tools::promote_args_t<T1, T2> gamma_p_derivative(T1 a, T2 x);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x, const Policy&);
+   tools::promote_args_t<T1, T2> gamma_p_derivative(T1 a, T2 x, const Policy&);
 
    // gamma inverse.
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p);
+   tools::promote_args_t<T1, T2> gamma_p_inv(T1 a, T2 p);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p, const Policy&);
+   tools::promote_args_t<T1, T2> gamma_p_inva(T1 a, T2 p, const Policy&);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p);
+   tools::promote_args_t<T1, T2> gamma_p_inva(T1 a, T2 p);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p, const Policy&);
+   tools::promote_args_t<T1, T2> gamma_p_inv(T1 a, T2 p, const Policy&);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q);
+   tools::promote_args_t<T1, T2> gamma_q_inv(T1 a, T2 q);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q, const Policy&);
+   tools::promote_args_t<T1, T2> gamma_q_inv(T1 a, T2 q, const Policy&);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q);
+   tools::promote_args_t<T1, T2> gamma_q_inva(T1 a, T2 q);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q, const Policy&);
+   tools::promote_args_t<T1, T2> gamma_q_inva(T1 a, T2 q, const Policy&);
 
    // digamma:
    template <class T>
-   typename tools::promote_args<T>::type digamma(T x);
+   tools::promote_args_t<T> digamma(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type digamma(T x, const Policy&);
+   tools::promote_args_t<T> digamma(T x, const Policy&);
 
    // trigamma:
    template <class T>
-   typename tools::promote_args<T>::type trigamma(T x);
+   tools::promote_args_t<T> trigamma(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type trigamma(T x, const Policy&);
+   tools::promote_args_t<T> trigamma(T x, const Policy&);
 
    // polygamma:
    template <class T>
-   typename tools::promote_args<T>::type polygamma(int n, T x);
+   tools::promote_args_t<T> polygamma(int n, T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type polygamma(int n, T x, const Policy&);
+   tools::promote_args_t<T> polygamma(int n, T x, const Policy&);
 
    // Hypotenuse function sqrt(x ^ 2 + y ^ 2).
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          hypot(T1 x, T2 y);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          hypot(T1 x, T2 y, const Policy&);
 
    // cbrt - cube root.
    template <class RT>
-   typename tools::promote_args<RT>::type cbrt(RT z);
+   tools::promote_args_t<RT> cbrt(RT z);
 
    template <class RT, class Policy>
-   typename tools::promote_args<RT>::type cbrt(RT z, const Policy&);
+   tools::promote_args_t<RT> cbrt(RT z, const Policy&);
 
    // log1p is log(x + 1)
    template <class T>
-   typename tools::promote_args<T>::type log1p(T);
+   tools::promote_args_t<T> log1p(T);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type log1p(T, const Policy&);
+   tools::promote_args_t<T> log1p(T, const Policy&);
 
    // log1pmx is log(x + 1) - x
    template <class T>
-   typename tools::promote_args<T>::type log1pmx(T);
+   tools::promote_args_t<T> log1pmx(T);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type log1pmx(T, const Policy&);
+   tools::promote_args_t<T> log1pmx(T, const Policy&);
 
    // Exp (x) minus 1 functions.
    template <class T>
-   typename tools::promote_args<T>::type expm1(T);
+   tools::promote_args_t<T> expm1(T);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type expm1(T, const Policy&);
+   tools::promote_args_t<T> expm1(T, const Policy&);
 
    // Power - 1
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          powm1(const T1 a, const T2 z);
 
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type
+   tools::promote_args_t<T1, T2>
          powm1(const T1 a, const T2 z, const Policy&);
 
    // sqrt(1+x) - 1
    template <class T>
-   typename tools::promote_args<T>::type sqrt1pm1(const T& val);
+   tools::promote_args_t<T> sqrt1pm1(const T& val);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type sqrt1pm1(const T& val, const Policy&);
+   tools::promote_args_t<T> sqrt1pm1(const T& val, const Policy&);
 
    // sinus cardinals:
    template <class T>
-   typename tools::promote_args<T>::type sinc_pi(T x);
+   tools::promote_args_t<T> sinc_pi(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type sinc_pi(T x, const Policy&);
+   tools::promote_args_t<T> sinc_pi(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type sinhc_pi(T x);
+   tools::promote_args_t<T> sinhc_pi(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type sinhc_pi(T x, const Policy&);
+   tools::promote_args_t<T> sinhc_pi(T x, const Policy&);
 
    // inverse hyperbolics:
    template<typename T>
-   typename tools::promote_args<T>::type asinh(T x);
+   tools::promote_args_t<T> asinh(T x);
 
    template<typename T, class Policy>
-   typename tools::promote_args<T>::type asinh(T x, const Policy&);
+   tools::promote_args_t<T> asinh(T x, const Policy&);
 
    template<typename T>
-   typename tools::promote_args<T>::type acosh(T x);
+   tools::promote_args_t<T> acosh(T x);
 
    template<typename T, class Policy>
-   typename tools::promote_args<T>::type acosh(T x, const Policy&);
+   tools::promote_args_t<T> acosh(T x, const Policy&);
 
    template<typename T>
-   typename tools::promote_args<T>::type atanh(T x);
+   tools::promote_args_t<T> atanh(T x);
 
    template<typename T, class Policy>
-   typename tools::promote_args<T>::type atanh(T x, const Policy&);
+   tools::promote_args_t<T> atanh(T x, const Policy&);
 
    namespace detail{
 
@@ -647,7 +647,7 @@ namespace boost
          using result_type = typename std::conditional<
             std::is_integral<T1>::value,
             typename tools::promote_args<T2>::type,
-            typename tools::promote_args<T1, T2>::type
+            tools::promote_args_t<T1, T2>
          >::type;
 
          typedef typename policies::precision<result_type, Policy>::type precision_type;
@@ -798,28 +798,28 @@ namespace boost
    std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_2(T1 v, T2 x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type airy_ai(T x, const Policy&);
+   tools::promote_args_t<T> airy_ai(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type airy_ai(T x);
+   tools::promote_args_t<T> airy_ai(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type airy_bi(T x, const Policy&);
+   tools::promote_args_t<T> airy_bi(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type airy_bi(T x);
+   tools::promote_args_t<T> airy_bi(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type airy_ai_prime(T x, const Policy&);
+   tools::promote_args_t<T> airy_ai_prime(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type airy_ai_prime(T x);
+   tools::promote_args_t<T> airy_ai_prime(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type airy_bi_prime(T x, const Policy&);
+   tools::promote_args_t<T> airy_bi_prime(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type airy_bi_prime(T x);
+   tools::promote_args_t<T> airy_bi_prime(T x);
 
    template <class T>
    T airy_ai_zero(int m);
@@ -856,16 +856,16 @@ namespace boost
                      const Policy&);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type sin_pi(T x, const Policy&);
+   tools::promote_args_t<T> sin_pi(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type sin_pi(T x);
+   tools::promote_args_t<T> sin_pi(T x);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type cos_pi(T x, const Policy&);
+   tools::promote_args_t<T> cos_pi(T x, const Policy&);
 
    template <class T>
-   typename tools::promote_args<T>::type cos_pi(T x);
+   tools::promote_args_t<T> cos_pi(T x);
 
    template <class T>
    int fpclassify BOOST_NO_MACRO_EXPAND(T t);
@@ -902,7 +902,7 @@ namespace boost
    {
       typedef typename std::conditional<
          policies::is_policy<U>::value,
-         typename tools::promote_args<T>::type,
+         tools::promote_args_t<T>,
          typename tools::promote_args<U>::type
       >::type type;
    };
@@ -910,219 +910,219 @@ namespace boost
    } // namespace detail
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type expint(unsigned n, T z, const Policy&);
+   tools::promote_args_t<T> expint(unsigned n, T z, const Policy&);
 
    template <class T, class U>
    typename detail::expint_result<T, U>::type expint(T const z, U const u);
 
    template <class T>
-   typename tools::promote_args<T>::type expint(T z);
+   tools::promote_args_t<T> expint(T z);
 
    // Zeta:
    template <class T, class Policy>
-   typename tools::promote_args<T>::type zeta(T s, const Policy&);
+   tools::promote_args_t<T> zeta(T s, const Policy&);
 
    // Owen's T function:
    template <class T1, class T2, class Policy>
-   typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a, const Policy& pol);
+   tools::promote_args_t<T1, T2> owens_t(T1 h, T2 a, const Policy& pol);
 
    template <class T1, class T2>
-   typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a);
+   tools::promote_args_t<T1, T2> owens_t(T1 h, T2 a);
 
    // Jacobi Functions:
    template <class T, class U, class V, class Policy>
-   typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&);
+   tools::promote_args_t<T, U, V> jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&);
 
    template <class T, class U, class V>
-   typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn = 0, V* pdn = 0);
+   tools::promote_args_t<T, U, V> jacobi_elliptic(T k, U theta, V* pcn = 0, V* pdn = 0);
 
    template <class U, class T, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_sn(U k, T theta, const Policy& pol);
 
    template <class U, class T>
-   typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta);
+   tools::promote_args_t<T, U> jacobi_sn(U k, T theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_cn(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_cn(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_dn(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_dn(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_cd(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_cd(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_dc(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_dc(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_ns(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_ns(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_sd(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_sd(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_ds(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_ds(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_nc(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_nc(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_nd(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_nd(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_sc(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_sc(T k, U theta);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_cs(T k, U theta, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta);
+   tools::promote_args_t<T, U> jacobi_cs(T k, U theta);
 
    // Jacobi Theta Functions:
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta1(T z, U q, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta1(T z, U q, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta1(T z, U q);
+   tools::promote_args_t<T, U> jacobi_theta1(T z, U q);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta2(T z, U q, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta2(T z, U q, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta2(T z, U q);
+   tools::promote_args_t<T, U> jacobi_theta2(T z, U q);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta3(T z, U q, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta3(T z, U q, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta3(T z, U q);
+   tools::promote_args_t<T, U> jacobi_theta3(T z, U q);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta4(T z, U q, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta4(T z, U q, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta4(T z, U q);
+   tools::promote_args_t<T, U> jacobi_theta4(T z, U q);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta1tau(T z, U tau, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta1tau(T z, U tau, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta1tau(T z, U tau);
+   tools::promote_args_t<T, U> jacobi_theta1tau(T z, U tau);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta2tau(T z, U tau, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta2tau(T z, U tau, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta2tau(T z, U tau);
+   tools::promote_args_t<T, U> jacobi_theta2tau(T z, U tau);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta3tau(T z, U tau, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta3tau(T z, U tau, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta3tau(T z, U tau);
+   tools::promote_args_t<T, U> jacobi_theta3tau(T z, U tau);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta4tau(T z, U tau, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta4tau(T z, U tau, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta4tau(T z, U tau);
+   tools::promote_args_t<T, U> jacobi_theta4tau(T z, U tau);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta3m1(T z, U q, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta3m1(T z, U q, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta3m1(T z, U q);
+   tools::promote_args_t<T, U> jacobi_theta3m1(T z, U q);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta4m1(T z, U q, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta4m1(T z, U q, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta4m1(T z, U q);
+   tools::promote_args_t<T, U> jacobi_theta4m1(T z, U q);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta3m1tau(T z, U tau, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta3m1tau(T z, U tau, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta3m1tau(T z, U tau);
+   tools::promote_args_t<T, U> jacobi_theta3m1tau(T z, U tau);
 
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type jacobi_theta4m1tau(T z, U tau, const Policy& pol);
+   tools::promote_args_t<T, U> jacobi_theta4m1tau(T z, U tau, const Policy& pol);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type jacobi_theta4m1tau(T z, U tau);
+   tools::promote_args_t<T, U> jacobi_theta4m1tau(T z, U tau);
 
 
    template <class T>
-   typename tools::promote_args<T>::type zeta(T s);
+   tools::promote_args_t<T> zeta(T s);
 
    // pow:
    template <int N, typename T, class Policy>
-   BOOST_CXX14_CONSTEXPR typename tools::promote_args<T>::type pow(T base, const Policy& policy);
+   BOOST_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base, const Policy& policy);
 
    template <int N, typename T>
-   BOOST_CXX14_CONSTEXPR typename tools::promote_args<T>::type pow(T base);
+   BOOST_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base);
 
    // next:
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type nextafter(const T&, const U&, const Policy&);
+   tools::promote_args_t<T, U> nextafter(const T&, const U&, const Policy&);
    template <class T, class U>
-   typename tools::promote_args<T, U>::type nextafter(const T&, const U&);
+   tools::promote_args_t<T, U> nextafter(const T&, const U&);
    template <class T, class Policy>
-   typename tools::promote_args<T>::type float_next(const T&, const Policy&);
+   tools::promote_args_t<T> float_next(const T&, const Policy&);
    template <class T>
-   typename tools::promote_args<T>::type float_next(const T&);
+   tools::promote_args_t<T> float_next(const T&);
    template <class T, class Policy>
-   typename tools::promote_args<T>::type float_prior(const T&, const Policy&);
+   tools::promote_args_t<T> float_prior(const T&, const Policy&);
    template <class T>
-   typename tools::promote_args<T>::type float_prior(const T&);
+   tools::promote_args_t<T> float_prior(const T&);
    template <class T, class U, class Policy>
-   typename tools::promote_args<T, U>::type float_distance(const T&, const U&, const Policy&);
+   tools::promote_args_t<T, U> float_distance(const T&, const U&, const Policy&);
    template <class T, class U>
-   typename tools::promote_args<T, U>::type float_distance(const T&, const U&);
+   tools::promote_args_t<T, U> float_distance(const T&, const U&);
    template <class T, class Policy>
-   typename tools::promote_args<T>::type float_advance(T val, int distance, const Policy& pol);
+   tools::promote_args_t<T> float_advance(T val, int distance, const Policy& pol);
    template <class T>
-   typename tools::promote_args<T>::type float_advance(const T& val, int distance);
+   tools::promote_args_t<T> float_advance(const T& val, int distance);
 
    template <class T, class Policy>
-   typename tools::promote_args<T>::type ulp(const T& val, const Policy& pol);
+   tools::promote_args_t<T> ulp(const T& val, const Policy& pol);
    template <class T>
-   typename tools::promote_args<T>::type ulp(const T& val);
+   tools::promote_args_t<T> ulp(const T& val);
 
    template <class T, class U>
-   typename tools::promote_args<T, U>::type relative_difference(const T&, const U&);
+   tools::promote_args_t<T, U> relative_difference(const T&, const U&);
    template <class T, class U>
-   typename tools::promote_args<T, U>::type epsilon_difference(const T&, const U&);
+   tools::promote_args_t<T, U> epsilon_difference(const T&, const U&);
 
    template<class T>
    BOOST_MATH_CONSTEXPR_TABLE_FUNCTION T unchecked_bernoulli_b2n(const std::size_t n);
@@ -1155,34 +1155,34 @@ namespace boost
 
    // Lambert W:
    template <class T, class Policy>
-   typename boost::math::tools::promote_args<T>::type lambert_w0(T z, const Policy& pol);
+   boost::math::tools::promote_args_t<T> lambert_w0(T z, const Policy& pol);
    template <class T>
-   typename boost::math::tools::promote_args<T>::type lambert_w0(T z);
+   boost::math::tools::promote_args_t<T> lambert_w0(T z);
    template <class T, class Policy>
-   typename boost::math::tools::promote_args<T>::type lambert_wm1(T z, const Policy& pol);
+   boost::math::tools::promote_args_t<T> lambert_wm1(T z, const Policy& pol);
    template <class T>
-   typename boost::math::tools::promote_args<T>::type lambert_wm1(T z);
+   boost::math::tools::promote_args_t<T> lambert_wm1(T z);
    template <class T, class Policy>
-   typename boost::math::tools::promote_args<T>::type lambert_w0_prime(T z, const Policy& pol);
+   boost::math::tools::promote_args_t<T> lambert_w0_prime(T z, const Policy& pol);
    template <class T>
-   typename boost::math::tools::promote_args<T>::type lambert_w0_prime(T z);
+   boost::math::tools::promote_args_t<T> lambert_w0_prime(T z);
    template <class T, class Policy>
-   typename boost::math::tools::promote_args<T>::type lambert_wm1_prime(T z, const Policy& pol);
+   boost::math::tools::promote_args_t<T> lambert_wm1_prime(T z, const Policy& pol);
    template <class T>
-   typename boost::math::tools::promote_args<T>::type lambert_wm1_prime(T z);
+   boost::math::tools::promote_args_t<T> lambert_wm1_prime(T z);
 
    // Hypergeometrics:
-   template <class T1, class T2> typename tools::promote_args<T1, T2>::type hypergeometric_1F0(T1 a, T2 z);
-   template <class T1, class T2, class Policy> typename tools::promote_args<T1, T2>::type hypergeometric_1F0(T1 a, T2 z, const Policy&);
+   template <class T1, class T2> tools::promote_args_t<T1, T2> hypergeometric_1F0(T1 a, T2 z);
+   template <class T1, class T2, class Policy> tools::promote_args_t<T1, T2> hypergeometric_1F0(T1 a, T2 z, const Policy&);
 
-   template <class T1, class T2> typename tools::promote_args<T1, T2>::type hypergeometric_0F1(T1 b, T2 z);
-   template <class T1, class T2, class Policy> typename tools::promote_args<T1, T2>::type hypergeometric_0F1(T1 b, T2 z, const Policy&);
+   template <class T1, class T2> tools::promote_args_t<T1, T2> hypergeometric_0F1(T1 b, T2 z);
+   template <class T1, class T2, class Policy> tools::promote_args_t<T1, T2> hypergeometric_0F1(T1 b, T2 z, const Policy&);
 
-   template <class T1, class T2, class T3> typename tools::promote_args<T1, T2, T3>::type hypergeometric_2F0(T1 a1, T2 a2, T3 z);
-   template <class T1, class T2, class T3, class Policy> typename tools::promote_args<T1, T2, T3>::type hypergeometric_2F0(T1 a1, T2 a2, T3 z, const Policy&);
+   template <class T1, class T2, class T3> tools::promote_args_t<T1, T2, T3> hypergeometric_2F0(T1 a1, T2 a2, T3 z);
+   template <class T1, class T2, class T3, class Policy> tools::promote_args_t<T1, T2, T3> hypergeometric_2F0(T1 a1, T2 a2, T3 z, const Policy&);
 
-   template <class T1, class T2, class T3> typename tools::promote_args<T1, T2, T3>::type hypergeometric_1F1(T1 a, T2 b, T3 z);
-   template <class T1, class T2, class T3, class Policy> typename tools::promote_args<T1, T2, T3>::type hypergeometric_1F1(T1 a, T2 b, T3 z, const Policy&);
+   template <class T1, class T2, class T3> tools::promote_args_t<T1, T2, T3> hypergeometric_1F1(T1 a, T2 b, T3 z);
+   template <class T1, class T2, class T3, class Policy> tools::promote_args_t<T1, T2, T3> hypergeometric_1F1(T1 a, T2 b, T3 z, const Policy&);
 
 
     } // namespace math
@@ -1201,7 +1201,7 @@ namespace boost
 
 #  define BOOST_MATH_DETAIL_11_FUNC(Policy)\
    template <class T, class U, class V>\
-   inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_1F1(const T& a, const U& b, const V& z)\
+   inline boost::math::tools::promote_args_t<T, U> hypergeometric_1F1(const T& a, const U& b, const V& z)\
    { return boost::math::hypergeometric_1F1(a, b, z, Policy()); }\
 
 #define BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(Policy)\
@@ -1210,99 +1210,99 @@ namespace boost
    BOOST_MATH_DETAIL_11_FUNC(Policy)\
    \
    template <class RT1, class RT2>\
-   inline typename boost::math::tools::promote_args<RT1, RT2>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2> \
    beta(RT1 a, RT2 b) { return ::boost::math::beta(a, b, Policy()); }\
 \
    template <class RT1, class RT2, class A>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, A>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, A> \
    beta(RT1 a, RT2 b, A x){ return ::boost::math::beta(a, b, x, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    betac(RT1 a, RT2 b, RT3 x) { return ::boost::math::betac(a, b, x, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibeta(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta(a, b, x, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibetac(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibetac(a, b, x, Policy()); }\
 \
    template <class T1, class T2, class T3, class T4>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type  \
+   inline boost::math::tools::promote_args_t<T1, T2, T3, T4>  \
    ibeta_inv(T1 a, T2 b, T3 p, T4* py){ return ::boost::math::ibeta_inv(a, b, p, py, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibeta_inv(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inv(a, b, p, Policy()); }\
 \
    template <class T1, class T2, class T3, class T4>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3, T4> \
    ibetac_inv(T1 a, T2 b, T3 q, T4* py){ return ::boost::math::ibetac_inv(a, b, q, py, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibeta_inva(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inva(a, b, p, Policy()); }\
 \
    template <class T1, class T2, class T3>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3> \
    ibetac_inva(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_inva(a, b, q, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibeta_invb(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_invb(a, b, p, Policy()); }\
 \
    template <class T1, class T2, class T3>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3> \
    ibetac_invb(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_invb(a, b, q, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibetac_inv(RT1 a, RT2 b, RT3 q){ return ::boost::math::ibetac_inv(a, b, q, Policy()); }\
 \
    template <class RT1, class RT2, class RT3>\
-   inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
+   inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
    ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta_derivative(a, b, x, Policy()); }\
 \
    template <class T> T binomial_coefficient(unsigned n, unsigned k){ return ::boost::math::binomial_coefficient<T, Policy>(n, k, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type erf(RT z) { return ::boost::math::erf(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> erf(RT z) { return ::boost::math::erf(z, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type erfc(RT z){ return ::boost::math::erfc(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> erfc(RT z){ return ::boost::math::erfc(z, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type erf_inv(RT z) { return ::boost::math::erf_inv(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> erf_inv(RT z) { return ::boost::math::erf_inv(z, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type erfc_inv(RT z){ return ::boost::math::erfc_inv(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> erfc_inv(RT z){ return ::boost::math::erfc_inv(z, Policy()); }\
 \
    using boost::math::legendre_next;\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type \
+   inline boost::math::tools::promote_args_t<T> \
    legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type \
+   inline boost::math::tools::promote_args_t<T> \
    legendre_p_prime(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type \
+   inline boost::math::tools::promote_args_t<T> \
    legendre_q(unsigned l, T x){ return ::boost::math::legendre_q(l, x, Policy()); }\
 \
    using ::boost::math::legendre_next;\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type \
+   inline boost::math::tools::promote_args_t<T> \
    legendre_p(int l, int m, T x){ return ::boost::math::legendre_p(l, m, x, Policy()); }\
 \
    using ::boost::math::laguerre_next;\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type \
+   inline boost::math::tools::promote_args_t<T> \
    laguerre(unsigned n, T x){ return ::boost::math::laguerre(n, x, Policy()); }\
 \
    template <class T1, class T2>\
@@ -1310,7 +1310,7 @@ namespace boost
    laguerre(unsigned n, T1 m, T2 x) { return ::boost::math::laguerre(n, m, x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type \
+   inline boost::math::tools::promote_args_t<T> \
    hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); }\
 \
    using boost::math::hermite_next;\
@@ -1329,70 +1329,70 @@ namespace boost
   using ::boost::math::chebyshev_clenshaw_recurrence;\
 \
    template <class T1, class T2>\
-   inline std::complex<typename boost::math::tools::promote_args<T1, T2>::type> \
+   inline std::complex<boost::math::tools::promote_args_t<T1, T2>> \
    spherical_harmonic(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic(n, m, theta, phi, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type \
+   inline boost::math::tools::promote_args_t<T1, T2> \
    spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi){ return ::boost::math::spherical_harmonic_r(n, m, theta, phi, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type \
+   inline boost::math::tools::promote_args_t<T1, T2> \
    spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic_i(n, m, theta, phi, Policy()); }\
 \
    template <class T1, class T2, class Policy>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type \
+   inline boost::math::tools::promote_args_t<T1, T2> \
       spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);\
 \
    template <class T1, class T2, class T3>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3> \
    ellint_rf(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rf(x, y, z, Policy()); }\
 \
    template <class T1, class T2, class T3>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3> \
    ellint_rd(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rd(x, y, z, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type \
+   inline boost::math::tools::promote_args_t<T1, T2> \
    ellint_rc(T1 x, T2 y){ return ::boost::math::ellint_rc(x, y, Policy()); }\
 \
    template <class T1, class T2, class T3, class T4>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3, T4> \
    ellint_rj(T1 x, T2 y, T3 z, T4 p){ return boost::math::ellint_rj(x, y, z, p, Policy()); }\
 \
    template <class T1, class T2, class T3>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
+   inline boost::math::tools::promote_args_t<T1, T2, T3> \
    ellint_rg(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rg(x, y, z, Policy()); }\
    \
    template <typename T>\
-   inline typename boost::math::tools::promote_args<T>::type ellint_2(T k){ return boost::math::ellint_2(k, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> ellint_2(T k){ return boost::math::ellint_2(k, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); }\
 \
    template <typename T>\
-   inline typename boost::math::tools::promote_args<T>::type ellint_d(T k){ return boost::math::ellint_d(k, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> ellint_d(T k){ return boost::math::ellint_d(k, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi){ return boost::math::ellint_d(k, phi, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> ellint_d(T1 k, T2 phi){ return boost::math::ellint_d(k, phi, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi){ return boost::math::jacobi_zeta(k, phi, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> jacobi_zeta(T1 k, T2 phi){ return boost::math::jacobi_zeta(k, phi, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi){ return boost::math::heuman_lambda(k, phi, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> heuman_lambda(T1 k, T2 phi){ return boost::math::heuman_lambda(k, phi, Policy()); }\
 \
    template <typename T>\
-   inline typename boost::math::tools::promote_args<T>::type ellint_1(T k){ return boost::math::ellint_1(k, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> ellint_1(T k){ return boost::math::ellint_1(k, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi){ return boost::math::ellint_1(k, phi, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> ellint_1(T1 k, T2 phi){ return boost::math::ellint_1(k, phi, Policy()); }\
 \
    template <class T1, class T2, class T3>\
-   inline typename boost::math::tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi){ return boost::math::ellint_3(k, v, phi, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2, T3> ellint_3(T1 k, T2 v, T3 phi){ return boost::math::ellint_3(k, v, phi, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v){ return boost::math::ellint_3(k, v, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> ellint_3(T1 k, T2 v){ return boost::math::ellint_3(k, v, Policy()); }\
 \
    using boost::math::max_factorial;\
    template <class RT>\
@@ -1401,101 +1401,101 @@ namespace boost
    template <class RT>\
    inline RT double_factorial(unsigned i){ return boost::math::double_factorial<RT>(i, Policy()); }\
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type falling_factorial(RT x, unsigned n){ return boost::math::falling_factorial(x, n, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> falling_factorial(RT x, unsigned n){ return boost::math::falling_factorial(x, n, Policy()); }\
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type rising_factorial(RT x, unsigned n){ return boost::math::rising_factorial(x, n, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> rising_factorial(RT x, unsigned n){ return boost::math::rising_factorial(x, n, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type tgamma(RT z){ return boost::math::tgamma(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> tgamma(RT z){ return boost::math::tgamma(z, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type tgamma1pm1(RT z){ return boost::math::tgamma1pm1(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> tgamma1pm1(RT z){ return boost::math::tgamma1pm1(z, Policy()); }\
 \
    template <class RT1, class RT2>\
-   inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z){ return boost::math::tgamma(a, z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT1, RT2> tgamma(RT1 a, RT2 z){ return boost::math::tgamma(a, z, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type lgamma(RT z, int* sign){ return boost::math::lgamma(z, sign, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> lgamma(RT z, int* sign){ return boost::math::lgamma(z, sign, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type lgamma(RT x){ return boost::math::lgamma(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> lgamma(RT x){ return boost::math::lgamma(x, Policy()); }\
 \
    template <class RT1, class RT2>\
-   inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z){ return boost::math::tgamma_lower(a, z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT1, RT2> tgamma_lower(RT1 a, RT2 z){ return boost::math::tgamma_lower(a, z, Policy()); }\
 \
    template <class RT1, class RT2>\
-   inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z){ return boost::math::gamma_q(a, z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT1, RT2> gamma_q(RT1 a, RT2 z){ return boost::math::gamma_q(a, z, Policy()); }\
 \
    template <class RT1, class RT2>\
-   inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z){ return boost::math::gamma_p(a, z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT1, RT2> gamma_p(RT1 a, RT2 z){ return boost::math::gamma_p(a, z, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta){ return boost::math::tgamma_delta_ratio(z, delta, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> tgamma_delta_ratio(T1 z, T2 delta){ return boost::math::tgamma_delta_ratio(z, delta, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b) { return boost::math::tgamma_ratio(a, b, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> tgamma_ratio(T1 a, T2 b) { return boost::math::tgamma_ratio(a, b, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x){ return boost::math::gamma_p_derivative(a, x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> gamma_p_derivative(T1 a, T2 x){ return boost::math::gamma_p_derivative(a, x, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p){ return boost::math::gamma_p_inv(a, p, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> gamma_p_inv(T1 a, T2 p){ return boost::math::gamma_p_inv(a, p, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p){ return boost::math::gamma_p_inva(a, p, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> gamma_p_inva(T1 a, T2 p){ return boost::math::gamma_p_inva(a, p, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q){ return boost::math::gamma_q_inv(a, q, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> gamma_q_inv(T1 a, T2 q){ return boost::math::gamma_q_inv(a, q, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q){ return boost::math::gamma_q_inva(a, q, Policy()); }\
+   inline boost::math::tools::promote_args_t<T1, T2> gamma_q_inva(T1 a, T2 q){ return boost::math::gamma_q_inva(a, q, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type digamma(T x){ return boost::math::digamma(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> digamma(T x){ return boost::math::digamma(x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type trigamma(T x){ return boost::math::trigamma(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> trigamma(T x){ return boost::math::trigamma(x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type polygamma(int n, T x){ return boost::math::polygamma(n, x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> polygamma(int n, T x){ return boost::math::polygamma(n, x, Policy()); }\
    \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type \
+   inline boost::math::tools::promote_args_t<T1, T2> \
    hypot(T1 x, T2 y){ return boost::math::hypot(x, y, Policy()); }\
 \
    template <class RT>\
-   inline typename boost::math::tools::promote_args<RT>::type cbrt(RT z){ return boost::math::cbrt(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT> cbrt(RT z){ return boost::math::cbrt(z, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type log1p(T x){ return boost::math::log1p(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> log1p(T x){ return boost::math::log1p(x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type log1pmx(T x){ return boost::math::log1pmx(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> log1pmx(T x){ return boost::math::log1pmx(x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type expm1(T x){ return boost::math::expm1(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> expm1(T x){ return boost::math::expm1(x, Policy()); }\
 \
    template <class T1, class T2>\
-   inline typename boost::math::tools::promote_args<T1, T2>::type \
+   inline boost::math::tools::promote_args_t<T1, T2> \
    powm1(const T1 a, const T2 z){ return boost::math::powm1(a, z, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type sqrt1pm1(const T& val){ return boost::math::sqrt1pm1(val, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> sqrt1pm1(const T& val){ return boost::math::sqrt1pm1(val, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type sinc_pi(T x){ return boost::math::sinc_pi(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> sinc_pi(T x){ return boost::math::sinc_pi(x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type sinhc_pi(T x){ return boost::math::sinhc_pi(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> sinhc_pi(T x){ return boost::math::sinhc_pi(x, Policy()); }\
 \
    template<typename T>\
-   inline typename boost::math::tools::promote_args<T>::type asinh(const T x){ return boost::math::asinh(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> asinh(const T x){ return boost::math::asinh(x, Policy()); }\
 \
    template<typename T>\
-   inline typename boost::math::tools::promote_args<T>::type acosh(const T x){ return boost::math::acosh(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> acosh(const T x){ return boost::math::acosh(x, Policy()); }\
 \
    template<typename T>\
-   inline typename boost::math::tools::promote_args<T>::type atanh(const T x){ return boost::math::atanh(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> atanh(const T x){ return boost::math::atanh(x, Policy()); }\
 \
    template <class T1, class T2>\
    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x)\
@@ -1568,10 +1568,10 @@ template <class OutputIterator, class T>\
    { boost::math::cyl_neumann_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type sin_pi(T x){ return boost::math::sin_pi(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> sin_pi(T x){ return boost::math::sin_pi(x, Policy()); }\
 \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type cos_pi(T x){ return boost::math::cos_pi(x, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> cos_pi(T x){ return boost::math::cos_pi(x, Policy()); }\
 \
    using boost::math::fpclassify;\
    using boost::math::isfinite;\
@@ -1584,14 +1584,14 @@ template <class OutputIterator, class T>\
    using boost::math::changesign;\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T,U>::type expint(T const& z, U const& u)\
+   inline typename boost::math::tools::promote_args_t<T,U> expint(T const& z, U const& u)\
    { return boost::math::expint(z, u, Policy()); }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type expint(T z){ return boost::math::expint(z, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> expint(T z){ return boost::math::expint(z, Policy()); }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type zeta(T s){ return boost::math::zeta(s, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> zeta(T s){ return boost::math::zeta(s, Policy()); }\
    \
    template <class T>\
    inline T round(const T& v){ using boost::math::round; return round(v, Policy()); }\
@@ -1621,16 +1621,16 @@ template <class OutputIterator, class T>\
    inline T modf(const T& v, long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
    \
    template <int N, class T>\
-   inline typename boost::math::tools::promote_args<T>::type pow(T v){ return boost::math::pow<N>(v, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> pow(T v){ return boost::math::pow<N>(v, Policy()); }\
    \
-   template <class T> T nextafter(const T& a, const T& b){ return boost::math::nextafter(a, b, Policy()); }\
-   template <class T> T float_next(const T& a){ return boost::math::float_next(a, Policy()); }\
-   template <class T> T float_prior(const T& a){ return boost::math::float_prior(a, Policy()); }\
-   template <class T> T float_distance(const T& a, const T& b){ return boost::math::float_distance(a, b, Policy()); }\
-   template <class T> T ulp(const T& a){ return boost::math::ulp(a, Policy()); }\
+   template <class T> T nextafter(const T& a, const T& b){ return static_cast<T>(boost::math::nextafter(a, b, Policy())); }\
+   template <class T> T float_next(const T& a){ return static_cast<T>(boost::math::float_next(a, Policy())); }\
+   template <class T> T float_prior(const T& a){ return static_cast<T>(boost::math::float_prior(a, Policy())); }\
+   template <class T> T float_distance(const T& a, const T& b){ return static_cast<T>(boost::math::float_distance(a, b, Policy())); }\
+   template <class T> T ulp(const T& a){ return static_cast<T>(boost::math::ulp(a, Policy())); }\
    \
    template <class RT1, class RT2>\
-   inline typename boost::math::tools::promote_args<RT1, RT2>::type owens_t(RT1 a, RT2 z){ return boost::math::owens_t(a, z, Policy()); }\
+   inline boost::math::tools::promote_args_t<RT1, RT2> owens_t(RT1 a, RT2 z){ return boost::math::owens_t(a, z, Policy()); }\
    \
    template <class T1, class T2>\
    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_1(T1 v, T2 x)\
@@ -1649,119 +1649,119 @@ template <class OutputIterator, class T>\
    { return boost::math::sph_hankel_2(v, x, Policy()); }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn, T* pdn)\
-   { return boost::math::jacobi_elliptic(k, theta, pcn, pdn, Policy()); }\
+   inline boost::math::tools::promote_args_t<T> jacobi_elliptic(T k, T theta, T* pcn, T* pdn)\
+   { return static_cast<boost::math::tools::promote_args_t<T>>(boost::math::jacobi_elliptic(k, theta, pcn, pdn, Policy())); }\
    \
    template <class U, class T>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_sn(U k, T theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_sn(U k, T theta)\
    { return boost::math::jacobi_sn(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_cn(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_cn(T k, U theta)\
    { return boost::math::jacobi_cn(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_dn(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_dn(T k, U theta)\
    { return boost::math::jacobi_dn(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_cd(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_cd(T k, U theta)\
    { return boost::math::jacobi_cd(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_dc(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_dc(T k, U theta)\
    { return boost::math::jacobi_dc(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_ns(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_ns(T k, U theta)\
    { return boost::math::jacobi_ns(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_sd(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_sd(T k, U theta)\
    { return boost::math::jacobi_sd(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_ds(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_ds(T k, U theta)\
    { return boost::math::jacobi_ds(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_nc(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_nc(T k, U theta)\
    { return boost::math::jacobi_nc(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_nd(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_nd(T k, U theta)\
    { return boost::math::jacobi_nd(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_sc(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_sc(T k, U theta)\
    { return boost::math::jacobi_sc(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_cs(T k, U theta)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_cs(T k, U theta)\
    { return boost::math::jacobi_cs(k, theta, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta1(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta1(T z, U q)\
    { return boost::math::jacobi_theta1(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta2(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta2(T z, U q)\
    { return boost::math::jacobi_theta2(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta3(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta3(T z, U q)\
    { return boost::math::jacobi_theta3(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta4(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta4(T z, U q)\
    { return boost::math::jacobi_theta4(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta1tau(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta1tau(T z, U q)\
    { return boost::math::jacobi_theta1tau(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta2tau(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta2tau(T z, U q)\
    { return boost::math::jacobi_theta2tau(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta3tau(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta3tau(T z, U q)\
    { return boost::math::jacobi_theta3tau(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta4tau(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta4tau(T z, U q)\
    { return boost::math::jacobi_theta4tau(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta3m1(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta3m1(T z, U q)\
    { return boost::math::jacobi_theta3m1(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta4m1(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta4m1(T z, U q)\
    { return boost::math::jacobi_theta4m1(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta3m1tau(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta3m1tau(T z, U q)\
    { return boost::math::jacobi_theta3m1tau(z, q, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type jacobi_theta4m1tau(T z, U q)\
+   inline boost::math::tools::promote_args_t<T, U> jacobi_theta4m1tau(T z, U q)\
    { return boost::math::jacobi_theta4m1tau(z, q, Policy()); }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type airy_ai(T x)\
+   inline boost::math::tools::promote_args_t<T> airy_ai(T x)\
    {  return boost::math::airy_ai(x, Policy());  }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type airy_bi(T x)\
+   inline boost::math::tools::promote_args_t<T> airy_bi(T x)\
    {  return boost::math::airy_bi(x, Policy());  }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type airy_ai_prime(T x)\
+   inline boost::math::tools::promote_args_t<T> airy_ai_prime(T x)\
    {  return boost::math::airy_ai_prime(x, Policy());  }\
    \
    template <class T>\
-   inline typename boost::math::tools::promote_args<T>::type airy_bi_prime(T x)\
+   inline boost::math::tools::promote_args_t<T> airy_bi_prime(T x)\
    {  return boost::math::airy_bi_prime(x, Policy());  }\
    \
    template <class T>\
@@ -1792,21 +1792,21 @@ template <class OutputIterator, class T>\
    OutputIterator tangent_t2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
    { return boost::math::tangent_t2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
    \
-   template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_w0(T z) { return boost::math::lambert_w0(z, Policy()); }\
-   template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_wm1(T z) { return boost::math::lambert_w0(z, Policy()); }\
-   template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_w0_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
-   template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_wm1_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
+   template <class T> inline boost::math::tools::promote_args_t<T> lambert_w0(T z) { return boost::math::lambert_w0(z, Policy()); }\
+   template <class T> inline boost::math::tools::promote_args_t<T> lambert_wm1(T z) { return boost::math::lambert_w0(z, Policy()); }\
+   template <class T> inline boost::math::tools::promote_args_t<T> lambert_w0_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
+   template <class T> inline boost::math::tools::promote_args_t<T> lambert_wm1_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_1F0(const T& a, const U& z)\
+   inline boost::math::tools::promote_args_t<T, U> hypergeometric_1F0(const T& a, const U& z)\
    { return boost::math::hypergeometric_1F0(a, z, Policy()); }\
    \
    template <class T, class U>\
-   inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_0F1(const T& a, const U& z)\
+   inline boost::math::tools::promote_args_t<T, U> hypergeometric_0F1(const T& a, const U& z)\
    { return boost::math::hypergeometric_0F1(a, z, Policy()); }\
    \
    template <class T, class U, class V>\
-   inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_2F0(const T& a1, const U& a2, const V& z)\
+   inline boost::math::tools::promote_args_t<T, U> hypergeometric_2F0(const T& a1, const U& a2, const V& z)\
    { return boost::math::hypergeometric_2F0(a1, a2, z, Policy()); }\
    \
 
diff --git a/contrib/restricted/boost/math/include/boost/math/tools/config.hpp b/contrib/restricted/boost/math/include/boost/math/tools/config.hpp
index a52393e7bb..50c8cb04f7 100644
--- a/contrib/restricted/boost/math/include/boost/math/tools/config.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/tools/config.hpp
@@ -156,13 +156,27 @@
 #  endif
 #endif
 
-#endif
+#endif // Standalone config
 
 // If attributes are not defined make sure we don't have compiler errors
 #ifndef BOOST_MATH_MAYBE_UNUSED
 #  define BOOST_MATH_MAYBE_UNUSED 
 #endif
 
+// C++23
+#if __cplusplus > 202002L || _MSVC_LANG > 202002L
+#  if __GNUC__ >= 13
+     // libstdc++3 only defines to/from_chars for std::float128_t when one of these defines are set
+     // otherwise we're right out of luck...
+#    if defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) || defined(_GLIBCXX_HAVE_FLOAT128_MATH)
+#    include <cstring> // std::strlen is used with from_chars
+#    include <charconv>
+#    error #include <stdfloat>
+#    define BOOST_MATH_USE_CHARCONV_FOR_CONVERSION
+#endif
+#  endif
+#endif
+
 #include <algorithm>  // for min and max
 #include <limits>
 #include <cmath>
diff --git a/contrib/restricted/boost/math/include/boost/math/tools/promotion.hpp b/contrib/restricted/boost/math/include/boost/math/tools/promotion.hpp
index 55ba064c71..80b3d89a10 100644
--- a/contrib/restricted/boost/math/include/boost/math/tools/promotion.hpp
+++ b/contrib/restricted/boost/math/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>)
+#  error #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;
 
@@ -72,25 +90,52 @@ namespace boost
         // for both parameter types, if integral promote to double.
         using T1P = typename promote_arg<T1>::type; // T1 perhaps promoted.
         using T2P = typename promote_arg<T2>::type; // T2 perhaps promoted.
-
-        using type = typename std::conditional<
+        using intermediate_type = typename std::conditional<
           std::is_floating_point<T1P>::value && std::is_floating_point<T2P>::value, // both T1P and T2P are floating-point?
+#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 
 #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 
              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,
           // else one or the other is a user-defined type:
           typename std::conditional<!std::is_floating_point<T2P>::value && std::is_convertible<T1P, T2P>::value, T2P, T1P>::type>::type;
+
+#ifdef __STDCPP_FLOAT64_T__
+          // If long doubles are doubles then we should prefer to use std::float64_t when available
+          using type = std::conditional_t<(sizeof(double) == sizeof(long double) && std::is_same<intermediate_type, long double>::value), std::float64_t, intermediate_type>;
+#else
+          using type = intermediate_type;
+#endif
       }; // promote_arg2
       // These full specialisations reduce std::conditional usage and speed up
       // compilation:
@@ -111,6 +156,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::float32_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;
 
diff --git a/contrib/restricted/boost/math/ya.make b/contrib/restricted/boost/math/ya.make
index dcd074ca45..a692f03ae5 100644
--- a/contrib/restricted/boost/math/ya.make
+++ b/contrib/restricted/boost/math/ya.make
@@ -6,9 +6,9 @@ LICENSE(BSL-1.0)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.82.0)
+VERSION(1.83.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/math/archive/boost-1.82.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/math/archive/boost-1.83.0.tar.gz)
 
 PEERDIR(
     contrib/restricted/boost/assert