418 lines · plain
1// (C) Copyright John Maddock 2005-2006.2// Use, modification and distribution are subject to the3// Boost Software License, Version 1.0. (See accompanying file4// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)5 6#ifndef BOOST_MATH_LOG1P_INCLUDED7#define BOOST_MATH_LOG1P_INCLUDED8 9#ifdef _MSC_VER10#pragma once11#pragma warning(push)12#pragma warning(disable:4702) // Unreachable code (release mode only warning)13#endif14 15#if defined __has_include16# if ((__cplusplus > 202002L) || (defined(_MSVC_LANG) && (_MSVC_LANG > 202002L)))17# if __has_include (<stdfloat>)18# include <stdfloat>19# endif20# endif21#endif22 23#include <boost/math/tools/config.hpp>24#include <boost/math/tools/series.hpp>25#include <boost/math/tools/rational.hpp>26#include <boost/math/tools/big_constant.hpp>27#include <boost/math/tools/numeric_limits.hpp>28#include <boost/math/tools/cstdint.hpp>29#include <boost/math/tools/promotion.hpp>30#include <boost/math/tools/precision.hpp>31#include <boost/math/policies/error_handling.hpp>32#include <boost/math/special_functions/math_fwd.hpp>33#include <boost/math/tools/assert.hpp>34#include <boost/math/special_functions/fpclassify.hpp>35 36#if defined(__GNUC__) && defined(BOOST_MATH_USE_FLOAT128)37//38// This is the only way we can avoid39// warning: non-standard suffix on floating constant [-Wpedantic]40// when building with -Wall -pedantic. Neither __extension__41// nor #pragma diagnostic ignored work :(42//43#pragma GCC system_header44#endif45 46namespace boost{ namespace math{47 48namespace detail49{50 // Functor log1p_series returns the next term in the Taylor series51 // pow(-1, k-1)*pow(x, k) / k52 // each time that operator() is invoked.53 //54 template <class T>55 struct log1p_series56 {57 typedef T result_type;58 59 BOOST_MATH_GPU_ENABLED log1p_series(T x)60 : k(0), m_mult(-x), m_prod(-1){}61 62 BOOST_MATH_GPU_ENABLED T operator()()63 {64 m_prod *= m_mult;65 return m_prod / ++k;66 }67 68 BOOST_MATH_GPU_ENABLED int count()const69 {70 return k;71 }72 73 private:74 int k;75 const T m_mult;76 T m_prod;77 log1p_series(const log1p_series&) = delete;78 log1p_series& operator=(const log1p_series&) = delete;79 };80 81// Algorithm log1p is part of C99, but is not yet provided by many compilers.82//83// This version uses a Taylor series expansion for 0.5 > x > epsilon, which may84// require up to std::numeric_limits<T>::digits+1 terms to be calculated.85// It would be much more efficient to use the equivalence:86// log(1+x) == (log(1+x) * x) / ((1-x) - 1)87// Unfortunately many optimizing compilers make such a mess of this, that88// it performs no better than log(1+x): which is to say not very well at all.89//90template <class T, class Policy>91BOOST_MATH_GPU_ENABLED T log1p_imp(T const & x, const Policy& pol, const boost::math::integral_constant<int, 0>&)92{ // The function returns the natural logarithm of 1 + x.93 typedef typename tools::promote_args<T>::type result_type;94 BOOST_MATH_STD_USING95 96 constexpr auto function = "boost::math::log1p<%1%>(%1%)";97 98 if((x < -1) || (boost::math::isnan)(x))99 return policies::raise_domain_error<T>(function, "log1p(x) requires x > -1, but got x = %1%.", x, pol);100 if(x == -1)101 return -policies::raise_overflow_error<T>(function, nullptr, pol);102 103 result_type a = abs(result_type(x));104 if(a > result_type(0.5f))105 return log(1 + result_type(x));106 // Note that without numeric_limits specialisation support,107 // epsilon just returns zero, and our "optimisation" will always fail:108 if(a < tools::epsilon<result_type>())109 return x;110 detail::log1p_series<result_type> s(x);111 boost::math::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();112 113 result_type result = tools::sum_series(s, policies::get_epsilon<result_type, Policy>(), max_iter);114 115 policies::check_series_iterations<T>(function, max_iter, pol);116 return result;117}118 119template <class T, class Policy>120BOOST_MATH_GPU_ENABLED T log1p_imp(T const& x, const Policy& pol, const boost::math::integral_constant<int, 53>&)121{ // The function returns the natural logarithm of 1 + x.122 BOOST_MATH_STD_USING123 124 constexpr auto function = "boost::math::log1p<%1%>(%1%)";125 126 if(x < -1)127 return policies::raise_domain_error<T>(function, "log1p(x) requires x > -1, but got x = %1%.", x, pol);128 if(x == -1)129 return -policies::raise_overflow_error<T>(function, nullptr, pol);130 131 T a = fabs(x);132 if(a > 0.5f)133 return log(1 + x);134 // Note that without numeric_limits specialisation support,135 // epsilon just returns zero, and our "optimisation" will always fail:136 if(a < tools::epsilon<T>())137 return x;138 139 // Maximum Deviation Found: 1.846e-017140 // Expected Error Term: 1.843e-017141 // Maximum Relative Change in Control Points: 8.138e-004142 // Max Error found at double precision = 3.250766e-016143 BOOST_MATH_STATIC const T P[] = {144 static_cast<T>(0.15141069795941984e-16L),145 static_cast<T>(0.35495104378055055e-15L),146 static_cast<T>(0.33333333333332835L),147 static_cast<T>(0.99249063543365859L),148 static_cast<T>(1.1143969784156509L),149 static_cast<T>(0.58052937949269651L),150 static_cast<T>(0.13703234928513215L),151 static_cast<T>(0.011294864812099712L)152 };153 BOOST_MATH_STATIC const T Q[] = {154 static_cast<T>(1L),155 static_cast<T>(3.7274719063011499L),156 static_cast<T>(5.5387948649720334L),157 static_cast<T>(4.159201143419005L),158 static_cast<T>(1.6423855110312755L),159 static_cast<T>(0.31706251443180914L),160 static_cast<T>(0.022665554431410243L),161 static_cast<T>(-0.29252538135177773e-5L)162 };163 164 T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x);165 result *= x;166 167 return result;168}169 170template <class T, class Policy>171BOOST_MATH_GPU_ENABLED T log1p_imp(T const& x, const Policy& pol, const boost::math::integral_constant<int, 64>&)172{ // The function returns the natural logarithm of 1 + x.173 BOOST_MATH_STD_USING174 175 constexpr auto function = "boost::math::log1p<%1%>(%1%)";176 177 if(x < -1)178 return policies::raise_domain_error<T>(function, "log1p(x) requires x > -1, but got x = %1%.", x, pol);179 if(x == -1)180 return -policies::raise_overflow_error<T>(function, nullptr, pol);181 182 T a = fabs(x);183 if(a > 0.5f)184 return log(1 + x);185 // Note that without numeric_limits specialisation support,186 // epsilon just returns zero, and our "optimisation" will always fail:187 if(a < tools::epsilon<T>())188 return x;189 190 // Maximum Deviation Found: 8.089e-20191 // Expected Error Term: 8.088e-20192 // Maximum Relative Change in Control Points: 9.648e-05193 // Max Error found at long double precision = 2.242324e-19194 BOOST_MATH_STATIC const T P[] = {195 BOOST_MATH_BIG_CONSTANT(T, 64, -0.807533446680736736712e-19),196 BOOST_MATH_BIG_CONSTANT(T, 64, -0.490881544804798926426e-18),197 BOOST_MATH_BIG_CONSTANT(T, 64, 0.333333333333333373941),198 BOOST_MATH_BIG_CONSTANT(T, 64, 1.17141290782087994162),199 BOOST_MATH_BIG_CONSTANT(T, 64, 1.62790522814926264694),200 BOOST_MATH_BIG_CONSTANT(T, 64, 1.13156411870766876113),201 BOOST_MATH_BIG_CONSTANT(T, 64, 0.408087379932853785336),202 BOOST_MATH_BIG_CONSTANT(T, 64, 0.0706537026422828914622),203 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00441709903782239229447)204 };205 BOOST_MATH_STATIC const T Q[] = {206 BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),207 BOOST_MATH_BIG_CONSTANT(T, 64, 4.26423872346263928361),208 BOOST_MATH_BIG_CONSTANT(T, 64, 7.48189472704477708962),209 BOOST_MATH_BIG_CONSTANT(T, 64, 6.94757016732904280913),210 BOOST_MATH_BIG_CONSTANT(T, 64, 3.6493508622280767304),211 BOOST_MATH_BIG_CONSTANT(T, 64, 1.06884863623790638317),212 BOOST_MATH_BIG_CONSTANT(T, 64, 0.158292216998514145947),213 BOOST_MATH_BIG_CONSTANT(T, 64, 0.00885295524069924328658),214 BOOST_MATH_BIG_CONSTANT(T, 64, -0.560026216133415663808e-6)215 };216 217 T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x);218 result *= x;219 220 return result;221}222 223template <class T, class Policy>224BOOST_MATH_GPU_ENABLED T log1p_imp(T const& x, const Policy& pol, const boost::math::integral_constant<int, 24>&)225{ // The function returns the natural logarithm of 1 + x.226 BOOST_MATH_STD_USING227 228 constexpr auto function = "boost::math::log1p<%1%>(%1%)";229 230 if(x < -1)231 return policies::raise_domain_error<T>(232 function, "log1p(x) requires x > -1, but got x = %1%.", x, pol);233 if(x == -1)234 return -policies::raise_overflow_error<T>(235 function, nullptr, pol);236 237 T a = fabs(x);238 if(a > 0.5f)239 return log(1 + x);240 // Note that without numeric_limits specialisation support,241 // epsilon just returns zero, and our "optimisation" will always fail:242 if(a < tools::epsilon<T>())243 return x;244 245 // Maximum Deviation Found: 6.910e-08246 // Expected Error Term: 6.910e-08247 // Maximum Relative Change in Control Points: 2.509e-04248 // Max Error found at double precision = 6.910422e-08249 // Max Error found at float precision = 8.357242e-08250 BOOST_MATH_STATIC const T P[] = {251 -0.671192866803148236519e-7L,252 0.119670999140731844725e-6L,253 0.333339469182083148598L,254 0.237827183019664122066L255 };256 BOOST_MATH_STATIC const T Q[] = {257 1L,258 1.46348272586988539733L,259 0.497859871350117338894L,260 -0.00471666268910169651936L261 };262 263 T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x);264 result *= x;265 266 return result;267}268 269} // namespace detail270 271template <class T, class Policy>272BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type log1p(T x, const Policy&)273{274 typedef typename tools::promote_args<T>::type result_type;275 typedef typename policies::evaluation<result_type, Policy>::type value_type;276 typedef typename policies::precision<result_type, Policy>::type precision_type;277 typedef typename policies::normalise<278 Policy,279 policies::promote_float<false>,280 policies::promote_double<false>,281 policies::discrete_quantile<>,282 policies::assert_undefined<> >::type forwarding_policy;283 284 typedef boost::math::integral_constant<int,285 precision_type::value <= 0 ? 0 :286 precision_type::value <= 53 ? 53 :287 precision_type::value <= 64 ? 64 : 0288 > tag_type;289 290 return policies::checked_narrowing_cast<result_type, forwarding_policy>(291 detail::log1p_imp(static_cast<value_type>(x), forwarding_policy(), tag_type()), "boost::math::log1p<%1%>(%1%)");292}293 294template <class Policy>295BOOST_MATH_GPU_ENABLED inline float log1p(float x, const Policy& pol)296{297 if(x < -1)298 return policies::raise_domain_error<float>("log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol);299 if(x == -1)300 return -policies::raise_overflow_error<float>("log1p<%1%>(%1%)", nullptr, pol);301 #ifndef BOOST_MATH_HAS_NVRTC302 return std::log1p(x);303 #else304 return ::log1pf(x);305 #endif306}307#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS308template <class Policy>309BOOST_MATH_GPU_ENABLED inline long double log1p(long double x, const Policy& pol)310{311 if(x < -1)312 return policies::raise_domain_error<long double>("log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol);313 if(x == -1)314 return -policies::raise_overflow_error<long double>("log1p<%1%>(%1%)", nullptr, pol);315 return std::log1p(x);316}317#endif318template <class Policy>319BOOST_MATH_GPU_ENABLED inline double log1p(double x, const Policy& pol)320{321 if(x < -1)322 return policies::raise_domain_error<double>("log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol);323 if(x == -1)324 return -policies::raise_overflow_error<double>("log1p<%1%>(%1%)", nullptr, pol);325 #ifndef BOOST_MATH_HAS_NVRTC326 return std::log1p(x);327 #else328 return ::log1p(x);329 #endif330}331 332template <class T>333BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type log1p(T x)334{335 return boost::math::log1p(x, policies::policy<>());336}337//338// Compute log(1+x)-x:339//340template <class T, class Policy>341BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type342 log1pmx(T x, const Policy& pol)343{344 typedef typename tools::promote_args<T>::type result_type;345 BOOST_MATH_STD_USING346 constexpr auto function = "boost::math::log1pmx<%1%>(%1%)";347 348 if(x < -1)349 return policies::raise_domain_error<T>(function, "log1pmx(x) requires x > -1, but got x = %1%.", x, pol);350 if(x == -1)351 return -policies::raise_overflow_error<T>(function, nullptr, pol);352 353 result_type a = abs(result_type(x));354 if(a > result_type(0.95f))355 return log(1 + result_type(x)) - result_type(x);356 // Note that without numeric_limits specialisation support,357 // epsilon just returns zero, and our "optimisation" will always fail:358 if(a < tools::epsilon<result_type>())359 return -x * x / 2;360 boost::math::detail::log1p_series<T> s(x);361 s();362 boost::math::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();363 364 T result = boost::math::tools::sum_series(s, policies::get_epsilon<T, Policy>(), max_iter);365 366 policies::check_series_iterations<T>(function, max_iter, pol);367 return result;368}369 370template <class T>371BOOST_MATH_GPU_ENABLED inline typename tools::promote_args<T>::type log1pmx(T x)372{373 return log1pmx(x, policies::policy<>());374}375 376//377// Specific width floating point types:378//379#ifdef __STDCPP_FLOAT32_T__380template <class Policy>381BOOST_MATH_GPU_ENABLED inline std::float32_t log1p(std::float32_t x, const Policy& pol)382{383 return boost::math::log1p(static_cast<float>(x), pol);384}385#endif386#ifdef __STDCPP_FLOAT64_T__387template <class Policy>388BOOST_MATH_GPU_ENABLED inline std::float64_t log1p(std::float64_t x, const Policy& pol)389{390 return boost::math::log1p(static_cast<double>(x), pol);391}392#endif393#ifdef __STDCPP_FLOAT128_T__394template <class Policy>395BOOST_MATH_GPU_ENABLED inline std::float128_t log1p(std::float128_t x, const Policy& pol)396{397 if constexpr (std::numeric_limits<long double>::digits == std::numeric_limits<std::float128_t>::digits)398 {399 return boost::math::log1p(static_cast<long double>(x), pol);400 }401 else402 {403 return boost::math::detail::log1p_imp(x, pol, boost::math::integral_constant<int, 0>());404 }405}406#endif407} // namespace math408} // namespace boost409 410#ifdef _MSC_VER411#pragma warning(pop)412#endif413 414#endif // BOOST_MATH_LOG1P_INCLUDED415 416 417 418