[Boost-commit] svn:boost r46206 - in sandbox/math_toolkit: boost/math/policies boost/math/special_functions libs/math/test

From: bruno.lalande_at_[hidden]
Date: 2008-06-06 19:57:25

Author: bruno.lalande
Date: 2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
New Revision: 46206
URL: http://svn.boost.org/trac/boost/changeset/46206

Log:
Changed undeterminate to indeterminate.
Text files modified: 
   sandbox/math_toolkit/boost/math/policies/error_handling.hpp |    28 +++++++++++++-------------              
   sandbox/math_toolkit/boost/math/policies/policy.hpp         |    16 +++++++-------                          
   sandbox/math_toolkit/boost/math/special_functions/pow.hpp   |     2                                         
   sandbox/math_toolkit/libs/math/test/pow_test.cpp            |     4 +-                                      
   sandbox/math_toolkit/libs/math/test/test_error_handling.cpp |    20 +++++++++---------                      
   sandbox/math_toolkit/libs/math/test/test_policy.cpp         |    42 ++++++++++++++++++++--------------------
   sandbox/math_toolkit/libs/math/test/test_policy_2.cpp       |    24 +++++++++++-----------                  
   7 files changed, 68 insertions(+), 68 deletions(-)

Modified: sandbox/math_toolkit/boost/math/policies/error_handling.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/policies/error_handling.hpp	(original)
+++ sandbox/math_toolkit/boost/math/policies/error_handling.hpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -63,7 +63,7 @@
 template <class T>
 T user_rounding_error(const char* function, const char* message, const T& val);
 template <class T>
-T user_undeterminate_result_error(const char* function, const char* message, const T& val);
+T user_indeterminate_result_error(const char* function, const char* message, const T& val);
 
 namespace detail
 {
@@ -429,12 +429,12 @@
 }
 
 template <class T, class R>
-inline T raise_undeterminate_result_error(
+inline T raise_indeterminate_result_error(
            const char* function, 
            const char* message, 
            const T& val, 
            const R& ,
-           const ::boost::math::policies::undeterminate_result_error< ::boost::math::policies::throw_on_error>&)
+           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:
@@ -442,12 +442,12 @@
 }
 
 template <class T, class R>
-inline T raise_undeterminate_result_error(
+inline T raise_indeterminate_result_error(
            const char* , 
            const char* , 
            const T& , 
            const R& result, 
-           const ::boost::math::policies::undeterminate_result_error< ::boost::math::policies::ignore_error>&)
+           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:
@@ -455,12 +455,12 @@
 }
 
 template <class T, class R>
-inline T raise_undeterminate_result_error(
+inline T raise_indeterminate_result_error(
            const char* , 
            const char* , 
            const T& , 
            const R& result, 
-           const ::boost::math::policies::undeterminate_result_error< ::boost::math::policies::errno_on_error>&)
+           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
@@ -469,14 +469,14 @@
 }
 
 template <class T, class R>
-inline T raise_undeterminate_result_error(
+inline T raise_indeterminate_result_error(
            const char* function, 
            const char* message, 
            const T& val, 
            const R& , 
-           const ::boost::math::policies::undeterminate_result_error< ::boost::math::policies::user_error>&)
+           const ::boost::math::policies::indeterminate_result_error< ::boost::math::policies::user_error>&)
 {
-   return user_undeterminate_result_error(function, message, val);
+   return user_indeterminate_result_error(function, message, val);
 }
 
 }  // namespace detail
@@ -546,11 +546,11 @@
 }
 
 template <class T, class R, class Policy>
-inline T raise_undeterminate_result_error(const char* function, const char* message, const T& val, const R& result, const Policy&)
+inline T raise_indeterminate_result_error(const char* function, const char* message, const T& val, const R& result, const Policy&)
 {
-   typedef typename Policy::undeterminate_result_error_type policy_type;
-   return detail::raise_undeterminate_result_error(
-      function, message ? message : "Undeterminate result with value %1%",
+   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());
 }
 

Modified: sandbox/math_toolkit/boost/math/policies/policy.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/policies/policy.hpp	(original)
+++ sandbox/math_toolkit/boost/math/policies/policy.hpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -63,8 +63,8 @@
 #ifndef BOOST_MATH_DENORM_ERROR_POLICY
 #define BOOST_MATH_DENORM_ERROR_POLICY ignore_error
 #endif
-#ifndef BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY
-#define BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY ignore_error
+#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
@@ -185,7 +185,7 @@
 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, undeterminate_result_error, BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY)
