Added boost header
This commit is contained in:
Christophe Riccio
657
test/external/boost/math/policies/error_handling.hpp
vendored
Normal file
657
test/external/boost/math/policies/error_handling.hpp
vendored
Normal file
@@ -0,0 +1,657 @@
|
||||
// Copyright John Maddock 2007.
|
||||
// Copyright Paul A. Bristow 2007.
|
||||
|
||||
// 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_POLICY_ERROR_HANDLING_HPP
|
||||
#define BOOST_MATH_POLICY_ERROR_HANDLING_HPP
|
||||
|
||||
#include <stdexcept>
|
||||
#include <iomanip>
|
||||
#include <string>
|
||||
#include <cerrno>
|
||||
#include <boost/config/no_tr1/cmath.hpp>
|
||||
#include <stdexcept>
|
||||
#include <boost/math/tools/config.hpp>
|
||||
#include <boost/math/policies/policy.hpp>
|
||||
#include <boost/math/tools/precision.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push) // Quiet warnings in boost/format.hpp
|
||||
# pragma warning(disable: 4996) // _SCL_SECURE_NO_DEPRECATE
|
||||
# pragma warning(disable: 4512) // assignment operator could not be generated.
|
||||
// And warnings in error handling:
|
||||
# pragma warning(disable: 4702) // unreachable code
|
||||
// Note that this only occurs when the compiler can deduce code is unreachable,
|
||||
// for example when policy macros are used to ignore errors rather than throw.
|
||||
#endif
|
||||
#include <boost/format.hpp>
|
||||
|
||||
namespace boost{ namespace math{
|
||||
|
||||
class evaluation_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
evaluation_error(const std::string& s) : std::runtime_error(s){}
|
||||
};
|
||||
|
||||
class rounding_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
rounding_error(const std::string& s) : std::runtime_error(s){}
|
||||
};
|
||||
|
||||
namespace policies{
|
||||
//
|
||||
// Forward declarations of user error handlers,
|
||||
// it's up to the user to provide the definition of these:
|
||||
//
|
||||
template <class T>
|
||||
T user_domain_error(const char* function, const char* message, const T& val);
|
||||
template <class T>
|
||||
T user_pole_error(const char* function, const char* message, const T& val);
|
||||
template <class T>
|
||||
T user_overflow_error(const char* function, const char* message, const T& val);
|
||||
template <class T>
|
||||
T user_underflow_error(const char* function, const char* message, const T& val);
|
||||
template <class T>
|
||||
T user_denorm_error(const char* function, const char* message, const T& val);
|
||||
template <class T>
|
||||
T user_evaluation_error(const char* function, const char* message, const T& val);
|
||||
template <class T, class TargetType>
|
||||
T user_rounding_error(const char* function, const char* message, const T& val, const TargetType& t);
|
||||
template <class T>
|
||||
T user_indeterminate_result_error(const char* function, const char* message, const T& val);
|
||||
|
||||
namespace detail
|
||||
{
|
||||
//
|
||||
// Helper function to avoid binding rvalue to non-const-reference,
|
||||
// in other words a warning suppression mechansim:
|
||||
//
|
||||
template <class Formatter, class Group>
|
||||
inline std::string do_format(Formatter f, const Group& g)
|
||||
{
|
||||
return (f % g).str();
|
||||
}
|
||||
|
||||
template <class E, class T>
|
||||
void raise_error(const char* function, const char* message)
|
||||
{
|
||||
if(function == 0)
|
||||
function = "Unknown function operating on type %1%";
|
||||
if(message == 0)
|
||||
message = "Cause unknown";
|
||||
|
||||
std::string msg("Error in function ");
|
||||
msg += (boost::format(function) % typeid(T).name()).str();
|
||||
msg += ": ";
|
||||
msg += message;
|
||||
|
||||
E e(msg);
|
||||
boost::throw_exception(e);
|
||||
}
|
||||
|
||||
template <class E, class T>
|
||||
void raise_error(const char* function, const char* message, const T& val)
|
||||
{
|
||||
if(function == 0)
|
||||
function = "Unknown function operating on type %1%";
|
||||
if(message == 0)
|
||||
message = "Cause unknown: error caused by bad argument with value %1%";
|
||||
|
||||
std::string msg("Error in function ");
|
||||
msg += (boost::format(function) % typeid(T).name()).str();
|
||||
msg += ": ";
|
||||
msg += message;
|
||||
|
||||
int prec = 2 + (boost::math::policies::digits<T, boost::math::policies::policy<> >() * 30103UL) / 100000UL;
|
||||
msg = do_format(boost::format(msg), boost::io::group(std::setprecision(prec), val));
|
||||
|
||||
E e(msg);
|
||||
boost::throw_exception(e);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_domain_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::domain_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<std::domain_error, T>(function, message, val);
|
||||
// we never get here:
|
||||
return std::numeric_limits<T>::quiet_NaN();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_domain_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& ,
|
||||
const ::boost::math::policies::domain_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return std::numeric_limits<T>::quiet_NaN();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_domain_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& ,
|
||||
const ::boost::math::policies::domain_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
errno = EDOM;
|
||||
// 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 std::numeric_limits<T>::quiet_NaN();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_domain_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::domain_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_domain_error(function, message, val);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_pole_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::pole_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
return boost::math::policies::detail::raise_domain_error(function, message, val, ::boost::math::policies::domain_error< ::boost::math::policies::throw_on_error>());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_pole_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::pole_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
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(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::pole_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
return ::boost::math::policies::detail::raise_domain_error(function, message, val, ::boost::math::policies::domain_error< ::boost::math::policies::errno_on_error>());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_pole_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::pole_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_pole_error(function, message, val);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_overflow_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const ::boost::math::policies::overflow_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<std::overflow_error, T>(function, message ? message : "numeric overflow");
|
||||
// we never get here:
|
||||
return std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : boost::math::tools::max_value<T>();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_overflow_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const ::boost::math::policies::overflow_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : boost::math::tools::max_value<T>();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_overflow_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const ::boost::math::policies::overflow_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
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 std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : boost::math::tools::max_value<T>();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_overflow_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const ::boost::math::policies::overflow_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_overflow_error(function, message, std::numeric_limits<T>::infinity());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_underflow_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const ::boost::math::policies::underflow_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<std::underflow_error, T>(function, message ? message : "numeric underflow");
|
||||
// we never get here:
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_underflow_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const ::boost::math::policies::underflow_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return T(0);
|
||||
}
|
||||
|
||||
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>&)
|
||||
{
|
||||
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 T(0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_underflow_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const ::boost::math::policies::underflow_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_underflow_error(function, message, T(0));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_denorm_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& /* val */,
|
||||
const ::boost::math::policies::denorm_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<std::underflow_error, T>(function, message ? message : "denormalised result");
|
||||
// we never get here:
|
||||
return T(0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_denorm_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& val,
|
||||
const ::boost::math::policies::denorm_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return val;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_denorm_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& val,
|
||||
const ::boost::math::policies::denorm_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_denorm_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::denorm_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_denorm_error(function, message, val);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_evaluation_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::evaluation_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<boost::math::evaluation_error, T>(function, message, val);
|
||||
// we never get here:
|
||||
return T(0);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_evaluation_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& val,
|
||||
const ::boost::math::policies::evaluation_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return val;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_evaluation_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& val,
|
||||
const ::boost::math::policies::evaluation_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
errno = EDOM;
|
||||
// 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;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T raise_evaluation_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const ::boost::math::policies::evaluation_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_evaluation_error(function, message, val);
|
||||
}
|
||||
|
||||
template <class T, class TargetType>
|
||||
inline T raise_rounding_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const TargetType&,
|
||||
const ::boost::math::policies::rounding_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<boost::math::rounding_error, T>(function, message, val);
|
||||
// we never get here:
|
||||
return T(0);
|
||||
}
|
||||
|
||||
template <class T, class TargetType>
|
||||
inline T raise_rounding_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& val,
|
||||
const TargetType&,
|
||||
const ::boost::math::policies::rounding_error< ::boost::math::policies::ignore_error>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return std::numeric_limits<T>::is_specialized ? (val > 0 ? (std::numeric_limits<T>::max)() : -(std::numeric_limits<T>::max)()): val;
|
||||
}
|
||||
|
||||
template <class T, class TargetType>
|
||||
inline T raise_rounding_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& val,
|
||||
const TargetType&,
|
||||
const ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
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 std::numeric_limits<T>::is_specialized ? (val > 0 ? (std::numeric_limits<T>::max)() : -(std::numeric_limits<T>::max)()): val;
|
||||
}
|
||||
|
||||
template <class T, class TargetType>
|
||||
inline T raise_rounding_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const TargetType& t,
|
||||
const ::boost::math::policies::rounding_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_rounding_error(function, message, val, t);
|
||||
}
|
||||
|
||||
template <class T, class R>
|
||||
inline T raise_indeterminate_result_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const R& ,
|
||||
const ::boost::math::policies::indeterminate_result_error< ::boost::math::policies::throw_on_error>&)
|
||||
{
|
||||
raise_error<std::domain_error, T>(function, message, val);
|
||||
// we never get here:
|
||||
return std::numeric_limits<T>::quiet_NaN();
|
||||
}
|
||||
|
||||
template <class T, class R>
|
||||
inline 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>&)
|
||||
{
|
||||
// This may or may not do the right thing, but the user asked for the error
|
||||
// to be ignored so here we go anyway:
|
||||
return result;
|
||||
}
|
||||
|
||||
template <class T, class R>
|
||||
inline T raise_indeterminate_result_error(
|
||||
const char* ,
|
||||
const char* ,
|
||||
const T& ,
|
||||
const R& result,
|
||||
const ::boost::math::policies::indeterminate_result_error< ::boost::math::policies::errno_on_error>&)
|
||||
{
|
||||
errno = EDOM;
|
||||
// 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 result;
|
||||
}
|
||||
|
||||
template <class T, class R>
|
||||
inline T raise_indeterminate_result_error(
|
||||
const char* function,
|
||||
const char* message,
|
||||
const T& val,
|
||||
const R& ,
|
||||
const ::boost::math::policies::indeterminate_result_error< ::boost::math::policies::user_error>&)
|
||||
{
|
||||
return user_indeterminate_result_error(function, message, val);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T raise_domain_error(const char* function, const char* message, const T& val, const Policy&)
|
||||
{
|
||||
typedef typename Policy::domain_error_type policy_type;
|
||||
return detail::raise_domain_error(
|
||||
function, message ? message : "Domain Error evaluating function at %1%",
|
||||
val, policy_type());
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T raise_pole_error(const char* function, const char* message, const T& val, const Policy&)
|
||||
{
|
||||
typedef typename Policy::pole_error_type policy_type;
|
||||
return detail::raise_pole_error(
|
||||
function, message ? message : "Evaluation of function at pole %1%",
|
||||
val, policy_type());
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T raise_overflow_error(const char* function, const char* message, const Policy&)
|
||||
{
|
||||
typedef typename Policy::overflow_error_type policy_type;
|
||||
return detail::raise_overflow_error<T>(
|
||||
function, message ? message : "Overflow Error",
|
||||
policy_type());
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T raise_underflow_error(const char* function, const char* message, const Policy&)
|
||||
{
|
||||
typedef typename Policy::underflow_error_type policy_type;
|
||||
return detail::raise_underflow_error<T>(
|
||||
function, message ? message : "Underflow Error",
|
||||
policy_type());
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T raise_denorm_error(const char* function, const char* message, const T& val, const Policy&)
|
||||
{
|
||||
typedef typename Policy::denorm_error_type policy_type;
|
||||
return detail::raise_denorm_error<T>(
|
||||
function, message ? message : "Denorm Error",
|
||||
val,
|
||||
policy_type());
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T raise_evaluation_error(const char* function, const char* message, const T& val, const Policy&)
|
||||
{
|
||||
typedef typename Policy::evaluation_error_type policy_type;
|
||||
return detail::raise_evaluation_error(
|
||||
function, message ? message : "Internal Evaluation Error, best value so far was %1%",
|
||||
val, policy_type());
|
||||
}
|
||||
|
||||
template <class T, class TargetType, class Policy>
|
||||
inline T raise_rounding_error(const char* function, const char* message, const T& val, const TargetType& t, const Policy&)
|
||||
{
|
||||
typedef typename Policy::rounding_error_type policy_type;
|
||||
return detail::raise_rounding_error(
|
||||
function, message ? message : "Value %1% can not be represented in the target integer type.",
|
||||
val, t, policy_type());
|
||||
}
|
||||
|
||||
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&)
|
||||
{
|
||||
typedef typename Policy::indeterminate_result_error_type policy_type;
|
||||
return detail::raise_indeterminate_result_error(
|
||||
function, message ? message : "Indeterminate result with value %1%",
|
||||
val, result, policy_type());
|
||||
}
|
||||
|
||||
//
|
||||
// checked_narrowing_cast:
|
||||
//
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template <class R, class T, class Policy>
|
||||
inline bool check_overflow(T val, R* result, const char* function, const Policy& pol)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
if(fabs(val) > tools::max_value<R>())
|
||||
{
|
||||
*result = static_cast<R>(boost::math::policies::detail::raise_overflow_error<R>(function, 0, pol));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template <class R, class T, class Policy>
|
||||
inline bool check_underflow(T val, R* result, const char* function, const Policy& pol)
|
||||
{
|
||||
if((val != 0) && (static_cast<R>(val) == 0))
|
||||
{
|
||||
*result = static_cast<R>(boost::math::policies::detail::raise_underflow_error<R>(function, 0, pol));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template <class R, class T, class Policy>
|
||||
inline bool check_denorm(T val, R* result, const char* function, const Policy& pol)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
if((fabs(val) < static_cast<T>(tools::min_value<R>())) && (static_cast<R>(val) != 0))
|
||||
{
|
||||
*result = static_cast<R>(boost::math::policies::detail::raise_denorm_error<R>(function, 0, static_cast<R>(val), pol));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// 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; }
|
||||
template <class R, class T>
|
||||
inline bool check_underflow(T /* val */, R* /* result */, const char* /* function */, const underflow_error<ignore_error>&){ 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; }
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class R, class Policy, class T>
|
||||
inline R checked_narrowing_cast(T val, const char* function)
|
||||
{
|
||||
typedef typename Policy::overflow_error_type overflow_type;
|
||||
typedef typename Policy::underflow_error_type underflow_type;
|
||||
typedef typename Policy::denorm_error_type denorm_type;
|
||||
//
|
||||
// Most of what follows will evaluate to a no-op:
|
||||
//
|
||||
R result = 0;
|
||||
if(detail::check_overflow<R>(val, &result, function, overflow_type()))
|
||||
return result;
|
||||
if(detail::check_underflow<R>(val, &result, function, underflow_type()))
|
||||
return result;
|
||||
if(detail::check_denorm<R>(val, &result, function, denorm_type()))
|
||||
return result;
|
||||
|
||||
return static_cast<R>(val);
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline void check_series_iterations(const char* function, boost::uintmax_t max_iter, const Policy& pol)
|
||||
{
|
||||
if(max_iter >= policies::get_max_series_iterations<Policy>())
|
||||
raise_evaluation_error<T>(
|
||||
function,
|
||||
"Series evaluation exceeded %1% iterations, giving up now.", static_cast<T>(static_cast<double>(max_iter)), pol);
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline void check_root_iterations(const char* function, boost::uintmax_t max_iter, const Policy& pol)
|
||||
{
|
||||
if(max_iter >= policies::get_max_root_iterations<Policy>())
|
||||
raise_evaluation_error<T>(
|
||||
function,
|
||||
"Root finding evaluation exceeded %1% iterations, giving up now.", static_cast<T>(static_cast<double>(max_iter)), pol);
|
||||
}
|
||||
|
||||
} //namespace policies
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
}} // namespaces boost/math
|
||||
|
||||
#endif // BOOST_MATH_POLICY_ERROR_HANDLING_HPP
|
||||
|
||||
959
test/external/boost/math/policies/policy.hpp
vendored
Normal file
959
test/external/boost/math/policies/policy.hpp
vendored
Normal file
@@ -0,0 +1,959 @@
|
||||
// Copyright John Maddock 2007.
|
||||
// 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_POLICY_HPP
|
||||
#define BOOST_MATH_POLICY_HPP
|
||||
|
||||
#include <boost/mpl/list.hpp>
|
||||
#include <boost/mpl/contains.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/find_if.hpp>
|
||||
#include <boost/mpl/remove_if.hpp>
|
||||
#include <boost/mpl/vector.hpp>
|
||||
#include <boost/mpl/push_back.hpp>
|
||||
#include <boost/mpl/at.hpp>
|
||||
#include <boost/mpl/size.hpp>
|
||||
#include <boost/mpl/comparison.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/math/tools/config.hpp>
|
||||
#include <limits>
|
||||
// Sadly we do need the .h versions of these to be sure of getting
|
||||
// FLT_MANT_DIG etc.
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
#include <stddef.h>
|
||||
#include <math.h>
|
||||
|
||||
namespace boost{ namespace math{
|
||||
|
||||
namespace tools{
|
||||
|
||||
template <class T>
|
||||
int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T));
|
||||
template <class T>
|
||||
T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T));
|
||||
|
||||
}
|
||||
|
||||
namespace policies{
|
||||
|
||||
//
|
||||
// Define macros for our default policies, if they're not defined already:
|
||||
//
|
||||
#ifndef BOOST_MATH_DOMAIN_ERROR_POLICY
|
||||
#define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_POLE_ERROR_POLICY
|
||||
#define BOOST_MATH_POLE_ERROR_POLICY throw_on_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_OVERFLOW_ERROR_POLICY
|
||||
#define BOOST_MATH_OVERFLOW_ERROR_POLICY throw_on_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_EVALUATION_ERROR_POLICY
|
||||
#define BOOST_MATH_EVALUATION_ERROR_POLICY throw_on_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_ROUNDING_ERROR_POLICY
|
||||
#define BOOST_MATH_ROUNDING_ERROR_POLICY throw_on_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_UNDERFLOW_ERROR_POLICY
|
||||
#define BOOST_MATH_UNDERFLOW_ERROR_POLICY ignore_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_DENORM_ERROR_POLICY
|
||||
#define BOOST_MATH_DENORM_ERROR_POLICY ignore_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY
|
||||
#define BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY ignore_error
|
||||
#endif
|
||||
#ifndef BOOST_MATH_DIGITS10_POLICY
|
||||
#define BOOST_MATH_DIGITS10_POLICY 0
|
||||
#endif
|
||||
#ifndef BOOST_MATH_PROMOTE_FLOAT_POLICY
|
||||
#define BOOST_MATH_PROMOTE_FLOAT_POLICY true
|
||||
#endif
|
||||
#ifndef BOOST_MATH_PROMOTE_DOUBLE_POLICY
|
||||
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
#define BOOST_MATH_PROMOTE_DOUBLE_POLICY false
|
||||
#else
|
||||
#define BOOST_MATH_PROMOTE_DOUBLE_POLICY true
|
||||
#endif
|
||||
#endif
|
||||
#ifndef BOOST_MATH_DISCRETE_QUANTILE_POLICY
|
||||
#define BOOST_MATH_DISCRETE_QUANTILE_POLICY integer_round_outwards
|
||||
#endif
|
||||
#ifndef BOOST_MATH_ASSERT_UNDEFINED_POLICY
|
||||
#define BOOST_MATH_ASSERT_UNDEFINED_POLICY true
|
||||
#endif
|
||||
#ifndef BOOST_MATH_MAX_SERIES_ITERATION_POLICY
|
||||
#define BOOST_MATH_MAX_SERIES_ITERATION_POLICY 1000000
|
||||
#endif
|
||||
#ifndef BOOST_MATH_MAX_ROOT_ITERATION_POLICY
|
||||
#define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 200
|
||||
#endif
|
||||
|
||||
#if !defined(__BORLANDC__) \
|
||||
&& !(defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ <= 2))
|
||||
#define BOOST_MATH_META_INT(type, name, Default)\
|
||||
template <type N = Default> struct name : public boost::mpl::int_<N>{};\
|
||||
namespace detail{\
|
||||
template <type N>\
|
||||
char test_is_valid_arg(const name<N>*);\
|
||||
char test_is_default_arg(const name<Default>*);\
|
||||
template <class T> struct is_##name##_imp\
|
||||
{\
|
||||
template <type N> static char test(const name<N>*);\
|
||||
static double test(...);\
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof(test(static_cast<T*>(0))) == 1);\
|
||||
};\
|
||||
}\
|
||||
template <class T> struct is_##name : public boost::mpl::bool_< ::boost::math::policies::detail::is_##name##_imp<T>::value>{};
|
||||
|
||||
#define BOOST_MATH_META_BOOL(name, Default)\
|
||||
template <bool N = Default> struct name : public boost::mpl::bool_<N>{};\
|
||||
namespace detail{\
|
||||
template <bool N>\
|
||||
char test_is_valid_arg(const name<N>*);\
|
||||
char test_is_default_arg(const name<Default>*);\
|
||||
template <class T> struct is_##name##_imp\
|
||||
{\
|
||||
template <bool N> static char test(const name<N>*);\
|
||||
static double test(...);\
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof(test(static_cast<T*>(0))) == 1);\
|
||||
};\
|
||||
}\
|
||||
template <class T> struct is_##name : public boost::mpl::bool_< ::boost::math::policies::detail::is_##name##_imp<T>::value>{};
|
||||
#else
|
||||
#define BOOST_MATH_META_INT(Type, name, Default)\
|
||||
template <Type N = Default> struct name : public boost::mpl::int_<N>{};\
|
||||
namespace detail{\
|
||||
template <Type N>\
|
||||
char test_is_valid_arg(const name<N>*);\
|
||||
char test_is_default_arg(const name<Default>*);\
|
||||
template <class T> struct is_##name##_tester\
|
||||
{\
|
||||
template <Type N> static char test(const name<N>&);\
|
||||
static double test(...);\
|
||||
};\
|
||||
template <class T> struct is_##name##_imp\
|
||||
{\
|
||||
static T inst;\
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof( ::boost::math::policies::detail::is_##name##_tester<T>::test(inst)) == 1);\
|
||||
};\
|
||||
}\
|
||||
template <class T> struct is_##name : public boost::mpl::bool_< ::boost::math::policies::detail::is_##name##_imp<T>::value>\
|
||||
{\
|
||||
template <class U> struct apply{ typedef is_##name<U> type; };\
|
||||
};
|
||||
|
||||
#define BOOST_MATH_META_BOOL(name, Default)\
|
||||
template <bool N = Default> struct name : public boost::mpl::bool_<N>{};\
|
||||
namespace detail{\
|
||||
template <bool N>\
|
||||
char test_is_valid_arg(const name<N>*);\
|
||||
char test_is_default_arg(const name<Default>*);\
|
||||
template <class T> struct is_##name##_tester\
|
||||
{\
|
||||
template <bool N> static char test(const name<N>&);\
|
||||
static double test(...);\
|
||||
};\
|
||||
template <class T> struct is_##name##_imp\
|
||||
{\
|
||||
static T inst;\
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof( ::boost::math::policies::detail::is_##name##_tester<T>::test(inst)) == 1);\
|
||||
};\
|
||||
}\
|
||||
template <class T> struct is_##name : public boost::mpl::bool_< ::boost::math::policies::detail::is_##name##_imp<T>::value>\
|
||||
{\
|
||||
template <class U> struct apply{ typedef is_##name<U> type; };\
|
||||
};
|
||||
#endif
|
||||
//
|
||||
// Begin by defining policy types for error handling:
|
||||
//
|
||||
enum error_policy_type
|
||||
{
|
||||
throw_on_error = 0,
|
||||
errno_on_error = 1,
|
||||
ignore_error = 2,
|
||||
user_error = 3
|
||||
};
|
||||
|
||||
BOOST_MATH_META_INT(error_policy_type, domain_error, BOOST_MATH_DOMAIN_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, pole_error, BOOST_MATH_POLE_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, overflow_error, BOOST_MATH_OVERFLOW_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, underflow_error, BOOST_MATH_UNDERFLOW_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, denorm_error, BOOST_MATH_DENORM_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, evaluation_error, BOOST_MATH_EVALUATION_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, rounding_error, BOOST_MATH_ROUNDING_ERROR_POLICY)
|
||||
BOOST_MATH_META_INT(error_policy_type, indeterminate_result_error, BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY)
|
||||
|
||||
//
|
||||
// Policy types for internal promotion:
|
||||
//
|
||||
BOOST_MATH_META_BOOL(promote_float, BOOST_MATH_PROMOTE_FLOAT_POLICY)
|
||||
BOOST_MATH_META_BOOL(promote_double, BOOST_MATH_PROMOTE_DOUBLE_POLICY)
|
||||
BOOST_MATH_META_BOOL(assert_undefined, BOOST_MATH_ASSERT_UNDEFINED_POLICY)
|
||||
//
|
||||
// Policy types for discrete quantiles:
|
||||
//
|
||||
enum discrete_quantile_policy_type
|
||||
{
|
||||
real,
|
||||
integer_round_outwards,
|
||||
integer_round_inwards,
|
||||
integer_round_down,
|
||||
integer_round_up,
|
||||
integer_round_nearest
|
||||
};
|
||||
|
||||
BOOST_MATH_META_INT(discrete_quantile_policy_type, discrete_quantile, BOOST_MATH_DISCRETE_QUANTILE_POLICY)
|
||||
//
|
||||
// Precision:
|
||||
//
|
||||
BOOST_MATH_META_INT(int, digits10, BOOST_MATH_DIGITS10_POLICY)
|
||||
BOOST_MATH_META_INT(int, digits2, 0)
|
||||
//
|
||||
// Iterations:
|
||||
//
|
||||
BOOST_MATH_META_INT(unsigned long, max_series_iterations, BOOST_MATH_MAX_SERIES_ITERATION_POLICY)
|
||||
BOOST_MATH_META_INT(unsigned long, max_root_iterations, BOOST_MATH_MAX_ROOT_ITERATION_POLICY)
|
||||
//
|
||||
// Define the names for each possible policy:
|
||||
//
|
||||
#define BOOST_MATH_PARAMETER(name)\
|
||||
BOOST_PARAMETER_TEMPLATE_KEYWORD(name##_name)\
|
||||
BOOST_PARAMETER_NAME(name##_name)
|
||||
|
||||
struct default_policy{};
|
||||
|
||||
namespace detail{
|
||||
//
|
||||
// Trait to work out bits precision from digits10 and digits2:
|
||||
//
|
||||
template <class Digits10, class Digits2>
|
||||
struct precision
|
||||
{
|
||||
//
|
||||
// Now work out the precision:
|
||||
//
|
||||
typedef typename mpl::if_c<
|
||||
(Digits10::value == 0),
|
||||
digits2<0>,
|
||||
digits2<((Digits10::value + 1) * 1000L) / 301L>
|
||||
>::type digits2_type;
|
||||
public:
|
||||
#ifdef __BORLANDC__
|
||||
typedef typename mpl::if_c<
|
||||
(Digits2::value > ::boost::math::policies::detail::precision<Digits10,Digits2>::digits2_type::value),
|
||||
Digits2, digits2_type>::type type;
|
||||
#else
|
||||
typedef typename mpl::if_c<
|
||||
(Digits2::value > digits2_type::value),
|
||||
Digits2, digits2_type>::type type;
|
||||
#endif
|
||||
};
|
||||
|
||||
template <class A, class B, bool b>
|
||||
struct select_result
|
||||
{
|
||||
typedef A type;
|
||||
};
|
||||
template <class A, class B>
|
||||
struct select_result<A, B, false>
|
||||
{
|
||||
typedef typename mpl::deref<B>::type type;
|
||||
};
|
||||
|
||||
template <class Seq, class Pred, class DefaultType>
|
||||
struct find_arg
|
||||
{
|
||||
private:
|
||||
typedef typename mpl::find_if<Seq, Pred>::type iter;
|
||||
typedef typename mpl::end<Seq>::type end_type;
|
||||
public:
|
||||
typedef typename select_result<
|
||||
DefaultType, iter,
|
||||
::boost::is_same<iter, end_type>::value>::type type;
|
||||
};
|
||||
|
||||
double test_is_valid_arg(...);
|
||||
double test_is_default_arg(...);
|
||||
char test_is_valid_arg(const default_policy*);
|
||||
char test_is_default_arg(const default_policy*);
|
||||
|
||||
template <class T>
|
||||
struct is_valid_policy_imp
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof(::boost::math::policies::detail::test_is_valid_arg(static_cast<T*>(0))) == 1);
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_default_policy_imp
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof(::boost::math::policies::detail::test_is_default_arg(static_cast<T*>(0))) == 1);
|
||||
};
|
||||
|
||||
template <class T> struct is_valid_policy
|
||||
: public mpl::bool_<
|
||||
::boost::math::policies::detail::is_valid_policy_imp<T>::value>
|
||||
{};
|
||||
|
||||
template <class T> struct is_default_policy
|
||||
: public mpl::bool_<
|
||||
::boost::math::policies::detail::is_default_policy_imp<T>::value>
|
||||
{
|
||||
template <class U>
|
||||
struct apply
|
||||
{
|
||||
typedef is_default_policy<U> type;
|
||||
};
|
||||
};
|
||||
|
||||
template <class Seq, class T, int N>
|
||||
struct append_N
|
||||
{
|
||||
typedef typename mpl::push_back<Seq, T>::type new_seq;
|
||||
typedef typename append_N<new_seq, T, N-1>::type type;
|
||||
};
|
||||
|
||||
template <class Seq, class T>
|
||||
struct append_N<Seq, T, 0>
|
||||
{
|
||||
typedef Seq type;
|
||||
};
|
||||
|
||||
//
|
||||
// Traits class to work out what template parameters our default
|
||||
// policy<> class will have when modified for forwarding:
|
||||
//
|
||||
template <bool f, bool d>
|
||||
struct default_args
|
||||
{
|
||||
typedef promote_float<false> arg1;
|
||||
typedef promote_double<false> arg2;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct default_args<false, false>
|
||||
{
|
||||
typedef default_policy arg1;
|
||||
typedef default_policy arg2;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct default_args<true, false>
|
||||
{
|
||||
typedef promote_float<false> arg1;
|
||||
typedef default_policy arg2;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct default_args<false, true>
|
||||
{
|
||||
typedef promote_double<false> arg1;
|
||||
typedef default_policy arg2;
|
||||
};
|
||||
|
||||
typedef default_args<BOOST_MATH_PROMOTE_FLOAT_POLICY, BOOST_MATH_PROMOTE_DOUBLE_POLICY>::arg1 forwarding_arg1;
|
||||
typedef default_args<BOOST_MATH_PROMOTE_FLOAT_POLICY, BOOST_MATH_PROMOTE_DOUBLE_POLICY>::arg2 forwarding_arg2;
|
||||
|
||||
} // detail
|
||||
//
|
||||
// Now define the policy type with enough arguments to handle all
|
||||
// the policies:
|
||||
//
|
||||
template <class A1 = default_policy,
|
||||
class A2 = default_policy,
|
||||
class A3 = default_policy,
|
||||
class A4 = default_policy,
|
||||
class A5 = default_policy,
|
||||
class A6 = default_policy,
|
||||
class A7 = default_policy,
|
||||
class A8 = default_policy,
|
||||
class A9 = default_policy,
|
||||
class A10 = default_policy,
|
||||
class A11 = default_policy,
|
||||
class A12 = default_policy,
|
||||
class A13 = default_policy>
|
||||
struct policy
|
||||
{
|
||||
private:
|
||||
//
|
||||
// Validate all our arguments:
|
||||
//
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A1>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A2>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A3>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A4>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A5>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A6>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A7>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A8>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A9>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A10>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A11>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A12>::value);
|
||||
BOOST_STATIC_ASSERT(::boost::math::policies::detail::is_valid_policy<A13>::value);
|
||||
//
|
||||
// Typelist of the arguments:
|
||||
//
|
||||
typedef mpl::list<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> arg_list;
|
||||
|
||||
public:
|
||||
typedef typename detail::find_arg<arg_list, is_domain_error<mpl::_1>, domain_error<> >::type domain_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_pole_error<mpl::_1>, pole_error<> >::type pole_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_overflow_error<mpl::_1>, overflow_error<> >::type overflow_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_underflow_error<mpl::_1>, underflow_error<> >::type underflow_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_denorm_error<mpl::_1>, denorm_error<> >::type denorm_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_evaluation_error<mpl::_1>, evaluation_error<> >::type evaluation_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_rounding_error<mpl::_1>, rounding_error<> >::type rounding_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_indeterminate_result_error<mpl::_1>, indeterminate_result_error<> >::type indeterminate_result_error_type;
|
||||
private:
|
||||
//
|
||||
// Now work out the precision:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_digits10<mpl::_1>, digits10<> >::type digits10_type;
|
||||
typedef typename detail::find_arg<arg_list, is_digits2<mpl::_1>, digits2<> >::type bits_precision_type;
|
||||
public:
|
||||
typedef typename detail::precision<digits10_type, bits_precision_type>::type precision_type;
|
||||
//
|
||||
// Internal promotion:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_promote_float<mpl::_1>, promote_float<> >::type promote_float_type;
|
||||
typedef typename detail::find_arg<arg_list, is_promote_double<mpl::_1>, promote_double<> >::type promote_double_type;
|
||||
//
|
||||
// Discrete quantiles:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_discrete_quantile<mpl::_1>, discrete_quantile<> >::type discrete_quantile_type;
|
||||
//
|
||||
// Mathematically undefined properties:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_assert_undefined<mpl::_1>, discrete_quantile<> >::type assert_undefined_type;
|
||||
//
|
||||
// Max iterations:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, max_series_iterations<> >::type max_series_iterations_type;
|
||||
typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, max_root_iterations<> >::type max_root_iterations_type;
|
||||
};
|
||||
//
|
||||
// These full specializations are defined to reduce the amount of
|
||||
// template instantiations that have to take place when using the default
|
||||
// policies, they have quite a large impact on compile times:
|
||||
//
|
||||
template <>
|
||||
struct policy<default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy>
|
||||
{
|
||||
public:
|
||||
typedef domain_error<> domain_error_type;
|
||||
typedef pole_error<> pole_error_type;
|
||||
typedef overflow_error<> overflow_error_type;
|
||||
typedef underflow_error<> underflow_error_type;
|
||||
typedef denorm_error<> denorm_error_type;
|
||||
typedef evaluation_error<> evaluation_error_type;
|
||||
typedef rounding_error<> rounding_error_type;
|
||||
typedef indeterminate_result_error<> indeterminate_result_error_type;
|
||||
#if BOOST_MATH_DIGITS10_POLICY == 0
|
||||
typedef digits2<> precision_type;
|
||||
#else
|
||||
typedef detail::precision<digits10<>, digits2<> >::type precision_type;
|
||||
#endif
|
||||
typedef promote_float<> promote_float_type;
|
||||
typedef promote_double<> promote_double_type;
|
||||
typedef discrete_quantile<> discrete_quantile_type;
|
||||
typedef assert_undefined<> assert_undefined_type;
|
||||
typedef max_series_iterations<> max_series_iterations_type;
|
||||
typedef max_root_iterations<> max_root_iterations_type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct policy<detail::forwarding_arg1, detail::forwarding_arg2, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy>
|
||||
{
|
||||
public:
|
||||
typedef domain_error<> domain_error_type;
|
||||
typedef pole_error<> pole_error_type;
|
||||
typedef overflow_error<> overflow_error_type;
|
||||
typedef underflow_error<> underflow_error_type;
|
||||
typedef denorm_error<> denorm_error_type;
|
||||
typedef evaluation_error<> evaluation_error_type;
|
||||
typedef rounding_error<> rounding_error_type;
|
||||
typedef indeterminate_result_error<> indeterminate_result_error_type;
|
||||
#if BOOST_MATH_DIGITS10_POLICY == 0
|
||||
typedef digits2<> precision_type;
|
||||
#else
|
||||
typedef detail::precision<digits10<>, digits2<> >::type precision_type;
|
||||
#endif
|
||||
typedef promote_float<false> promote_float_type;
|
||||
typedef promote_double<false> promote_double_type;
|
||||
typedef discrete_quantile<> discrete_quantile_type;
|
||||
typedef assert_undefined<> assert_undefined_type;
|
||||
typedef max_series_iterations<> max_series_iterations_type;
|
||||
typedef max_root_iterations<> max_root_iterations_type;
|
||||
};
|
||||
|
||||
template <class Policy,
|
||||
class A1 = default_policy,
|
||||
class A2 = default_policy,
|
||||
class A3 = default_policy,
|
||||
class A4 = default_policy,
|
||||
class A5 = default_policy,
|
||||
class A6 = default_policy,
|
||||
class A7 = default_policy,
|
||||
class A8 = default_policy,
|
||||
class A9 = default_policy,
|
||||
class A10 = default_policy,
|
||||
class A11 = default_policy,
|
||||
class A12 = default_policy,
|
||||
class A13 = default_policy>
|
||||
struct normalise
|
||||
{
|
||||
private:
|
||||
typedef mpl::list<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> arg_list;
|
||||
typedef typename detail::find_arg<arg_list, is_domain_error<mpl::_1>, typename Policy::domain_error_type >::type domain_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_pole_error<mpl::_1>, typename Policy::pole_error_type >::type pole_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_overflow_error<mpl::_1>, typename Policy::overflow_error_type >::type overflow_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_underflow_error<mpl::_1>, typename Policy::underflow_error_type >::type underflow_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_denorm_error<mpl::_1>, typename Policy::denorm_error_type >::type denorm_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_evaluation_error<mpl::_1>, typename Policy::evaluation_error_type >::type evaluation_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_rounding_error<mpl::_1>, typename Policy::rounding_error_type >::type rounding_error_type;
|
||||
typedef typename detail::find_arg<arg_list, is_indeterminate_result_error<mpl::_1>, typename Policy::indeterminate_result_error_type >::type indeterminate_result_error_type;
|
||||
//
|
||||
// Now work out the precision:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_digits10<mpl::_1>, digits10<> >::type digits10_type;
|
||||
typedef typename detail::find_arg<arg_list, is_digits2<mpl::_1>, typename Policy::precision_type >::type bits_precision_type;
|
||||
typedef typename detail::precision<digits10_type, bits_precision_type>::type precision_type;
|
||||
//
|
||||
// Internal promotion:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_promote_float<mpl::_1>, typename Policy::promote_float_type >::type promote_float_type;
|
||||
typedef typename detail::find_arg<arg_list, is_promote_double<mpl::_1>, typename Policy::promote_double_type >::type promote_double_type;
|
||||
//
|
||||
// Discrete quantiles:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_discrete_quantile<mpl::_1>, typename Policy::discrete_quantile_type >::type discrete_quantile_type;
|
||||
//
|
||||
// Mathematically undefined properties:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_assert_undefined<mpl::_1>, discrete_quantile<> >::type assert_undefined_type;
|
||||
//
|
||||
// Max iterations:
|
||||
//
|
||||
typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, max_series_iterations<> >::type max_series_iterations_type;
|
||||
typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, max_root_iterations<> >::type max_root_iterations_type;
|
||||
//
|
||||
// Define a typelist of the policies:
|
||||
//
|
||||
typedef mpl::vector<
|
||||
domain_error_type,
|
||||
pole_error_type,
|
||||
overflow_error_type,
|
||||
underflow_error_type,
|
||||
denorm_error_type,
|
||||
evaluation_error_type,
|
||||
rounding_error_type,
|
||||
indeterminate_result_error_type,
|
||||
precision_type,
|
||||
promote_float_type,
|
||||
promote_double_type,
|
||||
discrete_quantile_type,
|
||||
assert_undefined_type,
|
||||
max_series_iterations_type,
|
||||
max_root_iterations_type> result_list;
|
||||
//
|
||||
// Remove all the policies that are the same as the default:
|
||||
//
|
||||
typedef typename mpl::remove_if<result_list, detail::is_default_policy<mpl::_> >::type reduced_list;
|
||||
//
|
||||
// Pad out the list with defaults:
|
||||
//
|
||||
typedef typename detail::append_N<reduced_list, default_policy, (14 - ::boost::mpl::size<reduced_list>::value)>::type result_type;
|
||||
public:
|
||||
typedef policy<
|
||||
typename mpl::at<result_type, mpl::int_<0> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<1> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<2> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<3> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<4> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<5> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<6> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<7> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<8> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<9> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<10> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<11> >::type,
|
||||
typename mpl::at<result_type, mpl::int_<12> >::type > type;
|
||||
};
|
||||
//
|
||||
// Full specialisation to speed up compilation of the common case:
|
||||
//
|
||||
template <>
|
||||
struct normalise<policy<>,
|
||||
promote_float<false>,
|
||||
promote_double<false>,
|
||||
discrete_quantile<>,
|
||||
assert_undefined<>,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy>
|
||||
{
|
||||
typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct normalise<policy<detail::forwarding_arg1, detail::forwarding_arg2>,
|
||||
promote_float<false>,
|
||||
promote_double<false>,
|
||||
discrete_quantile<>,
|
||||
assert_undefined<>,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy,
|
||||
default_policy>
|
||||
{
|
||||
typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
|
||||
};
|
||||
|
||||
inline policy<> make_policy()
|
||||
{ return policy<>(); }
|
||||
|
||||
template <class A1>
|
||||
inline typename normalise<policy<>, A1>::type make_policy(const A1&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
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&)
|
||||
{
|
||||
typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type result_type;
|
||||
return result_type();
|
||||
}
|
||||
|
||||
//
|
||||
// Traits class to handle internal promotion:
|
||||
//
|
||||
template <class Real, class Policy>
|
||||
struct evaluation
|
||||
{
|
||||
typedef Real type;
|
||||
};
|
||||
|
||||
template <class Policy>
|
||||
struct evaluation<float, Policy>
|
||||
{
|
||||
typedef typename mpl::if_<typename Policy::promote_float_type, double, float>::type type;
|
||||
};
|
||||
|
||||
template <class Policy>
|
||||
struct evaluation<double, Policy>
|
||||
{
|
||||
typedef typename mpl::if_<typename Policy::promote_double_type, long double, double>::type type;
|
||||
};
|
||||
|
||||
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
|
||||
template <class Real>
|
||||
struct basic_digits : public mpl::int_<0>{ };
|
||||
template <>
|
||||
struct basic_digits<float> : public mpl::int_<FLT_MANT_DIG>{ };
|
||||
template <>
|
||||
struct basic_digits<double> : public mpl::int_<DBL_MANT_DIG>{ };
|
||||
template <>
|
||||
struct basic_digits<long double> : public mpl::int_<LDBL_MANT_DIG>{ };
|
||||
|
||||
template <class Real, class Policy>
|
||||
struct precision
|
||||
{
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<Real>::radix == 2);
|
||||
typedef typename Policy::precision_type precision_type;
|
||||
typedef basic_digits<Real> digits_t;
|
||||
typedef typename mpl::if_<
|
||||
mpl::equal_to<digits_t, mpl::int_<0> >,
|
||||
// Possibly unknown precision:
|
||||
precision_type,
|
||||
typename mpl::if_<
|
||||
mpl::or_<mpl::less_equal<digits_t, precision_type>, mpl::less_equal<precision_type, mpl::int_<0> > >,
|
||||
// Default case, full precision for RealType:
|
||||
digits2< ::std::numeric_limits<Real>::digits>,
|
||||
// User customised precision:
|
||||
precision_type
|
||||
>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class Policy>
|
||||
struct precision<float, Policy>
|
||||
{
|
||||
typedef digits2<FLT_MANT_DIG> type;
|
||||
};
|
||||
template <class Policy>
|
||||
struct precision<double, Policy>
|
||||
{
|
||||
typedef digits2<DBL_MANT_DIG> type;
|
||||
};
|
||||
template <class Policy>
|
||||
struct precision<long double, Policy>
|
||||
{
|
||||
typedef digits2<LDBL_MANT_DIG> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
template <class Real, class Policy>
|
||||
struct precision
|
||||
{
|
||||
BOOST_STATIC_ASSERT((::std::numeric_limits<Real>::radix == 2) || ((::std::numeric_limits<Real>::is_specialized == 0) || (::std::numeric_limits<Real>::digits == 0)));
|
||||
#ifndef __BORLANDC__
|
||||
typedef typename Policy::precision_type precision_type;
|
||||
typedef typename mpl::if_c<
|
||||
((::std::numeric_limits<Real>::is_specialized == 0) || (::std::numeric_limits<Real>::digits == 0)),
|
||||
// Possibly unknown precision:
|
||||
precision_type,
|
||||
typename mpl::if_c<
|
||||
((::std::numeric_limits<Real>::digits <= precision_type::value)
|
||||
|| (Policy::precision_type::value <= 0)),
|
||||
// Default case, full precision for RealType:
|
||||
digits2< ::std::numeric_limits<Real>::digits>,
|
||||
// User customised precision:
|
||||
precision_type
|
||||
>::type
|
||||
>::type type;
|
||||
#else
|
||||
typedef typename Policy::precision_type precision_type;
|
||||
typedef mpl::int_< ::std::numeric_limits<Real>::digits> digits_t;
|
||||
typedef mpl::bool_< ::std::numeric_limits<Real>::is_specialized> spec_t;
|
||||
typedef typename mpl::if_<
|
||||
mpl::or_<mpl::equal_to<spec_t, mpl::false_>, mpl::equal_to<digits_t, mpl::int_<0> > >,
|
||||
// Possibly unknown precision:
|
||||
precision_type,
|
||||
typename mpl::if_<
|
||||
mpl::or_<mpl::less_equal<digits_t, precision_type>, mpl::less_equal<precision_type, mpl::int_<0> > >,
|
||||
// Default case, full precision for RealType:
|
||||
digits2< ::std::numeric_limits<Real>::digits>,
|
||||
// User customised precision:
|
||||
precision_type
|
||||
>::type
|
||||
>::type type;
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <class T, class Policy>
|
||||
inline int digits_imp(mpl::true_ const&)
|
||||
{
|
||||
#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
|
||||
typedef typename boost::math::policies::precision<T, Policy>::type p_t;
|
||||
return p_t::value;
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline int digits_imp(mpl::false_ const&)
|
||||
{
|
||||
return tools::digits<T>();
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T, class Policy>
|
||||
inline int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T))
|
||||
{
|
||||
typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type;
|
||||
return detail::digits_imp<T, Policy>(tag_type());
|
||||
}
|
||||
|
||||
template <class Policy>
|
||||
inline unsigned long get_max_series_iterations()
|
||||
{
|
||||
typedef typename Policy::max_series_iterations_type iter_type;
|
||||
return iter_type::value;
|
||||
}
|
||||
|
||||
template <class Policy>
|
||||
inline unsigned long get_max_root_iterations()
|
||||
{
|
||||
typedef typename Policy::max_root_iterations_type iter_type;
|
||||
return iter_type::value;
|
||||
}
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <class T, class Digits, class Small, class Default>
|
||||
struct series_factor_calc
|
||||
{
|
||||
static T get()
|
||||
{
|
||||
return ldexp(T(1.0), 1 - Digits::value);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T, class Digits>
|
||||
struct series_factor_calc<T, Digits, mpl::true_, mpl::true_>
|
||||
{
|
||||
static T get()
|
||||
{
|
||||
return boost::math::tools::epsilon<T>();
|
||||
}
|
||||
};
|
||||
template <class T, class Digits>
|
||||
struct series_factor_calc<T, Digits, mpl::true_, mpl::false_>
|
||||
{
|
||||
static T get()
|
||||
{
|
||||
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()
|
||||
{
|
||||
return boost::math::tools::epsilon<T>();
|
||||
}
|
||||
};
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T get_epsilon_imp(mpl::true_ const&)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::radix == 2);
|
||||
#else
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::radix == 2);
|
||||
#endif
|
||||
typedef typename boost::math::policies::precision<T, Policy>::type p_t;
|
||||
typedef mpl::bool_<p_t::value <= std::numeric_limits<boost::uintmax_t>::digits> is_small_int;
|
||||
typedef mpl::bool_<p_t::value >= std::numeric_limits<T>::digits> is_default_value;
|
||||
return series_factor_calc<T, p_t, is_small_int, is_default_value>::get();
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T get_epsilon_imp(mpl::false_ const&)
|
||||
{
|
||||
return tools::epsilon<T>();
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T, class Policy>
|
||||
inline T get_epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(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());
|
||||
}
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <class A1,
|
||||
class A2,
|
||||
class A3,
|
||||
class A4,
|
||||
class A5,
|
||||
class A6,
|
||||
class A7,
|
||||
class A8,
|
||||
class A9,
|
||||
class A10,
|
||||
class A11>
|
||||
char test_is_policy(const policy<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11>*);
|
||||
double test_is_policy(...);
|
||||
|
||||
template <class P>
|
||||
struct is_policy_imp
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::math::policies::detail::test_is_policy(static_cast<P*>(0))) == 1));
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <class P>
|
||||
struct is_policy : public mpl::bool_< ::boost::math::policies::detail::is_policy_imp<P>::value> {};
|
||||
|
||||
}}} // namespaces
|
||||
|
||||
#endif // BOOST_MATH_POLICY_HPP
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user