Index: boost_1_81_0/boost/math/policies/error_handling.hpp
===================================================================
--- boost_1_81_0.orig/boost/math/policies/error_handling.hpp
+++ boost_1_81_0/boost/math/policies/error_handling.hpp
@@ -9,7 +9,7 @@
 #define BOOST_MATH_POLICY_ERROR_HANDLING_HPP
 
 #include <boost/math/tools/config.hpp>
-#include <iomanip>
+//#include <iomanip>
 #include <string>
 #include <cstring>
 #ifndef BOOST_NO_RTTI
@@ -36,7 +36,7 @@
 // Note that this only occurs when the compiler can deduce code is unreachable,
 // for example when policy macros are used to ignore errors rather than throw.
 #endif
-#include <sstream>
+//#include <sstream>
 
 namespace boost{ namespace math{
 
@@ -81,6 +81,7 @@ T user_indeterminate_result_error(const
 namespace detail
 {
 
+#if 0
 template <class T>
 std::string prec_format(const T& val)
 {
@@ -94,6 +95,7 @@ std::string prec_format(const T& val)
    ss << val;
    return ss.str();
 }
+#endif
 
 inline void replace_all_in_string(std::string& result, const char* what, const char* with)
 {
@@ -155,6 +157,7 @@ void raise_error(const char* pfunction,
   BOOST_MATH_THROW_EXCEPTION(E(msg))
 }
 
+#if 0
 template <class E, class T>
 void raise_error(const char* pfunction, const char* pmessage, const T& val)
 {
@@ -213,6 +216,7 @@ inline constexpr T raise_domain_error(
    // to be ignored so here we go anyway:
    return std::numeric_limits<T>::quiet_NaN();
 }
+#endif
 
 template <class T>
 inline T raise_domain_error(
@@ -237,6 +241,7 @@ inline T raise_domain_error(
    return user_domain_error(function, message, val);
 }
 
+#if 0
 template <class T>
 inline T raise_pole_error(
            const char* function,
@@ -250,6 +255,7 @@ inline T raise_pole_error(
    return boost::math::policies::detail::raise_domain_error(function, message, val,  ::boost::math::policies::domain_error< ::boost::math::policies::throw_on_error>());
 #endif
 }
+#endif
 
 template <class T>
 inline constexpr T raise_pole_error(
@@ -281,6 +287,7 @@ inline T raise_pole_error(
    return user_pole_error(function, message, val);
 }
 
+#if 0
 template <class T>
 inline T raise_overflow_error(
            const char* function,
@@ -322,6 +329,7 @@ inline constexpr T raise_overflow_error(
    // to be ignored so here we go anyway:
    return std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : boost::math::tools::max_value<T>();
 }
+#endif
 
 template <class T>
 inline constexpr T raise_overflow_error(
@@ -383,6 +391,7 @@ inline T raise_overflow_error(
    return user_overflow_error(function, m.c_str(), std::numeric_limits<T>::infinity());
 }
 
+#if 0
 template <class T>
 inline T raise_underflow_error(
            const char* function,
@@ -397,6 +406,7 @@ inline T raise_underflow_error(
    return 0;
 #endif
 }
+#endif
 
 template <class T>
 inline constexpr T raise_underflow_error(
@@ -430,6 +440,7 @@ inline T raise_underflow_error(
    return user_underflow_error(function, message, T(0));
 }
 
+#if 0
 template <class T>
 inline T raise_denorm_error(
            const char* function,
@@ -445,6 +456,7 @@ inline T raise_denorm_error(
    return T(0);
 #endif
 }
+#endif
 
 template <class T>
 inline constexpr T raise_denorm_error(
@@ -481,6 +493,7 @@ inline T raise_denorm_error(
    return user_denorm_error(function, message, val);
 }
 
+#if 0
 template <class T>
 inline T raise_evaluation_error(
            const char* function,
@@ -496,6 +509,7 @@ inline T raise_evaluation_error(
    return T(0);
 #endif
 }
+#endif
 
 template <class T>
 inline constexpr T raise_evaluation_error(
@@ -532,6 +546,7 @@ inline T raise_evaluation_error(
    return user_evaluation_error(function, message, val);
 }
 
+#if 0
 template <class T, class TargetType>
 inline TargetType raise_rounding_error(
            const char* function,
@@ -548,6 +563,7 @@ inline TargetType raise_rounding_error(
    return TargetType(0);
 #endif
 }
+#endif
 
 template <class T, class TargetType>
 inline constexpr TargetType raise_rounding_error(
@@ -588,6 +604,7 @@ inline TargetType raise_rounding_error(
    return user_rounding_error(function, message, val, t);
 }
 
+#if 0
 template <class T, class R>
 inline T raise_indeterminate_result_error(
            const char* function,
@@ -604,6 +621,7 @@ inline T raise_indeterminate_result_erro
    return std::numeric_limits<T>::quiet_NaN();
 #endif
 }
+#endif
 
 template <class T, class R>
 inline constexpr T raise_indeterminate_result_error(