+BOOST_MATH_META_INT(error_policy_type, indeterminate_result_error, BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY)
 
 //
 // Policy types for internal promotion:
@@ -407,7 +407,7 @@
    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_undeterminate_result_error<mpl::_1>, undeterminate_result_error<> >::type undeterminate_result_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:
@@ -451,7 +451,7 @@
    typedef denorm_error<> denorm_error_type;
    typedef evaluation_error<> evaluation_error_type;
    typedef rounding_error<> rounding_error_type;
-   typedef undeterminate_result_error<> undeterminate_result_error_type;
+   typedef indeterminate_result_error<> indeterminate_result_error_type;
 #if BOOST_MATH_DIGITS10_POLICY == 0
    typedef digits2<> precision_type;
 #else
@@ -476,7 +476,7 @@
    typedef denorm_error<> denorm_error_type;
    typedef evaluation_error<> evaluation_error_type;
    typedef rounding_error<> rounding_error_type;
-   typedef undeterminate_result_error<> undeterminate_result_error_type;
+   typedef indeterminate_result_error<> indeterminate_result_error_type;
 #if BOOST_MATH_DIGITS10_POLICY == 0
    typedef digits2<> precision_type;
 #else
@@ -515,7 +515,7 @@
    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_undeterminate_result_error<mpl::_1>, typename Policy::undeterminate_result_error_type >::type undeterminate_result_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:
    //
@@ -551,7 +551,7 @@
       denorm_error_type,
       evaluation_error_type,
       rounding_error_type,
-      undeterminate_result_error_type,
+      indeterminate_result_error_type,
       precision_type,
       promote_float_type,
       promote_double_type,

