fix recursion depth: is_heap, is_heap_until

libs/algorithm/test/is_heap.cpp

@@ -0,0 +1,85 @@
+#ifndef SPROUT_LIBS_ALGORITHM_TEST_IS_HEAP_CPP
+#define SPROUT_LIBS_ALGORITHM_TEST_IS_HEAP_CPP
+
+#include <sprout/algorithm/is_heap.hpp>
+#include <sprout/array.hpp>
+#include <sprout/container.hpp>
+#include <testspr/tools.hpp>
+
+namespace testspr {
+	static void algorithm_is_heap_test() {
+		using namespace sprout;
+		{
+			SPROUT_STATIC_CONSTEXPR auto arr1 = array<int, 10>{{10, 9, 8, 6, 7, 2, 5, 3, 4, 1}};
+			SPROUT_STATIC_CONSTEXPR auto arr2 = array<int, 10>{{10, 9, 8, 6, 7, 2, 5, 13, 14, 11}};
+
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr1),
+					sprout::end(arr1)
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr2),
+					sprout::end(arr2)
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr2),
+					sprout::begin(arr2) + 5
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr2),
+					sprout::end(arr2),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(!result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(result);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
+					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_is_heap_test
+#	include <testspr/include_main.hpp>
+#endif
+
+#endif	// #ifndef SPROUT_LIBS_ALGORITHM_TEST_IS_HEAP_CPP

libs/algorithm/test/is_heap_until.cpp

@@ -0,0 +1,85 @@
+#ifndef SPROUT_LIBS_ALGORITHM_TEST_IS_HEAP_UNTIL_CPP
+#define SPROUT_LIBS_ALGORITHM_TEST_IS_HEAP_UNTIL_CPP
+
+#include <sprout/algorithm/is_heap_until.hpp>
+#include <sprout/array.hpp>
+#include <sprout/container.hpp>
+#include <testspr/tools.hpp>
+
+namespace testspr {
+	static void algorithm_is_heap_until_test() {
+		using namespace sprout;
+		{
+			SPROUT_STATIC_CONSTEXPR auto arr1 = array<int, 10>{{10, 9, 8, 6, 7, 2, 5, 3, 4, 1}};
+			SPROUT_STATIC_CONSTEXPR auto arr2 = array<int, 10>{{10, 9, 8, 6, 7, 2, 5, 13, 14, 11}};
+
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr1),
+					sprout::end(arr1)
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr2),
+					sprout::end(arr2)
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr2),
+					sprout::begin(arr2) + 5
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 5);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr1),
+					sprout::end(arr1),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr2),
+					sprout::end(arr2),
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 7);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr1),
+					sprout::begin(arr1) + 5,
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
+					sprout::begin(arr2),
+					sprout::begin(arr2) + 5,
+					testspr::less<int>()
+					);
+				TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 5);
+			}
+		}
+	}
+}	// namespace testspr
+
+#ifndef TESTSPR_CPP_INCLUDE
+#	define TESTSPR_TEST_FUNCTION testspr::algorithm_is_heap_until_test
+#	include <testspr/include_main.hpp>
+#endif
+
+#endif	// #ifndef SPROUT_LIBS_ALGORITHM_TEST_IS_HEAP_UNTIL_CPP

libs/algorithm/test/non_modifying.cpp

@@ -32,6 +32,8 @@
 #include "./equal_range.cpp"
 #include "./binary_search.cpp"
 #include "./includes.cpp"
+#include "./is_heap.cpp"
+#include "./is_heap_until.cpp"
 
 #ifdef TESTSPR_CPP_INCLUDE_DISABLE_SPROUT_LIBS_ALGORITHM_TEST_NON_MODIFYIING_CPP
 #	undef TESTSPR_CPP_INCLUDE
@@ -65,6 +67,8 @@ namespace testspr {
 		testspr::algorithm_equal_range_test();
 		testspr::algorithm_binary_search_test();
 		testspr::algorithm_includes_test();
+		testspr::algorithm_is_heap_test();
+		testspr::algorithm_is_heap_until_test();
 	}
 }	// namespace testspr
 

sprout/algorithm/is_heap.hpp

@@ -1,24 +1,33 @@
 #ifndef SPROUT_ALGORITHM_IS_HEAP_HPP
 #define SPROUT_ALGORITHM_IS_HEAP_HPP
 
+#include <iterator>
 #include <sprout/config.hpp>
 #include <sprout/algorithm/is_heap_until.hpp>
