fix recursion depth: lexicographical_compare

libs/algorithm/test/lexicographical_compare.cpp

@@ -0,0 +1,160 @@
+#ifndef SPROUT_LIBS_ALGORITHM_TEST_LEXICOGRAPHICAL_COMPARE_CPP
+#define SPROUT_LIBS_ALGORITHM_TEST_LEXICOGRAPHICAL_COMPARE_CPP
+
+#include <sprout/algorithm/lexicographical_compare.hpp>
+#include <sprout/array.hpp>
+#include <sprout/container.hpp>
+#include <testspr/tools.hpp>
+
+namespace testspr {
+	static void algorithm_lexicographical_compare_test() {
+		using namespace sprout;
+		{
+			SPROUT_STATIC_CONSTEXPR auto arr1 = array<int, 10>{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}};
+			SPROUT_STATIC_CONSTEXPR auto arr2 = array<int, 10>{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}};
+			SPROUT_STATIC_CONSTEXPR auto arr3 = array<int, 10>{{1, 2, 3, 4, 5, 6, 7, 1, 2, 3}};
+			SPROUT_STATIC_CONSTEXPR auto arr4 = array<int, 10>{{1, 2, 3, 4, 5, 6, 7, 11, 12, 13}};
+
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr2),
+					sprout::end(arr2)
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr3),
+					sprout::end(arr3)
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr4),
+					sprout::end(arr4)
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					sprout::begin(arr2),
+					sprout::end(arr2)
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					sprout::begin(arr3),
+					sprout::end(arr3)
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					sprout::begin(arr4),
+					sprout::end(arr4)
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr2),
+					sprout::begin(arr2) + 5
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr2),
+					sprout::end(arr2),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr3),
+					sprout::end(arr3),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr4),
+					sprout::end(arr4),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					sprout::begin(arr2),
+					sprout::end(arr2),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					sprout::begin(arr3),
+					sprout::end(arr3),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					sprout::begin(arr4),
+					sprout::end(arr4),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					sprout::begin(arr2),
+					sprout::begin(arr2) + 5,
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+		}
+	}
+}	// namespace testspr
+
+#ifndef TESTSPR_CPP_INCLUDE
+#	define TESTSPR_TEST_FUNCTION testspr::algorithm_lexicographical_compare_test
+#	include <testspr/include_main.hpp>
+#endif
+
+#endif	// #ifndef SPROUT_LIBS_ALGORITHM_TEST_LEXICOGRAPHICAL_COMPARE_CPP

libs/algorithm/test/non_modifying.cpp

@@ -40,6 +40,7 @@
 #include "./min_element.cpp"
 #include "./max_element.cpp"
 #include "./minmax_element.cpp"
+#include "./lexicographical_compare.cpp"
 
 #ifdef TESTSPR_CPP_INCLUDE_DISABLE_SPROUT_LIBS_ALGORITHM_TEST_NON_MODIFYIING_CPP
 #	undef TESTSPR_CPP_INCLUDE
@@ -81,6 +82,7 @@ namespace testspr {
 		testspr::algorithm_min_element_test();
 		testspr::algorithm_max_element_test();
 		testspr::algorithm_minmax_element_test();
+		testspr::algorithm_lexicographical_compare_test();
 	}
 }	// namespace testspr
 

sprout/algorithm/find_end.hpp

@@ -107,6 +107,13 @@ namespace sprout {
 	}	// namespace detail
 
 	// 25.2.6 Find end