Modified: sandbox/math_toolkit/boost/math/special_functions/pow.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/pow.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/pow.hpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -96,7 +96,7 @@
     {
         if (base == 0)
         {
-            return policies::raise_undeterminate_result_error<T>(
+            return policies::raise_indeterminate_result_error<T>(
                        "boost::math::pow(%1%)",
                        "The result of pow<0>(%1%) is undetermined",
                        base,

Modified: sandbox/math_toolkit/libs/math/test/pow_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/pow_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/pow_test.cpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -120,7 +120,7 @@
 
 namespace boost { namespace math { namespace policies {
 template <class T>
-T user_undeterminate_result_error(const char*, const char*, const T&)
+T user_indeterminate_result_error(const char*, const char*, const T&)
 { return T(456.78); }
 }}}
 
@@ -137,7 +137,7 @@
 
     BOOST_CHECK(pow<0>(
                     0.0,
-                    policy< ::boost::math::policies::undeterminate_result_error<user_error> >()
+                    policy< ::boost::math::policies::indeterminate_result_error<user_error> >()
                 )
                 == 456.78);
 }

Modified: sandbox/math_toolkit/libs/math/test/test_error_handling.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_error_handling.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_error_handling.cpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -54,7 +54,7 @@
 }
 
 template <class T>
-T user_undeterminate_result_error(const char* , const char* , const T& )
+T user_indeterminate_result_error(const char* , const char* , const T& )
 {
    throw user_defined_error();
 }
@@ -76,7 +76,7 @@
    underflow_error<throw_on_error>,
    denorm_error<throw_on_error>,
    evaluation_error<throw_on_error>,
-   undeterminate_result_error<throw_on_error> > throw_policy;
+   indeterminate_result_error<throw_on_error> > throw_policy;
 policy<
    domain_error<errno_on_error>,
    pole_error<errno_on_error>,
@@ -84,7 +84,7 @@
    underflow_error<errno_on_error>,
    denorm_error<errno_on_error>,
    evaluation_error<errno_on_error>,
-   undeterminate_result_error<errno_on_error> > errno_policy;
+   indeterminate_result_error<errno_on_error> > errno_policy;
 policy<
    domain_error<ignore_error>,
    pole_error<ignore_error>,
@@ -92,7 +92,7 @@
    underflow_error<ignore_error>,
    denorm_error<ignore_error>,
    evaluation_error<ignore_error>,
-   undeterminate_result_error<ignore_error> > ignore_policy;
+   indeterminate_result_error<ignore_error> > ignore_policy;
 policy<
    domain_error<user_error>,
    pole_error<user_error>,
@@ -100,7 +100,7 @@
    underflow_error<user_error>,
    denorm_error<user_error>,
    evaluation_error<user_error>,
-   undeterminate_result_error<user_error> > user_policy;
+   indeterminate_result_error<user_error> > user_policy;
 policy<> default_policy;
 
 #define TEST_EXCEPTION(expression, exception)\
@@ -129,8 +129,8 @@
    TEST_EXCEPTION(boost::math::policies::raise_denorm_error<T>(func, 0, T(0), throw_policy), std::underflow_error);
    TEST_EXCEPTION(boost::math::policies::raise_evaluation_error(func, msg1, T(1.25), throw_policy), boost::math::evaluation_error);
    TEST_EXCEPTION(boost::math::policies::raise_evaluation_error(func, 0, T(1.25), throw_policy), boost::math::evaluation_error);
-   TEST_EXCEPTION(boost::math::policies::raise_undeterminate_result_error(func, msg1, T(1.25), T(12.34), throw_policy), std::domain_error);
-   TEST_EXCEPTION(boost::math::policies::raise_undeterminate_result_error(func, 0, T(1.25), T(12.34), throw_policy), std::domain_error);
+   TEST_EXCEPTION(boost::math::policies::raise_indeterminate_result_error(func, msg1, T(1.25), T(12.34), throw_policy), std::domain_error);
+   TEST_EXCEPTION(boost::math::policies::raise_indeterminate_result_error(func, 0, T(1.25), T(12.34), throw_policy), std::domain_error);
    //
    // Now try user error handlers: these should all throw user_error():
    // - because by design these are undefined and must be defined by the user ;-)
@@ -140,7 +140,7 @@
    BOOST_CHECK_THROW(boost::math::policies::raise_underflow_error<T>(func, msg2, user_policy), user_defined_error);
    BOOST_CHECK_THROW(boost::math::policies::raise_denorm_error<T>(func, msg2, T(0), user_policy), user_defined_error);
    BOOST_CHECK_THROW(boost::math::policies::raise_evaluation_error(func, msg1, T(0.0), user_policy), user_defined_error);
-   BOOST_CHECK_THROW(boost::math::policies::raise_undeterminate_result_error(func, msg1, T(0.0), T(0.0), user_policy), user_defined_error);
+   BOOST_CHECK_THROW(boost::math::policies::raise_indeterminate_result_error(func, msg1, T(0.0), T(0.0), user_policy), user_defined_error);
 
    // Test with ignore_error
    //BOOST_CHECK(boost::math::isnan(boost::math::policies::raise_domain_error(func, msg1, T(0.0), ignore_policy)));
@@ -149,7 +149,7 @@
    BOOST_CHECK_EQUAL(boost::math::policies::raise_underflow_error<T>(func, msg2, ignore_policy), T(0));
    BOOST_CHECK_EQUAL(boost::math::policies::raise_denorm_error<T>(func, msg2, T(1.25), ignore_policy), T(1.25));
    //BOOST_CHECK_EQUAL(boost::math::policies::raise_evaluation_error(func, msg1, T(0.0), ignore_policy), std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : boost::math::tools::max_value<T>());
-   BOOST_CHECK_EQUAL(boost::math::policies::raise_undeterminate_result_error(func, 0, T(0.0), T(12.34), ignore_policy), T(12.34));
+   BOOST_CHECK_EQUAL(boost::math::policies::raise_indeterminate_result_error(func, 0, T(0.0), T(12.34), ignore_policy), T(12.34));
 
    // Test with errno_on_error
    //errno = 0;
@@ -171,7 +171,7 @@
    //BOOST_CHECK_EQUAL(boost::math::policies::raise_evaluation_error(func, msg1, T(0.0), errno_policy), std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : boost::math::tools::max_value<T>());
    //BOOST_CHECK(errno == EDOM);
    errno = 0;
-   BOOST_CHECK(boost::math::policies::raise_undeterminate_result_error(func, 0, T(0.0), T(12.34), errno_policy) == T(12.34));
+   BOOST_CHECK(boost::math::policies::raise_indeterminate_result_error(func, 0, T(0.0), T(12.34), errno_policy) == T(12.34));
    BOOST_CHECK_EQUAL(errno, EDOM);
 }
 

Modified: sandbox/math_toolkit/libs/math/test/test_policy.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_policy.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_policy.cpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -42,7 +42,7 @@
    BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -54,7 +54,7 @@
    BOOST_CHECK((is_same<policy<pole_error<user_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<pole_error<user_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<pole_error<user_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<pole_error<user_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<pole_error<user_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<pole_error<user_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<pole_error<user_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<pole_error<user_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -66,7 +66,7 @@
    BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -78,7 +78,7 @@
    BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::underflow_error_type, underflow_error<errno_on_error> >::value));
    BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -90,7 +90,7 @@
    BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
    BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::denorm_error_type, denorm_error<errno_on_error> >::value));
    BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -102,23 +102,23 @@
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::denorm_error_type, policy<>::denorm_error_type >::value));
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::evaluation_error_type, evaluation_error<errno_on_error> >::value));
-   BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::undeterminate_result_error_type, policy<>::undeterminate_result_error_type >::value));
+   BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
    BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::denorm_error_type, policy<>::denorm_error_type >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::undeterminate_result_error_type, undeterminate_result_error<ignore_error> >::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