+#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
 
 namespace sprout {
 	// Copyright (C) 2011 RiSK (sscrisk)
 
 	// 25.4.6.5 is_heap
-	template<typename RandomAccessIterator>
+	//
-	inline SPROUT_CONSTEXPR bool
+	//	recursion depth:
-	is_heap(RandomAccessIterator first, RandomAccessIterator last) {
+	//		O(log N)
-		return sprout::is_heap_until(first, last) == last;
+	//
-	}
-
 	template<typename RandomAccessIterator, typename Compare>
 	inline SPROUT_CONSTEXPR bool
 	is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp) {
 		return sprout::is_heap_until(first, last, comp) == last;
 	}
+
+	template<typename RandomAccessIterator>
+	inline SPROUT_CONSTEXPR bool
+	is_heap(RandomAccessIterator first, RandomAccessIterator last) {
+		return sprout::is_heap(
+			first, last,
+			NS_SSCRISK_CEL_OR_SPROUT::less<typename std::iterator_traits<RandomAccessIterator>::value_type>()
+			);
+	}
 }	// namespace sprout
 
 #endif	// #ifndef SPROUT_ALGORITHM_IS_HEAP_HPP

sprout/algorithm/is_heap_until.hpp

@@ -1,42 +1,70 @@
 #ifndef SPROUT_ALGORITHM_IS_HEAP_UNTIL_HPP
 #define SPROUT_ALGORITHM_IS_HEAP_UNTIL_HPP
 
-#include <cstddef>
+#include <iterator>
 #include <sprout/config.hpp>
 #include <sprout/iterator/operation.hpp>
 #include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT
 #include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
 
 namespace sprout {
-	// Copyright (C) 2011 RiSK (sscrisk)
-
 	namespace detail {
+		template<typename RandomAccessIterator, typename Compare>
+		inline SPROUT_CONSTEXPR typename std::iterator_traits<RandomAccessIterator>::difference_type
+		is_heap_until_impl(
+			RandomAccessIterator it, Compare comp,
+			typename std::iterator_traits<RandomAccessIterator>::difference_type first, typename std::iterator_traits<RandomAccessIterator>::difference_type last,
+			typename std::iterator_traits<RandomAccessIterator>::difference_type pivot, typename std::iterator_traits<RandomAccessIterator>::difference_type found
+			)
+		{
+			return found != first ? found
+				: pivot == 0 ? (!comp(it[first], it[(first - 1) / 2]) ? first : last)
+				: sprout::detail::is_heap_until_impl(
+					it, comp, first + pivot, last,
+					((last - first) - pivot) / 2,
+					sprout::detail::is_heap_until_impl(
+						it, comp, first, first + pivot,
+						pivot / 2,
+						first
+						)
+					)
+				;
+		}
+
 		template<typename RandomAccessIterator, typename Compare>
 		inline SPROUT_CONSTEXPR RandomAccessIterator
 		is_heap_until_impl(
 			RandomAccessIterator first, RandomAccessIterator last, Compare comp,
-			std::size_t n
+			typename std::iterator_traits<RandomAccessIterator>::difference_type size
 			)
 		{
-			return sprout::next(first, n) == last || !comp(first[n], first[(n - 1) / 2]) ? sprout::next(first, n)
+			return size < 2 ? last
-				: sprout::detail::is_heap_until_impl(first, last, comp, n + 1)
+				: sprout::next(first, sprout::detail::is_heap_until_impl(first, comp, 1, size, (size - 1) / 2, 1))
 				;
 		}
 	}	// namespace detail
 
 	// 25.4.6.5 is_heap
-	template<typename RandomAccessIterator>
+	//
-	inline SPROUT_CONSTEXPR RandomAccessIterator
+	//	recursion depth:
-	is_heap_until(RandomAccessIterator first, RandomAccessIterator last) {
+	//		O(log N)
-		return sprout::is_heap_until(first, last, NS_SSCRISK_CEL_OR_SPROUT::less<decltype(*first)>());
+	//
-	}
-
 	template<typename RandomAccessIterator, typename Compare>
 	inline SPROUT_CONSTEXPR RandomAccessIterator
 	is_heap_until(RandomAccessIterator first, RandomAccessIterator last, Compare comp) {
-		return NS_SSCRISK_CEL_OR_SPROUT::distance(first, last) < 2 ? last
+		return sprout::detail::is_heap_until_impl(
-			: sprout::detail::is_heap_until_impl(first, last, comp, 1)
+			first, last, comp,
-			;
+			NS_SSCRISK_CEL_OR_SPROUT::distance(first, last)
+			);
+	}
+
+	template<typename RandomAccessIterator>
+	inline SPROUT_CONSTEXPR RandomAccessIterator
+	is_heap_until(RandomAccessIterator first, RandomAccessIterator last) {
+		return sprout::is_heap_until(
+			first, last,
+			NS_SSCRISK_CEL_OR_SPROUT::less<typename std::iterator_traits<RandomAccessIterator>::value_type>()
+			);
 	}
 }	// namespace sprout