From 74ea8bdfda52949982dac8c0b524f47865d94499 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 16 Feb 2021 14:54:39 +0300
Subject: [PATCH] Add mp_at and mp_find_if [ci skip]

---
 include/boost/math/tools/mp.hpp | 147 +++++++++++++++++--
 test/test_policy.cpp            | 252 ++++++++++++++++----------------
 test/test_policy_2.cpp          |  28 ++--
 test/test_policy_3.cpp          |  28 ++--
 test/test_policy_4.cpp          |  28 ++--
 test/test_policy_5.cpp          |  28 ++--
 test/test_policy_6.cpp          |  28 ++--
 test/test_policy_7.cpp          |   6 +-
 test/test_policy_8.cpp          |   6 +-
 9 files changed, 335 insertions(+), 216 deletions(-)

diff --git a/include/boost/math/tools/mp.hpp b/include/boost/math/tools/mp.hpp
index a5e81e217..9a4177ee3 100644
--- a/include/boost/math/tools/mp.hpp
+++ b/include/boost/math/tools/mp.hpp
@@ -15,6 +15,22 @@
 
 namespace boost { namespace math { namespace tools {
 
+// Types:
+// Typelist 
+template<typename... T>
+struct mp_list {};
+
+// Size_t
+template<std::size_t N> 
+using mp_size_t = std::integral_constant<std::size_t, N>;
+
+// Boolean
+template<bool B>
+using mp_bool = std::integral_constant<bool, B>;
+
+
+
+
 namespace detail {
 
 // Size
@@ -47,6 +63,97 @@ struct mp_back_impl<L<T..., B>>
     using type = B;
 };
 
+// At
+// TODO - Use tree based lookup for larger typelists
+// http://odinthenerd.blogspot.com/2017/04/tree-based-lookup-why-kvasirmpl-is.html
+template<typename L, std::size_t>
+struct mp_at {};
+
+template<template<typename...> class L, typename T0, typename... T>
+struct mp_at<L<T0, T...>, 0>
+{
+    using type = T0;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename... T>
+struct mp_at<L<T0, T1, T...>, 1>
+{
+    using type = T1;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename... T>
+struct mp_at<L<T0, T1, T2, T...>, 2>
+{
+    using type = T2;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T...>, 3>
+{
+    using type = T3;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T...>, 4>
+{
+    using type = T4;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T...>, 5>
+{
+    using type = T5;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T...>, 6>
+{
+    using type = T6;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename T7, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T7, T...>, 7>
+{
+    using type = T7;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename T7, typename T8, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T7, T8, T...>, 8>
+{
+    using type = T8;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename T7, typename T8, typename T9, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>, 9>
+{
+    using type = T9;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename T7, typename T8, typename T9, typename T10, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, 10>
+{
+    using type = T10;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename T7, typename T8, typename T9, typename T10, typename T11, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T...>, 11>
+{
+    using type = T11;
+};
+
+template<template<typename...> class L, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
+         typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename... T>
+struct mp_at<L<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T...>, 12>
+{
+    using type = T12;
+};
+
 // Push back
 template<typename L, typename... T> 
 struct mp_push_back_impl {};
@@ -67,24 +174,33 @@ struct mp_push_front_impl<L<U...>, T...>
     using type = L<T..., U...>;
 };
 
+// Find if
+template<typename Iter>
+constexpr std::size_t find_index(const Iter first, const Iter last)
+{
+    return first == last || *first ? 0 : 1 + find_index(first + 1, last);
+}
+
+template<typename L, template<typename...> class P>
+struct mp_find_if_impl {};
+
+template<template<typename...> class L, template<typename...> class P> 
+struct mp_find_if_impl<L<>, P>
+{
+    using type = mp_size_t<0>;
+};
+
+template<template<typename...> class L, typename... T, template<typename...> class P> 
+struct mp_find_if_impl<L<T...>, P>
+{
+    static constexpr bool v[] = {P<T>::value...};
+    using type = mp_size_t<find_index(v, v + sizeof...(T))>;
+};
+
 } // namespace detail
 
 
 
-// Types:
-// Typelist 
-template<typename... T>
-struct mp_list {};
-
-// Size_t
-template<std::size_t N> 
-using mp_size_t = std::integral_constant<std::size_t, N>;
-
-// Boolean
-template<bool B>
-using mp_bool = std::integral_constant<bool, B>;
-
-
 
 // User Interfaces
 template<typename T> 
@@ -102,6 +218,9 @@ using mp_push_back = typename detail::mp_push_back_impl<L, T...>::type;
 template<typename L, typename... T> 
 using mp_push_front = typename detail::mp_push_front_impl<L, T...>::type;
 
+template<typename L, template<typename...> class P> 
+using mp_find_if = typename detail::mp_find_if_impl<L, P>::type;
+
 }}} // namespaces
 
 #endif // BOOST_MATH_TOOLS_MP
diff --git a/test/test_policy.cpp b/test/test_policy.cpp
index 05ac4b778..62a467621 100644
--- a/test/test_policy.cpp
+++ b/test/test_policy.cpp
@@ -7,20 +7,20 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
@@ -35,140 +35,140 @@ BOOST_AUTO_TEST_CASE( test_main )
    BOOST_CHECK(is_digits10<digits10<ignore_error> >::value);
    BOOST_CHECK(0 == is_digits10<digits2<ignore_error> >::value);
 
-   BOOST_CHECK((is_same<policy<>::domain_error_type, domain_error<BOOST_MATH_DOMAIN_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<>::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<>::domain_error_type, domain_error<BOOST_MATH_DOMAIN_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<>::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
 
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<pole_error<user_error> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<pole_error<user_error> >::pole_error_type, pole_error<user_error> >::value));
-   BOOST_CHECK((is_same<policy<pole_error<user_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<pole_error<user_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::pole_error_type, pole_error<user_error> >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<pole_error<user_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::overflow_error_type, overflow_error<errno_on_error> >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<overflow_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::overflow_error_type, overflow_error<errno_on_error> >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<overflow_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<underflow_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::underflow_error_type, underflow_error<errno_on_error> >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<underflow_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<denorm_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::denorm_error_type, denorm_error<errno_on_error> >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::indeterminate_result_error_type, indeterminate_result_error<BOOST_MATH_INDETERMINATE_RESULT_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<errno_on_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<evaluation_error<errno_on_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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((std::is_same<policy<evaluation_error<errno_on_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::evaluation_error_type, evaluation_error<errno_on_error> >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<evaluation_error<errno_on_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((std::is_same<policy<indeterminate_result_error<ignore_error> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::indeterminate_result_error_type, indeterminate_result_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<indeterminate_result_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::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));
-   BOOST_CHECK((is_same<policy<digits2<20> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<digits2<20> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::precision_type, digits2<20> >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<promote_float<false> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<promote_float<false> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<promote_float<false> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<promote_float<false> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::precision_type, policy<>::precision_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::promote_float_type, promote_float<false> >::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<promote_float<false> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<promote_double<false> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<promote_double<false> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<promote_double<false> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<promote_double<false> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::precision_type, policy<>::precision_type >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::promote_float_type,  policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::promote_double_type, promote_double<false> >::value));
+   BOOST_CHECK((std::is_same<policy<promote_double<false> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
-   BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::domain_error_type, policy<>::domain_error_type >::value));
-   BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::pole_error_type, policy<>::pole_error_type >::value));
-   BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::overflow_error_type, policy<>::overflow_error_type >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<discrete_quantile<integer_round_up> >::discrete_quantile_type, discrete_quantile<integer_round_up> >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::domain_error_type, policy<>::domain_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::pole_error_type, policy<>::pole_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::overflow_error_type, policy<>::overflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::underflow_error_type, policy<>::underflow_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::denorm_error_type, policy<>::denorm_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::evaluation_error_type, policy<>::evaluation_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::indeterminate_result_error_type, policy<>::indeterminate_result_error_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::precision_type, policy<>::precision_type >::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::promote_float_type,  policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<discrete_quantile<integer_round_up> >::discrete_quantile_type, discrete_quantile<integer_round_up> >::value));
 
    
 } // BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_policy_2.cpp b/test/test_policy_2.cpp
index b86bad456..83a64bbf2 100644
--- a/test/test_policy_2.cpp
+++ b/test/test_policy_2.cpp
@@ -7,19 +7,19 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
@@ -28,17 +28,17 @@ BOOST_AUTO_TEST_CASE( test_main )
    using namespace boost::math::policies;
    using namespace boost;
 
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::overflow_error_type, overflow_error<ignore_error> >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::overflow_error_type, overflow_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::underflow_error_type, underflow_error<BOOST_MATH_UNDERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::denorm_error_type, denorm_error<BOOST_MATH_DENORM_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::evaluation_error_type, evaluation_error<BOOST_MATH_EVALUATION_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::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((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<domain_error<ignore_error>, overflow_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
    
 } // BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_policy_3.cpp b/test/test_policy_3.cpp
index 4d9061a37..5e103b1c9 100644
--- a/test/test_policy_3.cpp
+++ b/test/test_policy_3.cpp
@@ -7,20 +7,20 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
@@ -29,17 +29,17 @@ BOOST_AUTO_TEST_CASE( test_main )
    using namespace boost::math::policies;
    using namespace boost;
 
-   BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
-   BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
-   BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
-   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> >::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));
-   BOOST_CHECK((is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::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((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::denorm_error_type, denorm_error<throw_on_error> >::value));
+   BOOST_CHECK((std::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((std::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((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::precision_type, policy<>::precision_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::promote_float_type, policy<>::promote_float_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::promote_double_type, policy<>::promote_double_type>::value));
+   BOOST_CHECK((std::is_same<policy<denorm_error<throw_on_error>, domain_error<ignore_error> >::discrete_quantile_type, policy<>::discrete_quantile_type>::value));
 
    
 } // BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_policy_4.cpp b/test/test_policy_4.cpp
index 270756d95..a4839bda7 100644
--- a/test/test_policy_4.cpp
+++ b/test/test_policy_4.cpp
@@ -7,19 +7,19 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
@@ -28,17 +28,17 @@ BOOST_AUTO_TEST_CASE( test_main )
    using namespace boost::math::policies;
    using namespace boost;
 
-   BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::domain_error_type, domain_error<ignore_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> >::pole_error_type, pole_error<BOOST_MATH_POLE_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> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_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> >::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> >::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));
-   BOOST_CHECK((is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::discrete_quantile_type, discrete_quantile<integer_round_down> >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::domain_error_type, domain_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::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((std::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((std::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((std::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((std::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((std::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((std::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));
+   BOOST_CHECK((std::is_same<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::discrete_quantile_type, discrete_quantile<integer_round_down> >::value));
 
    
 } // BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_policy_5.cpp b/test/test_policy_5.cpp
index ed3ee17e0..7862d3a57 100644
--- a/test/test_policy_5.cpp
+++ b/test/test_policy_5.cpp
@@ -7,20 +7,20 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
@@ -29,17 +29,17 @@ BOOST_AUTO_TEST_CASE( test_main )
    using namespace boost::math::policies;
    using namespace boost;
 
-   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::domain_error_type, domain_error<ignore_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::pole_error_type, pole_error<BOOST_MATH_POLE_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::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_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::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::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));
-   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::discrete_quantile_type, discrete_quantile<integer_round_down> >::value));
+   BOOST_CHECK((std::is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::domain_error_type, domain_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::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((std::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((std::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((std::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((std::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((std::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((std::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));
+   BOOST_CHECK((std::is_same<normalise<policy<digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> > >::type::discrete_quantile_type, discrete_quantile<integer_round_down> >::value));
 
    
 } // BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_policy_6.cpp b/test/test_policy_6.cpp
index a5531d6b4..eaa0d2093 100644
--- a/test/test_policy_6.cpp
+++ b/test/test_policy_6.cpp
@@ -7,19 +7,19 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
@@ -28,17 +28,17 @@ BOOST_AUTO_TEST_CASE( test_main )
    using namespace boost::math::policies;
    using namespace boost;
 
-   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::domain_error_type, domain_error<ignore_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::pole_error_type, pole_error<BOOST_MATH_POLE_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::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_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::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::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));
-   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::discrete_quantile_type, discrete_quantile<integer_round_down> >::value));
+   BOOST_CHECK((std::is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::type::domain_error_type, domain_error<ignore_error> >::value));
+   BOOST_CHECK((std::is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error> >::type::pole_error_type, pole_error<BOOST_MATH_POLE_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::overflow_error_type, overflow_error<BOOST_MATH_OVERFLOW_ERROR_POLICY> >::value));
+   BOOST_CHECK((std::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((std::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((std::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((std::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((std::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((std::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((std::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));
+   BOOST_CHECK((std::is_same<normalise<policy<>, digits2<20>, promote_float<false>, discrete_quantile<integer_round_down>, denorm_error<throw_on_error>, domain_error<ignore_error>  >::type::discrete_quantile_type, discrete_quantile<integer_round_down> >::value));
 
    
 } // BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_policy_7.cpp b/test/test_policy_7.cpp
index 99792ceae..b8501cfe3 100644
--- a/test/test_policy_7.cpp
+++ b/test/test_policy_7.cpp
@@ -7,20 +7,20 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }
 
 
diff --git a/test/test_policy_8.cpp b/test/test_policy_8.cpp
index 96d5e4e3a..14a2897ad 100644
--- a/test/test_policy_8.cpp
+++ b/test/test_policy_8.cpp
@@ -7,19 +7,19 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/math/policies/policy.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <boost/test/unit_test.hpp> // for test_main
 #include <iostream>
+#include <type_traits>
 
 template <class P1, class P2>
 bool check_same(const P1&, const P2&)
 {
-   if(!boost::is_same<P1, P2>::value)
+   if(!std::is_same<P1, P2>::value)
    {
       std::cout << "P1 = " << typeid(P1).name() << std::endl;
       std::cout << "P2 = " << typeid(P2).name() << std::endl;
    }
-   return boost::is_same<P1, P2>::value;
+   return std::is_same<P1, P2>::value;
 }