-   BOOST_CHECK((is_same<policy<undeterminate_result_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<ignore_error> >::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((is_same<policy<indeterminate_result_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
    BOOST_CHECK((is_same<policy<digits2<20> >::domain_error_type, policy<>::domain_error_type >::value));
    BOOST_CHECK((is_same<policy<digits2<20> >::pole_error_type, policy<>::pole_error_type >::value));
@@ -126,7 +126,7 @@
    BOOST_CHECK((is_same<policy<digits2<20> >::underflow_error_type, policy<>::underflow_error_type >::value));
    BOOST_CHECK((is_same<policy<digits2<20> >::denorm_error_type, policy<>::denorm_error_type >::value));
    BOOST_CHECK((is_same<policy<digits2<20> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
-   BOOST_CHECK((is_same<policy<digits2<20> >::undeterminate_result_error_type, policy<>::undeterminate_result_error_type >::value));
+   BOOST_CHECK((is_same<policy<digits2<20> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
    BOOST_CHECK((is_same<policy<digits2<20> >::precision_type, digits2<20> >::value));
    BOOST_CHECK((is_same<policy<digits2<20> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<digits2<20> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -138,7 +138,7 @@
    BOOST_CHECK((is_same<policy<promote_float<false> >::underflow_error_type, policy<>::underflow_error_type >::value));
    BOOST_CHECK((is_same<policy<promote_float<false> >::denorm_error_type, policy<>::denorm_error_type >::value));
    BOOST_CHECK((is_same<policy<promote_float<false> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
-   BOOST_CHECK((is_same<policy<promote_float<false> >::undeterminate_result_error_type, policy<>::undeterminate_result_error_type >::value));
+   BOOST_CHECK((is_same<policy<promote_float<false> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
    BOOST_CHECK((is_same<policy<promote_float<false> >::precision_type, policy<>::precision_type >::value));
    BOOST_CHECK((is_same<policy<promote_float<false> >::promote_float_type, promote_float<false> >::value));
    BOOST_CHECK((is_same<policy<promote_float<false> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -150,7 +150,7 @@
    BOOST_CHECK((is_same<policy<promote_double<false> >::underflow_error_type, policy<>::underflow_error_type >::value));
    BOOST_CHECK((is_same<policy<promote_double<false> >::denorm_error_type, policy<>::denorm_error_type >::value));
    BOOST_CHECK((is_same<policy<promote_double<false> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
-   BOOST_CHECK((is_same<policy<promote_double<false> >::undeterminate_result_error_type, policy<>::undeterminate_result_error_type >::value));
+   BOOST_CHECK((is_same<policy<promote_double<false> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
    BOOST_CHECK((is_same<policy<promote_double<false> >::precision_type, policy<>::precision_type >::value));
    BOOST_CHECK((is_same<policy<promote_double<false> >::promote_float_type,  policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<promote_double<false> >::promote_double_type, promote_double<false> >::value));
@@ -162,7 +162,7 @@
    BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::underflow_error_type, policy<>::underflow_error_type >::value));
    BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::denorm_error_type, policy<>::denorm_error_type >::value));
    BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
-   BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::undeterminate_result_error_type, policy<>::undeterminate_result_error_type >::value));
+   BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
    BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::precision_type, policy<>::precision_type >::value));
    BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::promote_float_type,  policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::promote_double_type, policy<>::promote_double_type>::value));

Modified: sandbox/math_toolkit/libs/math/test/test_policy_2.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_policy_2.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_policy_2.cpp	2008-06-06 19:57:24 EDT (Fri, 06 Jun 2008)
@@ -33,7 +33,7 @@
    BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -45,7 +45,7 @@
    BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::denorm_error_type, denorm_error<throw_on_error> >::value));
    BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
    BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
    BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -57,7 +57,7 @@
    BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::denorm_error_type, denorm_error<throw_on_error> >::value));
    BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::precision_type, digits2<20> >::value));
    BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::promote_float_type, promote_float<false> >::value));
    BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
@@ -69,7 +69,7 @@
    BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::denorm_error_type, denorm_error<throw_on_error> >::value));
    BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::precision_type, digits2<20> >::value));
    BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::promote_float_type, promote_float<false> >::value));
    BOOST_CHECK((is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::promote_double_type, policy<>::promote_double_type>::value));
