Remove libc++ workaround

Author: mborland

include/boost/math/concepts/concepts.hpp

@@ -175,30 +175,18 @@ concept arbitrary_numerical_type = arbitrary_real_or_complex_type<T> ||
 template <typename T>
 concept policy = boost::math::policies::is_policy<T>::value;
 
-// Workaround for LIBCPP versions that have <concepts> but have not implemented concepts in <iterator>
-#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 13000
-
-template <typename T>
-concept forward_iterator = std::is_same_v<typename std::iterator_traits<T>::iterator_category(), std::forward_iterator_tag>;
-
-template <typename T>
-concept bidirectional_iterator = std::is_same_v<typename std::iterator_traits<T>::iterator_category(), std::bidirectional_iterator_tag>;
-
 template <typename T>
-concept random_access_iterator = std::is_same_v<typename std::iterator_traits<T>::iterator_category(), std::random_access_iterator_tag>;
-
-#else
+concept forward_iterator = std::derived_from<typename std::iterator_traits<T>::iterator_category, std::forward_iterator_tag>;
 
 template <typename T>
-concept forward_iterator = std::forward_iterator<T>;
+concept bidirectional_iterator = std::derived_from<typename std::iterator_traits<T>::iterator_category, std::bidirectional_iterator_tag>;
 
 template <typename T>
-concept bidirectional_iterator = std::bidirectional_iterator<T>;
+concept random_access_iterator = std::derived_from<typename std::iterator_traits<T>::iterator_category, std::random_access_iterator_tag>;
 
-template <typename T>
-concept random_access_iterator = std::random_access_iterator<T>;
-
-#endif
+template <typename I, typename T>
+concept output_iterator = std::derived_from<typename std::iterator_traits<I>::iterator_category, std::input_iterator_tag> &&
+                          std::derived_from<typename std::iterator_traits<T>::iterator_category, std::output_iterator_tag>;
 
 template <typename T>
 concept is_container = detail::has_begin_v<T> &&
@@ -230,25 +218,19 @@ concept random_access_container = is_container<T> &&
 #define BOOST_MATH_ARBITRARY_COMPLEX boost::math::concepts::arbitrary_complex_type
 #define BOOST_MATH_ARBITRARY_REAL_OR_COMPLEX boost::math::concepts::arbitrary_real_or_complex_type
 #define BOOST_MATH_ARBITRARY_NUMERICAL boost::math::concepts::arbitrary_numerical_type
+
 #define BOOST_MATH_POLICY boost::math::concepts::policy
+
 #define BOOST_MATH_CONTAINER boost::math::concepts::is_container
 #define BOOST_MATH_RANDOM_ACCESS_CONTAINER boost::math::concepts::random_access_container
-#define BOOST_MATH_REQUIRES(X, T) requires X<T>
-
-// Workaround for LIBCPP versions that have <concepts> but have not implemented concepts in <iterator>
-#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 13000
 
 #define BOOST_MATH_FORWARD_ITER boost::math::concepts::forward_iterator
 #define BOOST_MATH_BIDIRECTIONAL_ITER boost::math::concepts::bidirectional_iterator
 #define BOOST_MATH_RANDOM_ACCESS_ITER boost::math::concepts::random_access_iterator
+#define BOOST_MATH_OUTPUT_ITER(I, T) boost::math::concepts::output_iterator<I, T>
+#define BOOST_MATH_REQUIRES_ITER(X) requires X
 
-#else
-
-#define BOOST_MATH_FORWARD_ITER std::forward_iterator
-#define BOOST_MATH_BIDIRECTIONAL_ITER std::bidirectional_iterator
-#define BOOST_MATH_RANDOM_ACCESS_ITER std::random_access_iterator
-
-#endif // Workaround for LIBCPP
+#define BOOST_MATH_REQUIRES(X, T) requires X<T>
 
 #ifdef BOOST_MATH_EXEC_COMPATIBLE
 #include <execution>
@@ -365,6 +347,14 @@ concept execution_policy = std::is_execution_policy_v<std::remove_cvref_t<T>>;
 #  define BOOST_MATH_RANDOM_ACCESS_ITER typename
 #endif
 
+#ifndef BOOST_MATH_OUTPUT_ITER
+#  define BOOST_MATH_OUTPUT_ITER(I, T)
+#endif
+
+#ifndef BOOST_MATH_REQUIRES_ITER
+#  define BOOST_MATH_REQUIRES_ITER(X)
+#endif
+
 #ifndef BOOST_MATH_CONTAINER
 #  define BOOST_MATH_CONTAINER typename
 #endif

include/boost/math/statistics/univariate_statistics.hpp

@@ -598,6 +598,7 @@ inline auto interquartile_range(RandomAccessContainer & v)
 }
 
 template<BOOST_MATH_EXECUTION_POLICY ExecutionPolicy, BOOST_MATH_FORWARD_ITER ForwardIterator, class OutputIterator>
+    BOOST_MATH_REQUIRES_ITER(BOOST_MATH_OUTPUT_ITER(ForwardIterator, OutputIterator))
 inline OutputIterator mode(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, OutputIterator output)
 {
     if(!std::is_sorted(exec, first, last))
@@ -616,12 +617,14 @@ inline OutputIterator mode(ExecutionPolicy&& exec, ForwardIterator first, Forwar
 }
 
 template<BOOST_MATH_EXECUTION_POLICY ExecutionPolicy, BOOST_MATH_CONTAINER Container, class OutputIterator>
+    BOOST_MATH_REQUIRES_ITER(BOOST_MATH_OUTPUT_ITER(typename Container::iterator, OutputIterator))
 inline OutputIterator mode(ExecutionPolicy&& exec, Container & v, OutputIterator output)
 {
     return mode(exec, std::begin(v), std::end(v), output);
 }
 
 template<BOOST_MATH_FORWARD_ITER ForwardIterator, class OutputIterator>
+    BOOST_MATH_REQUIRES_ITER(BOOST_MATH_OUTPUT_ITER(ForwardIterator, OutputIterator))
 inline OutputIterator mode(ForwardIterator first, ForwardIterator last, OutputIterator output)
 {
     return mode(std::execution::seq, first, last, output);
@@ -636,6 +639,7 @@ template<BOOST_MATH_CONTAINER Container, class OutputIterator, std::enable_if_t<
                                                                  && !std::is_convertible_v<std::execution::unsequenced_policy, Container>
                                                                  #endif
                                                                  , bool> = true>
+    BOOST_MATH_REQUIRES_ITER(BOOST_MATH_OUTPUT_ITER(typename Container::iterator, OutputIterator))
 inline OutputIterator mode(Container & v, OutputIterator output)
 {
     return mode(std::execution::seq, std::begin(v), std::end(v), output);