// (C) Copyright John Maddock 2005-2006. | |
// 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_LOG1P_INCLUDED | |
#define BOOST_MATH_LOG1P_INCLUDED | |
#ifdef _MSC_VER | |
#pragma once | |
#endif | |
#include <boost/config/no_tr1/cmath.hpp> | |
#include <math.h> // platform's ::log1p | |
#include <boost/limits.hpp> | |
#include <boost/math/tools/config.hpp> | |
#include <boost/math/tools/series.hpp> | |
#include <boost/math/tools/rational.hpp> | |
#include <boost/math/policies/error_handling.hpp> | |
#include <boost/math/special_functions/math_fwd.hpp> | |
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS | |
# include <boost/static_assert.hpp> | |
#else | |
# include <boost/assert.hpp> | |
#endif | |
namespace boost{ namespace math{ | |
namespace detail | |
{ | |
// Functor log1p_series returns the next term in the Taylor series | |
// pow(-1, k-1)*pow(x, k) / k | |
// each time that operator() is invoked. | |
// | |
template <class T> | |
struct log1p_series | |
{ | |
typedef T result_type; | |
log1p_series(T x) | |
: k(0), m_mult(-x), m_prod(-1){} | |
T operator()() | |
{ | |
m_prod *= m_mult; | |
return m_prod / ++k; | |
} | |
int count()const | |
{ | |
return k; | |
} | |
private: | |
int k; | |
const T m_mult; | |
T m_prod; | |
log1p_series(const log1p_series&); | |
log1p_series& operator=(const log1p_series&); | |
}; | |
// Algorithm log1p is part of C99, but is not yet provided by many compilers. | |
// | |
// This version uses a Taylor series expansion for 0.5 > x > epsilon, which may | |
// require up to std::numeric_limits<T>::digits+1 terms to be calculated. | |
// It would be much more efficient to use the equivalence: | |
// log(1+x) == (log(1+x) * x) / ((1-x) - 1) | |
// Unfortunately many optimizing compilers make such a mess of this, that | |
// it performs no better than log(1+x): which is to say not very well at all. | |
// | |
template <class T, class Policy> | |
T log1p_imp(T const & x, const Policy& pol, const mpl::int_<0>&) | |
{ // The function returns the natural logarithm of 1 + x. | |
typedef typename tools::promote_args<T>::type result_type; | |
BOOST_MATH_STD_USING | |
static const char* function = "boost::math::log1p<%1%>(%1%)"; | |
if(x < -1) | |
return policies::raise_domain_error<T>( | |
function, "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<T>( | |
function, 0, pol); | |
result_type a = abs(result_type(x)); | |
if(a > result_type(0.5f)) | |
return log(1 + result_type(x)); | |
// Note that without numeric_limits specialisation support, | |
// epsilon just returns zero, and our "optimisation" will always fail: | |
if(a < tools::epsilon<result_type>()) | |
return x; | |
detail::log1p_series<result_type> s(x); | |
boost::uintmax_t max_iter = policies::get_max_series_iterations<Policy>(); | |
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) && !BOOST_WORKAROUND(__EDG_VERSION__, <= 245) | |
result_type result = tools::sum_series(s, policies::get_epsilon<result_type, Policy>(), max_iter); | |
#else | |
result_type zero = 0; | |
result_type result = tools::sum_series(s, policies::get_epsilon<result_type, Policy>(), max_iter, zero); | |
#endif | |
policies::check_series_iterations(function, max_iter, pol); | |
return result; | |
} | |
template <class T, class Policy> | |
T log1p_imp(T const& x, const Policy& pol, const mpl::int_<53>&) | |
{ // The function returns the natural logarithm of 1 + x. | |
BOOST_MATH_STD_USING | |
static const char* function = "boost::math::log1p<%1%>(%1%)"; | |
if(x < -1) | |
return policies::raise_domain_error<T>( | |
function, "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<T>( | |
function, 0, pol); | |
T a = fabs(x); | |
if(a > 0.5f) | |
return log(1 + x); | |
// Note that without numeric_limits specialisation support, | |
// epsilon just returns zero, and our "optimisation" will always fail: | |
if(a < tools::epsilon<T>()) | |
return x; | |
// Maximum Deviation Found: 1.846e-017 | |
// Expected Error Term: 1.843e-017 | |
// Maximum Relative Change in Control Points: 8.138e-004 | |
// Max Error found at double precision = 3.250766e-016 | |
static const T P[] = { | |
0.15141069795941984e-16L, | |
0.35495104378055055e-15L, | |
0.33333333333332835L, | |
0.99249063543365859L, | |
1.1143969784156509L, | |
0.58052937949269651L, | |
0.13703234928513215L, | |
0.011294864812099712L | |
}; | |
static const T Q[] = { | |
1L, | |
3.7274719063011499L, | |
5.5387948649720334L, | |
4.159201143419005L, | |
1.6423855110312755L, | |
0.31706251443180914L, | |
0.022665554431410243L, | |
-0.29252538135177773e-5L | |
}; | |
T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x); | |
result *= x; | |
return result; | |
} | |
template <class T, class Policy> | |
T log1p_imp(T const& x, const Policy& pol, const mpl::int_<64>&) | |
{ // The function returns the natural logarithm of 1 + x. | |
BOOST_MATH_STD_USING | |
static const char* function = "boost::math::log1p<%1%>(%1%)"; | |
if(x < -1) | |
return policies::raise_domain_error<T>( | |
function, "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<T>( | |
function, 0, pol); | |
T a = fabs(x); | |
if(a > 0.5f) | |
return log(1 + x); | |
// Note that without numeric_limits specialisation support, | |
// epsilon just returns zero, and our "optimisation" will always fail: | |
if(a < tools::epsilon<T>()) | |
return x; | |
// Maximum Deviation Found: 8.089e-20 | |
// Expected Error Term: 8.088e-20 | |
// Maximum Relative Change in Control Points: 9.648e-05 | |
// Max Error found at long double precision = 2.242324e-19 | |
static const T P[] = { | |
-0.807533446680736736712e-19L, | |
-0.490881544804798926426e-18L, | |
0.333333333333333373941L, | |
1.17141290782087994162L, | |
1.62790522814926264694L, | |
1.13156411870766876113L, | |
0.408087379932853785336L, | |
0.0706537026422828914622L, | |
0.00441709903782239229447L | |
}; | |
static const T Q[] = { | |
1L, | |
4.26423872346263928361L, | |
7.48189472704477708962L, | |
6.94757016732904280913L, | |
3.6493508622280767304L, | |
1.06884863623790638317L, | |
0.158292216998514145947L, | |
0.00885295524069924328658L, | |
-0.560026216133415663808e-6L | |
}; | |
T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x); | |
result *= x; | |
return result; | |
} | |
template <class T, class Policy> | |
T log1p_imp(T const& x, const Policy& pol, const mpl::int_<24>&) | |
{ // The function returns the natural logarithm of 1 + x. | |
BOOST_MATH_STD_USING | |
static const char* function = "boost::math::log1p<%1%>(%1%)"; | |
if(x < -1) | |
return policies::raise_domain_error<T>( | |
function, "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<T>( | |
function, 0, pol); | |
T a = fabs(x); | |
if(a > 0.5f) | |
return log(1 + x); | |
// Note that without numeric_limits specialisation support, | |
// epsilon just returns zero, and our "optimisation" will always fail: | |
if(a < tools::epsilon<T>()) | |
return x; | |
// Maximum Deviation Found: 6.910e-08 | |
// Expected Error Term: 6.910e-08 | |
// Maximum Relative Change in Control Points: 2.509e-04 | |
// Max Error found at double precision = 6.910422e-08 | |
// Max Error found at float precision = 8.357242e-08 | |
static const T P[] = { | |
-0.671192866803148236519e-7L, | |
0.119670999140731844725e-6L, | |
0.333339469182083148598L, | |
0.237827183019664122066L | |
}; | |
static const T Q[] = { | |
1L, | |
1.46348272586988539733L, | |
0.497859871350117338894L, | |
-0.00471666268910169651936L | |
}; | |
T result = 1 - x / 2 + tools::evaluate_polynomial(P, x) / tools::evaluate_polynomial(Q, x); | |
result *= x; | |
return result; | |
} | |
} // namespace detail | |
template <class T, class Policy> | |
inline typename tools::promote_args<T>::type log1p(T x, const Policy&) | |
{ | |
typedef typename tools::promote_args<T>::type result_type; | |
typedef typename policies::evaluation<result_type, Policy>::type value_type; | |
typedef typename policies::precision<result_type, Policy>::type precision_type; | |
typedef typename policies::normalise< | |
Policy, | |
policies::promote_float<false>, | |
policies::promote_double<false>, | |
policies::discrete_quantile<>, | |
policies::assert_undefined<> >::type forwarding_policy; | |
typedef typename mpl::if_< | |
mpl::less_equal<precision_type, mpl::int_<0> >, | |
mpl::int_<0>, | |
typename mpl::if_< | |
mpl::less_equal<precision_type, mpl::int_<53> >, | |
mpl::int_<53>, // double | |
typename mpl::if_< | |
mpl::less_equal<precision_type, mpl::int_<64> >, | |
mpl::int_<64>, // 80-bit long double | |
mpl::int_<0> // too many bits, use generic version. | |
>::type | |
>::type | |
>::type tag_type; | |
return policies::checked_narrowing_cast<result_type, forwarding_policy>( | |
detail::log1p_imp(static_cast<value_type>(x), forwarding_policy(), tag_type()), "boost::math::log1p<%1%>(%1%)"); | |
} | |
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
// These overloads work around a type deduction bug: | |
inline float log1p(float z) | |
{ | |
return log1p<float>(z); | |
} | |
inline double log1p(double z) | |
{ | |
return log1p<double>(z); | |
} | |
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS | |
inline long double log1p(long double z) | |
{ | |
return log1p<long double>(z); | |
} | |
#endif | |
#endif | |
#ifdef log1p | |
# ifndef BOOST_HAS_LOG1P | |
# define BOOST_HAS_LOG1P | |
# endif | |
# undef log1p | |
#endif | |
#if defined(BOOST_HAS_LOG1P) && !(defined(__osf__) && defined(__DECCXX_VER)) | |
# ifdef BOOST_MATH_USE_C99 | |
template <class Policy> | |
inline float log1p(float x, const Policy& pol) | |
{ | |
if(x < -1) | |
return policies::raise_domain_error<float>( | |
"log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<float>( | |
"log1p<%1%>(%1%)", 0, pol); | |
return ::log1pf(x); | |
} | |
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS | |
template <class Policy> | |
inline long double log1p(long double x, const Policy& pol) | |
{ | |
if(x < -1) | |
return policies::raise_domain_error<long double>( | |
"log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<long double>( | |
"log1p<%1%>(%1%)", 0, pol); | |
return ::log1pl(x); | |
} | |
#endif | |
#else | |
template <class Policy> | |
inline float log1p(float x, const Policy& pol) | |
{ | |
if(x < -1) | |
return policies::raise_domain_error<float>( | |
"log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<float>( | |
"log1p<%1%>(%1%)", 0, pol); | |
return ::log1p(x); | |
} | |
#endif | |
template <class Policy> | |
inline double log1p(double x, const Policy& pol) | |
{ | |
if(x < -1) | |
return policies::raise_domain_error<double>( | |
"log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<double>( | |
"log1p<%1%>(%1%)", 0, pol); | |
return ::log1p(x); | |
} | |
#elif defined(_MSC_VER) && (BOOST_MSVC >= 1400) | |
// | |
// You should only enable this branch if you are absolutely sure | |
// that your compilers optimizer won't mess this code up!! | |
// Currently tested with VC8 and Intel 9.1. | |
// | |
template <class Policy> | |
inline double log1p(double x, const Policy& pol) | |
{ | |
if(x < -1) | |
return policies::raise_domain_error<double>( | |
"log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<double>( | |
"log1p<%1%>(%1%)", 0, pol); | |
double u = 1+x; | |
if(u == 1.0) | |
return x; | |
else | |
return ::log(u)*(x/(u-1.0)); | |
} | |
template <class Policy> | |
inline float log1p(float x, const Policy& pol) | |
{ | |
return static_cast<float>(boost::math::log1p(static_cast<double>(x), pol)); | |
} | |
#ifndef _WIN32_WCE | |
// | |
// For some reason this fails to compile under WinCE... | |
// Needs more investigation. | |
// | |
template <class Policy> | |
inline long double log1p(long double x, const Policy& pol) | |
{ | |
if(x < -1) | |
return policies::raise_domain_error<long double>( | |
"log1p<%1%>(%1%)", "log1p(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<long double>( | |
"log1p<%1%>(%1%)", 0, pol); | |
long double u = 1+x; | |
if(u == 1.0) | |
return x; | |
else | |
return ::logl(u)*(x/(u-1.0)); | |
} | |
#endif | |
#endif | |
template <class T> | |
inline typename tools::promote_args<T>::type log1p(T x) | |
{ | |
return boost::math::log1p(x, policies::policy<>()); | |
} | |
// | |
// Compute log(1+x)-x: | |
// | |
template <class T, class Policy> | |
inline typename tools::promote_args<T>::type | |
log1pmx(T x, const Policy& pol) | |
{ | |
typedef typename tools::promote_args<T>::type result_type; | |
BOOST_MATH_STD_USING | |
static const char* function = "boost::math::log1pmx<%1%>(%1%)"; | |
if(x < -1) | |
return policies::raise_domain_error<T>( | |
function, "log1pmx(x) requires x > -1, but got x = %1%.", x, pol); | |
if(x == -1) | |
return -policies::raise_overflow_error<T>( | |
function, 0, pol); | |
result_type a = abs(result_type(x)); | |
if(a > result_type(0.95f)) | |
return log(1 + result_type(x)) - result_type(x); | |
// Note that without numeric_limits specialisation support, | |
// epsilon just returns zero, and our "optimisation" will always fail: | |
if(a < tools::epsilon<result_type>()) | |
return -x * x / 2; | |
boost::math::detail::log1p_series<T> s(x); | |
s(); | |
boost::uintmax_t max_iter = policies::get_max_series_iterations<Policy>(); | |
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) | |
T zero = 0; | |
T result = boost::math::tools::sum_series(s, policies::get_epsilon<T, Policy>(), max_iter, zero); | |
#else | |
T result = boost::math::tools::sum_series(s, policies::get_epsilon<T, Policy>(), max_iter); | |
#endif | |
policies::check_series_iterations(function, max_iter, pol); | |
return result; | |
} | |
template <class T> | |
inline typename tools::promote_args<T>::type log1pmx(T x) | |
{ | |
return log1pmx(x, policies::policy<>()); | |
} | |
} // namespace math | |
} // namespace boost | |
#endif // BOOST_MATH_LOG1P_INCLUDED | |