/usr/include/boost/math/special_functions
Edit: /usr/include/boost/math/special_functions/relative_difference.hpp (5455B)
// (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
#include
#include
namespace boost{
namespace math{
template
typename boost::math::tools::promote_args::type relative_difference(const T& arg_a, const U& arg_b)
{
typedef typename boost::math::tools::promote_args::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(),
static_cast((std::numeric_limits::min)()));
result_type max_val = (std::min)(
tools::max_value(),
static_cast((std::numeric_limits::max)()));
#else
result_type min_val = tools::min_value();
result_type max_val = tools::max_value();
#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 infinities:
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__)) && (LDBL_MAX_EXP <= DBL_MAX_EXP)
template <>
inline boost::math::tools::promote_args::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(), tools::min_value());
double max_val = (std::min)((double)tools::max_value(), tools::max_value());
// 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 infinities:
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
inline typename boost::math::tools::promote_args::type epsilon_difference(const T& arg_a, const U& arg_b)
{
typedef typename boost::math::tools::promote_args::type result_type;
result_type r = relative_difference(arg_a, arg_b);
if(tools::max_value() * boost::math::tools::epsilon() < r)
return tools::max_value();
return r / boost::math::tools::epsilon();
}
} // namespace math
} // namespace boost
#endif