diff options
| author | DongHun Kwak <dh0128.kwak@samsung.com> | 2016-10-06 10:33:54 +0900 |
|---|---|---|
| committer | DongHun Kwak <dh0128.kwak@samsung.com> | 2016-10-06 10:36:09 +0900 |
| commit | d9ec475d945d3035377a0d89ed42e382d8988891 (patch) | |
| tree | 34aff2cee4b209906243ab5499d61f3edee2982f /boost/math | |
| parent | 71d216b90256936a9638f325af9bc69d720e75de (diff) | |
| download | boost-d9ec475d945d3035377a0d89ed42e382d8988891.tar.gz boost-d9ec475d945d3035377a0d89ed42e382d8988891.tar.bz2 boost-d9ec475d945d3035377a0d89ed42e382d8988891.zip | |
Imported Upstream version 1.60.0
Change-Id: Ie709530d6d5841088ceaba025cbe175a4ef43050
Signed-off-by: DongHun Kwak <dh0128.kwak@samsung.com>
Diffstat (limited to 'boost/math')
179 files changed, 2857 insertions, 2218 deletions
diff --git a/boost/math/concepts/real_concept.hpp b/boost/math/concepts/real_concept.hpp index 2b105e6c85..3a759955ab 100644 --- a/boost/math/concepts/real_concept.hpp +++ b/boost/math/concepts/real_concept.hpp @@ -215,10 +215,17 @@ inline real_concept floor(real_concept a) { return std::floor(a.value()); } inline real_concept modf(real_concept a, real_concept* ipart) { +#ifdef __MINGW32__ + real_concept_base_type ip; + real_concept_base_type result = boost::math::modf(a.value(), &ip); + *ipart = ip; + return result; +#else real_concept_base_type ip; real_concept_base_type result = std::modf(a.value(), &ip); *ipart = ip; return result; +#endif } inline real_concept frexp(real_concept a, int* expon) { return std::frexp(a.value(), expon); } @@ -368,7 +375,7 @@ inline concepts::real_concept epsilon<concepts::real_concept>(BOOST_MATH_EXPLICI } template <> -inline int digits<concepts::real_concept>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(concepts::real_concept)) +inline BOOST_MATH_CONSTEXPR int digits<concepts::real_concept>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(concepts::real_concept)) BOOST_NOEXCEPT { // Assume number of significand bits is same as real_concept_base_type, // unless std::numeric_limits<T>::is_specialized to provide digits. @@ -381,6 +388,26 @@ inline int digits<concepts::real_concept>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC } } // namespace tools +/* +namespace policies { + namespace detail { + + template <class T> + inline concepts::real_concept raise_rounding_error( + const char*, + const char*, + const T& val, + const concepts::real_concept&, + const ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) + { + errno = ERANGE; + // This may or may not do the right thing, but the user asked for the error + // to be silent so here we go anyway: + return val > 0 ? boost::math::tools::max_value<concepts::real_concept>() : -boost::math::tools::max_value<concepts::real_concept>(); + } + + } +}*/ #if defined(__SGI_STL_PORT) || defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) // diff --git a/boost/math/concepts/std_real_concept.hpp b/boost/math/concepts/std_real_concept.hpp index c565ce3773..b297501d98 100644 --- a/boost/math/concepts/std_real_concept.hpp +++ b/boost/math/concepts/std_real_concept.hpp @@ -378,7 +378,7 @@ inline concepts::std_real_concept epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC } template <> -inline int digits<concepts::std_real_concept>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(concepts::std_real_concept)) +inline BOOST_MATH_CONSTEXPR int digits<concepts::std_real_concept>(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(concepts::std_real_concept)) BOOST_NOEXCEPT { // Assume number of significand bits is same as std_real_concept_base_type, // unless std::numeric_limits<T>::is_specialized to provide digits. return digits<concepts::std_real_concept_base_type>(); diff --git a/boost/math/constants/constants.hpp b/boost/math/constants/constants.hpp index 59873c60d8..2a28f98f9e 100644 --- a/boost/math/constants/constants.hpp +++ b/boost/math/constants/constants.hpp @@ -158,7 +158,7 @@ namespace boost{ namespace math #endif } template <class Real> - const char* convert_from_string(const char* p, const mpl::true_&) + BOOST_CONSTEXPR const char* convert_from_string(const char* p, const mpl::true_&) BOOST_NOEXCEPT { return p; } @@ -211,7 +211,7 @@ namespace boost{ namespace math #ifdef BOOST_MATH_USE_FLOAT128 # define BOOST_MATH_FLOAT128_CONSTANT_OVERLOAD(x) \ - static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_float128>&)\ + static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_float128>&) BOOST_NOEXCEPT\ { return BOOST_JOIN(x, Q); } #else # define BOOST_MATH_FLOAT128_CONSTANT_OVERLOAD(x) @@ -242,11 +242,11 @@ namespace boost{ namespace math constant_initializer<T, & BOOST_JOIN(constant_, name)<T>::get_from_string >::force_instantiate();\ return get_from_string();\ }\ - static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_float>)\ + static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_float>) BOOST_NOEXCEPT\ { return BOOST_JOIN(x, F); }\ - static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_double>&)\ + static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_double>&) BOOST_NOEXCEPT\ { return x; }\ - static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_long_double>&)\ + static inline BOOST_CONSTEXPR T get(const mpl::int_<construct_from_long_double>&) BOOST_NOEXCEPT\ { return BOOST_JOIN(x, L); }\ BOOST_MATH_FLOAT128_CONSTANT_OVERLOAD(x) \ template <int N> static inline const T& get(const mpl::int_<N>&)\ @@ -262,9 +262,9 @@ namespace boost{ namespace math \ \ /* The actual forwarding function: */ \ - template <class T, class Policy> inline BOOST_CONSTEXPR typename detail::constant_return<T, Policy>::type name(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T) BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(Policy))\ + template <class T, class Policy> inline BOOST_CONSTEXPR typename detail::constant_return<T, Policy>::type name(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T) BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(Policy)) BOOST_MATH_NOEXCEPT(T)\ { return detail:: BOOST_JOIN(constant_, name)<T>::get(typename construction_traits<T, Policy>::type()); }\ - template <class T> inline BOOST_CONSTEXPR typename detail::constant_return<T>::type name(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T))\ + template <class T> inline BOOST_CONSTEXPR typename detail::constant_return<T>::type name(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_MATH_NOEXCEPT(T)\ { return name<T, boost::math::policies::policy<> >(); }\ \ \ diff --git a/boost/math/cstdfloat/cstdfloat_iostream.hpp b/boost/math/cstdfloat/cstdfloat_iostream.hpp index ac94fd35f9..9aaf5f32fb 100644 --- a/boost/math/cstdfloat/cstdfloat_iostream.hpp +++ b/boost/math/cstdfloat/cstdfloat_iostream.hpp @@ -97,15 +97,18 @@ char* my_buffer2 = static_cast<char*>(0U); +#ifndef BOOST_NO_EXCEPTIONS try { +#endif my_buffer2 = new char[v + 3]; +#ifndef BOOST_NO_EXCEPTIONS } catch(const std::bad_alloc&) { BOOST_THROW_EXCEPTION(std::runtime_error("Formatting of boost::float128_t failed while allocating memory.")); } - +#endif const int v2 = ::quadmath_snprintf(my_buffer2, v + 3, my_format_string, diff --git a/boost/math/distributions/bernoulli.hpp b/boost/math/distributions/bernoulli.hpp index 1355eda229..09b8a0a3e1 100644 --- a/boost/math/distributions/bernoulli.hpp +++ b/boost/math/distributions/bernoulli.hpp @@ -89,7 +89,7 @@ namespace boost template <class RealType, class Policy> inline bool check_dist_and_prob(const char* function, RealType p, RealType prob, RealType* result, const Policy& /* pol */) { - if(check_dist(function, p, result, Policy(), typename policies::method_error_check<Policy>::type()) && detail::check_probability(function, prob, result, Policy()) == false) + if((check_dist(function, p, result, Policy(), typename policies::method_error_check<Policy>::type()) && detail::check_probability(function, prob, result, Policy())) == false) { return false; } diff --git a/boost/math/distributions/binomial.hpp b/boost/math/distributions/binomial.hpp index a48c89c5b9..620bf9b121 100644 --- a/boost/math/distributions/binomial.hpp +++ b/boost/math/distributions/binomial.hpp @@ -155,7 +155,7 @@ namespace boost template <class RealType, class Policy> inline bool check_dist_and_prob(const char* function, const RealType& N, RealType p, RealType prob, RealType* result, const Policy& pol) { - if(check_dist(function, N, p, result, pol) && detail::check_probability(function, prob, result, pol) == false) + if((check_dist(function, N, p, result, pol) && detail::check_probability(function, prob, result, pol)) == false) return false; return true; } diff --git a/boost/math/distributions/detail/hypergeometric_pdf.hpp b/boost/math/distributions/detail/hypergeometric_pdf.hpp index 1e6a5ca20d..4364266514 100644 --- a/boost/math/distributions/detail/hypergeometric_pdf.hpp +++ b/boost/math/distributions/detail/hypergeometric_pdf.hpp @@ -311,7 +311,7 @@ T hypergeometric_pdf_prime_loop_imp(hypergeometric_pdf_prime_loop_data& data, hy } if(prime_powers) { - T p = integer_power<T>(data.current_prime, prime_powers); + T p = integer_power<T>(static_cast<T>(data.current_prime), prime_powers); if((p > 1) && (tools::max_value<T>() / p < result.value)) { // diff --git a/boost/math/distributions/detail/hypergeometric_quantile.hpp b/boost/math/distributions/detail/hypergeometric_quantile.hpp index a855a4a777..2cdee23c10 100644 --- a/boost/math/distributions/detail/hypergeometric_quantile.hpp +++ b/boost/math/distributions/detail/hypergeometric_quantile.hpp @@ -130,6 +130,29 @@ unsigned hypergeometric_quantile_imp(T p, T q, unsigned r, unsigned n, unsigned unsigned x = base; result = hypergeometric_pdf<T>(x, r, n, N, pol); T diff = result; + if (diff == 0) + { + ++x; + // We want to skip through x values as fast as we can until we start getting non-zero values, + // otherwise we're just making lots of expensive PDF calls: + T log_pdf = boost::math::lgamma(static_cast<T>(n + 1), pol) + + boost::math::lgamma(static_cast<T>(r + 1), pol) + + boost::math::lgamma(static_cast<T>(N - n + 1), pol) + + boost::math::lgamma(static_cast<T>(N - r + 1), pol) + - boost::math::lgamma(static_cast<T>(N + 1), pol) + - boost::math::lgamma(static_cast<T>(x + 1), pol) + - boost::math::lgamma(static_cast<T>(n - x + 1), pol) + - boost::math::lgamma(static_cast<T>(r - x + 1), pol) + - boost::math::lgamma(static_cast<T>(N - n - r + x + 1), pol); + while (log_pdf < tools::log_min_value<T>()) + { + log_pdf += -log(static_cast<T>(x + 1)) + log(static_cast<T>(n - x)) + log(static_cast<T>(r - x)) - log(static_cast<T>(N - n - r + x + 1)); + ++x; + } + // By the time we get here, log_pdf may be fairly inaccurate due to + // roundoff errors, get a fresh PDF calculation before proceding: + diff = hypergeometric_pdf<T>(x, r, n, N, pol); + } while(result < p) { diff = (diff > tools::min_value<T>() * 8) @@ -155,6 +178,29 @@ unsigned hypergeometric_quantile_imp(T p, T q, unsigned r, unsigned n, unsigned unsigned x = lim; result = 0; T diff = hypergeometric_pdf<T>(x, r, n, N, pol); + if (diff == 0) + { + // We want to skip through x values as fast as we can until we start getting non-zero values, + // otherwise we're just making lots of expensive PDF calls: + --x; + T log_pdf = boost::math::lgamma(static_cast<T>(n + 1), pol) + + boost::math::lgamma(static_cast<T>(r + 1), pol) + + boost::math::lgamma(static_cast<T>(N - n + 1), pol) + + boost::math::lgamma(static_cast<T>(N - r + 1), pol) + - boost::math::lgamma(static_cast<T>(N + 1), pol) + - boost::math::lgamma(static_cast<T>(x + 1), pol) + - boost::math::lgamma(static_cast<T>(n - x + 1), pol) + - boost::math::lgamma(static_cast<T>(r - x + 1), pol) + - boost::math::lgamma(static_cast<T>(N - n - r + x + 1), pol); + while (log_pdf < tools::log_min_value<T>()) + { + log_pdf += log(static_cast<T>(x)) - log(static_cast<T>(n - x + 1)) - log(static_cast<T>(r - x + 1)) + log(static_cast<T>(N - n - r + x)); + --x; + } + // By the time we get here, log_pdf may be fairly inaccurate due to + // roundoff errors, get a fresh PDF calculation before proceding: + diff = hypergeometric_pdf<T>(x, r, n, N, pol); + } while(result + diff / 2 < q) { result += diff; diff --git a/boost/math/distributions/exponential.hpp b/boost/math/distributions/exponential.hpp index bfe7e6b4ac..05c49374ed 100644 --- a/boost/math/distributions/exponential.hpp +++ b/boost/math/distributions/exponential.hpp @@ -117,7 +117,7 @@ inline RealType pdf(const exponential_distribution<RealType, Policy>& dist, cons return result; // Workaround for VC11/12 bug: if ((boost::math::isinf)(x)) - return 0; + return 0; result = lambda * exp(-lambda * x); return result; } // pdf @@ -178,7 +178,7 @@ inline RealType cdf(const complemented2_type<exponential_distribution<RealType, return result; // Workaround for VC11/12 bug: if (c.param >= tools::max_value<RealType>()) - return 0; + return 0; result = exp(-c.param * lambda); return result; diff --git a/boost/math/distributions/extreme_value.hpp b/boost/math/distributions/extreme_value.hpp index 4c6b710cbd..cb86de6612 100644 --- a/boost/math/distributions/extreme_value.hpp +++ b/boost/math/distributions/extreme_value.hpp @@ -100,12 +100,12 @@ inline RealType pdf(const extreme_value_distribution<RealType, Policy>& dist, co RealType a = dist.location(); RealType b = dist.scale(); RealType result = 0; - if((boost::math::isinf)(x)) - return 0.0f; if(0 == detail::verify_scale_b(function, b, &result, Policy())) return result; if(0 == detail::check_finite(function, a, &result, Policy())) return result; + if((boost::math::isinf)(x)) + return 0.0f; if(0 == detail::check_x(function, x, &result, Policy())) return result; RealType e = (a - x) / b; diff --git a/boost/math/distributions/fisher_f.hpp b/boost/math/distributions/fisher_f.hpp index 9e259bcc96..798db2fa75 100644 --- a/boost/math/distributions/fisher_f.hpp +++ b/boost/math/distributions/fisher_f.hpp @@ -78,10 +78,10 @@ RealType pdf(const fisher_f_distribution<RealType, Policy>& dist, const RealType // Error check: RealType error_result = 0; static const char* function = "boost::math::pdf(fisher_f_distribution<%1%> const&, %1%)"; - if(false == detail::check_df( + if(false == (detail::check_df( function, df1, &error_result, Policy()) && detail::check_df( - function, df2, &error_result, Policy())) + function, df2, &error_result, Policy()))) return error_result; if((x < 0) || !(boost::math::isfinite)(x)) diff --git a/boost/math/distributions/geometric.hpp b/boost/math/distributions/geometric.hpp index 88947d6c57..6c9713eadd 100644 --- a/boost/math/distributions/geometric.hpp +++ b/boost/math/distributions/geometric.hpp @@ -105,7 +105,7 @@ namespace boost template <class RealType, class Policy> inline bool check_dist_and_prob(const char* function, RealType p, RealType prob, RealType* result, const Policy& pol) { - if(check_dist(function, p, result, pol) && detail::check_probability(function, prob, result, pol) == false) + if((check_dist(function, p, result, pol) && detail::check_probability(function, prob, result, pol)) == false) { return false; } diff --git a/boost/math/distributions/hypergeometric.hpp b/boost/math/distributions/hypergeometric.hpp index 5d1ebc7388..21449638d9 100644 --- a/boost/math/distributions/hypergeometric.hpp +++ b/boost/math/distributions/hypergeometric.hpp @@ -41,12 +41,12 @@ namespace boost { namespace math { unsigned defective()const { - return m_n; + return m_r; } unsigned sample_count()const { - return m_r; + return m_n; } bool check_params(const char* function, RealType* result)const @@ -84,9 +84,9 @@ namespace boost { namespace math { private: // Data members: - unsigned m_n; // number of "defective" items + unsigned m_n; // number of items picked unsigned m_N; // number of "total" items - unsigned m_r; // number of items picked + unsigned m_r; // number of "defective" items }; // class hypergeometric_distribution @@ -99,8 +99,8 @@ namespace boost { namespace math { # pragma warning(push) # pragma warning(disable:4267) #endif - unsigned r = dist.sample_count(); - unsigned n = dist.defective(); + unsigned r = dist.defective(); + unsigned n = dist.sample_count(); unsigned N = dist.total(); unsigned l = static_cast<unsigned>((std::max)(0, (int)(n + r) - (int)(N))); unsigned u = (std::min)(r, n); @@ -127,7 +127,7 @@ namespace boost { namespace math { return result; return boost::math::detail::hypergeometric_pdf<RealType>( - x, dist.sample_count(), dist.defective(), dist.total(), Policy()); + x, dist.defective(), dist.sample_count(), dist.total(), Policy()); } template <class RealType, class Policy, class U> @@ -156,7 +156,7 @@ namespace boost { namespace math { return result; return boost::math::detail::hypergeometric_cdf<RealType>( - x, dist.sample_count(), dist.defective(), dist.total(), false, Policy()); + x, dist.defective(), dist.sample_count(), dist.total(), false, Policy()); } template <class RealType, class Policy, class U> @@ -185,7 +185,7 @@ namespace boost { namespace math { return result; return boost::math::detail::hypergeometric_cdf<RealType>( - c.param, c.dist.sample_count(), c.dist.defective(), c.dist.total(), true, Policy()); + c.param, c.dist.defective(), c.dist.sample_count(), c.dist.total(), true, Policy()); } template <class RealType, class Policy, class U> @@ -214,7 +214,7 @@ namespace boost { namespace math { if (false == dist.check_params(function, &result)) return result; if(false == detail::check_probability(function, p, &result, Policy())) return result; - return static_cast<RealType>(detail::hypergeometric_quantile(p, RealType(1 - p), dist.sample_count(), dist.defective(), dist.total(), Policy())); + return static_cast<RealType>(detail::hypergeometric_quantile(p, RealType(1 - p), dist.defective(), dist.sample_count(), dist.total(), Policy())); } // quantile template <class RealType, class Policy> @@ -228,30 +228,30 @@ namespace boost { namespace math { if (false == c.dist.check_params(function, &result)) return result; if(false == detail::check_probability(function, c.param, &result, Policy())) return result; - return static_cast<RealType>(detail::hypergeometric_quantile(RealType(1 - c.param), c.param, c.dist.sample_count(), c.dist.defective(), c.dist.total(), Policy())); + return static_cast<RealType>(detail::hypergeometric_quantile(RealType(1 - c.param), c.param, c.dist.defective(), c.dist.sample_count(), c.dist.total(), Policy())); } // quantile template <class RealType, class Policy> inline RealType mean(const hypergeometric_distribution<RealType, Policy>& dist) { - return static_cast<RealType>(dist.sample_count() * dist.defective()) / dist.total(); + return static_cast<RealType>(dist.defective() * dist.sample_count()) / dist.total(); } // RealType mean(const hypergeometric_distribution<RealType, Policy>& dist) template <class RealType, class Policy> inline RealType variance(const hypergeometric_distribution<RealType, Policy>& dist) { - RealType r = static_cast<RealType>(dist.sample_count()); - RealType n = static_cast<RealType>(dist.defective()); + RealType r = static_cast<RealType>(dist.defective()); + RealType n = static_cast<RealType>(dist.sample_count()); RealType N = static_cast<RealType>(dist.total()); - return r * (n / N) * (1 - n / N) * (N - r) / (N - 1); + return n * r * (N - r) * (N - n) / (N * N * (N - 1)); } // RealType variance(const hypergeometric_distribution<RealType, Policy>& dist) template <class RealType, class Policy> inline RealType mode(const hypergeometric_distribution<RealType, Policy>& dist) { BOOST_MATH_STD_USING - RealType r = static_cast<RealType>(dist.sample_count()); - RealType n = static_cast<RealType>(dist.defective()); + RealType r = static_cast<RealType>(dist.defective()); + RealType n = static_cast<RealType>(dist.sample_count()); RealType N = static_cast<RealType>(dist.total()); return floor((r + 1) * (n + 1) / (N + 2)); } @@ -260,17 +260,17 @@ namespace boost { namespace math { inline RealType skewness(const hypergeometric_distribution<RealType, Policy>& dist) { BOOST_MATH_STD_USING - RealType r = static_cast<RealType>(dist.sample_count()); - RealType n = static_cast<RealType>(dist.defective()); + RealType r = static_cast<RealType>(dist.defective()); + RealType n = static_cast<RealType>(dist.sample_count()); RealType N = static_cast<RealType>(dist.total()); - return (N - 2 * n) * sqrt(N - 1) * (N - 2 * r) / (sqrt(n * r * (N - n) * (N - r)) * (N - 2)); + return (N - 2 * r) * sqrt(N - 1) * (N - 2 * n) / (sqrt(n * r * (N - r) * (N - n)) * (N - 2)); } // RealType skewness(const hypergeometric_distribution<RealType, Policy>& dist) template <class RealType, class Policy> inline RealType kurtosis_excess(const hypergeometric_distribution<RealType, Policy>& dist) { - RealType r = static_cast<RealType>(dist.sample_count()); - RealType n = static_cast<RealType>(dist.defective()); + RealType r = static_cast<RealType>(dist.defective()); + RealType n = static_cast<RealType>(dist.sample_count()); RealType N = static_cast<RealType>(dist.total()); RealType t1 = N * N * (N - 1) / (r * (N - 2) * (N - 3) * (N - r)); RealType t2 = (N * (N + 1) - 6 * N * (N - r)) / (n * (N - n)) diff --git a/boost/math/distributions/inverse_gaussian.hpp b/boost/math/distributions/inverse_gaussian.hpp index eeca12ad48..e3aa4e0650 100644 --- a/boost/math/distributions/inverse_gaussian.hpp +++ b/boost/math/distributions/inverse_gaussian.hpp @@ -82,6 +82,7 @@ public: RealType result; detail::check_scale(function, l_scale, &result, Policy()); detail::check_location(function, l_mean, &result, Policy()); + detail::check_x_gt0(function, l_mean, &result, Policy()); } RealType mean()const @@ -146,6 +147,10 @@ inline RealType pdf(const inverse_gaussian_distribution<RealType, Policy>& dist, { return result; } + if(false == detail::check_x_gt0(function, mean, &result, Policy())) + { + return result; + } if(false == detail::check_positive_x(function, x, &result, Policy())) { return result; @@ -179,6 +184,10 @@ inline RealType cdf(const inverse_gaussian_distribution<RealType, Policy>& dist, { return result; } + if (false == detail::check_x_gt0(function, mean, &result, Policy())) + { + return result; + } if(false == detail::check_positive_x(function, x, &result, Policy())) { return result; @@ -322,6 +331,8 @@ inline RealType quantile(const inverse_gaussian_distribution<RealType, Policy>& return result; if(false == detail::check_location(function, mean, &result, Policy())) return result; + if (false == detail::check_x_gt0(function, mean, &result, Policy())) + return result; if(false == detail::check_probability(function, p, &result, Policy())) return result; if (p == 0) @@ -380,6 +391,8 @@ inline RealType cdf(const complemented2_type<inverse_gaussian_distribution<RealT return result; if(false == detail::check_location(function, mean, &result, Policy())) return result; + if (false == detail::check_x_gt0(function, mean, &result, Policy())) + return result; if(false == detail::check_positive_x(function, x, &result, Policy())) return result; @@ -412,6 +425,8 @@ inline RealType quantile(const complemented2_type<inverse_gaussian_distribution< return result; if(false == detail::check_location(function, mean, &result, Policy())) return result; + if (false == detail::check_x_gt0(function, mean, &result, Policy())) + return result; RealType q = c.param; if(false == detail::check_probability(function, q, &result, Policy())) return result; diff --git a/boost/math/distributions/negative_binomial.hpp b/boost/math/distributions/negative_binomial.hpp index ca5723fa7d..3b4de4062f 100644 --- a/boost/math/distributions/negative_binomial.hpp +++ b/boost/math/distributions/negative_binomial.hpp @@ -124,7 +124,7 @@ namespace boost template <class RealType, class Policy> inline bool check_dist_and_prob(const char* function, const RealType& r, RealType p, RealType prob, RealType* result, const Policy& pol) { - if(check_dist(function, r, p, result, pol) && detail::check_probability(function, prob, result, pol) == false) + if((check_dist(function, r, p, result, pol) && detail::check_probability(function, prob, result, pol)) == false) { return false; } diff --git a/boost/math/distributions/non_central_beta.hpp b/boost/math/distributions/non_central_beta.hpp index 6e699e509f..aa66ecec0d 100644 --- a/boost/math/distributions/non_central_beta.hpp +++ b/boost/math/distributions/non_central_beta.hpp @@ -515,7 +515,11 @@ namespace boost T non_central_beta_pdf(T a, T b, T lam, T x, T y, const Policy& pol) { BOOST_MATH_STD_USING - using namespace boost::math; + // + // Special cases: + // + if((x == 0) || (y == 0)) + return 0; // // Variables come first: // diff --git a/boost/math/distributions/non_central_chi_squared.hpp b/boost/math/distributions/non_central_chi_squared.hpp index 88933c1956..97f87ed4c0 100644 --- a/boost/math/distributions/non_central_chi_squared.hpp +++ b/boost/math/distributions/non_central_chi_squared.hpp @@ -73,7 +73,7 @@ namespace boost // int k = iround(lambda, pol); // Forwards and backwards Poisson weights: - T poisf = boost::math::gamma_p_derivative(1 + k, lambda, pol); + T poisf = boost::math::gamma_p_derivative(static_cast<T>(1 + k), lambda, pol); T poisb = poisf * k / lambda; // Initial forwards central chi squared term: T gamf = boost::math::gamma_q(del + k, y, pol); @@ -225,7 +225,7 @@ namespace boost // Central chi squared term for backward iteration: T gamkb = gamkf; // Forwards Poisson weight: - T poiskf = gamma_p_derivative(k+1, del, pol); + T poiskf = gamma_p_derivative(static_cast<T>(k+1), del, pol); // Backwards Poisson weight: T poiskb = poiskf; // Forwards gamma function recursion term: @@ -295,7 +295,7 @@ namespace boost T l2 = lambda / 2; T sum = 0; int k = itrunc(l2); - T pois = gamma_p_derivative(k + 1, l2, pol) * gamma_p_derivative(n2 + k, x2); + T pois = gamma_p_derivative(static_cast<T>(k + 1), l2, pol) * gamma_p_derivative(static_cast<T>(n2 + k), x2); if(pois == 0) return 0; T poisb = pois; @@ -334,7 +334,7 @@ namespace boost BOOST_MATH_STD_USING value_type result; if(l == 0) - result = cdf(boost::math::chi_squared_distribution<RealType, Policy>(k), x); + return invert == false ? cdf(boost::math::chi_squared_distribution<RealType, Policy>(k), x) : cdf(complement(boost::math::chi_squared_distribution<RealType, Policy>(k), x)); else if(x > k + l) { // Complement is the smaller of the two: @@ -442,7 +442,7 @@ namespace boost // noncentral chi squared", Biometrika 46: 364. // See also: // "A comparison of approximations to percentiles of the noncentral chi2-distribution", - // Hardeo Sahai and Mario Miguel Ojeda, Revista de Matematica: Teoria y Aplicaciones 2003 10(1–2) : 57–76. + // Hardeo Sahai and Mario Miguel Ojeda, Revista de Matematica: Teoria y Aplicaciones 2003 10(1-2) : 57-76. // Note that the latter reference refers to an approximation of the CDF, when they really mean the quantile. // value_type b = -(l * l) / (k + 3 * l); @@ -693,18 +693,18 @@ namespace boost static RealType find_degrees_of_freedom(RealType lam, RealType x, RealType p) { const char* function = "non_central_chi_squared<%1%>::find_degrees_of_freedom"; - typedef typename policies::evaluation<RealType, Policy>::type value_type; + typedef typename policies::evaluation<RealType, Policy>::type eval_type; typedef typename policies::normalise< Policy, policies::promote_float<false>, policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - value_type result = detail::find_degrees_of_freedom( - static_cast<value_type>(lam), - static_cast<value_type>(x), - static_cast<value_type>(p), - static_cast<value_type>(1-p), + eval_type result = detail::find_degrees_of_freedom( + static_cast<eval_type>(lam), + static_cast<eval_type>(x), + static_cast<eval_type>(p), + static_cast<eval_type>(1-p), forwarding_policy()); return policies::checked_narrowing_cast<RealType, forwarding_policy>( result, @@ -714,18 +714,18 @@ namespace boost static RealType find_degrees_of_freedom(const complemented3_type<A,B,C>& c) { const char* function = "non_central_chi_squared<%1%>::find_degrees_of_freedom"; - typedef typename policies::evaluation<RealType, Policy>::type value_type; + typedef typename policies::evaluation<RealType, Policy>::type eval_type; typedef typename policies::normalise< Policy, policies::promote_float<false>, policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - value_type result = detail::find_degrees_of_freedom( - static_cast<value_type>(c.dist), - static_cast<value_type>(c.param1), - static_cast<value_type>(1-c.param2), - static_cast<value_type>(c.param2), + eval_type result = detail::find_degrees_of_freedom( + static_cast<eval_type>(c.dist), + static_cast<eval_type>(c.param1), + static_cast<eval_type>(1-c.param2), + static_cast<eval_type>(c.param2), forwarding_policy()); return policies::checked_narrowing_cast<RealType, forwarding_policy>( result, @@ -734,18 +734,18 @@ namespace boost static RealType find_non_centrality(RealType v, RealType x, RealType p) { const char* function = "non_central_chi_squared<%1%>::find_non_centrality"; - typedef typename policies::evaluation<RealType, Policy>::type value_type; + typedef typename policies::evaluation<RealType, Policy>::type eval_type; typedef typename policies::normalise< Policy, policies::promote_float<false>, policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - value_type result = detail::find_non_centrality( - static_cast<value_type>(v), - static_cast<value_type>(x), - static_cast<value_type>(p), - static_cast<value_type>(1-p), + eval_type result = detail::find_non_centrality( + static_cast<eval_type>(v), + static_cast<eval_type>(x), + static_cast<eval_type>(p), + static_cast<eval_type>(1-p), forwarding_policy()); return policies::checked_narrowing_cast<RealType, forwarding_policy>( result, @@ -755,18 +755,18 @@ namespace boost static RealType find_non_centrality(const complemented3_type<A,B,C>& c) { const char* function = "non_central_chi_squared<%1%>::find_non_centrality"; - typedef typename policies::evaluation<RealType, Policy>::type value_type; + typedef typename policies::evaluation<RealType, Policy>::type eval_type; typedef typename policies::normalise< Policy, policies::promote_float<false>, policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - value_type result = detail::find_non_centrality( - static_cast<value_type>(c.dist), - static_cast<value_type>(c.param1), - static_cast<value_type>(1-c.param2), - static_cast<value_type>(c.param2), + eval_type result = detail::find_non_centrality( + static_cast<eval_type>(c.dist), + static_cast<eval_type>(c.param1), + static_cast<eval_type>(1-c.param2), + static_cast<eval_type>(c.param2), forwarding_policy()); return policies::checked_narrowing_cast<RealType, forwarding_policy>( result, diff --git a/boost/math/distributions/non_central_t.hpp b/boost/math/distributions/non_central_t.hpp index df7a58e575..718453b657 100644 --- a/boost/math/distributions/non_central_t.hpp +++ b/boost/math/distributions/non_central_t.hpp @@ -90,7 +90,7 @@ namespace boost betaf -= xtermf; T term = poisf * betaf; sum += term; - if((fabs(last_term) > fabs(term)) && (fabs(term/sum) < errtol)) + if((fabs(last_term) >= fabs(term)) && (fabs(term/sum) < errtol)) break; last_term = term; ++count; @@ -358,7 +358,7 @@ namespace boost s = boost::math::sign(pzero - q); if(s != boost::math::sign(guess)) { - guess = s; + guess = static_cast<T>(s); } value_type result = detail::generic_quantile( diff --git a/boost/math/distributions/rayleigh.hpp b/boost/math/distributions/rayleigh.hpp index 01f38c0b01..744733a9fa 100644 --- a/boost/math/distributions/rayleigh.hpp +++ b/boost/math/distributions/rayleigh.hpp @@ -182,7 +182,7 @@ inline RealType cdf(const complemented2_type<rayleigh_distribution<RealType, Pol RealType ea = x * x / (2 * sigma * sigma); // Fix for VC11/12 x64 bug in exp(float): if (ea >= tools::max_value<RealType>()) - return 0; + return 0; result = exp(-ea); return result; } // cdf complement diff --git a/boost/math/distributions/skew_normal.hpp b/boost/math/distributions/skew_normal.hpp index 98348e59bb..f348347ede 100644 --- a/boost/math/distributions/skew_normal.hpp +++ b/boost/math/distributions/skew_normal.hpp @@ -122,15 +122,6 @@ namespace boost{ namespace math{ const RealType shape = dist.shape(); static const char* function = "boost::math::pdf(const skew_normal_distribution<%1%>&, %1%)"; - if((boost::math::isinf)(x)) - { - return 0; // pdf + and - infinity is zero. - } - // Below produces MSVC 4127 warnings, so the above used instead. - //if(std::numeric_limits<RealType>::has_infinity && abs(x) == std::numeric_limits<RealType>::infinity()) - //{ // pdf + and - infinity is zero. - // return 0; - //} RealType result = 0; if(false == detail::check_scale(function, scale, &result, Policy())) @@ -145,6 +136,15 @@ namespace boost{ namespace math{ { return result; } + if((boost::math::isinf)(x)) + { + return 0; // pdf + and - infinity is zero. + } + // Below produces MSVC 4127 warnings, so the above used instead. + //if(std::numeric_limits<RealType>::has_infinity && abs(x) == std::numeric_limits<RealType>::infinity()) + //{ // pdf + and - infinity is zero. + // return 0; + //} if(false == detail::check_x(function, x, &result, Policy())) { return result; diff --git a/boost/math/distributions/triangular.hpp b/boost/math/distributions/triangular.hpp index 78ef0df744..1e49a38faf 100644 --- a/boost/math/distributions/triangular.hpp +++ b/boost/math/distributions/triangular.hpp @@ -8,6 +8,12 @@ #define BOOST_STATS_TRIANGULAR_HPP // http://mathworld.wolfram.com/TriangularDistribution.html +// Note that the 'constructors' defined by Wolfram are difference from those here, +// for example +// N[variance[triangulardistribution{1, +2}, 1.5], 50] computes +// 0.041666666666666666666666666666666666666666666666667 +// TriangularDistribution{1, +2}, 1.5 is the analog of triangular_distribution(1, 1.5, 2) + // http://en.wikipedia.org/wiki/Triangular_distribution #include <boost/math/distributions/fwd.hpp> @@ -449,7 +455,7 @@ namespace boost{ namespace math } RealType lower = dist.lower(); RealType upper = dist.upper(); - if (mode < (upper - lower) / 2) + if (mode >= (upper + lower) / 2) { return lower + sqrt((upper - lower) * (mode - lower)) / constants::root_two<RealType>(); } @@ -475,7 +481,9 @@ namespace boost{ namespace math return result; } return root_two<RealType>() * (lower + upper - 2 * mode) * (2 * lower - upper - mode) * (lower - 2 * upper + mode) / - (5 * pow((lower * lower + upper + upper + mode * mode - lower * upper - lower * mode - upper * mode), RealType(3)/RealType(2))); + (5 * pow((lower * lower + upper * upper + mode * mode + - lower * upper - lower * mode - upper * mode), RealType(3)/RealType(2))); + // #11768: Skewness formula for triangular distribution is incorrect - corrected 29 Oct 2015 for release 1.61. } // RealType skewness(const triangular_distribution<RealType, Policy>& dist) template <class RealType, class Policy> diff --git a/boost/math/distributions/uniform.hpp b/boost/math/distributions/uniform.hpp index a20597a66a..856c144e36 100644 --- a/boost/math/distributions/uniform.hpp +++ b/boost/math/distributions/uniform.hpp @@ -269,15 +269,18 @@ namespace boost{ namespace math return result; } if(false == detail::check_probability("boost::math::quantile(const uniform_distribution<%1%>&, %1%)", q, &result, Policy())) - if(q == 0) - { - return lower; - } - if(q == 1) - { - return upper; - } - return -q * (upper - lower) + upper; + { + return result; + } + if(q == 0) + { + return upper; + } + if(q == 1) + { + return lower; + } + return -q * (upper - lower) + upper; } // RealType quantile(const complemented2_type<uniform_distribution<RealType, Policy>, RealType>& c) template <class RealType, class Policy> diff --git a/boost/math/policies/error_handling.hpp b/boost/math/policies/error_handling.hpp index 674759006e..285fbea7c4 100644 --- a/boost/math/policies/error_handling.hpp +++ b/boost/math/policies/error_handling.hpp @@ -157,11 +157,11 @@ inline T raise_domain_error( } template <class T> -inline T raise_domain_error( +inline BOOST_MATH_CONSTEXPR T raise_domain_error( const char* , const char* , const T& , - const ::boost::math::policies::domain_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::domain_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -173,7 +173,7 @@ inline T raise_domain_error( const char* , const char* , const T& , - const ::boost::math::policies::domain_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::domain_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = EDOM; // This may or may not do the right thing, but the user asked for the error @@ -202,21 +202,21 @@ inline T raise_pole_error( } template <class T> -inline T raise_pole_error( +inline BOOST_MATH_CONSTEXPR T raise_pole_error( const char* function, const char* message, const T& val, - const ::boost::math::policies::pole_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::pole_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { return ::boost::math::policies::detail::raise_domain_error(function, message, val, ::boost::math::policies::domain_error< ::boost::math::policies::ignore_error>()); } template <class T> -inline T raise_pole_error( +inline BOOST_MATH_CONSTEXPR T raise_pole_error( const char* function, const char* message, const T& val, - const ::boost::math::policies::pole_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::pole_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { return ::boost::math::policies::detail::raise_domain_error(function, message, val, ::boost::math::policies::domain_error< ::boost::math::policies::errno_on_error>()); } @@ -256,10 +256,10 @@ inline T raise_overflow_error( } template <class T> -inline T raise_overflow_error( +inline BOOST_MATH_CONSTEXPR T raise_overflow_error( const char* , const char* , - const ::boost::math::policies::overflow_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::overflow_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -267,11 +267,11 @@ inline T raise_overflow_error( } template <class T> -inline T raise_overflow_error( +inline BOOST_MATH_CONSTEXPR T raise_overflow_error( const char* , const char* , const T&, - const ::boost::math::policies::overflow_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::overflow_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -282,7 +282,7 @@ template <class T> inline T raise_overflow_error( const char* , const char* , - const ::boost::math::policies::overflow_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::overflow_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = ERANGE; // This may or may not do the right thing, but the user asked for the error @@ -295,7 +295,7 @@ inline T raise_overflow_error( const char* , const char* , const T&, - const ::boost::math::policies::overflow_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::overflow_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = ERANGE; // This may or may not do the right thing, but the user asked for the error @@ -342,10 +342,10 @@ inline T raise_underflow_error( } template <class T> -inline T raise_underflow_error( +inline BOOST_MATH_CONSTEXPR T raise_underflow_error( const char* , const char* , - const ::boost::math::policies::underflow_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::underflow_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -356,7 +356,7 @@ template <class T> inline T raise_underflow_error( const char* /* function */, const char* /* message */, - const ::boost::math::policies::underflow_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::underflow_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = ERANGE; // This may or may not do the right thing, but the user asked for the error @@ -386,11 +386,11 @@ inline T raise_denorm_error( } template <class T> -inline T raise_denorm_error( +inline BOOST_MATH_CONSTEXPR T raise_denorm_error( const char* , const char* , const T& val, - const ::boost::math::policies::denorm_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::denorm_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -402,7 +402,7 @@ inline T raise_denorm_error( const char* , const char* , const T& val, - const ::boost::math::policies::denorm_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::denorm_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = ERANGE; // This may or may not do the right thing, but the user asked for the error @@ -433,11 +433,11 @@ inline T raise_evaluation_error( } template <class T> -inline T raise_evaluation_error( +inline BOOST_MATH_CONSTEXPR T raise_evaluation_error( const char* , const char* , const T& val, - const ::boost::math::policies::evaluation_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::evaluation_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -449,7 +449,7 @@ inline T raise_evaluation_error( const char* , const char* , const T& val, - const ::boost::math::policies::evaluation_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::evaluation_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = EDOM; // This may or may not do the right thing, but the user asked for the error @@ -481,12 +481,12 @@ inline TargetType raise_rounding_error( } template <class T, class TargetType> -inline TargetType raise_rounding_error( +inline BOOST_MATH_CONSTEXPR TargetType raise_rounding_error( const char* , const char* , const T& val, const TargetType&, - const ::boost::math::policies::rounding_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::rounding_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -500,7 +500,7 @@ inline TargetType raise_rounding_error( const char* , const T& val, const TargetType&, - const ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error>&) + const ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) { errno = ERANGE; // This may or may not do the right thing, but the user asked for the error @@ -509,6 +509,20 @@ inline TargetType raise_rounding_error( return val > 0 ? (std::numeric_limits<TargetType>::max)() : (std::numeric_limits<TargetType>::is_integer ? (std::numeric_limits<TargetType>::min)() : -(std::numeric_limits<TargetType>::max)()); } +template <class T> +inline T raise_rounding_error( + const char* , + const char* , + const T& val, + const T&, + const ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error>&) BOOST_MATH_NOEXCEPT(T) +{ + errno = ERANGE; + // This may or may not do the right thing, but the user asked for the error + // to be silent so here we go anyway: + return val > 0 ? boost::math::tools::max_value<T>() : -boost::math::tools::max_value<T>(); +} + template <class T, class TargetType> inline TargetType raise_rounding_error( const char* function, @@ -534,12 +548,12 @@ inline T raise_indeterminate_result_error( } template <class T, class R> -inline T raise_indeterminate_result_error( +inline BOOST_MATH_CONSTEXPR T raise_indeterminate_result_error( const char* , const char* , const T& , const R& result, - const ::boost::math::policies::indeterminate_result_error< ::boost::math::policies::ignore_error>&) + const ::boost::math::policies::indeterminate_result_error< ::boost::math::policies::ignore_error>&) BOOST_MATH_NOEXCEPT(T) { // This may or may not do the right thing, but the user asked for the error // to be ignored so here we go anyway: @@ -574,7 +588,7 @@ inline T raise_indeterminate_result_error( } // namespace detail template <class T, class Policy> -inline T raise_domain_error(const char* function, const char* message, const T& val, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_domain_error(const char* function, const char* message, const T& val, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::domain_error_type policy_type; return detail::raise_domain_error( @@ -583,7 +597,7 @@ inline T raise_domain_error(const char* function, const char* message, const T& } template <class T, class Policy> -inline T raise_pole_error(const char* function, const char* message, const T& val, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_pole_error(const char* function, const char* message, const T& val, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::pole_error_type policy_type; return detail::raise_pole_error( @@ -592,7 +606,7 @@ inline T raise_pole_error(const char* function, const char* message, const T& va } template <class T, class Policy> -inline T raise_overflow_error(const char* function, const char* message, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_overflow_error(const char* function, const char* message, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::overflow_error_type policy_type; return detail::raise_overflow_error<T>( @@ -601,7 +615,7 @@ inline T raise_overflow_error(const char* function, const char* message, const P } template <class T, class Policy> -inline T raise_overflow_error(const char* function, const char* message, const T& val, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_overflow_error(const char* function, const char* message, const T& val, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::overflow_error_type policy_type; return detail::raise_overflow_error( @@ -610,7 +624,7 @@ inline T raise_overflow_error(const char* function, const char* message, const T } template <class T, class Policy> -inline T raise_underflow_error(const char* function, const char* message, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_underflow_error(const char* function, const char* message, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::underflow_error_type policy_type; return detail::raise_underflow_error<T>( @@ -619,7 +633,7 @@ inline T raise_underflow_error(const char* function, const char* message, const } template <class T, class Policy> -inline T raise_denorm_error(const char* function, const char* message, const T& val, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_denorm_error(const char* function, const char* message, const T& val, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::denorm_error_type policy_type; return detail::raise_denorm_error<T>( @@ -629,7 +643,7 @@ inline T raise_denorm_error(const char* function, const char* message, const T& } template <class T, class Policy> -inline T raise_evaluation_error(const char* function, const char* message, const T& val, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_evaluation_error(const char* function, const char* message, const T& val, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::evaluation_error_type policy_type; return detail::raise_evaluation_error( @@ -638,7 +652,7 @@ inline T raise_evaluation_error(const char* function, const char* message, const } template <class T, class TargetType, class Policy> -inline TargetType raise_rounding_error(const char* function, const char* message, const T& val, const TargetType& t, const Policy&) +inline BOOST_MATH_CONSTEXPR TargetType raise_rounding_error(const char* function, const char* message, const T& val, const TargetType& t, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::rounding_error_type policy_type; return detail::raise_rounding_error( @@ -647,7 +661,7 @@ inline TargetType raise_rounding_error(const char* function, const char* message } template <class T, class R, class Policy> -inline T raise_indeterminate_result_error(const char* function, const char* message, const T& val, const R& result, const Policy&) +inline BOOST_MATH_CONSTEXPR T raise_indeterminate_result_error(const char* function, const char* message, const T& val, const R& result, const Policy&) BOOST_NOEXCEPT_IF(is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T)) { typedef typename Policy::indeterminate_result_error_type policy_type; return detail::raise_indeterminate_result_error( @@ -662,7 +676,7 @@ namespace detail { template <class R, class T, class Policy> -inline bool check_overflow(T val, R* result, const char* function, const Policy& pol) +inline bool check_overflow(T val, R* result, const char* function, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && (Policy::value != throw_on_error) && (Policy::value != user_error)) { BOOST_MATH_STD_USING if(fabs(val) > tools::max_value<R>()) @@ -674,7 +688,7 @@ inline bool check_overflow(T val, R* result, const char* function, const Policy& return false; } template <class R, class T, class Policy> -inline bool check_overflow(std::complex<T> val, R* result, const char* function, const Policy& pol) +inline bool check_overflow(std::complex<T> val, R* result, const char* function, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && (Policy::value != throw_on_error) && (Policy::value != user_error)) { typedef typename R::value_type r_type; r_type re, im; @@ -684,7 +698,7 @@ inline bool check_overflow(std::complex<T> val, R* result, const char* function, return r; } template <class R, class T, class Policy> -inline bool check_underflow(T val, R* result, const char* function, const Policy& pol) +inline bool check_underflow(T val, R* result, const char* function, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && (Policy::value != throw_on_error) && (Policy::value != user_error)) { if((val != 0) && (static_cast<R>(val) == 0)) { @@ -694,7 +708,7 @@ inline bool check_underflow(T val, R* result, const char* function, const Policy return false; } template <class R, class T, class Policy> -inline bool check_underflow(std::complex<T> val, R* result, const char* function, const Policy& pol) +inline bool check_underflow(std::complex<T> val, R* result, const char* function, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && (Policy::value != throw_on_error) && (Policy::value != user_error)) { typedef typename R::value_type r_type; r_type re, im; @@ -704,7 +718,7 @@ inline bool check_underflow(std::complex<T> val, R* result, const char* function return r; } template <class R, class T, class Policy> -inline bool check_denorm(T val, R* result, const char* function, const Policy& pol) +inline bool check_denorm(T val, R* result, const char* function, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && (Policy::value != throw_on_error) && (Policy::value != user_error)) { BOOST_MATH_STD_USING if((fabs(val) < static_cast<T>(tools::min_value<R>())) && (static_cast<R>(val) != 0)) @@ -715,7 +729,7 @@ inline bool check_denorm(T val, R* result, const char* function, const Policy& p return false; } template <class R, class T, class Policy> -inline bool check_denorm(std::complex<T> val, R* result, const char* function, const Policy& pol) +inline bool check_denorm(std::complex<T> val, R* result, const char* function, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && (Policy::value != throw_on_error) && (Policy::value != user_error)) { typedef typename R::value_type r_type; r_type re, im; @@ -727,22 +741,28 @@ inline bool check_denorm(std::complex<T> val, R* result, const char* function, c // Default instantiations with ignore_error policy. template <class R, class T> -inline bool check_overflow(T /* val */, R* /* result */, const char* /* function */, const overflow_error<ignore_error>&){ return false; } +inline BOOST_MATH_CONSTEXPR bool check_overflow(T /* val */, R* /* result */, const char* /* function */, const overflow_error<ignore_error>&) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T)) +{ return false; } template <class R, class T> -inline bool check_overflow(std::complex<T> /* val */, R* /* result */, const char* /* function */, const overflow_error<ignore_error>&){ return false; } +inline BOOST_MATH_CONSTEXPR bool check_overflow(std::complex<T> /* val */, R* /* result */, const char* /* function */, const overflow_error<ignore_error>&) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T)) +{ return false; } template <class R, class T> -inline bool check_underflow(T /* val */, R* /* result */, const char* /* function */, const underflow_error<ignore_error>&){ return false; } +inline BOOST_MATH_CONSTEXPR bool check_underflow(T /* val */, R* /* result */, const char* /* function */, const underflow_error<ignore_error>&) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T)) +{ return false; } template <class R, class T> -inline bool check_underflow(std::complex<T> /* val */, R* /* result */, const char* /* function */, const underflow_error<ignore_error>&){ return false; } +inline BOOST_MATH_CONSTEXPR bool check_underflow(std::complex<T> /* val */, R* /* result */, const char* /* function */, const underflow_error<ignore_error>&) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T)) +{ return false; } template <class R, class T> -inline bool check_denorm(T /* val */, R* /* result*/, const char* /* function */, const denorm_error<ignore_error>&){ return false; } +inline BOOST_MATH_CONSTEXPR bool check_denorm(T /* val */, R* /* result*/, const char* /* function */, const denorm_error<ignore_error>&) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T)) +{ return false; } template <class R, class T> -inline bool check_denorm(std::complex<T> /* val */, R* /* result*/, const char* /* function */, const denorm_error<ignore_error>&){ return false; } +inline BOOST_MATH_CONSTEXPR bool check_denorm(std::complex<T> /* val */, R* /* result*/, const char* /* function */, const denorm_error<ignore_error>&) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T)) +{ return false; } } // namespace detail template <class R, class Policy, class T> -inline R checked_narrowing_cast(T val, const char* function) +inline R checked_narrowing_cast(T val, const char* function) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(R) && BOOST_MATH_IS_FLOAT(T) && is_noexcept_error_policy<Policy>::value) { typedef typename Policy::overflow_error_type overflow_type; typedef typename Policy::underflow_error_type underflow_type; @@ -762,7 +782,7 @@ inline R checked_narrowing_cast(T val, const char* function) } template <class T, class Policy> -inline void check_series_iterations(const char* function, boost::uintmax_t max_iter, const Policy& pol) +inline void check_series_iterations(const char* function, boost::uintmax_t max_iter, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && is_noexcept_error_policy<Policy>::value) { if(max_iter >= policies::get_max_series_iterations<Policy>()) raise_evaluation_error<T>( @@ -771,7 +791,7 @@ inline void check_series_iterations(const char* function, boost::uintmax_t max_i } template <class T, class Policy> -inline void check_root_iterations(const char* function, boost::uintmax_t max_iter, const Policy& pol) +inline void check_root_iterations(const char* function, boost::uintmax_t max_iter, const Policy& pol) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && is_noexcept_error_policy<Policy>::value) { if(max_iter >= policies::get_max_root_iterations<Policy>()) raise_evaluation_error<T>( @@ -788,7 +808,7 @@ namespace detail{ // that value usually comes from one of the error handlers above: // template <class T> -std::pair<T, T> pair_from_single(const T& val) +std::pair<T, T> pair_from_single(const T& val) BOOST_MATH_NOEXCEPT(T) { return std::make_pair(val, val); } diff --git a/boost/math/policies/policy.hpp b/boost/math/policies/policy.hpp index 71309fa116..de813fb8aa 100644 --- a/boost/math/policies/policy.hpp +++ b/boost/math/policies/policy.hpp @@ -33,9 +33,9 @@ namespace boost{ namespace math{ namespace tools{ template <class T> -int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)); +BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT; template <class T> -T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)); +BOOST_MATH_CONSTEXPR T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T); } @@ -44,6 +44,28 @@ namespace policies{ // // Define macros for our default policies, if they're not defined already: // +// Special cases for exceptions disabled first: +// +#ifdef BOOST_NO_EXCEPTIONS +# ifndef BOOST_MATH_DOMAIN_ERROR_POLICY +# define BOOST_MATH_DOMAIN_ERROR_POLICY errno_on_error +# endif +# ifndef BOOST_MATH_POLE_ERROR_POLICY +# define BOOST_MATH_POLE_ERROR_POLICY errno_on_error +# endif +# ifndef BOOST_MATH_OVERFLOW_ERROR_POLICY +# define BOOST_MATH_OVERFLOW_ERROR_POLICY errno_on_error +# endif +# ifndef BOOST_MATH_EVALUATION_ERROR_POLICY +# define BOOST_MATH_EVALUATION_ERROR_POLICY errno_on_error +# endif +# ifndef BOOST_MATH_ROUNDING_ERROR_POLICY +# define BOOST_MATH_ROUNDING_ERROR_POLICY errno_on_error +# endif +#endif +// +// Then the regular cases: +// #ifndef BOOST_MATH_DOMAIN_ERROR_POLICY #define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error #endif @@ -622,81 +644,81 @@ struct normalise<policy<detail::forwarding_arg1, detail::forwarding_arg2>, typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type; }; -inline policy<> make_policy() +inline BOOST_MATH_CONSTEXPR policy<> make_policy() BOOST_NOEXCEPT { return policy<>(); } template <class A1> -inline typename normalise<policy<>, A1>::type make_policy(const A1&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1>::type make_policy(const A1&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1>::type result_type; return result_type(); } template <class A1, class A2> -inline typename normalise<policy<>, A1, A2>::type make_policy(const A1&, const A2&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2>::type make_policy(const A1&, const A2&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2>::type result_type; return result_type(); } template <class A1, class A2, class A3> -inline typename normalise<policy<>, A1, A2, A3>::type make_policy(const A1&, const A2&, const A3&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3>::type make_policy(const A1&, const A2&, const A3&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4> -inline typename normalise<policy<>, A1, A2, A3, A4>::type make_policy(const A1&, const A2&, const A3&, const A4&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4>::type make_policy(const A1&, const A2&, const A3&, const A4&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5> -inline typename normalise<policy<>, A1, A2, A3, A4, A5>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5, class A6> -inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5, class A6, class A7> -inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> -inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> -inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> -inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type result_type; return result_type(); } template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> -inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&, const A11&) +inline BOOST_MATH_CONSTEXPR typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&, const A11&) BOOST_NOEXCEPT { typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type result_type; return result_type(); @@ -825,7 +847,7 @@ struct precision<BOOST_MATH_FLOAT128_TYPE, Policy> namespace detail{ template <class T, class Policy> -inline int digits_imp(mpl::true_ const&) +inline BOOST_MATH_CONSTEXPR int digits_imp(mpl::true_ const&) BOOST_NOEXCEPT { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); @@ -837,7 +859,7 @@ inline int digits_imp(mpl::true_ const&) } template <class T, class Policy> -inline int digits_imp(mpl::false_ const&) +inline BOOST_MATH_CONSTEXPR int digits_imp(mpl::false_ const&) BOOST_NOEXCEPT { return tools::digits<T>(); } @@ -845,26 +867,26 @@ inline int digits_imp(mpl::false_ const&) } // namespace detail template <class T, class Policy> -inline int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT { typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type; return detail::digits_imp<T, Policy>(tag_type()); } template <class T, class Policy> -inline int digits_base10(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR int digits_base10(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT { return boost::math::policies::digits<T, Policy>() * 301 / 1000L; } template <class Policy> -inline unsigned long get_max_series_iterations() +inline BOOST_MATH_CONSTEXPR unsigned long get_max_series_iterations() BOOST_NOEXCEPT { typedef typename Policy::max_series_iterations_type iter_type; return iter_type::value; } template <class Policy> -inline unsigned long get_max_root_iterations() +inline BOOST_MATH_CONSTEXPR unsigned long get_max_root_iterations() BOOST_NOEXCEPT { typedef typename Policy::max_root_iterations_type iter_type; return iter_type::value; @@ -875,7 +897,7 @@ namespace detail{ template <class T, class Digits, class Small, class Default> struct series_factor_calc { - static T get() + static T get() BOOST_MATH_NOEXCEPT(T) { return ldexp(T(1.0), 1 - Digits::value); } @@ -884,7 +906,7 @@ struct series_factor_calc template <class T, class Digits> struct series_factor_calc<T, Digits, mpl::true_, mpl::true_> { - static T get() + static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T) { return boost::math::tools::epsilon<T>(); } @@ -892,23 +914,24 @@ struct series_factor_calc<T, Digits, mpl::true_, mpl::true_> template <class T, class Digits> struct series_factor_calc<T, Digits, mpl::true_, mpl::false_> { - static T get() + BOOST_STATIC_CONSTANT(boost::uintmax_t, v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1)); + + static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T) { - static const boost::uintmax_t v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1); return 1 / static_cast<T>(v); } }; template <class T, class Digits> struct series_factor_calc<T, Digits, mpl::false_, mpl::true_> { - static T get() + static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T) { return boost::math::tools::epsilon<T>(); } }; template <class T, class Policy> -inline T get_epsilon_imp(mpl::true_ const&) +inline BOOST_MATH_CONSTEXPR T get_epsilon_imp(mpl::true_ const&) BOOST_MATH_NOEXCEPT(T) { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); @@ -924,7 +947,7 @@ inline T get_epsilon_imp(mpl::true_ const&) } template <class T, class Policy> -inline T get_epsilon_imp(mpl::false_ const&) +inline BOOST_MATH_CONSTEXPR T get_epsilon_imp(mpl::false_ const&) BOOST_MATH_NOEXCEPT(T) { return tools::epsilon<T>(); } @@ -932,7 +955,7 @@ inline T get_epsilon_imp(mpl::false_ const&) } // namespace detail template <class T, class Policy> -inline T get_epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T get_epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { typedef mpl::bool_< (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::radix == 2)) > tag_type; return detail::get_epsilon_imp<T, Policy>(tag_type()); @@ -973,7 +996,7 @@ struct constructor_error_check { typedef typename Policy::domain_error_type domain_error_type; typedef typename mpl::if_c< - (domain_error_type::value == throw_on_error) || (domain_error_type::value == user_error), + (domain_error_type::value == throw_on_error) || (domain_error_type::value == user_error) || (domain_error_type::value == errno_on_error), mpl::true_, mpl::false_>::type type; }; @@ -987,10 +1010,33 @@ struct method_error_check mpl::false_, mpl::true_>::type type; }; +// +// Does the Policy ever throw on error? +// +template <class Policy> +struct is_noexcept_error_policy +{ + typedef typename Policy::domain_error_type t1; + typedef typename Policy::pole_error_type t2; + typedef typename Policy::overflow_error_type t3; + typedef typename Policy::underflow_error_type t4; + typedef typename Policy::denorm_error_type t5; + typedef typename Policy::evaluation_error_type t6; + typedef typename Policy::rounding_error_type t7; + typedef typename Policy::indeterminate_result_error_type t8; + + BOOST_STATIC_CONSTANT(bool, value = + ((t1::value != throw_on_error) && (t1::value != user_error) + && (t2::value != throw_on_error) && (t2::value != user_error) + && (t3::value != throw_on_error) && (t3::value != user_error) + && (t4::value != throw_on_error) && (t4::value != user_error) + && (t5::value != throw_on_error) && (t5::value != user_error) + && (t6::value != throw_on_error) && (t6::value != user_error) + && (t7::value != throw_on_error) && (t7::value != user_error) + && (t8::value != throw_on_error) && (t8::value != user_error))); +}; }}} // namespaces #endif // BOOST_MATH_POLICY_HPP - - diff --git a/boost/math/special_functions.hpp b/boost/math/special_functions.hpp index 52e412ed8b..367701c2a9 100644 --- a/boost/math/special_functions.hpp +++ b/boost/math/special_functions.hpp @@ -67,5 +67,7 @@ #include <boost/math/special_functions/next.hpp> #include <boost/math/special_functions/owens_t.hpp> #include <boost/math/special_functions/hankel.hpp> +#include <boost/math/special_functions/ulp.hpp> +#include <boost/math/special_functions/relative_difference.hpp> #endif // BOOST_MATH_SPECIAL_FUNCTIONS_HPP diff --git a/boost/math/special_functions/bernoulli.hpp b/boost/math/special_functions/bernoulli.hpp index 5f2b7e1422..e5323fbd42 100644 --- a/boost/math/special_functions/bernoulli.hpp +++ b/boost/math/special_functions/bernoulli.hpp @@ -63,7 +63,7 @@ inline T bernoulli_b2n(const int i, const Policy &pol) if(i < 0) return policies::raise_domain_error<T>("boost::math::bernoulli_b2n<%1%>", "Index should be >= 0 but got %1%", T(i), pol); - T result = 0; // The = 0 is just to silence compiler warings :-( + T result = static_cast<T>(0); // The = 0 is just to silence compiler warnings :-( boost::math::detail::bernoulli_number_imp<T>(&result, static_cast<std::size_t>(i), 1u, pol, tag_type()); return result; } diff --git a/boost/math/special_functions/bessel.hpp b/boost/math/special_functions/bessel.hpp index eab723d8ba..1b57e0a873 100644 --- a/boost/math/special_functions/bessel.hpp +++ b/boost/math/special_functions/bessel.hpp @@ -302,20 +302,9 @@ inline T cyl_neumann_imp(T v, T x, const bessel_maybe_int_tag&, const Policy& po if(floor(v) == v) { - if(asymptotic_bessel_large_x_limit(v, x)) - { - T r = asymptotic_bessel_y_large_x_2(static_cast<T>(abs(v)), x); - if((v < 0) && (itrunc(v, pol) & 1)) - r = -r; - BOOST_MATH_INSTRUMENT_VARIABLE(r); - return r; - } - else - { - T r = bessel_yn(itrunc(v, pol), x, pol); - BOOST_MATH_INSTRUMENT_VARIABLE(r); - return r; - } + T r = bessel_yn(itrunc(v, pol), x, pol); + BOOST_MATH_INSTRUMENT_VARIABLE(r); + return r; } T r = cyl_neumann_imp<T>(v, x, bessel_no_int_tag(), pol); BOOST_MATH_INSTRUMENT_VARIABLE(r); @@ -325,20 +314,7 @@ inline T cyl_neumann_imp(T v, T x, const bessel_maybe_int_tag&, const Policy& po template <class T, class Policy> inline T cyl_neumann_imp(int v, T x, const bessel_int_tag&, const Policy& pol) { - BOOST_MATH_STD_USING - - BOOST_MATH_INSTRUMENT_VARIABLE(v); - BOOST_MATH_INSTRUMENT_VARIABLE(x); - - if(asymptotic_bessel_large_x_limit(T(v), x)) - { - T r = asymptotic_bessel_y_large_x_2(static_cast<T>(abs(v)), x); - if((v < 0) && (v & 1)) - r = -r; - return r; - } - else - return bessel_yn(v, x, pol); + return bessel_yn(v, x, pol); } template <class T, class Policy> @@ -582,7 +558,7 @@ inline typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i( policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_i_imp<value_type>(v, static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_i<%1%>(%1%,%1%)"); + return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_i_imp<value_type>(static_cast<value_type>(v), static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_i<%1%>(%1%,%1%)"); } template <class T1, class T2> diff --git a/boost/math/special_functions/bessel_prime.hpp b/boost/math/special_functions/bessel_prime.hpp index c5f2d58c2b..2a09b2046b 100644 --- a/boost/math/special_functions/bessel_prime.hpp +++ b/boost/math/special_functions/bessel_prime.hpp @@ -237,7 +237,7 @@ inline typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j_ policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_j_prime_imp<tag_type, value_type>(v, static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_j_prime<%1%,%1%>(%1%,%1%)"); + return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_j_prime_imp<tag_type, value_type>(static_cast<value_type>(v), static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_j_prime<%1%,%1%>(%1%,%1%)"); } template <class T1, class T2> @@ -279,7 +279,7 @@ inline typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i_ policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_i_prime_imp<value_type>(v, static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_i_prime<%1%>(%1%,%1%)"); + return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_i_prime_imp<value_type>(static_cast<value_type>(v), static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_i_prime<%1%>(%1%,%1%)"); } template <class T1, class T2> @@ -301,7 +301,7 @@ inline typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k_ policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_k_prime_imp<tag_type, value_type>(v, static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_k_prime<%1%,%1%>(%1%,%1%)"); + return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_k_prime_imp<tag_type, value_type>(static_cast<value_type>(v), static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_bessel_k_prime<%1%,%1%>(%1%,%1%)"); } template <class T1, class T2> @@ -323,7 +323,7 @@ inline typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann_p policies::promote_double<false>, policies::discrete_quantile<>, policies::assert_undefined<> >::type forwarding_policy; - return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_neumann_prime_imp<tag_type, value_type>(v, static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_neumann_prime<%1%,%1%>(%1%,%1%)"); + return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_neumann_prime_imp<tag_type, value_type>(static_cast<value_type>(v), static_cast<value_type>(x), forwarding_policy()), "boost::math::cyl_neumann_prime<%1%,%1%>(%1%,%1%)"); } template <class T1, class T2> diff --git a/boost/math/special_functions/beta.hpp b/boost/math/special_functions/beta.hpp index 98d8f7fa80..35b114ef15 100644 --- a/boost/math/special_functions/beta.hpp +++ b/boost/math/special_functions/beta.hpp @@ -47,13 +47,19 @@ T beta_imp(T a, T b, const Lanczos&, const Policy& pol) // Special cases: if((c == a) && (b < tools::epsilon<T>())) - return boost::math::tgamma(b, pol); + return 1 / b; else if((c == b) && (a < tools::epsilon<T>())) - return boost::math::tgamma(a, pol); + return 1 / a; if(b == 1) return 1/a; else if(a == 1) return 1/b; + else if(c < tools::epsilon<T>()) + { + result = c / a; + result /= b; + return result; + } /* // @@ -82,11 +88,11 @@ T beta_imp(T a, T b, const Lanczos&, const Policy& pol) std::swap(a, b); // Lanczos calculation: - T agh = a + Lanczos::g() - T(0.5); - T bgh = b + Lanczos::g() - T(0.5); - T cgh = c + Lanczos::g() - T(0.5); - result = Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b) / Lanczos::lanczos_sum_expG_scaled(c); - T ambh = a - T(0.5) - b; + T agh = static_cast<T>(a + Lanczos::g() - 0.5f); + T bgh = static_cast<T>(b + Lanczos::g() - 0.5f); + T cgh = static_cast<T>(c + Lanczos::g() - 0.5f); + result = Lanczos::lanczos_sum_expG_scaled(a) * (Lanczos::lanczos_sum_expG_scaled(b) / Lanczos::lanczos_sum_expG_scaled(c)); + T ambh = a - 0.5f - b; if((fabs(b * ambh) < (cgh * 100)) && (a > 100)) { // Special case where the base of the power term is close to 1 @@ -199,7 +205,9 @@ T ibeta_power_terms(T a, T y, const Lanczos&, bool normalised, - const Policy& pol) + const Policy& pol, + T prefix = 1, + const char* function = "boost::math::ibeta<%1%>(%1%, %1%, %1%)") { BOOST_MATH_STD_USING @@ -211,14 +219,17 @@ T ibeta_power_terms(T a, T result; - T prefix = 1; T c = a + b; // combine power terms with Lanczos approximation: - T agh = a + Lanczos::g() - T(0.5); - T bgh = b + Lanczos::g() - T(0.5); - T cgh = c + Lanczos::g() - T(0.5); + T agh = static_cast<T>(a + Lanczos::g() - 0.5f); + T bgh = static_cast<T>(b + Lanczos::g() - 0.5f); + T cgh = static_cast<T>(c + Lanczos::g() - 0.5f); result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b)); + result *= prefix; + // combine with the leftover terms from the Lanczos approximation: + result *= sqrt(bgh / boost::math::constants::e<T>()); + result *= sqrt(agh / cgh); // l1 and l2 are the base of the exponents minus one: T l1 = (x * b - y * agh) / agh; @@ -308,7 +319,15 @@ T ibeta_power_terms(T a, // First base near 1 only: T l = a * boost::math::log1p(l1, pol) + b * log((y * cgh) / bgh); - result *= exp(l); + if((l <= tools::log_min_value<T>()) || (l >= tools::log_max_value<T>())) + { + l += log(result); + if(l >= tools::log_max_value<T>()) + return policies::raise_overflow_error<T>(function, 0, pol); + result = exp(l); + } + else + result *= exp(l); BOOST_MATH_INSTRUMENT_VARIABLE(result); } else @@ -316,7 +335,15 @@ T ibeta_power_terms(T a, // Second base near 1 only: T l = b * boost::math::log1p(l2, pol) + a * log((x * cgh) / agh); - result *= exp(l); + if((l <= tools::log_min_value<T>()) || (l >= tools::log_max_value<T>())) + { + l += log(result); + if(l >= tools::log_max_value<T>()) + return policies::raise_overflow_error<T>(function, 0, pol); + result = exp(l); + } + else + result *= exp(l); BOOST_MATH_INSTRUMENT_VARIABLE(result); } } @@ -337,11 +364,41 @@ T ibeta_power_terms(T a, || (l2 <= tools::log_min_value<T>()) ) { - // Oops, overflow, sidestep: + // Oops, under/overflow, sidestep if we can: if(a < b) - result *= pow(pow(b2, b/a) * b1, a); + { + T p1 = pow(b2, b / a); + T l3 = a * (log(b1) + log(p1)); + if((l3 < tools::log_max_value<T>()) + && (l3 > tools::log_min_value<T>())) + { + result *= pow(p1 * b1, a); + } + else + { + l2 += l1 + log(result); + if(l2 >= tools::log_max_value<T>()) + return policies::raise_overflow_error<T>(function, 0, pol); + result = exp(l2); + } + } else - result *= pow(pow(b1, a/b) * b2, b); + { + T p1 = pow(b1, a / b); + T l3 = (log(p1) + log(b2)) * b; + if((l3 < tools::log_max_value<T>()) + && (l3 > tools::log_min_value<T>())) + { + result *= pow(p1 * b2, b); + } + else + { + l2 += l1 + log(result); + if(l2 >= tools::log_max_value<T>()) + return policies::raise_overflow_error<T>(function, 0, pol); + result = exp(l2); + } + } BOOST_MATH_INSTRUMENT_VARIABLE(result); } else @@ -351,10 +408,6 @@ T ibeta_power_terms(T a, BOOST_MATH_INSTRUMENT_VARIABLE(result); } } - // combine with the leftover terms from the Lanczos approximation: - result *= sqrt(bgh / boost::math::constants::e<T>()); - result *= sqrt(agh / cgh); - result *= prefix; BOOST_MATH_INSTRUMENT_VARIABLE(result); @@ -380,7 +433,9 @@ T ibeta_power_terms(T a, T y, const boost::math::lanczos::undefined_lanczos&, bool normalised, - const Policy& pol) + const Policy& pol, + T prefix = 1, + const char* = "boost::math::ibeta<%1%>(%1%, %1%, %1%)") { BOOST_MATH_STD_USING @@ -411,7 +466,7 @@ T ibeta_power_terms(T a, T b1 = (x * lc) / la; T b2 = (y * lc) / lb; - T e1 = lc - la - lb; + T e1 = -5; // lc - la - lb; T lb1 = a * log(b1); T lb2 = b * log(b2); @@ -423,21 +478,23 @@ T ibeta_power_terms(T a, || (e1 <= tools::log_min_value<T>()) ) { - result = exp(lb1 + lb2 - e1); + result = exp(lb1 + lb2 - e1 + log(prefix)); } else { T p1, p2; - if((fabs(b1 - 1) * a < 10) && (a > 1)) - p1 = exp(a * boost::math::log1p((x * b - y * la) / la, pol)); + p1 = (x * b - y * la) / la; + if(fabs(p1) < 0.5f) + p1 = exp(a * boost::math::log1p(p1, pol)); else p1 = pow(b1, a); - if((fabs(b2 - 1) * b < 10) && (b > 1)) - p2 = exp(b * boost::math::log1p((y * a - x * lb) / lb, pol)); + p2 = (y * a - x * lb) / lb; + if(fabs(p2) < 0.5f) + p2 = exp(b * boost::math::log1p(p2, pol)); else p2 = pow(b2, b); T p3 = exp(e1); - result = p1 * p2 / p3; + result = prefix * p1 * (p2 / p3); } // and combine with the remaining gamma function components: result /= sa * sb / sc; @@ -480,21 +537,43 @@ T ibeta_series(T a, T b, T x, T s0, const Lanczos&, bool normalised, T* p_deriva T c = a + b; // incomplete beta power term, combined with the Lanczos approximation: - T agh = a + Lanczos::g() - T(0.5); - T bgh = b + Lanczos::g() - T(0.5); - T cgh = c + Lanczos::g() - T(0.5); + T agh = static_cast<T>(a + Lanczos::g() - 0.5f); + T bgh = static_cast<T>(b + Lanczos::g() - 0.5f); + T cgh = static_cast<T>(c + Lanczos::g() - 0.5f); result = Lanczos::lanczos_sum_expG_scaled(c) / (Lanczos::lanczos_sum_expG_scaled(a) * Lanczos::lanczos_sum_expG_scaled(b)); - if(a * b < bgh * 10) - result *= exp((b - 0.5f) * boost::math::log1p(a / bgh, pol)); - else - result *= pow(cgh / bgh, b - 0.5f); - result *= pow(x * cgh / agh, a); - result *= sqrt(agh / boost::math::constants::e<T>()); - if(p_derivative) + T l1 = log(cgh / bgh) * (b - 0.5f); + T l2 = log(x * cgh / agh) * a; + // + // Check for over/underflow in the power terms: + // + if((l1 > tools::log_min_value<T>()) + && (l1 < tools::log_max_value<T>()) + && (l2 > tools::log_min_value<T>()) + && (l2 < tools::log_max_value<T>())) { - *p_derivative = result * pow(y, b); - BOOST_ASSERT(*p_derivative >= 0); + if(a * b < bgh * 10) + result *= exp((b - 0.5f) * boost::math::log1p(a / bgh, pol)); + else + result *= pow(cgh / bgh, b - 0.5f); + result *= pow(x * cgh / agh, a); + result *= sqrt(agh / boost::math::constants::e<T>()); + + if(p_derivative) + { + *p_derivative = result * pow(y, b); + BOOST_ASSERT(*p_derivative >= 0); + } + } + else + { + // + // Oh dear, we need logs, and this *will* cancel: + // + result = log(result) + l1 + l2 + (log(agh) - 1) / 2; + if(p_derivative) + *p_derivative = exp(result + b * log(y)); + result = exp(result); } } else @@ -606,7 +685,7 @@ struct ibeta_fraction2_t T denom = (a + 2 * m - 1); aN /= denom * denom; - T bN = m; + T bN = static_cast<T>(m); bN += (m * (b - m) * x) / (a + 2*m - 1); bN += ((a + m) * (a * y - b * x + 1 + m *(2 - x))) / (a + 2*m + 1); @@ -943,12 +1022,12 @@ T ibeta_imp(T a, T b, T x, const Policy& pol, bool inv, bool normalised, T* p_de if(b == 0) return policies::raise_domain_error<T>(function, "The arguments a and b to the incomplete beta function cannot both be zero, with x=%1%.", x, pol); if(b > 0) - return inv ? 0 : 1; + return static_cast<T>(inv ? 0 : 1); } else if(b == 0) { if(a > 0) - return inv ? 1 : 0; + return static_cast<T>(inv ? 1 : 0); } } else @@ -1200,7 +1279,7 @@ T ibeta_imp(T a, T b, T x, const Policy& pol, bool inv, bool normalised, T* p_de if(b < 40) { - if((floor(a) == a) && (floor(b) == b) && (a < (std::numeric_limits<int>::max)() - 100)) + if((floor(a) == a) && (floor(b) == b) && (a < (std::numeric_limits<int>::max)() - 100) && (y != 1)) { // relate to the binomial distribution and use a finite sum: T k = a - 1; @@ -1342,20 +1421,8 @@ T ibeta_derivative_imp(T a, T b, T x, const Policy& pol) // Now the regular cases: // typedef typename lanczos::lanczos<T, Policy>::type lanczos_type; - T f1 = ibeta_power_terms<T>(a, b, x, 1 - x, lanczos_type(), true, pol); T y = (1 - x) * x; - - if(f1 == 0) - return 0; - - if((tools::max_value<T>() * y < f1)) - { - // overflow: - return policies::raise_overflow_error<T>(function, 0, pol); - } - - f1 /= y; - + T f1 = ibeta_power_terms<T>(a, b, x, 1 - x, lanczos_type(), true, pol, 1 / y, function); return f1; } // diff --git a/boost/math/special_functions/detail/bernoulli_details.hpp b/boost/math/special_functions/detail/bernoulli_details.hpp index 525c1fccf4..c12a172b60 100644 --- a/boost/math/special_functions/detail/bernoulli_details.hpp +++ b/boost/math/special_functions/detail/bernoulli_details.hpp @@ -202,9 +202,13 @@ struct bernoulli_initializer // initialize our dymanic table: // boost::math::bernoulli_b2n<T>(2, Policy()); +#ifndef BOOST_NO_EXCEPTIONS try{ +#endif boost::math::bernoulli_b2n<T>(max_bernoulli_b2n<T>::value + 1, Policy()); +#ifndef BOOST_NO_EXCEPTIONS } catch(const std::overflow_error&){} +#endif boost::math::tangent_t2n<T>(2, Policy()); } void force_instantiate()const{} @@ -254,7 +258,9 @@ struct fixed_vector : private std::allocator<T> void resize(unsigned n, const T& val) { if(n > m_capacity) - throw std::runtime_error("Exhausted storage for Bernoulli numbers."); + { + BOOST_THROW_EXCEPTION(std::runtime_error("Exhausted storage for Bernoulli numbers.")); + } for(unsigned i = m_used; i < n; ++i) new (m_data + i) T(val); m_used = n; @@ -432,11 +438,11 @@ public: // if(start + n >= bn.size()) { - std::size_t new_size = (std::min)((std::max)((std::max)(start + n, std::size_t(bn.size() + 20)), std::size_t(50)), std::size_t(bn.capacity())); + std::size_t new_size = (std::min)((std::max)((std::max)(std::size_t(start + n), std::size_t(bn.size() + 20)), std::size_t(50)), std::size_t(bn.capacity())); tangent_numbers_series(new_size); } - for(std::size_t i = (std::max)(max_bernoulli_b2n<T>::value + 1, start); i < start + n; ++i) + for(std::size_t i = (std::max)(std::size_t(max_bernoulli_b2n<T>::value + 1), start); i < start + n; ++i) { *out = (i >= m_overflow_limit) ? policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(std::size_t)", 0, T(i), pol) : bn[i]; ++out; @@ -448,11 +454,11 @@ public: boost::detail::lightweight_mutex::scoped_lock l(m_mutex); if(start + n >= bn.size()) { - std::size_t new_size = (std::min)((std::max)((std::max)(start + n, std::size_t(bn.size() + 20)), std::size_t(50)), std::size_t(bn.capacity())); + std::size_t new_size = (std::min)((std::max)((std::max)(std::size_t(start + n), std::size_t(bn.size() + 20)), std::size_t(50)), std::size_t(bn.capacity())); tangent_numbers_series(new_size); } - for(std::size_t i = (std::max)(max_bernoulli_b2n<T>::value + 1, start); i < start + n; ++i) + for(std::size_t i = (std::max)(std::size_t(max_bernoulli_b2n<T>::value + 1), start); i < start + n; ++i) { *out = (i >= m_overflow_limit) ? policies::raise_overflow_error<T>("boost::math::bernoulli_b2n<%1%>(std::size_t)", 0, T(i), pol) : bn[i]; ++out; @@ -473,7 +479,7 @@ public: { if(start + n >= bn.size()) { - std::size_t new_size = (std::min)((std::max)((std::max)(start + n, std::size_t(bn.size() + 20)), std::size_t(50)), std::size_t(bn.capacity())); + std::size_t new_size = (std::min)((std::max)((std::max)(std::size_t(start + n), std::size_t(bn.size() + 20)), std::size_t(50)), std::size_t(bn.capacity())); tangent_numbers_series(new_size); } m_counter.store(static_cast<atomic_integer_type>(bn.size()), BOOST_MATH_ATOMIC_NS::memory_order_release); diff --git a/boost/math/special_functions/detail/bessel_derivatives_linear.hpp b/boost/math/special_functions/detail/bessel_derivatives_linear.hpp index 2ee86a03ee..72fddc61c6 100644 --- a/boost/math/special_functions/detail/bessel_derivatives_linear.hpp +++ b/boost/math/special_functions/detail/bessel_derivatives_linear.hpp @@ -37,13 +37,25 @@ inline T sph_bessel_j_derivative_linear(unsigned v, T x, Policy pol) template <class T, class Policy> inline T bessel_i_derivative_linear(T v, T x, Policy pol) { - return (boost::math::detail::cyl_bessel_i_imp<T>(v-1, x, pol) + boost::math::detail::cyl_bessel_i_imp<T>(v+1, x, pol)) / 2; + T result = boost::math::detail::cyl_bessel_i_imp<T>(v - 1, x, pol); + if(result >= tools::max_value<T>()) + return result; // result is infinite + T result2 = boost::math::detail::cyl_bessel_i_imp<T>(v + 1, x, pol); + if(result2 >= tools::max_value<T>() - result) + return result2; // result is infinite + return (result + result2) / 2; } template <class T, class Tag, class Policy> inline T bessel_k_derivative_linear(T v, T x, Tag tag, Policy pol) { - return (boost::math::detail::cyl_bessel_k_imp<T>(v-1, x, tag, pol) + boost::math::detail::cyl_bessel_k_imp<T>(v+1, x, tag, pol)) / -2; + T result = boost::math::detail::cyl_bessel_k_imp<T>(v - 1, x, tag, pol); + if(result >= tools::max_value<T>()) + return -result; // result is infinite + T result2 = boost::math::detail::cyl_bessel_k_imp<T>(v + 1, x, tag, pol); + if(result2 >= tools::max_value<T>() - result) + return -result2; // result is infinite + return (result + result2) / -2; } template <class T, class Policy> diff --git a/boost/math/special_functions/detail/bessel_ik.hpp b/boost/math/special_functions/detail/bessel_ik.hpp index 10118d9715..aac1781e10 100644 --- a/boost/math/special_functions/detail/bessel_ik.hpp +++ b/boost/math/special_functions/detail/bessel_ik.hpp @@ -374,6 +374,7 @@ int bessel_ik(T v, T x, T* I, T* K, int kind, const Policy& pol) prev = Ku; current = Ku1; T scale = 1; + T scale_sign = 1; for (k = 1; k <= n; k++) // forward recurrence for K { T fact = 2 * (u + k) / x; @@ -381,6 +382,7 @@ int bessel_ik(T v, T x, T* I, T* K, int kind, const Policy& pol) { prev /= current; scale /= current; + scale_sign *= boost::math::sign(current); current = 1; } next = fact * current + prev; @@ -426,7 +428,7 @@ int bessel_ik(T v, T x, T* I, T* K, int kind, const Policy& pol) if(fact == 0) *I = Iv; else if(tools::max_value<T>() * scale < fact) - *I = (org_kind & need_i) ? T(sign(fact) * sign(scale) * policies::raise_overflow_error<T>(function, 0, pol)) : T(0); + *I = (org_kind & need_i) ? T(sign(fact) * scale_sign * policies::raise_overflow_error<T>(function, 0, pol)) : T(0); else *I = Iv + fact / scale; // reflection formula } @@ -435,7 +437,7 @@ int bessel_ik(T v, T x, T* I, T* K, int kind, const Policy& pol) *I = Iv; } if(tools::max_value<T>() * scale < Kv) - *K = (org_kind & need_k) ? T(sign(Kv) * sign(scale) * policies::raise_overflow_error<T>(function, 0, pol)) : T(0); + *K = (org_kind & need_k) ? T(sign(Kv) * scale_sign * policies::raise_overflow_error<T>(function, 0, pol)) : T(0); else *K = Kv / scale; BOOST_MATH_INSTRUMENT_VARIABLE(*I); diff --git a/boost/math/special_functions/detail/bessel_jn.hpp b/boost/math/special_functions/detail/bessel_jn.hpp index 3f15f9cd87..2413630637 100644 --- a/boost/math/special_functions/detail/bessel_jn.hpp +++ b/boost/math/special_functions/detail/bessel_jn.hpp @@ -35,7 +35,7 @@ T bessel_jn(int n, T x, const Policy& pol) // if (n < 0) { - factor = (n & 0x1) ? -1 : 1; // J_{-n}(z) = (-1)^n J_n(z) + factor = static_cast<T>((n & 0x1) ? -1 : 1); // J_{-n}(z) = (-1)^n J_n(z) n = -n; } else @@ -50,6 +50,8 @@ T bessel_jn(int n, T x, const Policy& pol) // // Special cases: // + if(asymptotic_bessel_large_x_limit(T(n), x)) + return factor * asymptotic_bessel_j_large_x_2<T>(T(n), x); if (n == 0) { return factor * bessel_j0(x); @@ -64,9 +66,6 @@ T bessel_jn(int n, T x, const Policy& pol) return static_cast<T>(0); } - if(asymptotic_bessel_large_x_limit(T(n), x)) - return factor * asymptotic_bessel_j_large_x_2<T>(n, x); - BOOST_ASSERT(n > 1); T scale = 1; if (n < abs(x)) // forward recurrence diff --git a/boost/math/special_functions/detail/bessel_jy_asym.hpp b/boost/math/special_functions/detail/bessel_jy_asym.hpp index 81f6238e58..4d7ac485ad 100644 --- a/boost/math/special_functions/detail/bessel_jy_asym.hpp +++ b/boost/math/special_functions/detail/bessel_jy_asym.hpp @@ -120,6 +120,24 @@ inline T asymptotic_bessel_j_large_x_2(T v, T x) } template <class T> +inline bool asymptotic_bessel_large_x_limit(int v, const T& x) +{ + BOOST_MATH_STD_USING + // + // Determines if x is large enough compared to v to take the asymptotic + // forms above. From A&S 9.2.28 we require: + // v < x * eps^1/8 + // and from A&S 9.2.29 we require: + // v^12/10 < 1.5 * x * eps^1/10 + // using the former seems to work OK in practice with broadly similar + // error rates either side of the divide for v < 10000. + // At double precision eps^1/8 ~= 0.01. + // + BOOST_ASSERT(v >= 0); + return (v ? v : 1) < x * 0.004f; +} + +template <class T> inline bool asymptotic_bessel_large_x_limit(const T& v, const T& x) { BOOST_MATH_STD_USING diff --git a/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp b/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp index 0dc68fc73c..5425caf689 100644 --- a/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp +++ b/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp @@ -157,7 +157,8 @@ inline T bessel_y_derivative_small_z_series(T v, T x, const Policy& pol) gam = 1; if (boost::math::tools::max_value<T>() * p < gam) { - return -boost::math::policies::raise_overflow_error<T>(function, 0, pol); + // This term will overflow to -INF, when combined with the series below it becomes +INF: + return boost::math::policies::raise_overflow_error<T>(function, 0, pol); } } prefix = -gam / (boost::math::constants::pi<T>() * p); @@ -173,7 +174,7 @@ inline T bessel_y_derivative_small_z_series(T v, T x, const Policy& pol) scale /= (boost::math::tools::max_value<T>() / 4); if (boost::math::tools::log_max_value<T>() < prefix) { - return -boost::math::policies::raise_overflow_error<T>(function, 0, pol); + return boost::math::policies::raise_overflow_error<T>(function, 0, pol); } } prefix = -exp(prefix); diff --git a/boost/math/special_functions/detail/bessel_yn.hpp b/boost/math/special_functions/detail/bessel_yn.hpp index 0509062bbd..62d7377e4f 100644 --- a/boost/math/special_functions/detail/bessel_yn.hpp +++ b/boost/math/special_functions/detail/bessel_yn.hpp @@ -45,14 +45,13 @@ T bessel_yn(int n, T x, const Policy& pol) // if (n < 0) { - factor = (n & 0x1) ? -1 : 1; // Y_{-n}(z) = (-1)^n Y_n(z) + factor = static_cast<T>((n & 0x1) ? -1 : 1); // Y_{-n}(z) = (-1)^n Y_n(z) n = -n; } else { factor = 1; } - if(x < policies::get_epsilon<T, Policy>()) { T scale = 1; @@ -61,6 +60,10 @@ T bessel_yn(int n, T x, const Policy& pol) return boost::math::sign(scale) * boost::math::sign(value) * policies::raise_overflow_error<T>(function, 0, pol); value /= scale; } + else if(asymptotic_bessel_large_x_limit(n, x)) + { + value = factor * asymptotic_bessel_y_large_x_2(static_cast<T>(abs(n)), x); + } else if (n == 0) { value = bessel_y0(x, pol); @@ -76,23 +79,28 @@ T bessel_yn(int n, T x, const Policy& pol) int k = 1; BOOST_ASSERT(k < n); policies::check_series_iterations<T>("boost::math::bessel_y_n<%1%>(%1%,%1%)", n, pol); - do + T mult = 2 * k / x; + value = mult * current - prev; + prev = current; + current = value; + ++k; + if((mult > 1) && (fabs(current) > 1)) + { + prev /= current; + factor /= current; + value /= current; + current = 1; + } + while(k < n) { - T fact = 2 * k / x; - if((fact > 1) && ((tools::max_value<T>() - fabs(prev)) / fact < fabs(current))) - { - prev /= current; - factor /= current; - current = 1; - } - value = fact * current - prev; + mult = 2 * k / x; + value = mult * current - prev; prev = current; current = value; ++k; } - while(k < n); if(fabs(tools::max_value<T>() * factor) < fabs(value)) - return sign(value) * sign(value) * policies::raise_overflow_error<T>(function, 0, pol); + return sign(value) * sign(factor) * policies::raise_overflow_error<T>(function, 0, pol); value /= factor; } return value; diff --git a/boost/math/special_functions/detail/lanczos_sse2.hpp b/boost/math/special_functions/detail/lanczos_sse2.hpp index edef3a0412..b2dd7ea292 100644 --- a/boost/math/special_functions/detail/lanczos_sse2.hpp +++ b/boost/math/special_functions/detail/lanczos_sse2.hpp @@ -12,7 +12,7 @@ #include <emmintrin.h> -#if defined(__GNUC__) || defined(__PGI) +#if defined(__GNUC__) || defined(__PGI) || defined(__SUNPRO_CC) #define ALIGN16 __attribute__((__aligned__(16))) #else #define ALIGN16 __declspec(align(16)) diff --git a/boost/math/special_functions/detail/polygamma.hpp b/boost/math/special_functions/detail/polygamma.hpp index 4ef503bf7c..0267bd3ac8 100644 --- a/boost/math/special_functions/detail/polygamma.hpp +++ b/boost/math/special_functions/detail/polygamma.hpp @@ -44,7 +44,7 @@ // x is crazy large, just concentrate on the first part of the expression and use logs: if(n == 1) return 1 / x; T nlx = n * log(x); - if((nlx < tools::log_max_value<T>()) && (n < max_factorial<T>::value)) + if((nlx < tools::log_max_value<T>()) && (n < (int)max_factorial<T>::value)) return ((n & 1) ? 1 : -1) * boost::math::factorial<T>(n - 1) * pow(x, -n); else return ((n & 1) ? 1 : -1) * exp(boost::math::lgamma(T(n), pol) - n * log(x)); @@ -71,13 +71,13 @@ // or the power term underflows, this just gets set to 0 and then we // know that we have to use logs for the initial terms: // - part_term = ((n > boost::math::max_factorial<T>::value) && (T(n) * n > tools::log_max_value<T>())) + part_term = ((n > (int)boost::math::max_factorial<T>::value) && (T(n) * n > tools::log_max_value<T>())) ? T(0) : static_cast<T>(boost::math::factorial<T>(n - 1, pol) * pow(x, -n - 1)); if(part_term == 0) { // Either n is very large, or the power term underflows, // set the initial values of part_term, term and sum via logs: - part_term = boost::math::lgamma(n, pol) - (n + 1) * log(x); + part_term = static_cast<T>(boost::math::lgamma(n, pol) - (n + 1) * log(x)); sum = exp(part_term + log(n + 2 * x) - boost::math::constants::ln_two<T>()); part_term += log(T(n) * (n + 1)) - boost::math::constants::ln_two<T>() - log(x); part_term = exp(part_term); @@ -505,7 +505,7 @@ // would mean setting the limit to ~ 1 / n, // but we can tolerate a small amount of divergence: // - T small_x_limit = std::min(T(T(5) / n), T(0.25f)); + T small_x_limit = (std::min)(T(T(5) / n), T(0.25f)); if(x < small_x_limit) { return polygamma_nearzero(n, x, pol, function); diff --git a/boost/math/special_functions/detail/t_distribution_inv.hpp b/boost/math/special_functions/detail/t_distribution_inv.hpp index 72f6f0c646..e8bd0db28f 100644 --- a/boost/math/special_functions/detail/t_distribution_inv.hpp +++ b/boost/math/special_functions/detail/t_distribution_inv.hpp @@ -56,9 +56,9 @@ T inverse_students_t_hill(T ndf, T u, const Policy& pol) } else { - y = ((1 / (((ndf + 6) / (ndf * y) - 0.089f * d - 0.822f) + y = static_cast<T>(((1 / (((ndf + 6) / (ndf * y) - 0.089f * d - 0.822f) * (ndf + 2) * 3) + 0.5 / (ndf + 4)) * y - 1) - * (ndf + 1) / (ndf + 2) + 1 / y; + * (ndf + 1) / (ndf + 2) + 1 / y); } q = sqrt(ndf * y); @@ -144,41 +144,41 @@ T inverse_students_t_body_series(T df, T u, const Policy& pol) // only on the degrees of freedom (Eq 57 of Shaw): // T in = 1 / df; - c[2] = 0.16666666666666666667 + 0.16666666666666666667 * in; - c[3] = (0.0083333333333333333333 * in + c[2] = static_cast<T>(0.16666666666666666667 + 0.16666666666666666667 * in); + c[3] = static_cast<T>((0.0083333333333333333333 * in + 0.066666666666666666667) * in - + 0.058333333333333333333; - c[4] = ((0.00019841269841269841270 * in + + 0.058333333333333333333); + c[4] = static_cast<T>(((0.00019841269841269841270 * in + 0.0017857142857142857143) * in + 0.026785714285714285714) * in - + 0.025198412698412698413; - c[5] = (((2.7557319223985890653e-6 * in + + 0.025198412698412698413); + c[5] = static_cast<T>((((2.7557319223985890653e-6 * in + 0.00037477954144620811287) * in - 0.0011078042328042328042) * in + 0.010559964726631393298) * in - + 0.012039792768959435626; - c[6] = ((((2.5052108385441718775e-8 * in + + 0.012039792768959435626); + c[6] = static_cast<T>(((((2.5052108385441718775e-8 * in - 0.000062705427288760622094) * in + 0.00059458674042007375341) * in - 0.0016095979637646304313) * in + 0.0061039211560044893378) * in - + 0.0038370059724226390893; - c[7] = (((((1.6059043836821614599e-10 * in + + 0.0038370059724226390893); + c[7] = static_cast<T>((((((1.6059043836821614599e-10 * in + 0.000015401265401265401265) * in - 0.00016376804137220803887) * in + 0.00069084207973096861986) * in - 0.0012579159844784844785) * in + 0.0010898206731540064873) * in - + 0.0032177478835464946576; - c[8] = ((((((7.6471637318198164759e-13 * in + + 0.0032177478835464946576); + c[8] = static_cast<T>(((((((7.6471637318198164759e-13 * in - 3.9851014346715404916e-6) * in + 0.000049255746366361445727) * in - 0.00024947258047043099953) * in + 0.00064513046951456342991) * in - 0.00076245135440323932387) * in + 0.000033530976880017885309) * in - + 0.0017438262298340009980; - c[9] = (((((((2.8114572543455207632e-15 * in + + 0.0017438262298340009980); + c[9] = static_cast<T>((((((((2.8114572543455207632e-15 * in + 1.0914179173496789432e-6) * in - 0.000015303004486655377567) * in + 0.000090867107935219902229) * in @@ -186,8 +186,8 @@ T inverse_students_t_body_series(T df, T u, const Policy& pol) + 0.00051406605788341121363) * in - 0.00036307660358786885787) * in - 0.00031101086326318780412) * in - + 0.00096472747321388644237; - c[10] = ((((((((8.2206352466243297170e-18 * in + + 0.00096472747321388644237); + c[10] = static_cast<T>(((((((((8.2206352466243297170e-18 * in - 3.1239569599829868045e-7) * in + 4.8903045291975346210e-6) * in - 0.000033202652391372058698) * in @@ -196,7 +196,7 @@ T inverse_students_t_body_series(T df, T u, const Policy& pol) + 0.00035764655430568632777) * in - 0.00010230378073700412687) * in - 0.00036942667800009661203) * in - + 0.00054229262813129686486; + + 0.00054229262813129686486); // // The result is then a polynomial in v (see Eq 56 of Shaw): // @@ -285,7 +285,7 @@ T inverse_students_t(T df, T u, T v, const Policy& pol, bool* pexact = 0) // T a = 4 * (u - u * u);//1 - 4 * (u - 0.5f) * (u - 0.5f); T b = boost::math::cbrt(a); - static const T c = 0.85498797333834849467655443627193; + static const T c = static_cast<T>(0.85498797333834849467655443627193L); T p = 6 * (1 + c * (1 / b - 1)); T p0; do{ diff --git a/boost/math/special_functions/ellint_2.hpp b/boost/math/special_functions/ellint_2.hpp index f4f65cc11d..0d160ecdf1 100644 --- a/boost/math/special_functions/ellint_2.hpp +++ b/boost/math/special_functions/ellint_2.hpp @@ -103,17 +103,10 @@ T ellint_e_imp(T phi, T k, const Policy& pol) { return policies::raise_domain_error<T>("boost::math::ellint_2<%1%>(%1%, %1%)", "The parameter k is out of range, got k = %1%", k, pol); } - else if(rphi == 0) + else if(rphi < tools::root_epsilon<T>()) { - result = 0; - } - else if(sinp * sinp < tools::min_value<T>()) - { - T x = cosp * cosp; - T t = k * k * sinp * sinp; - T y = 1 - t; - T z = 1; - result = s * sinp * (ellint_rf_imp(x, y, z, pol) - t * ellint_rd_imp(x, y, z, pol) / 3); + // See http://functions.wolfram.com/EllipticIntegrals/EllipticE2/06/01/03/0001/ + result = s * rphi; } else { diff --git a/boost/math/special_functions/ellint_d.hpp b/boost/math/special_functions/ellint_d.hpp index 5bd065d6e3..bc5a4b2a56 100644 --- a/boost/math/special_functions/ellint_d.hpp +++ b/boost/math/special_functions/ellint_d.hpp @@ -60,7 +60,7 @@ T ellint_d_imp(T phi, T k, const Policy& pol) if(phi >= tools::max_value<T>()) { // Need to handle infinity as a special case: - result = policies::raise_overflow_error<T>("boost::math::ellint_e<%1%>(%1%,%1%)", 0, pol); + result = policies::raise_overflow_error<T>("boost::math::ellint_d<%1%>(%1%,%1%)", 0, pol); } else if(phi > 1 / tools::epsilon<T>()) { @@ -113,15 +113,11 @@ T ellint_d_imp(T k, const Policy& pol) BOOST_MATH_STD_USING using namespace boost::math::tools; - if (abs(k) > 1) + if (abs(k) >= 1) { - return policies::raise_domain_error<T>("boost::math::ellint_e<%1%>(%1%)", + return policies::raise_domain_error<T>("boost::math::ellint_d<%1%>(%1%)", "Got k = %1%, function requires |k| <= 1", k, pol); } - if (abs(k) == 1) - { - return static_cast<T>(1); - } if(fabs(k) <= tools::root_epsilon<T>()) return constants::pi<T>() / 4; diff --git a/boost/math/special_functions/fpclassify.hpp b/boost/math/special_functions/fpclassify.hpp index 8e75fae0f2..0a4e1ac7aa 100644 --- a/boost/math/special_functions/fpclassify.hpp +++ b/boost/math/special_functions/fpclassify.hpp @@ -80,6 +80,9 @@ is used. #if defined(_MSC_VER) || defined(__BORLANDC__) #include <float.h> #endif +#ifdef BOOST_MATH_USE_FLOAT128 +#include "quadmath.h" +#endif #ifdef BOOST_NO_STDC_NAMESPACE namespace std{ using ::abs; using ::fabs; } @@ -121,7 +124,10 @@ inline bool is_nan_helper(T, const boost::false_type&) { return false; } - +#ifdef BOOST_MATH_USE_FLOAT128 +inline bool is_nan_helper(__float128 f, const boost::true_type&) { return ::isnanq(f); } +inline bool is_nan_helper(__float128 f, const boost::false_type&) { return ::isnanq(f); } +#endif } namespace math{ @@ -513,6 +519,13 @@ inline bool (isinf)(long double x) return detail::isinf_impl(static_cast<value_type>(x), method()); } #endif +#ifdef BOOST_MATH_USE_FLOAT128 +template<> +inline bool (isinf)(__float128 x) +{ + return ::isinfq(x); +} +#endif //------------------------------------------------------------------------------ @@ -598,6 +611,13 @@ inline bool (isnan)(long double x) return detail::isnan_impl(x, method()); } #endif +#ifdef BOOST_MATH_USE_FLOAT128 +template<> +inline bool (isnan)(__float128 x) +{ + return ::isnanq(x); +} +#endif } // namespace math } // namespace boost diff --git a/boost/math/special_functions/gamma.hpp b/boost/math/special_functions/gamma.hpp index 1db1e4c2d3..3a3191a807 100644 --- a/boost/math/special_functions/gamma.hpp +++ b/boost/math/special_functions/gamma.hpp @@ -162,7 +162,7 @@ T gamma_imp(T z, const Policy& pol, const Lanczos& l) { if (z < 1 / tools::max_value<T>()) result = policies::raise_overflow_error<T>(function, 0, pol); - result *= 1 / z - constants::euler<T>(); + result *= 1 / z - constants::euler<T>(); } else { @@ -238,13 +238,13 @@ T lgamma_imp(T z, const Policy& pol, const Lanczos& l, int* sign = 0) } else if (z < tools::root_epsilon<T>()) { - if (0 == z) - return policies::raise_pole_error<T>(function, "Evaluation of lgamma at %1%.", z, pol); + if (0 == z) + return policies::raise_pole_error<T>(function, "Evaluation of lgamma at %1%.", z, pol); if (fabs(z) < 1 / tools::max_value<T>()) result = -log(fabs(z)); else - result = log(fabs(1 / z - constants::euler<T>())); - if (z < 0) + result = log(fabs(1 / z - constants::euler<T>())); + if (z < 0) sresult = -1; } else if(z < 15) @@ -526,9 +526,9 @@ T lgamma_imp(T z, const Policy& pol, const lanczos::undefined_lanczos&, int* sig if (zz < min_arg_for_recursion) { - // Here we simply take the logarithm of tgamma(). This is somewhat - // inefficient, but simple. The rationale is that the argument here - // is relatively small and overflow is not expected to be likely. + // Here we simply take the logarithm of tgamma(). This is somewhat + // inefficient, but simple. The rationale is that the argument here + // is relatively small and overflow is not expected to be likely. if (z > -tools::root_epsilon<T>()) { // Reflection formula may fail if z is very close to zero, let the series @@ -540,7 +540,7 @@ T lgamma_imp(T z, const Policy& pol, const lanczos::undefined_lanczos&, int* sig } return log_gamma_value; } - else + else { // No issue with spurious overflow in reflection formula, // just fall through to regular code: @@ -1394,7 +1394,7 @@ T tgamma_delta_ratio_imp_lanczos(T z, T delta, const Policy& pol, const Lanczos& return 1 / (z * boost::math::tgamma(z + delta, pol)); } } - T zgh = z + Lanczos::g() - constants::half<T>(); + T zgh = static_cast<T>(z + Lanczos::g() - constants::half<T>()); T result; if(fabs(delta) < 10) { diff --git a/boost/math/special_functions/math_fwd.hpp b/boost/math/special_functions/math_fwd.hpp index 96f60726a6..ca8e58144e 100644 --- a/boost/math/special_functions/math_fwd.hpp +++ b/boost/math/special_functions/math_fwd.hpp @@ -181,19 +181,19 @@ namespace boost template <class T> typename tools::promote_args<T>::type legendre_p(int l, T x); - +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) template <class T, class Policy> typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type legendre_p(int l, T x, const Policy& pol); - +#endif template <class T> typename tools::promote_args<T>::type legendre_q(unsigned l, T x); - +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) template <class T, class Policy> typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type legendre_q(unsigned l, T x, const Policy& pol); - +#endif template <class T1, class T2, class T3> typename tools::promote_args<T1, T2, T3>::type legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1); @@ -607,8 +607,10 @@ namespace boost template <class T1, class T2, class Policy> struct bessel_traits { - typedef typename tools::promote_args< - T1, T2 + typedef typename mpl::if_< + is_integral<T1>, + typename tools::promote_args<T2>::type, + typename tools::promote_args<T1, T2>::type >::type result_type; typedef typename policies::precision<result_type, Policy>::type precision_type; @@ -994,6 +996,16 @@ namespace boost template <class T> typename tools::promote_args<T>::type 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); + template <class T> + typename tools::promote_args<T>::type ulp(const T& val); + + template <class T, class U> + typename tools::promote_args<T, U>::type relative_difference(const T&, const U&); + template <class T, class U> + typename tools::promote_args<T, U>::type epsilon_difference(const T&, const U&); + template<class T> T unchecked_bernoulli_b2n(const std::size_t n); template <class T, class Policy> @@ -1447,6 +1459,7 @@ template <class OutputIterator, class T>\ 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 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()); }\ diff --git a/boost/math/special_functions/nonfinite_num_facets.hpp b/boost/math/special_functions/nonfinite_num_facets.hpp index 84d3f1070a..cd1eba9320 100644 --- a/boost/math/special_functions/nonfinite_num_facets.hpp +++ b/boost/math/special_functions/nonfinite_num_facets.hpp @@ -24,6 +24,7 @@ #include <locale> #include <boost/version.hpp> +#include <boost/throw_exception.hpp> #include <boost/math/special_functions/fpclassify.hpp> #include <boost/math/special_functions/sign.hpp> @@ -103,7 +104,7 @@ namespace boost { case FP_INFINITE: if(flags_ & trap_infinity) { - throw std::ios_base::failure("Infinity"); + BOOST_THROW_EXCEPTION(std::ios_base::failure("Infinity")); } else if((boost::math::signbit)(val)) { // negative infinity. @@ -122,7 +123,7 @@ namespace boost { case FP_NAN: if(flags_ & trap_nan) { - throw std::ios_base::failure("NaN"); + BOOST_THROW_EXCEPTION(std::ios_base::failure("NaN")); } else if((boost::math::signbit)(val)) { // negative so "-nan". diff --git a/boost/math/special_functions/owens_t.hpp b/boost/math/special_functions/owens_t.hpp index 6de93a4887..7fbd8918c0 100644 --- a/boost/math/special_functions/owens_t.hpp +++ b/boost/math/special_functions/owens_t.hpp @@ -61,9 +61,9 @@ namespace boost inline unsigned short owens_t_compute_code(const RealType h, const RealType a) { static const RealType hrange[] = - {0.02, 0.06, 0.09, 0.125, 0.26, 0.4, 0.6, 1.6, 1.7, 2.33, 2.4, 3.36, 3.4, 4.8}; + { 0.02f, 0.06f, 0.09f, 0.125f, 0.26f, 0.4f, 0.6f, 1.6f, 1.7f, 2.33f, 2.4f, 3.36f, 3.4f, 4.8f }; - static const RealType arange[] = {0.025, 0.09, 0.15, 0.36, 0.5, 0.9, 0.99999}; + static const RealType arange[] = { 0.025f, 0.09f, 0.15f, 0.36f, 0.5f, 0.9f, 0.99999f }; /* original select array from paper: 1, 1, 2,13,13,13,13,13,13,13,13,16,16,16, 9 @@ -229,17 +229,17 @@ namespace boost static const RealType c2[] = { - 0.99999999999999987510, - -0.99999999999988796462, 0.99999999998290743652, - -0.99999999896282500134, 0.99999996660459362918, - -0.99999933986272476760, 0.99999125611136965852, - -0.99991777624463387686, 0.99942835555870132569, - -0.99697311720723000295, 0.98751448037275303682, - -0.95915857980572882813, 0.89246305511006708555, - -0.76893425990463999675, 0.58893528468484693250, - -0.38380345160440256652, 0.20317601701045299653, - -0.82813631607004984866E-01, 0.24167984735759576523E-01, - -0.44676566663971825242E-02, 0.39141169402373836468E-03 + static_cast<RealType>(0.99999999999999987510), + static_cast<RealType>(-0.99999999999988796462), static_cast<RealType>(0.99999999998290743652), + static_cast<RealType>(-0.99999999896282500134), static_cast<RealType>(0.99999996660459362918), + static_cast<RealType>(-0.99999933986272476760), static_cast<RealType>(0.99999125611136965852), + static_cast<RealType>(-0.99991777624463387686), static_cast<RealType>(0.99942835555870132569), + static_cast<RealType>(-0.99697311720723000295), static_cast<RealType>(0.98751448037275303682), + static_cast<RealType>(-0.95915857980572882813), static_cast<RealType>(0.89246305511006708555), + static_cast<RealType>(-0.76893425990463999675), static_cast<RealType>(0.58893528468484693250), + static_cast<RealType>(-0.38380345160440256652), static_cast<RealType>(0.20317601701045299653), + static_cast<RealType>(-0.82813631607004984866E-01), static_cast<RealType>(0.24167984735759576523E-01), + static_cast<RealType>(-0.44676566663971825242E-02), static_cast<RealType>(0.39141169402373836468E-03) }; const RealType as = a*a; @@ -402,20 +402,22 @@ namespace boost */ const unsigned short m = 13; - static const RealType pts[] = {0.35082039676451715489E-02, - 0.31279042338030753740E-01, 0.85266826283219451090E-01, - 0.16245071730812277011, 0.25851196049125434828, - 0.36807553840697533536, 0.48501092905604697475, - 0.60277514152618576821, 0.71477884217753226516, - 0.81475510988760098605, 0.89711029755948965867, - 0.95723808085944261843, 0.99178832974629703586}; - static const RealType wts[] = { 0.18831438115323502887E-01, - 0.18567086243977649478E-01, 0.18042093461223385584E-01, - 0.17263829606398753364E-01, 0.16243219975989856730E-01, - 0.14994592034116704829E-01, 0.13535474469662088392E-01, - 0.11886351605820165233E-01, 0.10070377242777431897E-01, - 0.81130545742299586629E-02, 0.60419009528470238773E-02, - 0.38862217010742057883E-02, 0.16793031084546090448E-02}; + static const RealType pts[] = { + static_cast<RealType>(0.35082039676451715489E-02), + static_cast<RealType>(0.31279042338030753740E-01), static_cast<RealType>(0.85266826283219451090E-01), + static_cast<RealType>(0.16245071730812277011), static_cast<RealType>(0.25851196049125434828), + static_cast<RealType>(0.36807553840697533536), static_cast<RealType>(0.48501092905604697475), + static_cast<RealType>(0.60277514152618576821), static_cast<RealType>(0.71477884217753226516), + static_cast<RealType>(0.81475510988760098605), static_cast<RealType>(0.89711029755948965867), + static_cast<RealType>(0.95723808085944261843), static_cast<RealType>(0.99178832974629703586) }; + static const RealType wts[] = { + static_cast<RealType>(0.18831438115323502887E-01), + static_cast<RealType>(0.18567086243977649478E-01), static_cast<RealType>(0.18042093461223385584E-01), + static_cast<RealType>(0.17263829606398753364E-01), static_cast<RealType>(0.16243219975989856730E-01), + static_cast<RealType>(0.14994592034116704829E-01), static_cast<RealType>(0.13535474469662088392E-01), + static_cast<RealType>(0.11886351605820165233E-01), static_cast<RealType>(0.10070377242777431897E-01), + static_cast<RealType>(0.81130545742299586629E-02), static_cast<RealType>(0.60419009528470238773E-02), + static_cast<RealType>(0.38862217010742057883E-02), static_cast<RealType>(0.16793031084546090448E-02) }; const RealType as = a*a; const RealType hs = -h*h*boost::math::constants::half<RealType>(); @@ -575,14 +577,18 @@ namespace boost // when the last accelerated term was small enough... // int n; +#ifndef BOOST_NO_EXCEPTIONS try { +#endif n = itrunc(T(tools::log_max_value<T>() / 6)); +#ifndef BOOST_NO_EXCEPTIONS } catch(...) { n = (std::numeric_limits<int>::max)(); } +#endif n = (std::min)(n, 1500); T d = pow(3 + sqrt(T(8)), n); d = (d + 1 / d) / 2; @@ -689,14 +695,18 @@ namespace boost // when the last accelerated term was small enough... // int n; +#ifndef BOOST_NO_EXCEPTIONS try { +#endif n = itrunc(RealType(tools::log_max_value<RealType>() / 6)); +#ifndef BOOST_NO_EXCEPTIONS } catch(...) { n = (std::numeric_limits<int>::max)(); } +#endif n = (std::min)(n, 1500); RealType d = pow(3 + sqrt(RealType(8)), n); d = (d + 1 / d) / 2; @@ -858,25 +868,33 @@ namespace boost bool have_t1(false), have_t2(false); if(ah < 3) { +#ifndef BOOST_NO_EXCEPTIONS try { +#endif have_t1 = true; p1 = owens_t_T1_accelerated(h, a, forwarding_policy()); if(p1.second < target_precision) return p1.first; +#ifndef BOOST_NO_EXCEPTIONS } catch(const boost::math::evaluation_error&){} // T1 may fail and throw, that's OK +#endif } if(ah > 1) { +#ifndef BOOST_NO_EXCEPTIONS try { +#endif have_t2 = true; p2 = owens_t_T2_accelerated(h, a, ah, forwarding_policy()); if(p2.second < target_precision) return p2.first; +#ifndef BOOST_NO_EXCEPTIONS } catch(const boost::math::evaluation_error&){} // T2 may fail and throw, that's OK +#endif } // // If we haven't tried T1 yet, do it now - sometimes it succeeds and the number of iterations @@ -884,14 +902,18 @@ namespace boost // if(!have_t1) { +#ifndef BOOST_NO_EXCEPTIONS try { +#endif have_t1 = true; p1 = owens_t_T1_accelerated(h, a, forwarding_policy()); if(p1.second < target_precision) return p1.first; +#ifndef BOOST_NO_EXCEPTIONS } catch(const boost::math::evaluation_error&){} // T1 may fail and throw, that's OK +#endif } // // If we haven't tried T2 yet, do it now - sometimes it succeeds and the number of iterations @@ -899,24 +921,32 @@ namespace boost // if(!have_t2) { +#ifndef BOOST_NO_EXCEPTIONS try { +#endif have_t2 = true; p2 = owens_t_T2_accelerated(h, a, ah, forwarding_policy()); if(p2.second < target_precision) return p2.first; +#ifndef BOOST_NO_EXCEPTIONS } catch(const boost::math::evaluation_error&){} // T2 may fail and throw, that's OK +#endif } // // OK, nothing left to do but try the most expensive option which is T4, // this is often slow to converge, but when it does converge it tends to // be accurate: +#ifndef BOOST_NO_EXCEPTIONS try { +#endif return T4_mp(h, a, pol); +#ifndef BOOST_NO_EXCEPTIONS } catch(const boost::math::evaluation_error&){} // T4 may fail and throw, that's OK +#endif // // Now look back at the results from T1 and T2 and see if either gave better // results than we could get from the 64-bit precision versions. diff --git a/boost/math/special_functions/powm1.hpp b/boost/math/special_functions/powm1.hpp index f3af3d6e59..fe2fce35d8 100644 --- a/boost/math/special_functions/powm1.hpp +++ b/boost/math/special_functions/powm1.hpp @@ -13,23 +13,40 @@ #include <boost/math/special_functions/math_fwd.hpp> #include <boost/math/special_functions/log1p.hpp> #include <boost/math/special_functions/expm1.hpp> +#include <boost/math/special_functions/trunc.hpp> #include <boost/assert.hpp> namespace boost{ namespace math{ namespace detail{ template <class T, class Policy> -inline T powm1_imp(const T a, const T z, const Policy& pol) +inline T powm1_imp(const T x, const T y, const Policy& pol) { BOOST_MATH_STD_USING + static const char* function = "boost::math::powm1<%1%>(%1%, %1%)"; - if((fabs(a) < 1) || (fabs(z) < 1)) + if (x > 0) { - T p = log(a) * z; - if(fabs(p) < 2) - return boost::math::expm1(p, pol); - // otherwise fall though: + if ((fabs(y * (x - 1)) < 0.5) || (fabs(y) < 0.2)) + { + // We don't have any good/quick approximation for log(x) * y + // so just try it and see: + T l = y * log(x); + if (l < 0.5) + return boost::math::expm1(l); + if (l > boost::math::tools::log_max_value<T>()) + return boost::math::policies::raise_overflow_error<T>(function, 0, pol); + // fall through.... + } } - return pow(a, z) - 1; + else + { + // y had better be an integer: + if (boost::math::trunc(y) != y) + return boost::math::policies::raise_domain_error<T>(function, "For non-integral exponent, expected base > 0 but got %1%", x, pol); + if (boost::math::trunc(y / 2) == y / 2) + return powm1_imp(T(-x), y, pol); + } + return pow(x, y) - 1; } } // detail diff --git a/boost/math/special_functions/relative_difference.hpp b/boost/math/special_functions/relative_difference.hpp new file mode 100644 index 0000000000..544feda61b --- /dev/null +++ b/boost/math/special_functions/relative_difference.hpp @@ -0,0 +1,134 @@ +// (C) Copyright John Maddock 2006, 2015 +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_MATH_RELATIVE_ERROR +#define BOOST_MATH_RELATIVE_ERROR + +#include <boost/math/special_functions/fpclassify.hpp> +#include <boost/math/tools/promotion.hpp> +#include <boost/math/tools/precision.hpp> + +namespace boost{ + namespace math{ + + template <class T, class U> + typename boost::math::tools::promote_args<T,U>::type relative_difference(const T& arg_a, const U& arg_b) + { + typedef typename boost::math::tools::promote_args<T, U>::type result_type; + result_type a = arg_a; + result_type b = arg_b; + BOOST_MATH_STD_USING +#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS + // + // If math.h has no long double support we can't rely + // on the math functions generating exponents outside + // the range of a double: + // + result_type min_val = (std::max)( + tools::min_value<result_type>(), + static_cast<result_type>((std::numeric_limits<double>::min)())); + result_type max_val = (std::min)( + tools::max_value<result_type>(), + static_cast<result_type>((std::numeric_limits<double>::max)())); +#else + result_type min_val = tools::min_value<result_type>(); + result_type max_val = tools::max_value<result_type>(); +#endif + // Screen out NaN's first, if either value is a NaN then the distance is "infinite": + if((boost::math::isnan)(a) || (boost::math::isnan)(b)) + return max_val; + // Screen out infinites: + if(fabs(b) > max_val) + { + if(fabs(a) > max_val) + return (a < 0) == (b < 0) ? 0 : max_val; // one infinity is as good as another! + else + return max_val; // one infinity and one finite value implies infinite difference + } + else if(fabs(a) > max_val) + return max_val; // one infinity and one finite value implies infinite difference + + // + // If the values have different signs, treat as infinite difference: + // + if(((a < 0) != (b < 0)) && (a != 0) && (b != 0)) + return max_val; + a = fabs(a); + b = fabs(b); + // + // Now deal with zero's, if one value is zero (or denorm) then treat it the same as + // min_val for the purposes of the calculation that follows: + // + if(a < min_val) + a = min_val; + if(b < min_val) + b = min_val; + + return (std::max)(fabs((a - b) / a), fabs((a - b) / b)); + } + +#if defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) + template <> + inline boost::math::tools::promote_args<double, double>::type relative_difference(const double& arg_a, const double& arg_b) + { + BOOST_MATH_STD_USING + double a = arg_a; + double b = arg_b; + // + // On Mac OS X we evaluate "double" functions at "long double" precision, + // but "long double" actually has a very slightly narrower range than "double"! + // Therefore use the range of "long double" as our limits since results outside + // that range may have been truncated to 0 or INF: + // + double min_val = (std::max)((double)tools::min_value<long double>(), tools::min_value<double>()); + double max_val = (std::min)((double)tools::max_value<long double>(), tools::max_value<double>()); + + // Screen out NaN's first, if either value is a NaN then the distance is "infinite": + if((boost::math::isnan)(a) || (boost::math::isnan)(b)) + return max_val; + // Screen out infinites: + if(fabs(b) > max_val) + { + if(fabs(a) > max_val) + return 0; // one infinity is as good as another! + else + return max_val; // one infinity and one finite value implies infinite difference + } + else if(fabs(a) > max_val) + return max_val; // one infinity and one finite value implies infinite difference + + // + // If the values have different signs, treat as infinite difference: + // + if(((a < 0) != (b < 0)) && (a != 0) && (b != 0)) + return max_val; + a = fabs(a); + b = fabs(b); + // + // Now deal with zero's, if one value is zero (or denorm) then treat it the same as + // min_val for the purposes of the calculation that follows: + // + if(a < min_val) + a = min_val; + if(b < min_val) + b = min_val; + + return (std::max)(fabs((a - b) / a), fabs((a - b) / b)); + } +#endif + + template <class T, class U> + inline typename boost::math::tools::promote_args<T, U>::type epsilon_difference(const T& arg_a, const U& arg_b) + { + typedef typename boost::math::tools::promote_args<T, U>::type result_type; + result_type r = relative_difference(arg_a, arg_b); + if(tools::max_value<result_type>() * boost::math::tools::epsilon<result_type>() < r) + return tools::max_value<result_type>(); + return r / boost::math::tools::epsilon<result_type>(); + } +} // namespace math +} // namespace boost + +#endif diff --git a/boost/math/special_functions/trigamma.hpp b/boost/math/special_functions/trigamma.hpp index 6fccb36a3a..17c9174c78 100644 --- a/boost/math/special_functions/trigamma.hpp +++ b/boost/math/special_functions/trigamma.hpp @@ -69,22 +69,22 @@ T trigamma_prec(T x, const mpl::int_<53>*, const Policy&) // Expected Error Term : -6.895e-018 // Maximum Relative Change in Control Points : 8.497e-004 static const T P_4_inf[] = { - 0.68947581948701249e-17L, - 0.49999999999998975L, - 1.0177274392923795L, - 2.498208511343429L, - 2.1921221359427595L, - 1.5897035272532764L, - 0.40154388356961734L, + static_cast<T>(0.68947581948701249e-17L), + static_cast<T>(0.49999999999998975L), + static_cast<T>(1.0177274392923795L), + static_cast<T>(2.498208511343429L), + static_cast<T>(2.1921221359427595L), + static_cast<T>(1.5897035272532764L), + static_cast<T>(0.40154388356961734L), }; static const T Q_4_inf[] = { - 1.0L, - 1.7021215452463932L, - 4.4290431747556469L, - 2.9745631894384922L, - 2.3013614809773616L, - 0.28360399799075752L, - 0.022892987908906897L, + static_cast<T>(1.0L), + static_cast<T>(1.7021215452463932L), + static_cast<T>(4.4290431747556469L), + static_cast<T>(2.9745631894384922L), + static_cast<T>(2.3013614809773616L), + static_cast<T>(0.28360399799075752L), + static_cast<T>(0.022892987908906897L), }; if(x <= 2) diff --git a/boost/math/special_functions/ulp.hpp b/boost/math/special_functions/ulp.hpp new file mode 100644 index 0000000000..3d78a1c7c2 --- /dev/null +++ b/boost/math/special_functions/ulp.hpp @@ -0,0 +1,71 @@ +// (C) Copyright John Maddock 2015. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_MATH_SPECIAL_ULP_HPP +#define BOOST_MATH_SPECIAL_ULP_HPP + +#ifdef _MSC_VER +#pragma once +#endif + +#include <boost/math/special_functions/math_fwd.hpp> +#include <boost/math/policies/error_handling.hpp> +#include <boost/math/special_functions/fpclassify.hpp> +#include <boost/math/special_functions/next.hpp> + +namespace boost{ namespace math{ namespace detail{ + +template <class T, class Policy> +T ulp_imp(const T& val, const Policy& pol) +{ + BOOST_MATH_STD_USING + int expon; + static const char* function = "ulp<%1%>(%1%)"; + + int fpclass = (boost::math::fpclassify)(val); + + if(fpclass == (int)FP_NAN) + { + return policies::raise_domain_error<T>( + function, + "Argument must be finite, but got %1%", val, pol); + } + else if((fpclass == (int)FP_INFINITE) || (fabs(val) >= tools::max_value<T>())) + { + return (val < 0 ? -1 : 1) * policies::raise_overflow_error<T>(function, 0, pol); + } + else if(fpclass == FP_ZERO) + return detail::get_smallest_value<T>(); + // + // This code is almost the same as that for float_next, except for negative integers, + // where we preserve the relation ulp(x) == ulp(-x) as does Java: + // + frexp(fabs(val), &expon); + T diff = ldexp(T(1), expon - tools::digits<T>()); + if(diff == 0) + diff = detail::get_smallest_value<T>(); + return diff; +} + +} + +template <class T, class Policy> +inline typename tools::promote_args<T>::type ulp(const T& val, const Policy& pol) +{ + typedef typename tools::promote_args<T>::type result_type; + return detail::ulp_imp(static_cast<result_type>(val), pol); +} + +template <class T> +inline typename tools::promote_args<T>::type ulp(const T& val) +{ + return ulp(val, policies::policy<>()); +} + + +}} // namespaces + +#endif // BOOST_MATH_SPECIAL_ULP_HPP + diff --git a/boost/math/special_functions/zeta.hpp b/boost/math/special_functions/zeta.hpp index 1ba282f4d1..616bb0cccc 100644 --- a/boost/math/special_functions/zeta.hpp +++ b/boost/math/special_functions/zeta.hpp @@ -200,20 +200,20 @@ inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&) // Expected Error Term: -2.020e-18 // Max error found at double precision: 3.994987e-17 static const T P[6] = { - 0.24339294433593750202L, - -0.49092470516353571651L, - 0.0557616214776046784287L, - -0.00320912498879085894856L, - 0.000451534528645796438704L, - -0.933241270357061460782e-5L, + static_cast<T>(0.24339294433593750202L), + static_cast<T>(-0.49092470516353571651L), + static_cast<T>(0.0557616214776046784287L), + static_cast<T>(-0.00320912498879085894856L), + static_cast<T>(0.000451534528645796438704L), + static_cast<T>(-0.933241270357061460782e-5L), }; static const T Q[6] = { - 1L, - -0.279960334310344432495L, - 0.0419676223309986037706L, - -0.00413421406552171059003L, - 0.00024978985622317935355L, - -0.101855788418564031874e-4L, + static_cast<T>(1L), + static_cast<T>(-0.279960334310344432495L), + static_cast<T>(0.0419676223309986037706L), + static_cast<T>(-0.00413421406552171059003L), + static_cast<T>(0.00024978985622317935355L), + static_cast<T>(-0.101855788418564031874e-4L), }; result = tools::evaluate_polynomial(P, sc) / tools::evaluate_polynomial(Q, sc); result -= 1.2433929443359375F; @@ -225,20 +225,20 @@ inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&) // Maximum Deviation Found: 9.007e-20 // Expected Error Term: 9.007e-20 static const T P[6] = { - 0.577215664901532860516, - 0.243210646940107164097, - 0.0417364673988216497593, - 0.00390252087072843288378, - 0.000249606367151877175456, - 0.110108440976732897969e-4, + static_cast<T>(0.577215664901532860516L), + static_cast<T>(0.243210646940107164097L), + static_cast<T>(0.0417364673988216497593L), + static_cast<T>(0.00390252087072843288378L), + static_cast<T>(0.000249606367151877175456L), + static_cast<T>(0.110108440976732897969e-4L), }; static const T Q[6] = { - 1, - 0.295201277126631761737, - 0.043460910607305495864, - 0.00434930582085826330659, - 0.000255784226140488490982, - 0.10991819782396112081e-4, + static_cast<T>(1.0), + static_cast<T>(0.295201277126631761737L), + static_cast<T>(0.043460910607305495864L), + static_cast<T>(0.00434930582085826330659L), + static_cast<T>(0.000255784226140488490982L), + static_cast<T>(0.10991819782396112081e-4L), }; result = tools::evaluate_polynomial(P, T(-sc)) / tools::evaluate_polynomial(Q, T(-sc)); result += 1 / (-sc); @@ -249,21 +249,21 @@ inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&) // Expected Error Term: -5.946e-22 static const float Y = 0.6986598968505859375; static const T P[6] = { - -0.0537258300023595030676, - 0.0445163473292365591906, - 0.0128677673534519952905, - 0.00097541770457391752726, - 0.769875101573654070925e-4, - 0.328032510000383084155e-5, + static_cast<T>(-0.0537258300023595030676L), + static_cast<T>(0.0445163473292365591906L), + static_cast<T>(0.0128677673534519952905L), + static_cast<T>(0.00097541770457391752726L), + static_cast<T>(0.769875101573654070925e-4L), + static_cast<T>(0.328032510000383084155e-5L), }; static const T Q[7] = { - 1, - 0.33383194553034051422, - 0.0487798431291407621462, - 0.00479039708573558490716, - 0.000270776703956336357707, - 0.106951867532057341359e-4, - 0.236276623974978646399e-7, + 1.0f, + static_cast<T>(0.33383194553034051422L), + static_cast<T>(0.0487798431291407621462L), + static_cast<T>(0.00479039708573558490716L), + static_cast<T>(0.000270776703956336357707L), + static_cast<T>(0.106951867532057341359e-4L), + static_cast<T>(0.236276623974978646399e-7L), }; result = tools::evaluate_polynomial(P, T(s - 2)) / tools::evaluate_polynomial(Q, T(s - 2)); result += Y + 1 / (-sc); @@ -275,23 +275,23 @@ inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&) // Max error found at double precision: 2.009135e-16 static const T P[6] = { - -2.49710190602259410021, - -2.60013301809475665334, - -0.939260435377109939261, - -0.138448617995741530935, - -0.00701721240549802377623, - -0.229257310594893932383e-4, + static_cast<T>(-2.49710190602259410021L), + static_cast<T>(-2.60013301809475665334L), + static_cast<T>(-0.939260435377109939261L), + static_cast<T>(-0.138448617995741530935L), + static_cast<T>(-0.00701721240549802377623L), + static_cast<T>(-0.229257310594893932383e-4L), }; static const T Q[9] = { - 1, - 0.706039025937745133628, - 0.15739599649558626358, - 0.0106117950976845084417, - -0.36910273311764618902e-4, - 0.493409563927590008943e-5, - -0.234055487025287216506e-6, - 0.718833729365459760664e-8, - -0.1129200113474947419e-9, + 1.0f, + static_cast<T>(0.706039025937745133628L), + static_cast<T>(0.15739599649558626358L), + static_cast<T>(0.0106117950976845084417L), + static_cast<T>(-0.36910273311764618902e-4L), + static_cast<T>(0.493409563927590008943e-5L), + static_cast<T>(-0.234055487025287216506e-6L), + static_cast<T>(0.718833729365459760664e-8L), + static_cast<T>(-0.1129200113474947419e-9L), }; result = tools::evaluate_polynomial(P, T(s - 4)) / tools::evaluate_polynomial(Q, T(s - 4)); result = 1 + exp(result); @@ -302,24 +302,24 @@ inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&) // Expected Error Term: 7.117e-16 // Max error found at double precision: 9.387771e-16 static const T P[7] = { - -4.78558028495135619286, - -1.89197364881972536382, - -0.211407134874412820099, - -0.000189204758260076688518, - 0.00115140923889178742086, - 0.639949204213164496988e-4, - 0.139348932445324888343e-5, + static_cast<T>(-4.78558028495135619286L), + static_cast<T>(-1.89197364881972536382L), + static_cast<T>(-0.211407134874412820099L), + static_cast<T>(-0.000189204758260076688518L), + static_cast<T>(0.00115140923889178742086L), + static_cast<T>(0.639949204213164496988e-4L), + static_cast<T>(0.139348932445324888343e-5L), }; static const T Q[9] = { - 1, - 0.244345337378188557777, - 0.00873370754492288653669, - -0.00117592765334434471562, - -0.743743682899933180415e-4, - -0.21750464515767984778e-5, - 0.471001264003076486547e-8, - -0.833378440625385520576e-10, - 0.699841545204845636531e-12, + 1.0f, + static_cast<T>(0.244345337378188557777L), + static_cast<T>(0.00873370754492288653669L), + static_cast<T>(-0.00117592765334434471562L), + static_cast<T>(-0.743743682899933180415e-4L), + static_cast<T>(-0.21750464515767984778e-5L), + static_cast<T>(0.471001264003076486547e-8L), + static_cast<T>(-0.833378440625385520576e-10L), + static_cast<T>(0.699841545204845636531e-12L), }; result = tools::evaluate_polynomial(P, T(s - 7)) / tools::evaluate_polynomial(Q, T(s - 7)); result = 1 + exp(result); @@ -329,24 +329,24 @@ inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&) // Max error in interpolated form: 1.668e-17 // Max error found at long double precision: 1.669714e-17 static const T P[8] = { - -10.3948950573308896825, - -2.85827219671106697179, - -0.347728266539245787271, - -0.0251156064655346341766, - -0.00119459173416968685689, - -0.382529323507967522614e-4, - -0.785523633796723466968e-6, - -0.821465709095465524192e-8, + static_cast<T>(-10.3948950573308896825L), + static_cast<T>(-2.85827219671106697179L), + static_cast<T>(-0.347728266539245787271L), + static_cast<T>(-0.0251156064655346341766L), + static_cast<T>(-0.00119459173416968685689L), + static_cast<T>(-0.382529323507967522614e-4L), + static_cast<T>(-0.785523633796723466968e-6L), + static_cast<T>(-0.821465709095465524192e-8L), }; static const T Q[10] = { - 1, - 0.208196333572671890965, - 0.0195687657317205033485, - 0.00111079638102485921877, - 0.408507746266039256231e-4, - 0.955561123065693483991e-6, - 0.118507153474022900583e-7, - 0.222609483627352615142e-14, + 1.0f, + static_cast<T>(0.208196333572671890965L), + static_cast<T>(0.0195687657317205033485L), + static_cast<T>(0.00111079638102485921877L), + static_cast<T>(0.408507746266039256231e-4L), + static_cast<T>(0.955561123065693483991e-6L), + static_cast<T>(0.118507153474022900583e-7L), + static_cast<T>(0.222609483627352615142e-14L), }; result = tools::evaluate_polynomial(P, T(s - 15)) / tools::evaluate_polynomial(Q, T(s - 15)); result = 1 + exp(result); @@ -883,14 +883,14 @@ T zeta_imp_odd_integer(int s, const T& sc, const Policy& pol, const mpl::false_& if(!is_init) { is_init = true; - for(int k = 0; k < sizeof(results) / sizeof(results[0]); ++k) + for(unsigned k = 0; k < sizeof(results) / sizeof(results[0]); ++k) { T arg = k * 2 + 3; T c_arg = 1 - arg; results[k] = zeta_polynomial_series(arg, c_arg, pol); } } - int index = (s - 3) / 2; + unsigned index = (s - 3) / 2; return index >= sizeof(results) / sizeof(results[0]) ? zeta_polynomial_series(T(s), sc, pol): results[index]; } @@ -915,8 +915,12 @@ T zeta_imp(T s, T sc, const Policy& pol, const Tag& tag) // if(floor(s) == s) { +#ifndef BOOST_NO_EXCEPTIONS + // Without exceptions we expect itrunc to return INT_MAX on overflow + // and we fall through anyway. try { +#endif int v = itrunc(s); if(v == s) { @@ -925,12 +929,12 @@ T zeta_imp(T s, T sc, const Policy& pol, const Tag& tag) if(((-v) & 1) == 0) return 0; int n = (-v + 1) / 2; - if(n <= boost::math::max_bernoulli_b2n<T>::value) + if(n <= (int)boost::math::max_bernoulli_b2n<T>::value) return T((-v & 1) ? -1 : 1) * boost::math::unchecked_bernoulli_b2n<T>(n) / (1 - v); } else if((v & 1) == 0) { - if(((v / 2) <= boost::math::max_bernoulli_b2n<T>::value) && (v <= boost::math::max_factorial<T>::value)) + if(((v / 2) <= (int)boost::math::max_bernoulli_b2n<T>::value) && (v <= (int)boost::math::max_factorial<T>::value)) return T(((v / 2 - 1) & 1) ? -1 : 1) * ldexp(T(1), v - 1) * pow(constants::pi<T, Policy>(), v) * boost::math::unchecked_bernoulli_b2n<T>(v / 2) / boost::math::unchecked_factorial<T>(v); return T(((v / 2 - 1) & 1) ? -1 : 1) * ldexp(T(1), v - 1) * pow(constants::pi<T, Policy>(), v) * @@ -939,9 +943,11 @@ T zeta_imp(T s, T sc, const Policy& pol, const Tag& tag) else return zeta_imp_odd_integer(v, sc, pol, mpl::bool_<(Tag::value <= 113) && Tag::value>()); } +#ifndef BOOST_NO_EXCEPTIONS } catch(const boost::math::rounding_error&){} // Just fall through, s is too large to round catch(const std::overflow_error&){} +#endif } if(fabs(s) < tools::root_epsilon<T>()) diff --git a/boost/math/tools/big_constant.hpp b/boost/math/tools/big_constant.hpp index ff136337e1..4386609989 100644 --- a/boost/math/tools/big_constant.hpp +++ b/boost/math/tools/big_constant.hpp @@ -37,12 +37,12 @@ typedef long double largest_float; #endif template <class T> -inline BOOST_CONSTEXPR_OR_CONST T make_big_value(largest_float v, const char*, mpl::true_ const&, mpl::false_ const&) +inline BOOST_CONSTEXPR_OR_CONST T make_big_value(largest_float v, const char*, mpl::true_ const&, mpl::false_ const&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(v); } template <class T> -inline BOOST_CONSTEXPR_OR_CONST T make_big_value(largest_float v, const char*, mpl::true_ const&, mpl::true_ const&) +inline BOOST_CONSTEXPR_OR_CONST T make_big_value(largest_float v, const char*, mpl::true_ const&, mpl::true_ const&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(v); } @@ -54,7 +54,7 @@ inline T make_big_value(largest_float, const char* s, mpl::false_ const&, mpl::f } #endif template <class T> -inline BOOST_CONSTEXPR const char* make_big_value(largest_float, const char* s, mpl::false_ const&, mpl::true_ const&) +inline BOOST_MATH_CONSTEXPR const char* make_big_value(largest_float, const char* s, mpl::false_ const&, mpl::true_ const&) BOOST_MATH_NOEXCEPT(T) { return s; } diff --git a/boost/math/tools/config.hpp b/boost/math/tools/config.hpp index e88f578db7..ffd0ab43a6 100644 --- a/boost/math/tools/config.hpp +++ b/boost/math/tools/config.hpp @@ -11,6 +11,7 @@ #endif #include <boost/config.hpp> +#include <boost/predef.h> #include <boost/cstdint.hpp> // for boost::uintmax_t #include <boost/detail/workaround.hpp> #include <boost/type_traits/is_integral.hpp> @@ -183,14 +184,20 @@ // #ifdef BOOST_MSVC # define BOOST_MATH_POLY_METHOD 2 +# define BOOST_MATH_RATIONAL_METHOD 1 #elif defined(BOOST_INTEL) # define BOOST_MATH_POLY_METHOD 2 -# define BOOST_MATH_RATIONAL_METHOD 2 +# define BOOST_MATH_RATIONAL_METHOD 1 #elif defined(__GNUC__) +#if __GNUC__ < 4 # define BOOST_MATH_POLY_METHOD 3 # define BOOST_MATH_RATIONAL_METHOD 3 # define BOOST_MATH_INT_TABLE_TYPE(RT, IT) RT # define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##.0L +#else +# define BOOST_MATH_POLY_METHOD 3 +# define BOOST_MATH_RATIONAL_METHOD 1 +#endif #endif #if defined(BOOST_NO_LONG_LONG) && !defined(BOOST_MATH_INT_TABLE_TYPE) @@ -199,20 +206,54 @@ #endif // +// constexpr support, early GCC implementations can't cope so disable +// constexpr for them: +// +#if !defined(__clang) && defined(__GNUC__) +#if (__GNUC__ * 100 + __GNUC_MINOR__) < 490 +# define BOOST_MATH_DISABLE_CONSTEXPR +#endif +#endif + +#ifdef BOOST_MATH_DISABLE_CONSTEXPR +# define BOOST_MATH_CONSTEXPR +#else +# define BOOST_MATH_CONSTEXPR BOOST_CONSTEXPR +#endif + +// +// noexcept support: +// +#ifndef BOOST_NO_CXX11_NOEXCEPT +#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS +#include <type_traits> +# define BOOST_MATH_NOEXCEPT(T) noexcept(std::is_floating_point<T>::value) +# define BOOST_MATH_IS_FLOAT(T) (std::is_floating_point<T>::value) +#else +#include <boost/type_traits/is_floating_point.hpp> +# define BOOST_MATH_NOEXCEPT(T) noexcept(boost::is_floating_point<T>::value) +# define BOOST_MATH_IS_FLOAT(T) (boost::is_floating_point<T>::value) +#endif +#else +# define BOOST_MATH_NOEXCEPT(T) +# define BOOST_MATH_IS_FLOAT(T) false +#endif + +// // The maximum order of polynomial that will be evaluated // via an unrolled specialisation: // #ifndef BOOST_MATH_MAX_POLY_ORDER -# define BOOST_MATH_MAX_POLY_ORDER 17 +# define BOOST_MATH_MAX_POLY_ORDER 20 #endif // // Set the method used to evaluate polynomials and rationals: // #ifndef BOOST_MATH_POLY_METHOD -# define BOOST_MATH_POLY_METHOD 1 +# define BOOST_MATH_POLY_METHOD 2 #endif #ifndef BOOST_MATH_RATIONAL_METHOD -# define BOOST_MATH_RATIONAL_METHOD 0 +# define BOOST_MATH_RATIONAL_METHOD 1 #endif // // decide whether to store constants as integers or reals: @@ -224,7 +265,19 @@ # define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##SUF #endif // -// Test whether to support __float128: +// Test whether to support __float128, if we don't have quadmath.h then this can't currently work: +// +#ifndef BOOST_MATH_USE_FLOAT128 +#ifdef __has_include +#if ! __has_include("quadmath.h") +#define BOOST_MATH_DISABLE_FLOAT128 +#endif +#elif !defined(BOOST_ARCH_X86) +#define BOOST_MATH_DISABLE_FLOAT128 +#endif +#endif +// +// And then the actual configuration: // #if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__) \ && !defined(BOOST_MATH_DISABLE_FLOAT128) || defined(BOOST_MATH_USE_FLOAT128) @@ -296,13 +349,13 @@ namespace tools { template <class T> -inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c) +inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c) BOOST_MATH_NOEXCEPT(T) { return (std::max)((std::max)(a, b), c); } template <class T> -inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) +inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) BOOST_MATH_NOEXCEPT(T) { return (std::max)((std::max)(a, b), (std::max)(c, d)); } @@ -310,7 +363,7 @@ inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) } // namespace tools template <class T> -void suppress_unused_variable_warning(const T&) +void suppress_unused_variable_warning(const T&) BOOST_MATH_NOEXCEPT(T) { } diff --git a/boost/math/tools/detail/polynomial_horner1_10.hpp b/boost/math/tools/detail/polynomial_horner1_10.hpp index b13d6a3887..48cf9e39b3 100644 --- a/boost/math/tools/detail/polynomial_horner1_10.hpp +++ b/boost/math/tools/detail/polynomial_horner1_10.hpp @@ -12,67 +12,67 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_11.hpp b/boost/math/tools/detail/polynomial_horner1_11.hpp index f0cf67e959..e52595429e 100644 --- a/boost/math/tools/detail/polynomial_horner1_11.hpp +++ b/boost/math/tools/detail/polynomial_horner1_11.hpp @@ -12,73 +12,73 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_12.hpp b/boost/math/tools/detail/polynomial_horner1_12.hpp index 03b974ceca..10cd178975 100644 --- a/boost/math/tools/detail/polynomial_horner1_12.hpp +++ b/boost/math/tools/detail/polynomial_horner1_12.hpp @@ -12,79 +12,79 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_13.hpp b/boost/math/tools/detail/polynomial_horner1_13.hpp index b947f542c3..90fa9ec43d 100644 --- a/boost/math/tools/detail/polynomial_horner1_13.hpp +++ b/boost/math/tools/detail/polynomial_horner1_13.hpp @@ -12,85 +12,85 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_14.hpp b/boost/math/tools/detail/polynomial_horner1_14.hpp index 8374e38904..389c8063b0 100644 --- a/boost/math/tools/detail/polynomial_horner1_14.hpp +++ b/boost/math/tools/detail/polynomial_horner1_14.hpp @@ -12,91 +12,91 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_15.hpp b/boost/math/tools/detail/polynomial_horner1_15.hpp index ebfa463601..d196a41603 100644 --- a/boost/math/tools/detail/polynomial_horner1_15.hpp +++ b/boost/math/tools/detail/polynomial_horner1_15.hpp @@ -12,97 +12,97 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_16.hpp b/boost/math/tools/detail/polynomial_horner1_16.hpp index 60eb4dc675..fa48c6614c 100644 --- a/boost/math/tools/detail/polynomial_horner1_16.hpp +++ b/boost/math/tools/detail/polynomial_horner1_16.hpp @@ -12,103 +12,103 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_17.hpp b/boost/math/tools/detail/polynomial_horner1_17.hpp index 6233f1b07b..4575aeac7b 100644 --- a/boost/math/tools/detail/polynomial_horner1_17.hpp +++ b/boost/math/tools/detail/polynomial_horner1_17.hpp @@ -12,109 +12,109 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_18.hpp b/boost/math/tools/detail/polynomial_horner1_18.hpp index 2a06def44b..95dd400416 100644 --- a/boost/math/tools/detail/polynomial_horner1_18.hpp +++ b/boost/math/tools/detail/polynomial_horner1_18.hpp @@ -12,115 +12,115 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_19.hpp b/boost/math/tools/detail/polynomial_horner1_19.hpp index 8f0da8b219..6d73eb8ffc 100644 --- a/boost/math/tools/detail/polynomial_horner1_19.hpp +++ b/boost/math/tools/detail/polynomial_horner1_19.hpp @@ -12,121 +12,121 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((((((a[18] * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_2.hpp b/boost/math/tools/detail/polynomial_horner1_2.hpp index a0b10d5ee5..85640edf67 100644 --- a/boost/math/tools/detail/polynomial_horner1_2.hpp +++ b/boost/math/tools/detail/polynomial_horner1_2.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_20.hpp b/boost/math/tools/detail/polynomial_horner1_20.hpp index d1a886dd76..f8b7f34384 100644 --- a/boost/math/tools/detail/polynomial_horner1_20.hpp +++ b/boost/math/tools/detail/polynomial_horner1_20.hpp @@ -12,127 +12,127 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((((((((((((a[18] * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<20>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<20>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((((((((((((((a[19] * x + a[18]) * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_3.hpp b/boost/math/tools/detail/polynomial_horner1_3.hpp index 715a69aee0..c0ad4660e9 100644 --- a/boost/math/tools/detail/polynomial_horner1_3.hpp +++ b/boost/math/tools/detail/polynomial_horner1_3.hpp @@ -12,25 +12,25 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_4.hpp b/boost/math/tools/detail/polynomial_horner1_4.hpp index d74b7a6386..27ad74eb95 100644 --- a/boost/math/tools/detail/polynomial_horner1_4.hpp +++ b/boost/math/tools/detail/polynomial_horner1_4.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_5.hpp b/boost/math/tools/detail/polynomial_horner1_5.hpp index bb66e6c41d..5cfafb4052 100644 --- a/boost/math/tools/detail/polynomial_horner1_5.hpp +++ b/boost/math/tools/detail/polynomial_horner1_5.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_6.hpp b/boost/math/tools/detail/polynomial_horner1_6.hpp index a29c2710e8..f7f4bee480 100644 --- a/boost/math/tools/detail/polynomial_horner1_6.hpp +++ b/boost/math/tools/detail/polynomial_horner1_6.hpp @@ -12,43 +12,43 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_7.hpp b/boost/math/tools/detail/polynomial_horner1_7.hpp index 093ab89b02..c612822fc0 100644 --- a/boost/math/tools/detail/polynomial_horner1_7.hpp +++ b/boost/math/tools/detail/polynomial_horner1_7.hpp @@ -12,49 +12,49 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_8.hpp b/boost/math/tools/detail/polynomial_horner1_8.hpp index a3d329a37b..5d9b453b9d 100644 --- a/boost/math/tools/detail/polynomial_horner1_8.hpp +++ b/boost/math/tools/detail/polynomial_horner1_8.hpp @@ -12,55 +12,55 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner1_9.hpp b/boost/math/tools/detail/polynomial_horner1_9.hpp index e90f578d04..84977fd13b 100644 --- a/boost/math/tools/detail/polynomial_horner1_9.hpp +++ b/boost/math/tools/detail/polynomial_horner1_9.hpp @@ -12,61 +12,61 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner2_10.hpp b/boost/math/tools/detail/polynomial_horner2_10.hpp index 7c4101f465..f10c5d0492 100644 --- a/boost/math/tools/detail/polynomial_horner2_10.hpp +++ b/boost/math/tools/detail/polynomial_horner2_10.hpp @@ -12,72 +12,72 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_11.hpp b/boost/math/tools/detail/polynomial_horner2_11.hpp index bebd1e6483..757357addf 100644 --- a/boost/math/tools/detail/polynomial_horner2_11.hpp +++ b/boost/math/tools/detail/polynomial_horner2_11.hpp @@ -12,79 +12,79 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_12.hpp b/boost/math/tools/detail/polynomial_horner2_12.hpp index c4da24ac88..e0fc8a9df7 100644 --- a/boost/math/tools/detail/polynomial_horner2_12.hpp +++ b/boost/math/tools/detail/polynomial_horner2_12.hpp @@ -12,86 +12,86 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_13.hpp b/boost/math/tools/detail/polynomial_horner2_13.hpp index 5d7dddc5b5..c13a0a7cc2 100644 --- a/boost/math/tools/detail/polynomial_horner2_13.hpp +++ b/boost/math/tools/detail/polynomial_horner2_13.hpp @@ -12,93 +12,93 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_14.hpp b/boost/math/tools/detail/polynomial_horner2_14.hpp index 21a5a37903..ccc6e7d8da 100644 --- a/boost/math/tools/detail/polynomial_horner2_14.hpp +++ b/boost/math/tools/detail/polynomial_horner2_14.hpp @@ -12,100 +12,100 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_15.hpp b/boost/math/tools/detail/polynomial_horner2_15.hpp index 7b41214466..a409ba7fdb 100644 --- a/boost/math/tools/detail/polynomial_horner2_15.hpp +++ b/boost/math/tools/detail/polynomial_horner2_15.hpp @@ -12,107 +12,107 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_16.hpp b/boost/math/tools/detail/polynomial_horner2_16.hpp index aa3763ad65..a69c1a3619 100644 --- a/boost/math/tools/detail/polynomial_horner2_16.hpp +++ b/boost/math/tools/detail/polynomial_horner2_16.hpp @@ -12,114 +12,114 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_17.hpp b/boost/math/tools/detail/polynomial_horner2_17.hpp index 6ed5566d49..9e7c05d007 100644 --- a/boost/math/tools/detail/polynomial_horner2_17.hpp +++ b/boost/math/tools/detail/polynomial_horner2_17.hpp @@ -12,121 +12,121 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_18.hpp b/boost/math/tools/detail/polynomial_horner2_18.hpp index 02c72b8227..1ea0e052c0 100644 --- a/boost/math/tools/detail/polynomial_horner2_18.hpp +++ b/boost/math/tools/detail/polynomial_horner2_18.hpp @@ -12,128 +12,128 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((((a[17] * x2 + a[15]) * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_19.hpp b/boost/math/tools/detail/polynomial_horner2_19.hpp index 6e36ace904..45c125c871 100644 --- a/boost/math/tools/detail/polynomial_horner2_19.hpp +++ b/boost/math/tools/detail/polynomial_horner2_19.hpp @@ -12,135 +12,135 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((((a[17] * x2 + a[15]) * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((((a[18] * x2 + a[16]) * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((((a[17] * x2 + a[15]) * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_2.hpp b/boost/math/tools/detail/polynomial_horner2_2.hpp index e2a4e7faef..20da483c33 100644 --- a/boost/math/tools/detail/polynomial_horner2_2.hpp +++ b/boost/math/tools/detail/polynomial_horner2_2.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner2_20.hpp b/boost/math/tools/detail/polynomial_horner2_20.hpp index e394b6b325..956c6dba4f 100644 --- a/boost/math/tools/detail/polynomial_horner2_20.hpp +++ b/boost/math/tools/detail/polynomial_horner2_20.hpp @@ -12,142 +12,142 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((((a[17] * x2 + a[15]) * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((((a[16] * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((((((((a[18] * x2 + a[16]) * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((((a[17] * x2 + a[15]) * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<20>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<20>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((((((((a[19] * x2 + a[17]) * x2 + a[15]) * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((((a[18] * x2 + a[16]) * x2 + a[14]) * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_3.hpp b/boost/math/tools/detail/polynomial_horner2_3.hpp index 187b86c1ce..58b290c7c9 100644 --- a/boost/math/tools/detail/polynomial_horner2_3.hpp +++ b/boost/math/tools/detail/polynomial_horner2_3.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner2_4.hpp b/boost/math/tools/detail/polynomial_horner2_4.hpp index 84badc365a..74f969b749 100644 --- a/boost/math/tools/detail/polynomial_horner2_4.hpp +++ b/boost/math/tools/detail/polynomial_horner2_4.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner2_5.hpp b/boost/math/tools/detail/polynomial_horner2_5.hpp index 287b4be08e..134cbc8ef9 100644 --- a/boost/math/tools/detail/polynomial_horner2_5.hpp +++ b/boost/math/tools/detail/polynomial_horner2_5.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_6.hpp b/boost/math/tools/detail/polynomial_horner2_6.hpp index 3662d44f93..7cb75d75c8 100644 --- a/boost/math/tools/detail/polynomial_horner2_6.hpp +++ b/boost/math/tools/detail/polynomial_horner2_6.hpp @@ -12,44 +12,44 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_7.hpp b/boost/math/tools/detail/polynomial_horner2_7.hpp index 78ed0df54d..327639deb6 100644 --- a/boost/math/tools/detail/polynomial_horner2_7.hpp +++ b/boost/math/tools/detail/polynomial_horner2_7.hpp @@ -12,51 +12,51 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner2_8.hpp b/boost/math/tools/detail/polynomial_horner2_8.hpp index ac8e941180..2145ad6dcd 100644 --- a/boost/math/tools/detail/polynomial_horner2_8.hpp +++ b/boost/math/tools/detail/polynomial_horner2_8.hpp @@ -12,58 +12,58 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); diff --git a/boost/math/tools/detail/polynomial_horner2_9.hpp b/boost/math/tools/detail/polynomial_horner2_9.hpp index e1a3d17eca..08f6336e49 100644 --- a/boost/math/tools/detail/polynomial_horner2_9.hpp +++ b/boost/math/tools/detail/polynomial_horner2_9.hpp @@ -12,65 +12,65 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x); diff --git a/boost/math/tools/detail/polynomial_horner3_10.hpp b/boost/math/tools/detail/polynomial_horner3_10.hpp index 69736d7118..05ad20cc30 100644 --- a/boost/math/tools/detail/polynomial_horner3_10.hpp +++ b/boost/math/tools/detail/polynomial_horner3_10.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_11.hpp b/boost/math/tools/detail/polynomial_horner3_11.hpp index 273ed535cc..9f8628e750 100644 --- a/boost/math/tools/detail/polynomial_horner3_11.hpp +++ b/boost/math/tools/detail/polynomial_horner3_11.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_12.hpp b/boost/math/tools/detail/polynomial_horner3_12.hpp index 340567400b..ccb3ec4d10 100644 --- a/boost/math/tools/detail/polynomial_horner3_12.hpp +++ b/boost/math/tools/detail/polynomial_horner3_12.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_13.hpp b/boost/math/tools/detail/polynomial_horner3_13.hpp index 849c93e54a..a8cdf2c508 100644 --- a/boost/math/tools/detail/polynomial_horner3_13.hpp +++ b/boost/math/tools/detail/polynomial_horner3_13.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_14.hpp b/boost/math/tools/detail/polynomial_horner3_14.hpp index f5ac1df9d1..5eb4ef1f28 100644 --- a/boost/math/tools/detail/polynomial_horner3_14.hpp +++ b/boost/math/tools/detail/polynomial_horner3_14.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_15.hpp b/boost/math/tools/detail/polynomial_horner3_15.hpp index b57af7e3dc..7e8edcd8aa 100644 --- a/boost/math/tools/detail/polynomial_horner3_15.hpp +++ b/boost/math/tools/detail/polynomial_horner3_15.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -262,7 +262,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_16.hpp b/boost/math/tools/detail/polynomial_horner3_16.hpp index 1fc8560a21..58bea1581f 100644 --- a/boost/math/tools/detail/polynomial_horner3_16.hpp +++ b/boost/math/tools/detail/polynomial_horner3_16.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -262,7 +262,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -295,7 +295,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_17.hpp b/boost/math/tools/detail/polynomial_horner3_17.hpp index 4a0d0aa472..007b8a4918 100644 --- a/boost/math/tools/detail/polynomial_horner3_17.hpp +++ b/boost/math/tools/detail/polynomial_horner3_17.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -262,7 +262,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -295,7 +295,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -330,7 +330,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_18.hpp b/boost/math/tools/detail/polynomial_horner3_18.hpp index 899117d2f9..68935adba1 100644 --- a/boost/math/tools/detail/polynomial_horner3_18.hpp +++ b/boost/math/tools/detail/polynomial_horner3_18.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -262,7 +262,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -295,7 +295,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -330,7 +330,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -367,7 +367,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_19.hpp b/boost/math/tools/detail/polynomial_horner3_19.hpp index 7c4f728419..acffba6b47 100644 --- a/boost/math/tools/detail/polynomial_horner3_19.hpp +++ b/boost/math/tools/detail/polynomial_horner3_19.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -262,7 +262,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -295,7 +295,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -330,7 +330,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -367,7 +367,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -406,7 +406,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_2.hpp b/boost/math/tools/detail/polynomial_horner3_2.hpp index 372630cfd9..6b8d9a71f8 100644 --- a/boost/math/tools/detail/polynomial_horner3_2.hpp +++ b/boost/math/tools/detail/polynomial_horner3_2.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner3_20.hpp b/boost/math/tools/detail/polynomial_horner3_20.hpp index b20e0d5fe1..b3a170c095 100644 --- a/boost/math/tools/detail/polynomial_horner3_20.hpp +++ b/boost/math/tools/detail/polynomial_horner3_20.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -127,7 +127,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -150,7 +150,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -175,7 +175,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -202,7 +202,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -231,7 +231,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -262,7 +262,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -295,7 +295,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -330,7 +330,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -367,7 +367,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -406,7 +406,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -447,7 +447,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<20>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<20>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_3.hpp b/boost/math/tools/detail/polynomial_horner3_3.hpp index cc6b1a9351..05fe88fccc 100644 --- a/boost/math/tools/detail/polynomial_horner3_3.hpp +++ b/boost/math/tools/detail/polynomial_horner3_3.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner3_4.hpp b/boost/math/tools/detail/polynomial_horner3_4.hpp index 74192f0c90..b98d6f678d 100644 --- a/boost/math/tools/detail/polynomial_horner3_4.hpp +++ b/boost/math/tools/detail/polynomial_horner3_4.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } diff --git a/boost/math/tools/detail/polynomial_horner3_5.hpp b/boost/math/tools/detail/polynomial_horner3_5.hpp index 73d1900998..12e639cef3 100644 --- a/boost/math/tools/detail/polynomial_horner3_5.hpp +++ b/boost/math/tools/detail/polynomial_horner3_5.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_6.hpp b/boost/math/tools/detail/polynomial_horner3_6.hpp index da02574866..b645cb5bbc 100644 --- a/boost/math/tools/detail/polynomial_horner3_6.hpp +++ b/boost/math/tools/detail/polynomial_horner3_6.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_7.hpp b/boost/math/tools/detail/polynomial_horner3_7.hpp index d45a622278..3df4b5b4ef 100644 --- a/boost/math/tools/detail/polynomial_horner3_7.hpp +++ b/boost/math/tools/detail/polynomial_horner3_7.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_8.hpp b/boost/math/tools/detail/polynomial_horner3_8.hpp index d0198bf345..9a49d2555e 100644 --- a/boost/math/tools/detail/polynomial_horner3_8.hpp +++ b/boost/math/tools/detail/polynomial_horner3_8.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/polynomial_horner3_9.hpp b/boost/math/tools/detail/polynomial_horner3_9.hpp index b3e0b19970..3507d37604 100644 --- a/boost/math/tools/detail/polynomial_horner3_9.hpp +++ b/boost/math/tools/detail/polynomial_horner3_9.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class V> -inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) +inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) +inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[1] * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[2] * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]); } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -55,7 +55,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -70,7 +70,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -87,7 +87,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; @@ -106,7 +106,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*) } template <class T, class V> -inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) +inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { V x2 = x * x; V t[2]; diff --git a/boost/math/tools/detail/rational_horner1_10.hpp b/boost/math/tools/detail/rational_horner1_10.hpp index 919ba6d09f..e670853869 100644 --- a/boost/math/tools/detail/rational_horner1_10.hpp +++ b/boost/math/tools/detail/rational_horner1_10.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_11.hpp b/boost/math/tools/detail/rational_horner1_11.hpp index e17bfbc723..65e17598ff 100644 --- a/boost/math/tools/detail/rational_horner1_11.hpp +++ b/boost/math/tools/detail/rational_horner1_11.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_12.hpp b/boost/math/tools/detail/rational_horner1_12.hpp index 67b430a990..de33af0e07 100644 --- a/boost/math/tools/detail/rational_horner1_12.hpp +++ b/boost/math/tools/detail/rational_horner1_12.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_13.hpp b/boost/math/tools/detail/rational_horner1_13.hpp index 33ae67523c..ed4ac1af8b 100644 --- a/boost/math/tools/detail/rational_horner1_13.hpp +++ b/boost/math/tools/detail/rational_horner1_13.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_14.hpp b/boost/math/tools/detail/rational_horner1_14.hpp index 0c5f1884c6..a3222f8212 100644 --- a/boost/math/tools/detail/rational_horner1_14.hpp +++ b/boost/math/tools/detail/rational_horner1_14.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_15.hpp b/boost/math/tools/detail/rational_horner1_15.hpp index 848190761f..c8cd691573 100644 --- a/boost/math/tools/detail/rational_horner1_15.hpp +++ b/boost/math/tools/detail/rational_horner1_15.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((b[14] * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_16.hpp b/boost/math/tools/detail/rational_horner1_16.hpp index e0661f8b3e..8003c82db7 100644 --- a/boost/math/tools/detail/rational_horner1_16.hpp +++ b/boost/math/tools/detail/rational_horner1_16.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((b[14] * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -192,7 +192,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((b[15] * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_17.hpp b/boost/math/tools/detail/rational_horner1_17.hpp index f123da4c95..294c3f175d 100644 --- a/boost/math/tools/detail/rational_horner1_17.hpp +++ b/boost/math/tools/detail/rational_horner1_17.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((b[14] * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -192,7 +192,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((b[15] * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -204,7 +204,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((((b[16] * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_18.hpp b/boost/math/tools/detail/rational_horner1_18.hpp index 718ace87fc..1a48bba097 100644 --- a/boost/math/tools/detail/rational_horner1_18.hpp +++ b/boost/math/tools/detail/rational_horner1_18.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((b[14] * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -192,7 +192,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((b[15] * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -204,7 +204,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((((b[16] * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -216,7 +216,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((((b[17] * x + b[16]) * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_19.hpp b/boost/math/tools/detail/rational_horner1_19.hpp index c849ba8c06..12fd75cf1b 100644 --- a/boost/math/tools/detail/rational_horner1_19.hpp +++ b/boost/math/tools/detail/rational_horner1_19.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((b[14] * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -192,7 +192,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((b[15] * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -204,7 +204,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((((b[16] * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -216,7 +216,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((((b[17] * x + b[16]) * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -228,7 +228,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((((((a[18] * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((((((b[18] * x + b[17]) * x + b[16]) * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_2.hpp b/boost/math/tools/detail/rational_horner1_2.hpp index 87e41ab3f9..c838f2a2cd 100644 --- a/boost/math/tools/detail/rational_horner1_2.hpp +++ b/boost/math/tools/detail/rational_horner1_2.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_20.hpp b/boost/math/tools/detail/rational_horner1_20.hpp index e05eaaa89b..3ee3e966e6 100644 --- a/boost/math/tools/detail/rational_horner1_20.hpp +++ b/boost/math/tools/detail/rational_horner1_20.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -120,7 +120,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((b[9] * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -132,7 +132,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((b[10] * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -144,7 +144,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((b[11] * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -156,7 +156,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((b[12] * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -168,7 +168,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((b[13] * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((b[14] * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -192,7 +192,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((b[15] * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -204,7 +204,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((((b[16] * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -216,7 +216,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((((b[17] * x + b[16]) * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -228,7 +228,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((((((((((((a[18] * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((((((((((((b[18] * x + b[17]) * x + b[16]) * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -240,7 +240,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<20>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<20>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((((((((((((((a[19] * x + a[18]) * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((((((((((((((b[19] * x + b[18]) * x + b[17]) * x + b[16]) * x + b[15]) * x + b[14]) * x + b[13]) * x + b[12]) * x + b[11]) * x + b[10]) * x + b[9]) * x + b[8]) * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_3.hpp b/boost/math/tools/detail/rational_horner1_3.hpp index ac1b785e93..034ead3f66 100644 --- a/boost/math/tools/detail/rational_horner1_3.hpp +++ b/boost/math/tools/detail/rational_horner1_3.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_4.hpp b/boost/math/tools/detail/rational_horner1_4.hpp index eeced600f4..de2972f4c4 100644 --- a/boost/math/tools/detail/rational_horner1_4.hpp +++ b/boost/math/tools/detail/rational_horner1_4.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_5.hpp b/boost/math/tools/detail/rational_horner1_5.hpp index 0479f66376..a59ff114d1 100644 --- a/boost/math/tools/detail/rational_horner1_5.hpp +++ b/boost/math/tools/detail/rational_horner1_5.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_6.hpp b/boost/math/tools/detail/rational_horner1_6.hpp index db259968ee..c5000c5db4 100644 --- a/boost/math/tools/detail/rational_horner1_6.hpp +++ b/boost/math/tools/detail/rational_horner1_6.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_7.hpp b/boost/math/tools/detail/rational_horner1_7.hpp index b431fe91ef..bc860f3bf7 100644 --- a/boost/math/tools/detail/rational_horner1_7.hpp +++ b/boost/math/tools/detail/rational_horner1_7.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_8.hpp b/boost/math/tools/detail/rational_horner1_8.hpp index 5a04a7a343..69368978b6 100644 --- a/boost/math/tools/detail/rational_horner1_8.hpp +++ b/boost/math/tools/detail/rational_horner1_8.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner1_9.hpp b/boost/math/tools/detail/rational_horner1_9.hpp index 4b5465fc4a..0aafea15fd 100644 --- a/boost/math/tools/detail/rational_horner1_9.hpp +++ b/boost/math/tools/detail/rational_horner1_9.hpp @@ -12,19 +12,19 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); @@ -36,7 +36,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); @@ -48,7 +48,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); @@ -60,7 +60,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((b[4] * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -72,7 +72,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((b[5] * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -84,7 +84,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((b[6] * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -96,7 +96,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>((((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / (((((((b[7] * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); @@ -108,7 +108,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) return static_cast<V>(((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]) / ((((((((b[8] * x + b[7]) * x + b[6]) * x + b[5]) * x + b[4]) * x + b[3]) * x + b[2]) * x + b[1]) * x + b[0])); diff --git a/boost/math/tools/detail/rational_horner2_10.hpp b/boost/math/tools/detail/rational_horner2_10.hpp index e26d2d934f..127777bc2a 100644 --- a/boost/math/tools/detail/rational_horner2_10.hpp +++ b/boost/math/tools/detail/rational_horner2_10.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_11.hpp b/boost/math/tools/detail/rational_horner2_11.hpp index c05e697197..53983ed4ad 100644 --- a/boost/math/tools/detail/rational_horner2_11.hpp +++ b/boost/math/tools/detail/rational_horner2_11.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_12.hpp b/boost/math/tools/detail/rational_horner2_12.hpp index 4ee3734001..4ad0856b06 100644 --- a/boost/math/tools/detail/rational_horner2_12.hpp +++ b/boost/math/tools/detail/rational_horner2_12.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_13.hpp b/boost/math/tools/detail/rational_horner2_13.hpp index 37977a111d..5f9303d0c3 100644 --- a/boost/math/tools/detail/rational_horner2_13.hpp +++ b/boost/math/tools/detail/rational_horner2_13.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_14.hpp b/boost/math/tools/detail/rational_horner2_14.hpp index 78edfbbe1b..dc512f393f 100644 --- a/boost/math/tools/detail/rational_horner2_14.hpp +++ b/boost/math/tools/detail/rational_horner2_14.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_15.hpp b/boost/math/tools/detail/rational_horner2_15.hpp index 3cf4ef56a0..cf084e8be0 100644 --- a/boost/math/tools/detail/rational_horner2_15.hpp +++ b/boost/math/tools/detail/rational_horner2_15.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -202,7 +202,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_16.hpp b/boost/math/tools/detail/rational_horner2_16.hpp index 3936a1ba4b..3d13db2553 100644 --- a/boost/math/tools/detail/rational_horner2_16.hpp +++ b/boost/math/tools/detail/rational_horner2_16.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -202,7 +202,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -218,7 +218,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_17.hpp b/boost/math/tools/detail/rational_horner2_17.hpp index 4d253b9593..3adf4053bd 100644 --- a/boost/math/tools/detail/rational_horner2_17.hpp +++ b/boost/math/tools/detail/rational_horner2_17.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -202,7 +202,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -218,7 +218,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -234,7 +234,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_18.hpp b/boost/math/tools/detail/rational_horner2_18.hpp index 6c213ecfb0..607609fd8e 100644 --- a/boost/math/tools/detail/rational_horner2_18.hpp +++ b/boost/math/tools/detail/rational_horner2_18.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -202,7 +202,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -218,7 +218,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -234,7 +234,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -250,7 +250,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_19.hpp b/boost/math/tools/detail/rational_horner2_19.hpp index 88e0b9ff01..bc324c3be3 100644 --- a/boost/math/tools/detail/rational_horner2_19.hpp +++ b/boost/math/tools/detail/rational_horner2_19.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -202,7 +202,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -218,7 +218,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -234,7 +234,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -250,7 +250,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -266,7 +266,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_2.hpp b/boost/math/tools/detail/rational_horner2_2.hpp index 35b5abb354..95ec0251d5 100644 --- a/boost/math/tools/detail/rational_horner2_2.hpp +++ b/boost/math/tools/detail/rational_horner2_2.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } diff --git a/boost/math/tools/detail/rational_horner2_20.hpp b/boost/math/tools/detail/rational_horner2_20.hpp index dc73fdd58e..cf1211b61f 100644 --- a/boost/math/tools/detail/rational_horner2_20.hpp +++ b/boost/math/tools/detail/rational_horner2_20.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -122,7 +122,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -138,7 +138,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -154,7 +154,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -170,7 +170,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -186,7 +186,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -202,7 +202,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -218,7 +218,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -234,7 +234,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -250,7 +250,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -266,7 +266,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -282,7 +282,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<20>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<20>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_3.hpp b/boost/math/tools/detail/rational_horner2_3.hpp index 8838ac13e6..9ce437b41f 100644 --- a/boost/math/tools/detail/rational_horner2_3.hpp +++ b/boost/math/tools/detail/rational_horner2_3.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } diff --git a/boost/math/tools/detail/rational_horner2_4.hpp b/boost/math/tools/detail/rational_horner2_4.hpp index 5fe5ada83b..00543ede85 100644 --- a/boost/math/tools/detail/rational_horner2_4.hpp +++ b/boost/math/tools/detail/rational_horner2_4.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } diff --git a/boost/math/tools/detail/rational_horner2_5.hpp b/boost/math/tools/detail/rational_horner2_5.hpp index 48b8498bc7..d117b66633 100644 --- a/boost/math/tools/detail/rational_horner2_5.hpp +++ b/boost/math/tools/detail/rational_horner2_5.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_6.hpp b/boost/math/tools/detail/rational_horner2_6.hpp index 83631eaf51..c431d16344 100644 --- a/boost/math/tools/detail/rational_horner2_6.hpp +++ b/boost/math/tools/detail/rational_horner2_6.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_7.hpp b/boost/math/tools/detail/rational_horner2_7.hpp index 3ed86eafcd..2104302472 100644 --- a/boost/math/tools/detail/rational_horner2_7.hpp +++ b/boost/math/tools/detail/rational_horner2_7.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_8.hpp b/boost/math/tools/detail/rational_horner2_8.hpp index f8b36ece4a..fd98289b99 100644 --- a/boost/math/tools/detail/rational_horner2_8.hpp +++ b/boost/math/tools/detail/rational_horner2_8.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner2_9.hpp b/boost/math/tools/detail/rational_horner2_9.hpp index 88cc4e5fcf..1081ab2f8b 100644 --- a/boost/math/tools/detail/rational_horner2_9.hpp +++ b/boost/math/tools/detail/rational_horner2_9.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -58,7 +58,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -74,7 +74,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -90,7 +90,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -106,7 +106,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_10.hpp b/boost/math/tools/detail/rational_horner3_10.hpp index 019ffdacc3..7da05875f3 100644 --- a/boost/math/tools/detail/rational_horner3_10.hpp +++ b/boost/math/tools/detail/rational_horner3_10.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_11.hpp b/boost/math/tools/detail/rational_horner3_11.hpp index 13ce3134ae..df971197a3 100644 --- a/boost/math/tools/detail/rational_horner3_11.hpp +++ b/boost/math/tools/detail/rational_horner3_11.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_12.hpp b/boost/math/tools/detail/rational_horner3_12.hpp index 634140bd0d..668f76684f 100644 --- a/boost/math/tools/detail/rational_horner3_12.hpp +++ b/boost/math/tools/detail/rational_horner3_12.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_13.hpp b/boost/math/tools/detail/rational_horner3_13.hpp index 0b4974a501..b0b4c2ac58 100644 --- a/boost/math/tools/detail/rational_horner3_13.hpp +++ b/boost/math/tools/detail/rational_horner3_13.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_14.hpp b/boost/math/tools/detail/rational_horner3_14.hpp index 63f4e95963..92035ef806 100644 --- a/boost/math/tools/detail/rational_horner3_14.hpp +++ b/boost/math/tools/detail/rational_horner3_14.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_15.hpp b/boost/math/tools/detail/rational_horner3_15.hpp index c13500f130..9536ecd844 100644 --- a/boost/math/tools/detail/rational_horner3_15.hpp +++ b/boost/math/tools/detail/rational_horner3_15.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -782,7 +782,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_16.hpp b/boost/math/tools/detail/rational_horner3_16.hpp index b1c89774f8..7ccf8f6e7a 100644 --- a/boost/math/tools/detail/rational_horner3_16.hpp +++ b/boost/math/tools/detail/rational_horner3_16.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -782,7 +782,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -900,7 +900,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_17.hpp b/boost/math/tools/detail/rational_horner3_17.hpp index 9c3498ec24..1a35c47397 100644 --- a/boost/math/tools/detail/rational_horner3_17.hpp +++ b/boost/math/tools/detail/rational_horner3_17.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -782,7 +782,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -900,7 +900,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1026,7 +1026,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_18.hpp b/boost/math/tools/detail/rational_horner3_18.hpp index 5401e9f3a2..8a1c16eb2f 100644 --- a/boost/math/tools/detail/rational_horner3_18.hpp +++ b/boost/math/tools/detail/rational_horner3_18.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -782,7 +782,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -900,7 +900,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1026,7 +1026,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1160,7 +1160,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_19.hpp b/boost/math/tools/detail/rational_horner3_19.hpp index c111b68f1e..15d16bafc3 100644 --- a/boost/math/tools/detail/rational_horner3_19.hpp +++ b/boost/math/tools/detail/rational_horner3_19.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -782,7 +782,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -900,7 +900,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1026,7 +1026,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1160,7 +1160,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1302,7 +1302,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_2.hpp b/boost/math/tools/detail/rational_horner3_2.hpp index 35b5abb354..95ec0251d5 100644 --- a/boost/math/tools/detail/rational_horner3_2.hpp +++ b/boost/math/tools/detail/rational_horner3_2.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } diff --git a/boost/math/tools/detail/rational_horner3_20.hpp b/boost/math/tools/detail/rational_horner3_20.hpp index 7bee9b110a..78233214d8 100644 --- a/boost/math/tools/detail/rational_horner3_20.hpp +++ b/boost/math/tools/detail/rational_horner3_20.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -312,7 +312,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -390,7 +390,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -476,7 +476,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -570,7 +570,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -672,7 +672,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -782,7 +782,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -900,7 +900,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<16>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1026,7 +1026,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<17>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1160,7 +1160,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<18>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1302,7 +1302,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<19>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -1452,7 +1452,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<20>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<20>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_3.hpp b/boost/math/tools/detail/rational_horner3_3.hpp index 8838ac13e6..9ce437b41f 100644 --- a/boost/math/tools/detail/rational_horner3_3.hpp +++ b/boost/math/tools/detail/rational_horner3_3.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } diff --git a/boost/math/tools/detail/rational_horner3_4.hpp b/boost/math/tools/detail/rational_horner3_4.hpp index 5fe5ada83b..00543ede85 100644 --- a/boost/math/tools/detail/rational_horner3_4.hpp +++ b/boost/math/tools/detail/rational_horner3_4.hpp @@ -12,31 +12,31 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } diff --git a/boost/math/tools/detail/rational_horner3_5.hpp b/boost/math/tools/detail/rational_horner3_5.hpp index 23a606855b..35dce45a80 100644 --- a/boost/math/tools/detail/rational_horner3_5.hpp +++ b/boost/math/tools/detail/rational_horner3_5.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_6.hpp b/boost/math/tools/detail/rational_horner3_6.hpp index 186167d614..b9361ba07a 100644 --- a/boost/math/tools/detail/rational_horner3_6.hpp +++ b/boost/math/tools/detail/rational_horner3_6.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_7.hpp b/boost/math/tools/detail/rational_horner3_7.hpp index e08dce62d7..92b00b3a15 100644 --- a/boost/math/tools/detail/rational_horner3_7.hpp +++ b/boost/math/tools/detail/rational_horner3_7.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_8.hpp b/boost/math/tools/detail/rational_horner3_8.hpp index 3ceb717439..197b6c0550 100644 --- a/boost/math/tools/detail/rational_horner3_8.hpp +++ b/boost/math/tools/detail/rational_horner3_8.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/detail/rational_horner3_9.hpp b/boost/math/tools/detail/rational_horner3_9.hpp index 94dab4c0db..5aad957c37 100644 --- a/boost/math/tools/detail/rational_horner3_9.hpp +++ b/boost/math/tools/detail/rational_horner3_9.hpp @@ -12,37 +12,37 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) +inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(0); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(a[0]) / static_cast<V>(b[0]); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V) { return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0])); } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -80,7 +80,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -126,7 +126,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -180,7 +180,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { @@ -242,7 +242,7 @@ inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl:: } template <class T, class U, class V> -inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) +inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V) { if(x <= 1) { diff --git a/boost/math/tools/fraction.hpp b/boost/math/tools/fraction.hpp index b245ddd2a3..a787c603f3 100644 --- a/boost/math/tools/fraction.hpp +++ b/boost/math/tools/fraction.hpp @@ -33,11 +33,11 @@ namespace detail typedef typename Gen::result_type result_type; typedef typename Gen::result_type value_type; - static result_type a(const value_type&) + static result_type a(const value_type&) BOOST_MATH_NOEXCEPT(value_type) { return 1; } - static result_type b(const value_type& v) + static result_type b(const value_type& v) BOOST_MATH_NOEXCEPT(value_type) { return v; } @@ -49,11 +49,11 @@ namespace detail typedef typename Gen::result_type value_type; typedef typename value_type::first_type result_type; - static result_type a(const value_type& v) + static result_type a(const value_type& v) BOOST_MATH_NOEXCEPT(value_type) { return v.first; } - static result_type b(const value_type& v) + static result_type b(const value_type& v) BOOST_MATH_NOEXCEPT(value_type) { return v.second; } @@ -85,7 +85,8 @@ namespace detail // Note that the first a0 returned by generator Gen is disarded. // template <class Gen, class U> -inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, const U& factor, boost::uintmax_t& max_terms) +inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, const U& factor, boost::uintmax_t& max_terms) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { BOOST_MATH_STD_USING // ADL of std names @@ -126,6 +127,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(G template <class Gen, class U> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, const U& factor) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { boost::uintmax_t max_terms = (std::numeric_limits<boost::uintmax_t>::max)(); return continued_fraction_b(g, factor, max_terms); @@ -133,6 +135,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(G template <class Gen> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, int bits) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { BOOST_MATH_STD_USING // ADL of std names @@ -146,6 +149,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(G template <class Gen> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, int bits, boost::uintmax_t& max_terms) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { BOOST_MATH_STD_USING // ADL of std names @@ -172,6 +176,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(G // template <class Gen, class U> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, const U& factor, boost::uintmax_t& max_terms) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { BOOST_MATH_STD_USING // ADL of std names @@ -213,6 +218,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(G template <class Gen, class U> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, const U& factor) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { boost::uintmax_t max_iter = (std::numeric_limits<boost::uintmax_t>::max)(); return continued_fraction_a(g, factor, max_iter); @@ -220,6 +226,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(G template <class Gen> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, int bits) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { BOOST_MATH_STD_USING // ADL of std names @@ -234,6 +241,7 @@ inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(G template <class Gen> inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, int bits, boost::uintmax_t& max_terms) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()())) { BOOST_MATH_STD_USING // ADL of std names diff --git a/boost/math/tools/minima.hpp b/boost/math/tools/minima.hpp index 3dc5356f3e..b76dabe3f6 100644 --- a/boost/math/tools/minima.hpp +++ b/boost/math/tools/minima.hpp @@ -21,6 +21,7 @@ namespace boost{ namespace math{ namespace tools{ template <class F, class T> std::pair<T, T> brent_find_minima(F f, T min, T max, int bits, boost::uintmax_t& max_iter) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { BOOST_MATH_STD_USING bits = (std::min)(policies::digits<T, policies::policy<> >() / 2, bits); @@ -138,6 +139,7 @@ std::pair<T, T> brent_find_minima(F f, T min, T max, int bits, boost::uintmax_t& template <class F, class T> inline std::pair<T, T> brent_find_minima(F f, T min, T max, int digits) + BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); return brent_find_minima(f, min, max, digits, m); diff --git a/boost/math/tools/precision.hpp b/boost/math/tools/precision.hpp index ed146c458f..9631fc2eb6 100644 --- a/boost/math/tools/precision.hpp +++ b/boost/math/tools/precision.hpp @@ -39,7 +39,7 @@ namespace tools // See Conceptual Requirements for Real Number Types. template <class T> -inline int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) +inline BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_NOEXCEPT { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); @@ -54,7 +54,7 @@ inline int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) } template <class T> -inline T max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); @@ -66,7 +66,7 @@ inline T max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) // -max_value<double> = -1.79769e+308, max_value<double> = 1.79769e+308. template <class T> -inline T min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); @@ -86,13 +86,13 @@ namespace detail{ // For type float first: // template <class T> -inline T log_max_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return 88.0f; } template <class T> -inline T log_min_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return -87.0f; } @@ -100,13 +100,13 @@ inline T log_min_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE // Now double: // template <class T> -inline T log_max_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return 709.0; } template <class T> -inline T log_min_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return -708.0; } @@ -114,13 +114,13 @@ inline T log_min_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLAT // 80 and 128-bit long doubles: // template <class T> -inline T log_max_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return 11356.0L; } template <class T> -inline T log_min_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return -11355.0L; } @@ -128,17 +128,12 @@ inline T log_min_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLA template <class T> inline T log_max_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); -#else - BOOST_ASSERT(::std::numeric_limits<T>::is_specialized); -#endif BOOST_MATH_STD_USING #ifdef __SUNPRO_CC - static const T m = (std::numeric_limits<T>::max)(); + static const T m = boost::math::tools::max_value<T>(); static const T val = log(m); #else - static const T val = log((std::numeric_limits<T>::max)()); + static const T val = log(boost::math::tools::max_value<T>()); #endif return val; } @@ -146,30 +141,25 @@ inline T log_max_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_T template <class T> inline T log_min_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); -#else - BOOST_ASSERT(::std::numeric_limits<T>::is_specialized); -#endif BOOST_MATH_STD_USING #ifdef __SUNPRO_CC - static const T m = (std::numeric_limits<T>::min)(); + static const T m = boost::math::tools::min_value<T>(); static const T val = log(m); #else - static const T val = log((std::numeric_limits<T>::min)()); + static const T val = log(boost::math::tools::min_value<T>()); #endif return val; } template <class T> -inline T epsilon(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T epsilon(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T) { return std::numeric_limits<T>::epsilon(); } #if defined(__GNUC__) && ((LDBL_MANT_DIG == 106) || (__LDBL_MANT_DIG__ == 106)) template <> -inline long double epsilon<long double>(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(long double)) +inline BOOST_MATH_CONSTEXPR long double epsilon<long double>(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(long double)) BOOST_MATH_NOEXCEPT(long double) { // numeric_limits on Darwin (and elsewhere) tells lies here: // the issue is that long double on a few platforms is @@ -195,6 +185,27 @@ inline T epsilon(const mpl::false_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) return eps; } +template <class T> +struct log_limit_traits +{ + typedef typename mpl::if_c< + (std::numeric_limits<T>::radix == 2) && + (std::numeric_limits<T>::max_exponent == 128 + || std::numeric_limits<T>::max_exponent == 1024 + || std::numeric_limits<T>::max_exponent == 16384), + mpl::int_<(std::numeric_limits<T>::max_exponent > INT_MAX ? INT_MAX : static_cast<int>(std::numeric_limits<T>::max_exponent))>, + mpl::int_<0> + >::type tag_type; + BOOST_STATIC_CONSTANT(bool, value = tag_type::value ? true : false); + BOOST_STATIC_ASSERT(::std::numeric_limits<T>::is_specialized || (value == 0)); +}; + +template <class T, bool b> struct log_limit_noexcept_traits_imp : public log_limit_traits<T> {}; +template <class T> struct log_limit_noexcept_traits_imp<T, false> : public boost::integral_constant<bool, false> {}; + +template <class T> +struct log_limit_noexcept_traits : public log_limit_noexcept_traits_imp<T, BOOST_MATH_IS_FLOAT(T)> {}; + } // namespace detail #ifdef BOOST_MSVC @@ -203,19 +214,10 @@ inline T epsilon(const mpl::false_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) #endif template <class T> -inline T log_max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT_IF(detail::log_limit_noexcept_traits<T>::value) { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - typedef typename mpl::if_c< - (std::numeric_limits<T>::radix == 2) && - (std::numeric_limits<T>::max_exponent == 128 - || std::numeric_limits<T>::max_exponent == 1024 - || std::numeric_limits<T>::max_exponent == 16384), - mpl::int_<(std::numeric_limits<T>::max_exponent > INT_MAX ? INT_MAX : static_cast<int>(std::numeric_limits<T>::max_exponent))>, - mpl::int_<0> - >::type tag_type; - BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); - return detail::log_max_value<T>(tag_type()); + return detail::log_max_value<T>(typename detail::log_limit_traits<T>::tag_type()); #else BOOST_ASSERT(::std::numeric_limits<T>::is_specialized); BOOST_MATH_STD_USING @@ -225,20 +227,10 @@ inline T log_max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) } template <class T> -inline T log_min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) +inline BOOST_MATH_CONSTEXPR T log_min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT_IF(detail::log_limit_noexcept_traits<T>::value) { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - typedef typename mpl::if_c< - (std::numeric_limits<T>::radix == 2) && - (std::numeric_limits<T>::max_exponent == 128 - || std::numeric_limits<T>::max_exponent == 1024 - || std::numeric_limits<T>::max_exponent == 16384), - mpl::int_<(std::numeric_limits<T>::max_exponent > INT_MAX ? INT_MAX : static_cast<int>(std::numeric_limits<T>::max_exponent))>, - mpl::int_<0> - >::type tag_type; - - BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized); - return detail::log_min_value<T>(tag_type()); + return detail::log_min_value<T>(typename detail::log_limit_traits<T>::tag_type()); #else BOOST_ASSERT(::std::numeric_limits<T>::is_specialized); BOOST_MATH_STD_USING @@ -252,7 +244,7 @@ inline T log_min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) #endif template <class T> -inline T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) +inline BOOST_MATH_CONSTEXPR T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_MATH_NOEXCEPT(T) { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS return detail::epsilon<T>(mpl::bool_< ::std::numeric_limits<T>::is_specialized>()); @@ -266,25 +258,25 @@ inline T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) namespace detail{ template <class T> -inline T root_epsilon_imp(const mpl::int_<24>&) +inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.00034526698300124390839884978618400831996329879769945L); } template <class T> -inline T root_epsilon_imp(const T*, const mpl::int_<53>&) +inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.1490116119384765625e-7L); } template <class T> -inline T root_epsilon_imp(const T*, const mpl::int_<64>&) +inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.32927225399135962333569506281281311031656150598474e-9L); } template <class T> -inline T root_epsilon_imp(const T*, const mpl::int_<113>&) +inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.1387778780781445675529539585113525390625e-16L); } @@ -298,25 +290,25 @@ inline T root_epsilon_imp(const T*, const Tag&) } template <class T> -inline T cbrt_epsilon_imp(const mpl::int_<24>&) +inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.0049215666011518482998719164346805794944150447839903L); } template <class T> -inline T cbrt_epsilon_imp(const T*, const mpl::int_<53>&) +inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(6.05545445239333906078989272793696693569753008995e-6L); } template <class T> -inline T cbrt_epsilon_imp(const T*, const mpl::int_<64>&) +inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(4.76837158203125e-7L); } template <class T> -inline T cbrt_epsilon_imp(const T*, const mpl::int_<113>&) +inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(5.7749313854154005630396773604745549542403508090496e-12L); } @@ -330,25 +322,25 @@ inline T cbrt_epsilon_imp(const T*, const Tag&) } template <class T> -inline T forth_root_epsilon_imp(const T*, const mpl::int_<24>&) +inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.018581361171917516667460937040007436176452688944747L); } template <class T> -inline T forth_root_epsilon_imp(const T*, const mpl::int_<53>&) +inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.0001220703125L); } template <class T> -inline T forth_root_epsilon_imp(const T*, const mpl::int_<64>&) +inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.18145860519450699870567321328132261891067079047605e-4L); } template <class T> -inline T forth_root_epsilon_imp(const T*, const mpl::int_<113>&) +inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T) { return static_cast<T>(0.37252902984619140625e-8L); } @@ -361,27 +353,31 @@ inline T forth_root_epsilon_imp(const T*, const Tag&) return r_eps; } +template <class T> +struct root_epsilon_traits +{ + typedef mpl::int_< (::std::numeric_limits<T>::radix == 2) ? std::numeric_limits<T>::digits : 0> tag_type; + BOOST_STATIC_CONSTANT(bool, has_noexcept = (tag_type::value == 113) || (tag_type::value == 64) || (tag_type::value == 53) || (tag_type::value == 24)); +}; + } template <class T> -inline T root_epsilon() +inline BOOST_MATH_CONSTEXPR T root_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept) { - typedef mpl::int_< (::std::numeric_limits<T>::radix == 2) ? std::numeric_limits<T>::digits : 0> tag_type; - return detail::root_epsilon_imp(static_cast<T const*>(0), tag_type()); + return detail::root_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type()); } template <class T> -inline T cbrt_epsilon() +inline BOOST_MATH_CONSTEXPR T cbrt_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept) { - typedef mpl::int_< (::std::numeric_limits<T>::radix == 2) ? std::numeric_limits<T>::digits : 0> tag_type; - return detail::cbrt_epsilon_imp(static_cast<T const*>(0), tag_type()); + return detail::cbrt_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type()); } template <class T> -inline T forth_root_epsilon() +inline BOOST_MATH_CONSTEXPR T forth_root_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept) { - typedef mpl::int_< (::std::numeric_limits<T>::radix == 2) ? std::numeric_limits<T>::digits : 0> tag_type; - return detail::forth_root_epsilon_imp(static_cast<T const*>(0), tag_type()); + return detail::forth_root_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type()); } } // namespace tools diff --git a/boost/math/tools/promotion.hpp b/boost/math/tools/promotion.hpp index b3ad204077..494d7f99e2 100644 --- a/boost/math/tools/promotion.hpp +++ b/boost/math/tools/promotion.hpp @@ -86,13 +86,20 @@ namespace boost typedef typename mpl::if_< typename mpl::and_<is_floating_point<T1P>, is_floating_point<T2P> >::type, // both T1P and T2P are floating-point? - typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type, // either long double? - long double, // then result type is long double. - typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type, // either double? - double, // result type is double. - float // else result type is float. - >::type - >::type, +#ifdef BOOST_MATH_USE_FLOAT128 + typename mpl::if_< typename mpl::or_<is_same<__float128, T1P>, is_same<__float128, T2P> >::type, // either long double? + __float128, +#endif + typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type, // either long double? + long double, // then result type is long double. + typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type, // either double? + double, // result type is double. + float // else result type is float. + >::type +#ifdef BOOST_MATH_USE_FLOAT128 + >::type +#endif + >::type, // else one or the other is a user-defined type: typename mpl::if_< typename mpl::and_<mpl::not_<is_floating_point<T2P> >, ::boost::is_convertible<T1P, T2P> >, T2P, T1P>::type>::type type; }; // promote_arg2 diff --git a/boost/math/tools/rational.hpp b/boost/math/tools/rational.hpp index accffeaf26..d8bd4a73aa 100644 --- a/boost/math/tools/rational.hpp +++ b/boost/math/tools/rational.hpp @@ -168,12 +168,12 @@ namespace boost{ namespace math{ namespace tools{ // Forward declaration to keep two phase lookup happy: // template <class T, class U> -U evaluate_polynomial(const T* poly, U const& z, std::size_t count); +U evaluate_polynomial(const T* poly, U const& z, std::size_t count) BOOST_MATH_NOEXCEPT(U); namespace detail{ template <class T, class V, class Tag> -inline V evaluate_polynomial_c_imp(const T* a, const V& val, const Tag*) +inline V evaluate_polynomial_c_imp(const T* a, const V& val, const Tag*) BOOST_MATH_NOEXCEPT(V) { return evaluate_polynomial(a, val, Tag::value); } @@ -186,7 +186,7 @@ inline V evaluate_polynomial_c_imp(const T* a, const V& val, const Tag*) // the loop expanded versions above: // template <class T, class U> -inline U evaluate_polynomial(const T* poly, U const& z, std::size_t count) +inline U evaluate_polynomial(const T* poly, U const& z, std::size_t count) BOOST_MATH_NOEXCEPT(U) { BOOST_ASSERT(count > 0); U sum = static_cast<U>(poly[count - 1]); @@ -202,14 +202,14 @@ inline U evaluate_polynomial(const T* poly, U const& z, std::size_t count) // implementations above: // template <std::size_t N, class T, class V> -inline V evaluate_polynomial(const T(&a)[N], const V& val) +inline V evaluate_polynomial(const T(&a)[N], const V& val) BOOST_MATH_NOEXCEPT(V) { typedef mpl::int_<N> tag_type; return detail::evaluate_polynomial_c_imp(static_cast<const T*>(a), val, static_cast<tag_type const*>(0)); } template <std::size_t N, class T, class V> -inline V evaluate_polynomial(const boost::array<T,N>& a, const V& val) +inline V evaluate_polynomial(const boost::array<T,N>& a, const V& val) BOOST_MATH_NOEXCEPT(V) { typedef mpl::int_<N> tag_type; return detail::evaluate_polynomial_c_imp(static_cast<const T*>(a.data()), val, static_cast<tag_type const*>(0)); @@ -218,19 +218,19 @@ inline V evaluate_polynomial(const boost::array<T,N>& a, const V& val) // Even polynomials are trivial: just square the argument! // template <class T, class U> -inline U evaluate_even_polynomial(const T* poly, U z, std::size_t count) +inline U evaluate_even_polynomial(const T* poly, U z, std::size_t count) BOOST_MATH_NOEXCEPT(U) { return evaluate_polynomial(poly, U(z*z), count); } template <std::size_t N, class T, class V> -inline V evaluate_even_polynomial(const T(&a)[N], const V& z) +inline V evaluate_even_polynomial(const T(&a)[N], const V& z) BOOST_MATH_NOEXCEPT(V) { return evaluate_polynomial(a, V(z*z)); } template <std::size_t N, class T, class V> -inline V evaluate_even_polynomial(const boost::array<T,N>& a, const V& z) +inline V evaluate_even_polynomial(const boost::array<T,N>& a, const V& z) BOOST_MATH_NOEXCEPT(V) { return evaluate_polynomial(a, V(z*z)); } @@ -238,32 +238,32 @@ inline V evaluate_even_polynomial(const boost::array<T,N>& a, const V& z) // Odd polynomials come next: // template <class T, class U> -inline U evaluate_odd_polynomial(const T* poly, U z, std::size_t count) +inline U evaluate_odd_polynomial(const T* poly, U z, std::size_t count) BOOST_MATH_NOEXCEPT(U) { return poly[0] + z * evaluate_polynomial(poly+1, U(z*z), count-1); } template <std::size_t N, class T, class V> -inline V evaluate_odd_polynomial(const T(&a)[N], const V& z) +inline V evaluate_odd_polynomial(const T(&a)[N], const V& z) BOOST_MATH_NOEXCEPT(V) { typedef mpl::int_<N-1> tag_type; return a[0] + z * detail::evaluate_polynomial_c_imp(static_cast<const T*>(a) + 1, V(z*z), static_cast<tag_type const*>(0)); } template <std::size_t N, class T, class V> -inline V evaluate_odd_polynomial(const boost::array<T,N>& a, const V& z) +inline V evaluate_odd_polynomial(const boost::array<T,N>& a, const V& z) BOOST_MATH_NOEXCEPT(V) { typedef mpl::int_<N-1> tag_type; return a[0] + z * detail::evaluate_polynomial_c_imp(static_cast<const T*>(a.data()) + 1, V(z*z), static_cast<tag_type const*>(0)); } template <class T, class U, class V> -V evaluate_rational(const T* num, const U* denom, const V& z_, std::size_t count); +V evaluate_rational(const T* num, const U* denom, const V& z_, std::size_t count) BOOST_MATH_NOEXCEPT(V); namespace detail{ template <class T, class U, class V, class Tag> -inline V evaluate_rational_c_imp(const T* num, const U* denom, const V& z, const Tag*) +inline V evaluate_rational_c_imp(const T* num, const U* denom, const V& z, const Tag*) BOOST_MATH_NOEXCEPT(V) { return boost::math::tools::evaluate_rational(num, denom, z, Tag::value); } @@ -278,7 +278,7 @@ inline V evaluate_rational_c_imp(const T* num, const U* denom, const V& z, const // in our Lanczos code for example. // template <class T, class U, class V> -V evaluate_rational(const T* num, const U* denom, const V& z_, std::size_t count) +V evaluate_rational(const T* num, const U* denom, const V& z_, std::size_t count) BOOST_MATH_NOEXCEPT(V) { V z(z_); V s1, s2; @@ -311,13 +311,13 @@ V evaluate_rational(const T* num, const U* denom, const V& z_, std::size_t count } template <std::size_t N, class T, class U, class V> -inline V evaluate_rational(const T(&a)[N], const U(&b)[N], const V& z) +inline V evaluate_rational(const T(&a)[N], const U(&b)[N], const V& z) BOOST_MATH_NOEXCEPT(V) { return detail::evaluate_rational_c_imp(a, b, z, static_cast<const mpl::int_<N>*>(0)); } template <std::size_t N, class T, class U, class V> -inline V evaluate_rational(const boost::array<T,N>& a, const boost::array<U,N>& b, const V& z) +inline V evaluate_rational(const boost::array<T,N>& a, const boost::array<U,N>& b, const V& z) BOOST_MATH_NOEXCEPT(V) { return detail::evaluate_rational_c_imp(a.data(), b.data(), z, static_cast<mpl::int_<N>*>(0)); } diff --git a/boost/math/tools/real_cast.hpp b/boost/math/tools/real_cast.hpp index 9b854e3014..873e60259b 100644 --- a/boost/math/tools/real_cast.hpp +++ b/boost/math/tools/real_cast.hpp @@ -6,6 +6,8 @@ #ifndef BOOST_MATH_TOOLS_REAL_CAST_HPP #define BOOST_MATH_TOOLS_REAL_CAST_HPP +#include <boost/math/tools/config.hpp> + #ifdef _MSC_VER #pragma once #endif @@ -15,7 +17,7 @@ namespace boost{ namespace math namespace tools { template <class To, class T> - inline To real_cast(T t) + inline BOOST_MATH_CONSTEXPR To real_cast(T t) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && BOOST_MATH_IS_FLOAT(To)) { return static_cast<To>(t); } diff --git a/boost/math/tools/roots.hpp b/boost/math/tools/roots.hpp index 2442f5c2d1..25300fee38 100644 --- a/boost/math/tools/roots.hpp +++ b/boost/math/tools/roots.hpp @@ -36,9 +36,49 @@ namespace boost{ namespace math{ namespace tools{ namespace detail{ +namespace dummy{ + + template<int n, class T> + typename T::value_type get(const T&) BOOST_MATH_NOEXCEPT(T); +} + +template <class Tuple, class T> +void unpack_tuple(const Tuple& t, T& a, T& b) BOOST_MATH_NOEXCEPT(T) +{ + using dummy::get; + // Use ADL to find the right overload for get: + a = get<0>(t); + b = get<1>(t); +} template <class Tuple, class T> -inline void unpack_0(const Tuple& t, T& val) -{ val = boost::math::get<0>(t); } +void unpack_tuple(const Tuple& t, T& a, T& b, T& c) BOOST_MATH_NOEXCEPT(T) +{ + using dummy::get; + // Use ADL to find the right overload for get: + a = get<0>(t); + b = get<1>(t); + c = get<2>(t); +} + +template <class Tuple, class T> +inline void unpack_0(const Tuple& t, T& val) BOOST_MATH_NOEXCEPT(T) +{ + using dummy::get; + // Rely on ADL to find the correct overload of get: + val = get<0>(t); +} + +template <class T, class U, class V> +inline void unpack_tuple(const std::pair<T, U>& p, V& a, V& b) BOOST_MATH_NOEXCEPT(T) +{ + a = p.first; + b = p.second; +} +template <class T, class U, class V> +inline void unpack_0(const std::pair<T, U>& p, V& a) BOOST_MATH_NOEXCEPT(T) +{ + a = p.first; +} template <class F, class T> void handle_zero_derivative(F f, @@ -48,7 +88,7 @@ void handle_zero_derivative(F f, T& result, T& guess, const T& min, - const T& max) + const T& max) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { if(last_f0 == 0) { @@ -94,14 +134,20 @@ void handle_zero_derivative(F f, } // namespace template <class F, class T, class Tol, class Policy> -std::pair<T, T> bisect(F f, T min, T max, Tol tol, boost::uintmax_t& max_iter, const Policy& pol) +std::pair<T, T> bisect(F f, T min, T max, Tol tol, boost::uintmax_t& max_iter, const Policy& pol) BOOST_NOEXCEPT_IF(policies::is_noexcept_error_policy<Policy>::value && BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { T fmin = f(min); T fmax = f(max); if(fmin == 0) + { + max_iter = 2; return std::make_pair(min, min); + } if(fmax == 0) + { + max_iter = 2; return std::make_pair(max, max); + } // // Error checking: @@ -168,20 +214,21 @@ std::pair<T, T> bisect(F f, T min, T max, Tol tol, boost::uintmax_t& max_iter, c } template <class F, class T, class Tol> -inline std::pair<T, T> bisect(F f, T min, T max, Tol tol, boost::uintmax_t& max_iter) +inline std::pair<T, T> bisect(F f, T min, T max, Tol tol, boost::uintmax_t& max_iter) BOOST_NOEXCEPT_IF(policies::is_noexcept_error_policy<policies::policy<> >::value && BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { return bisect(f, min, max, tol, max_iter, policies::policy<>()); } template <class F, class T, class Tol> -inline std::pair<T, T> bisect(F f, T min, T max, Tol tol) +inline std::pair<T, T> bisect(F f, T min, T max, Tol tol) BOOST_NOEXCEPT_IF(policies::is_noexcept_error_policy<policies::policy<> >::value && BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); return bisect(f, min, max, tol, m, policies::policy<>()); } + template <class F, class T> -T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) +T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { BOOST_MATH_STD_USING @@ -189,7 +236,7 @@ T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_ T result = guess; T factor = static_cast<T>(ldexp(1.0, 1 - digits)); - T delta = 1; + T delta = tools::max_value<T>(); T delta1 = tools::max_value<T>(); T delta2 = tools::max_value<T>(); @@ -199,7 +246,8 @@ T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_ last_f0 = f0; delta2 = delta1; delta1 = delta; - boost::math::tie(f0, f1) = f(result); + detail::unpack_tuple(f(result), f0, f1); + --count; if(0 == f0) break; if(f1 == 0) @@ -243,7 +291,7 @@ T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_ max = guess; else min = guess; - }while(--count && (fabs(result * factor) < fabs(delta))); + }while(count && (fabs(result * factor) < fabs(delta))); max_iter -= count; @@ -262,213 +310,208 @@ T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_ } template <class F, class T> -inline T newton_raphson_iterate(F f, T guess, T min, T max, int digits) +inline T newton_raphson_iterate(F f, T guess, T min, T max, int digits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); return newton_raphson_iterate(f, guess, min, max, digits, m); } -template <class F, class T> -T halley_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) -{ - BOOST_MATH_STD_USING +namespace detail{ - T f0(0), f1, f2; - T result = guess; + struct halley_step + { + template <class T> + static T step(const T& /*x*/, const T& f0, const T& f1, const T& f2) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T)) + { + using std::fabs; + T denom = 2 * f0; + T num = 2 * f1 - f0 * (f2 / f1); + T delta; - T factor = static_cast<T>(ldexp(1.0, 1 - digits)); - T delta = (std::max)(T(10000000 * guess), T(10000000)); // arbitarily large delta - T last_f0 = 0; - T delta1 = delta; - T delta2 = delta; + BOOST_MATH_INSTRUMENT_VARIABLE(denom); + BOOST_MATH_INSTRUMENT_VARIABLE(num); - bool out_of_bounds_sentry = false; + if((fabs(num) < 1) && (fabs(denom) >= fabs(num) * tools::max_value<T>())) + { + // possible overflow, use Newton step: + delta = f0 / f1; + } + else + delta = denom / num; + return delta; + } + }; + + template <class Stepper, class F, class T> + T second_order_root_finder(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) + { + BOOST_MATH_STD_USING + + T f0(0), f1, f2; + T result = guess; + + T factor = static_cast<T>(ldexp(1.0, 1 - digits)); + T delta = (std::max)(T(10000000 * guess), T(10000000)); // arbitarily large delta + T last_f0 = 0; + T delta1 = delta; + T delta2 = delta; + + bool out_of_bounds_sentry = false; #ifdef BOOST_MATH_INSTRUMENT - std::cout << "Halley iteration, limit = " << factor << std::endl; + std::cout << "Second order root iteration, limit = " << factor << std::endl; #endif - boost::uintmax_t count(max_iter); + boost::uintmax_t count(max_iter); - do{ - last_f0 = f0; - delta2 = delta1; - delta1 = delta; - boost::math::tie(f0, f1, f2) = f(result); + do{ + last_f0 = f0; + delta2 = delta1; + delta1 = delta; + detail::unpack_tuple(f(result), f0, f1, f2); + --count; - BOOST_MATH_INSTRUMENT_VARIABLE(f0); - BOOST_MATH_INSTRUMENT_VARIABLE(f1); - BOOST_MATH_INSTRUMENT_VARIABLE(f2); - - if(0 == f0) - break; - if(f1 == 0) - { - // Oops zero derivative!!! + BOOST_MATH_INSTRUMENT_VARIABLE(f0); + BOOST_MATH_INSTRUMENT_VARIABLE(f1); + BOOST_MATH_INSTRUMENT_VARIABLE(f2); + + if(0 == f0) + break; + if(f1 == 0) + { + // Oops zero derivative!!! #ifdef BOOST_MATH_INSTRUMENT - std::cout << "Halley iteration, zero derivative found" << std::endl; + std::cout << "Second order root iteration, zero derivative found" << std::endl; #endif - detail::handle_zero_derivative(f, last_f0, f0, delta, result, guess, min, max); - } - else - { - if(f2 != 0) + detail::handle_zero_derivative(f, last_f0, f0, delta, result, guess, min, max); + } + else { - T denom = 2 * f0; - T num = 2 * f1 - f0 * (f2 / f1); - - BOOST_MATH_INSTRUMENT_VARIABLE(denom); - BOOST_MATH_INSTRUMENT_VARIABLE(num); - - if((fabs(num) < 1) && (fabs(denom) >= fabs(num) * tools::max_value<T>())) + if(f2 != 0) { - // possible overflow, use Newton step: - delta = f0 / f1; + delta = Stepper::step(result, f0, f1, f2); + if(delta * f1 / f0 < 0) + { + // Oh dear, we have a problem as Newton and Halley steps + // disagree about which way we should move. Probably + // there is cancelation error in the calculation of the + // Halley step, or else the derivatives are so small + // that their values are basically trash. We will move + // in the direction indicated by a Newton step, but + // by no more than twice the current guess value, otherwise + // we can jump way out of bounds if we're not careful. + // See https://svn.boost.org/trac/boost/ticket/8314. + delta = f0 / f1; + if(fabs(delta) > 2 * fabs(guess)) + delta = (delta < 0 ? -1 : 1) * 2 * fabs(guess); + } } else - delta = denom / num; - if(delta * f1 / f0 < 0) - { - // Oh dear, we have a problem as Newton and Halley steps - // disagree about which way we should move. Probably - // there is cancelation error in the calculation of the - // Halley step, or else the derivatives are so small - // that their values are basically trash. We will move - // in the direction indicated by a Newton step, but - // by no more than twice the current guess value, otherwise - // we can jump way out of bounds if we're not careful. - // See https://svn.boost.org/trac/boost/ticket/8314. delta = f0 / f1; - if(fabs(delta) > 2 * fabs(guess)) - delta = (delta < 0 ? -1 : 1) * 2 * fabs(guess); - } } - else - delta = f0 / f1; - } #ifdef BOOST_MATH_INSTRUMENT - std::cout << "Halley iteration, delta = " << delta << std::endl; + std::cout << "Second order root iteration, delta = " << delta << std::endl; #endif - T convergence = fabs(delta / delta2); - if((convergence > 0.8) && (convergence < 2)) - { - // last two steps haven't converged, try bisection: - delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2; - if(fabs(delta) > result) - delta = sign(delta) * result; // protect against huge jumps! - // reset delta2 so that this branch will *not* be taken on the - // next iteration: - delta2 = delta * 3; - BOOST_MATH_INSTRUMENT_VARIABLE(delta); - } - guess = result; - result -= delta; - BOOST_MATH_INSTRUMENT_VARIABLE(result); - - // check for out of bounds step: - if(result < min) - { - T diff = ((fabs(min) < 1) && (fabs(result) > 1) && (tools::max_value<T>() / fabs(result) < fabs(min))) ? T(1000) : T(result / min); - if(fabs(diff) < 1) - diff = 1 / diff; - if(!out_of_bounds_sentry && (diff > 0) && (diff < 3)) + T convergence = fabs(delta / delta2); + if((convergence > 0.8) && (convergence < 2)) { - // Only a small out of bounds step, lets assume that the result - // is probably approximately at min: - delta = 0.99f * (guess - min); - result = guess - delta; - out_of_bounds_sentry = true; // only take this branch once! + // last two steps haven't converged, try bisection: + delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2; + if(fabs(delta) > result) + delta = sign(delta) * result; // protect against huge jumps! + // reset delta2 so that this branch will *not* be taken on the + // next iteration: + delta2 = delta * 3; + BOOST_MATH_INSTRUMENT_VARIABLE(delta); } - else + guess = result; + result -= delta; + BOOST_MATH_INSTRUMENT_VARIABLE(result); + + // check for out of bounds step: + if(result < min) { - delta = (guess - min) / 2; - result = guess - delta; - if((result == min) || (result == max)) - break; + T diff = ((fabs(min) < 1) && (fabs(result) > 1) && (tools::max_value<T>() / fabs(result) < fabs(min))) ? T(1000) : T(result / min); + if(fabs(diff) < 1) + diff = 1 / diff; + if(!out_of_bounds_sentry && (diff > 0) && (diff < 3)) + { + // Only a small out of bounds step, lets assume that the result + // is probably approximately at min: + delta = 0.99f * (guess - min); + result = guess - delta; + out_of_bounds_sentry = true; // only take this branch once! + } + else + { + delta = (guess - min) / 2; + result = guess - delta; + if((result == min) || (result == max)) + break; + } } - } - else if(result > max) - { - T diff = ((fabs(max) < 1) && (fabs(result) > 1) && (tools::max_value<T>() / fabs(result) < fabs(max))) ? T(1000) : T(result / max); - if(fabs(diff) < 1) - diff = 1 / diff; - if(!out_of_bounds_sentry && (diff > 0) && (diff < 3)) + else if(result > max) { - // Only a small out of bounds step, lets assume that the result - // is probably approximately at min: - delta = 0.99f * (guess - max); - result = guess - delta; - out_of_bounds_sentry = true; // only take this branch once! + T diff = ((fabs(max) < 1) && (fabs(result) > 1) && (tools::max_value<T>() / fabs(result) < fabs(max))) ? T(1000) : T(result / max); + if(fabs(diff) < 1) + diff = 1 / diff; + if(!out_of_bounds_sentry && (diff > 0) && (diff < 3)) + { + // Only a small out of bounds step, lets assume that the result + // is probably approximately at min: + delta = 0.99f * (guess - max); + result = guess - delta; + out_of_bounds_sentry = true; // only take this branch once! + } + else + { + delta = (guess - max) / 2; + result = guess - delta; + if((result == min) || (result == max)) + break; + } } + // update brackets: + if(delta > 0) + max = guess; else - { - delta = (guess - max) / 2; - result = guess - delta; - if((result == min) || (result == max)) - break; - } - } - // update brackets: - if(delta > 0) - max = guess; - else - min = guess; - }while(--count && (fabs(result * factor) < fabs(delta))); + min = guess; + } while(count && (fabs(result * factor) < fabs(delta))); - max_iter -= count; + max_iter -= count; #ifdef BOOST_MATH_INSTRUMENT - std::cout << "Halley iteration, final count = " << max_iter << std::endl; + std::cout << "Second order root iteration, final count = " << max_iter << std::endl; #endif - return result; + return result; + } + } template <class F, class T> -inline T halley_iterate(F f, T guess, T min, T max, int digits) +T halley_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { - boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); - return halley_iterate(f, guess, min, max, digits, m); + return detail::second_order_root_finder<detail::halley_step>(f, guess, min, max, digits, max_iter); } template <class F, class T> -T schroeder_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) +inline T halley_iterate(F f, T guess, T min, T max, int digits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { - BOOST_MATH_STD_USING - - T f0(0), f1, f2, last_f0(0); - T result = guess; - - T factor = static_cast<T>(ldexp(1.0, 1 - digits)); - T delta = 0; - T delta1 = tools::max_value<T>(); - T delta2 = tools::max_value<T>(); - -#ifdef BOOST_MATH_INSTRUMENT - std::cout << "Schroeder iteration, limit = " << factor << std::endl; -#endif + boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); + return halley_iterate(f, guess, min, max, digits, m); +} - boost::uintmax_t count(max_iter); +namespace detail{ - do{ - last_f0 = f0; - delta2 = delta1; - delta1 = delta; - boost::math::tie(f0, f1, f2) = f(result); - if(0 == f0) - break; - if((f1 == 0) && (f2 == 0)) - { - // Oops zero derivative!!! -#ifdef BOOST_MATH_INSTRUMENT - std::cout << "Halley iteration, zero derivative found" << std::endl; -#endif - detail::handle_zero_derivative(f, last_f0, f0, delta, result, guess, min, max); - } - else + struct schroder_stepper + { + template <class T> + static T step(const T& x, const T& f0, const T& f1, const T& f2) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T)) { T ratio = f0 / f1; - if(ratio / result < 0.1) + T delta; + if(ratio / x < 0.1) { delta = ratio + (f2 / (2 * f1)) * ratio * ratio; // check second derivative doesn't over compensate: @@ -477,66 +520,44 @@ T schroeder_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& ma } else delta = ratio; // fall back to Newton iteration. + return delta; } - if(fabs(delta * 2) > fabs(delta2)) - { - // last two steps haven't converged, try bisection: - delta = (delta > 0) ? (result - min) / 2 : (result - max) / 2; - } - guess = result; - result -= delta; -#ifdef BOOST_MATH_INSTRUMENT - std::cout << "Halley iteration, delta = " << delta << std::endl; -#endif - if(result <= min) - { - delta = 0.5F * (guess - min); - result = guess - delta; - if((result == min) || (result == max)) - break; - } - else if(result >= max) - { - delta = 0.5F * (guess - max); - result = guess - delta; - if((result == min) || (result == max)) - break; - } - // update brackets: - if(delta > 0) - max = guess; - else - min = guess; - }while(--count && (fabs(result * factor) < fabs(delta))); - - max_iter -= count; + }; -#ifdef BOOST_MATH_INSTRUMENT - std::cout << "Schroeder iteration, final count = " << max_iter << std::endl; +} - static boost::uintmax_t max_count = 0; - if(max_iter > max_count) - { - max_count = max_iter; - std::cout << "Maximum iterations: " << max_iter << std::endl; - } -#endif +template <class F, class T> +T schroder_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) +{ + return detail::second_order_root_finder<detail::schroder_stepper>(f, guess, min, max, digits, max_iter); +} - return result; +template <class F, class T> +inline T schroder_iterate(F f, T guess, T min, T max, int digits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) +{ + boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); + return schroder_iterate(f, guess, min, max, digits, m); +} +// +// These two are the old spelling of this function, retained for backwards compatibity just in case: +// +template <class F, class T> +T schroeder_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) +{ + return detail::second_order_root_finder<detail::schroder_stepper>(f, guess, min, max, digits, max_iter); } template <class F, class T> -inline T schroeder_iterate(F f, T guess, T min, T max, int digits) +inline T schroeder_iterate(F f, T guess, T min, T max, int digits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && noexcept(std::declval<F>()(std::declval<T>()))) { boost::uintmax_t m = (std::numeric_limits<boost::uintmax_t>::max)(); - return schroeder_iterate(f, guess, min, max, digits, m); + return schroder_iterate(f, guess, min, max, digits, m); } + } // namespace tools } // namespace math } // namespace boost #endif // BOOST_MATH_TOOLS_NEWTON_SOLVER_HPP - - diff --git a/boost/math/tools/series.hpp b/boost/math/tools/series.hpp index a32a33fba1..ab01549a2d 100644 --- a/boost/math/tools/series.hpp +++ b/boost/math/tools/series.hpp @@ -21,7 +21,7 @@ namespace boost{ namespace math{ namespace tools{ // Simple series summation come first: // template <class Functor, class U, class V> -inline typename Functor::result_type sum_series(Functor& func, const U& factor, boost::uintmax_t& max_terms, const V& init_value) +inline typename Functor::result_type sum_series(Functor& func, const U& factor, boost::uintmax_t& max_terms, const V& init_value) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING @@ -44,14 +44,14 @@ inline typename Functor::result_type sum_series(Functor& func, const U& factor, } template <class Functor, class U> -inline typename Functor::result_type sum_series(Functor& func, const U& factor, boost::uintmax_t& max_terms) +inline typename Functor::result_type sum_series(Functor& func, const U& factor, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { typename Functor::result_type init_value = 0; return sum_series(func, factor, max_terms, init_value); } template <class Functor, class U> -inline typename Functor::result_type sum_series(Functor& func, int bits, boost::uintmax_t& max_terms, const U& init_value) +inline typename Functor::result_type sum_series(Functor& func, int bits, boost::uintmax_t& max_terms, const U& init_value) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING typedef typename Functor::result_type result_type; @@ -60,7 +60,7 @@ inline typename Functor::result_type sum_series(Functor& func, int bits, boost:: } template <class Functor> -inline typename Functor::result_type sum_series(Functor& func, int bits) +inline typename Functor::result_type sum_series(Functor& func, int bits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING typedef typename Functor::result_type result_type; @@ -70,7 +70,7 @@ inline typename Functor::result_type sum_series(Functor& func, int bits) } template <class Functor> -inline typename Functor::result_type sum_series(Functor& func, int bits, boost::uintmax_t& max_terms) +inline typename Functor::result_type sum_series(Functor& func, int bits, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING typedef typename Functor::result_type result_type; @@ -79,7 +79,7 @@ inline typename Functor::result_type sum_series(Functor& func, int bits, boost:: } template <class Functor, class U> -inline typename Functor::result_type sum_series(Functor& func, int bits, const U& init_value) +inline typename Functor::result_type sum_series(Functor& func, int bits, const U& init_value) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING boost::uintmax_t iters = (std::numeric_limits<boost::uintmax_t>::max)(); @@ -99,7 +99,7 @@ inline typename Functor::result_type sum_series(Functor& func, int bits, const U // in any case the result is still much better than a naive summation. // template <class Functor> -inline typename Functor::result_type kahan_sum_series(Functor& func, int bits) +inline typename Functor::result_type kahan_sum_series(Functor& func, int bits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING @@ -122,7 +122,7 @@ inline typename Functor::result_type kahan_sum_series(Functor& func, int bits) } template <class Functor> -inline typename Functor::result_type kahan_sum_series(Functor& func, int bits, boost::uintmax_t& max_terms) +inline typename Functor::result_type kahan_sum_series(Functor& func, int bits, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename Functor::result_type) && noexcept(std::declval<Functor>()())) { BOOST_MATH_STD_USING diff --git a/boost/math/tools/toms748_solve.hpp b/boost/math/tools/toms748_solve.hpp index 48737a821a..dca6bf0218 100644 --- a/boost/math/tools/toms748_solve.hpp +++ b/boost/math/tools/toms748_solve.hpp @@ -31,6 +31,10 @@ template <class T> class eps_tolerance { public: + eps_tolerance() + { + eps = 4 * tools::epsilon<T>(); + } eps_tolerance(unsigned bits) { BOOST_MATH_STD_USING @@ -108,7 +112,7 @@ void bracket(F f, T& a, T& b, T c, T& fa, T& fb, T& d, T& fd) } else if(c >= b - fabs(b) * tol) { - c = b - fabs(a) * tol; + c = b - fabs(b) * tol; } // // OK, lets invoke f(c): diff --git a/boost/math/tools/traits.hpp b/boost/math/tools/traits.hpp index c49bf19b86..385388a5e3 100644 --- a/boost/math/tools/traits.hpp +++ b/boost/math/tools/traits.hpp @@ -26,8 +26,7 @@ as defined above, and has member functions "scale" and "location". #endif #include <boost/mpl/has_xxx.hpp> -// should be the last #include -#include <boost/type_traits/detail/bool_trait_def.hpp> +#include <boost/type_traits/integral_constant.hpp> namespace boost{ namespace math{ namespace tools{ @@ -101,8 +100,8 @@ struct is_scaled_distribution_imp } // namespace detail -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_distribution,T,::boost::math::tools::detail::is_distribution_imp<T>::value) -BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_scaled_distribution,T,::boost::math::tools::detail::is_scaled_distribution_imp<T>::value) +template <class T> struct is_distribution : public boost::integral_constant<bool, ::boost::math::tools::detail::is_distribution_imp<T>::value> {}; +template <class T> struct is_scaled_distribution : public boost::integral_constant<bool, ::boost::math::tools::detail::is_scaled_distribution_imp<T>::value> {}; }}} diff --git a/boost/math/tools/workaround.hpp b/boost/math/tools/workaround.hpp index 20106814c7..29ce8b1c04 100644 --- a/boost/math/tools/workaround.hpp +++ b/boost/math/tools/workaround.hpp @@ -19,14 +19,14 @@ namespace boost{ namespace math{ namespace tools{ // std::fmod(1185.0L, 1.5L); // template <class T> -inline T fmod_workaround(T a, T b) +inline T fmod_workaround(T a, T b) BOOST_MATH_NOEXCEPT(T) { BOOST_MATH_STD_USING return fmod(a, b); } #if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && ((LDBL_MANT_DIG == 106) || (__LDBL_MANT_DIG__ == 106)) template <> -inline long double fmod_workaround(long double a, long double b) +inline long double fmod_workaround(long double a, long double b) BOOST_NOEXCEPT { return ::fmodl(a, b); } diff --git a/boost/math/tr1.hpp b/boost/math/tr1.hpp index df8ab0ef47..eae9216d04 100644 --- a/boost/math/tr1.hpp +++ b/boost/math/tr1.hpp @@ -105,7 +105,10 @@ namespace boost{ namespace math{ namespace tr1{ extern "C"{ #endif #if !(defined(BOOST_INTEL) && defined(__APPLE__)) && !(defined(__FLT_EVAL_METHOD__) && !defined(__cplusplus)) -#ifndef FLT_EVAL_METHOD +#if !defined(FLT_EVAL_METHOD) +typedef float float_t; +typedef double double_t; +#elif FLT_EVAL_METHOD == -1 typedef float float_t; typedef double double_t; #elif FLT_EVAL_METHOD == 0 |