+	//
+	//	recursion depth:
+	//		[first1, last1) is RandomAccessIterator -> O(log N1)
+	//		otherwise -> O(N1)
+	//		[first2, last2) is RandomAccessIterator -> O(log N2)
+	//		otherwise -> O(N2)
+	//
 	template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
 	inline SPROUT_CONSTEXPR ForwardIterator1
 	find_end(

sprout/algorithm/lexicographical_compare.hpp

@@ -3,12 +3,104 @@
 
 #include <sprout/config.hpp>
 #include <sprout/iterator/operation.hpp>
-#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
+#include <sprout/utility/pair.hpp>
+#include <sprout/algorithm/min.hpp>
+#include <sprout/functional/less.hpp>
+#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT
 
 namespace sprout {
-	// Copyright (C) 2011 RiSK (sscrisk)
+	namespace detail {
+		template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+		inline SPROUT_CONSTEXPR bool
+		lexicographical_compare_impl_ra_2(
+			RandomAccessIterator1 last1, RandomAccessIterator2 last2, Compare comp,
+			sprout::pair<RandomAccessIterator1, RandomAccessIterator2> const& found
+			)
+		{
+			return found.second == last2 ? false
+				: found.first == last1 || comp(*found.first, *found.second)
+				;
+		}
+		template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+		inline SPROUT_CONSTEXPR sprout::pair<RandomAccessIterator1, RandomAccessIterator2>
+		lexicographical_compare_impl_ra_1(
+			RandomAccessIterator1 first1, RandomAccessIterator1 last1, RandomAccessIterator2 first2, RandomAccessIterator2 last2, Compare comp,
+			typename std::iterator_traits<RandomAccessIterator1>::difference_type pivot, sprout::pair<RandomAccessIterator1, RandomAccessIterator2> const& found
+			)
+		{
+			typedef sprout::pair<RandomAccessIterator1, RandomAccessIterator2> found_type;
+			return found.first != first1 ? found
+				: pivot == 0 ? (comp(*first1, *first2) || comp(*first2, *first1) ? found_type(first1, first2) : found_type(last1, last2))
+				: sprout::detail::lexicographical_compare_impl_ra_1(
+					sprout::next(first1, pivot), last1, sprout::next(first2, pivot), last2, comp,
+					(NS_SSCRISK_CEL_OR_SPROUT::distance(first1, last1) - pivot) / 2,
+					sprout::detail::lexicographical_compare_impl_ra_1(
+						first1, sprout::next(first1, pivot), first2, sprout::next(first2, pivot), comp,
+						pivot / 2,
+						found_type(first1, first2)
+						)
+					)
+				;
+		}
+		template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+		inline SPROUT_CONSTEXPR bool
+		lexicographical_compare_impl_ra(
+			RandomAccessIterator1 first1, RandomAccessIterator1 last1, RandomAccessIterator2 first2, RandomAccessIterator2 last2, Compare comp,
+			typename std::iterator_traits<RandomAccessIterator1>::difference_type size
+			)
+		{
+			typedef sprout::pair<RandomAccessIterator1, RandomAccessIterator2> found_type;
+			return sprout::detail::lexicographical_compare_impl_ra_2(
+				last1, last2, comp,
+				sprout::detail::lexicographical_compare_impl_ra_1(
+					first1, sprout::next(first1, size), first2, sprout::next(first2, size), comp,
+					size / 2, found_type(first1, first2)
+					)
+				);
+		}
+		template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+		inline SPROUT_CONSTEXPR bool
+		lexicographical_compare(
+			RandomAccessIterator1 first1, RandomAccessIterator1 last1, RandomAccessIterator2 first2, RandomAccessIterator2 last2, Compare comp,
+			std::random_access_iterator_tag*
+			)
+		{
+			return first2 == last2 ? false
+				: first1 == last1 ? true
+				: sprout::detail::lexicographical_compare_impl_ra(
+					first1, last1, first2, last2, comp,
+					sprout::min(NS_SSCRISK_CEL_OR_SPROUT::distance(first1, last1), NS_SSCRISK_CEL_OR_SPROUT::distance(first2, last2))
+					)
+				;
+		}
+
+		// Copyright (C) 2011 RiSK (sscrisk)
+		template<typename InputIterator1, typename InputIterator2, typename Compare>
+		inline SPROUT_CONSTEXPR bool
+		lexicographical_compare_impl(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp) {
+			return first2 == last2 ? false
+				: first1 == last1 || comp(*first1, *first2) ? true
+				: comp(*first2, *first1) ? false
+				: sprout::detail::lexicographical_compare_impl(sprout::next(first1), last1, sprout::next(first2), last2, comp)
+				;
+		}
+		template<typename InputIterator1, typename InputIterator2, typename Compare>
+		inline SPROUT_CONSTEXPR bool
+		lexicographical_compare(
+			InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp,
+			void*
+			)
+		{
+			return sprout::detail::lexicographical_compare_impl(first1, last1, first2, last2, comp);
+		}
+	}	//namespace detail
 
 	// 25.4.8 Lexicographical comparison
+	//
+	//	recursion depth:
+	//		[first1, last1), [first2, last2) are RandomAccessIterator -> O(log N)
+	//		otherwise -> O(N)
+	//
 	template<typename InputIterator1, typename InputIterator2, typename Compare>
 	inline SPROUT_CONSTEXPR bool
 	lexicographical_compare(
@@ -17,11 +109,8 @@ namespace sprout {
 		Compare comp
 		)
 	{
-		return first2 == last2 ? false
+		typedef typename sprout::common_iterator_category<InputIterator1, InputIterator2>::type* category;
-			: first1 == last1 || comp(*first1, *first2) ? true
+		return sprout::detail::lexicographical_compare(first1, last1, first2, last2, comp, category());
-			: comp(*first2, *first1) ? false
-			: sprout::lexicographical_compare(sprout::next(first1), last1, sprout::next(first2), last2, comp)
-			;
 	}
 
 	template<typename InputIterator1, typename InputIterator2>
@@ -33,7 +122,7 @@ namespace sprout {
 	{
 		return sprout::lexicographical_compare(
 			first1, last1, first2, last2,
-			NS_SSCRISK_CEL_OR_SPROUT::less<decltype(*first1 + *first2)>()
+			sprout::less<>()
 			);
 	}
 }	// namespace sprout