@@ -81,7 +81,7 @@
    BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::denorm_error_type, denorm_error<throw_on_error> >::value));
    BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::undeterminate_result_error_type, undeterminate_result_error<BOOST_MATH_UNDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
    BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::precision_type, digits2<20> >::value));
    BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::promote_float_type, promote_float<false> >::value));
    BOOST_CHECK((is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::promote_double_type, policy<>::promote_double_type>::value));
@@ -93,7 +93,7 @@
    BOOST_CHECK(check_same(make_policy(promote_float<false>()), normalise<policy<promote_float<false> > >::type()));
    BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>()), normalise<policy<domain_error<ignore_error> > >::type()));
    BOOST_CHECK(check_same(make_policy(pole_error<ignore_error>()), normalise<policy<pole_error<ignore_error> > >::type()));
-   BOOST_CHECK(check_same(make_policy(undeterminate_result_error<ignore_error>()), normalise<policy<undeterminate_result_error<ignore_error> > >::type()));
+   BOOST_CHECK(check_same(make_policy(indeterminate_result_error<ignore_error>()), normalise<policy<indeterminate_result_error<ignore_error> > >::type()));
 
    BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>()), policy<domain_error<ignore_error> >()));
    BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>()), policy<domain_error<ignore_error>, pole_error<ignore_error> >()));
@@ -101,13 +101,13 @@
    BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error> >()));
    BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error> >()));
    BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error> >()));
-   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), undeterminate_result_error<throw_on_error>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, undeterminate_result_error<throw_on_error> >()));
-   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), undeterminate_result_error<throw_on_error>(), digits2<10>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, undeterminate_result_error<throw_on_error>, digits2<10> >()));
-   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), undeterminate_result_error<throw_on_error>(), digits10<5>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, undeterminate_result_error<throw_on_error>, digits2<19> >()));
-   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), undeterminate_result_error<throw_on_error>(), digits2<10>(), promote_float<false>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, undeterminate_result_error<throw_on_error>, digits2<10>, promote_float<false> >()));
+   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), indeterminate_result_error<throw_on_error>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, indeterminate_result_error<throw_on_error> >()));
+   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), indeterminate_result_error<throw_on_error>(), digits2<10>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, indeterminate_result_error<throw_on_error>, digits2<10> >()));
+   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), indeterminate_result_error<throw_on_error>(), digits10<5>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, indeterminate_result_error<throw_on_error>, digits2<19> >()));
+   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), indeterminate_result_error<throw_on_error>(), digits2<10>(), promote_float<false>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, indeterminate_result_error<throw_on_error>, digits2<10>, promote_float<false> >()));
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), undeterminate_result_error<throw_on_error>(), digits2<10>(), promote_float<false>(), promote_double<false>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, undeterminate_result_error<throw_on_error>, digits2<10>, promote_float<false>, promote_double<false> >()));
-   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), undeterminate_result_error<throw_on_error>(), digits2<10>(), promote_float<false>(), promote_double<false>(), discrete_quantile<integer_round_down>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, undeterminate_result_error<throw_on_error>, digits2<10>, promote_float<false>, promote_double<false>, discrete_quantile<integer_round_down> >()));
+   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), indeterminate_result_error<throw_on_error>(), digits2<10>(), promote_float<false>(), promote_double<false>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, indeterminate_result_error<throw_on_error>, digits2<10>, promote_float<false>, promote_double<false> >()));
+   BOOST_CHECK(check_same(make_policy(domain_error<ignore_error>(), pole_error<ignore_error>(), overflow_error<ignore_error>(), underflow_error<throw_on_error>(), denorm_error<throw_on_error>(), evaluation_error<ignore_error>(), indeterminate_result_error<throw_on_error>(), digits2<10>(), promote_float<false>(), promote_double<false>(), discrete_quantile<integer_round_down>()), policy<domain_error<ignore_error>, pole_error<ignore_error>, overflow_error<ignore_error>, underflow_error<throw_on_error>, denorm_error<throw_on_error>, evaluation_error<ignore_error>, indeterminate_result_error<throw_on_error>, digits2<10>, promote_float<false>, promote_double<false>, discrete_quantile<integer_round_down> >()));
 #endif
    return 0;
 } // int test_main(int, char* [])