diff options
author | robot-contrib <robot-contrib@yandex-team.com> | 2023-08-18 13:02:03 +0300 |
---|---|---|
committer | robot-contrib <robot-contrib@yandex-team.com> | 2023-08-18 16:45:32 +0300 |
commit | 5e2132416de6bd7cfdb2e359f1d8e1daa7290380 (patch) | |
tree | 9e6c9483cd9771a8e98f97bae85025cef1a896c6 | |
parent | f2318846c79045407d30ab0c1dbb44e1fcb749e0 (diff) | |
download | ydb-5e2132416de6bd7cfdb2e359f1d8e1daa7290380.tar.gz |
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 |