minor additions to api docs for partial_sort and partial_sort_copy

docs/sphinx/api/public_api.rst

@@ -78,6 +78,7 @@ Functions
 - :cpp:func:`hpx::none_of`
 - :cpp:func:`hpx::nth_element`
 - :cpp:func:`hpx::partial_sort`
+- :cpp:func:`hpx::partial_sort_copy`
 - :cpp:func:`hpx::partition`
 - :cpp:func:`hpx::partition_copy`
 - :cpp:func:`hpx::remove`
@@ -146,6 +147,8 @@ Functions
 - :cpp:func:`hpx::ranges::move`
 - :cpp:func:`hpx::ranges::none_of`
 - :cpp:func:`hpx::ranges::nth_element`
+- :cpp:func:`hpx::ranges::partial_sort`
+- :cpp:func:`hpx::ranges::partial_sort_copy`
 - :cpp:func:`hpx::ranges::partition`
 - :cpp:func:`hpx::ranges::partition_copy`
 - :cpp:func:`hpx::ranges::set_difference`

docs/sphinx/manual/writing_single_node_hpx_applications.rst

@@ -665,6 +665,10 @@ Parallel algorithms
      * Sorts the first elements in a range.
      * ``<hpx/algorithm.hpp>``
      * :cppreference-algorithm:`partial_sort`
+   * * :cpp:func:`hpx::partial_sort_copy`
+       * Sorts the first elements in a range, storing the result in another range.
+       * ``<hpx/algorithm.hpp>``
+       * :cppreference-algorithm:`partial_sort_copy`
    * * :cpp:func:`hpx::parallel::v1::sort_by_key`
      * Sorts one range of data using keys supplied in another range.
      * ``<hpx/algorithm.hpp>``

libs/core/algorithms/include/hpx/parallel/algorithms/partial_sort.hpp

@@ -1,5 +1,5 @@
 //  Copyright (c) 2020 Francisco Jose Tapia
-//  Copyright (c) 2020 Akhil J Nair
+//  Copyright (c) 2021 Akhil J Nair
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -115,6 +115,7 @@ namespace hpx {
 #include <hpx/executors/exception_list.hpp>
 #include <hpx/executors/execution_policy.hpp>
 #include <hpx/parallel/algorithms/detail/dispatch.hpp>
+#include <hpx/parallel/algorithms/detail/distance.hpp>
 #include <hpx/parallel/algorithms/detail/is_sorted.hpp>
 #include <hpx/parallel/algorithms/sort.hpp>
 #include <hpx/parallel/util/compare_projected.hpp>
@@ -432,7 +433,7 @@ namespace hpx { namespace parallel { inline namespace v1 {
     template <typename Iter, typename Sent, typename Comp>
     Iter sequential_partial_sort(Iter first, Iter middle, Sent end, Comp&& comp)
     {
-        std::int64_t nelem = detail::distance(first, end);
+        std::int64_t nelem = parallel::v1::detail::distance(first, end);
         HPX_ASSERT(nelem >= 0);
 
         std::int64_t nmid = middle - first;
@@ -467,7 +468,7 @@ namespace hpx { namespace parallel { inline namespace v1 {
     hpx::future<Iter> parallel_partial_sort(
         ExPolicy&& policy, Iter first, Iter middle, Sent end, Comp&& comp)
     {
-        std::int64_t nelem = detail::distance(first, end);
+        std::int64_t nelem = parallel::v1::detail::distance(first, end);
         HPX_ASSERT(nelem >= 0);
 
         std::int64_t nmid = middle - first;

libs/core/algorithms/include/hpx/parallel/algorithms/partial_sort_copy.hpp

@@ -5,6 +5,8 @@
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+/// \file parallel/algorithms/partial_sort_copy.hpp
+
 #pragma once
 
 #if defined(DOXYGEN)
@@ -344,12 +346,12 @@ namespace hpx {
                 hpx::traits::is_iterator_v<InIter> &&
                 hpx::traits::is_iterator_v<RandIter> &&
                 hpx::is_invocable_v<Comp,
-                    typename std::iterator_traits<RandIter>::value_type,
-                    typename std::iterator_traits<RandIter>::value_type
+                    typename std::iterator_traits<InIter>::value_type,
+                    typename std::iterator_traits<InIter>::value_type
                 >
             )>
         // clang-format on
-        friend RandIter tag_fallback_dispatch(hpx::partial_sort_copy_t,
+        friend RandIter tag_fallback_invoke(hpx::partial_sort_copy_t,
             InIter first, InIter last, RandIter d_first, RandIter d_last,
             Comp&& comp = Comp())
         {
@@ -378,13 +380,13 @@ namespace hpx {
                 hpx::traits::is_iterator_v<FwdIter> &&
                 hpx::traits::is_iterator_v<RandIter> &&
                 hpx::is_invocable_v<Comp,
-                    typename std::iterator_traits<RandIter>::value_type,
-                    typename std::iterator_traits<RandIter>::value_type
+                    typename std::iterator_traits<FwdIter>::value_type,
+                    typename std::iterator_traits<FwdIter>::value_type
                 >
             )>
         // clang-format on
         friend parallel::util::detail::algorithm_result_t<ExPolicy, RandIter>
-        tag_fallback_dispatch(hpx::partial_sort_copy_t, ExPolicy&& policy,
+        tag_fallback_invoke(hpx::partial_sort_copy_t, ExPolicy&& policy,
             FwdIter first, FwdIter last, RandIter d_first, RandIter d_last,
             Comp&& comp = Comp())
         {

libs/core/algorithms/include/hpx/parallel/container_algorithms/partial_sort.hpp

@@ -294,7 +294,7 @@ namespace hpx { namespace ranges {
                 >
             )>
         // clang-format on
-        friend RandomIt tag_fallback_dispatch(hpx::ranges::partial_sort_t,
+        friend RandomIt tag_fallback_invoke(hpx::ranges::partial_sort_t,
             RandomIt first, RandomIt middle, Sent last, Comp&& comp = Comp(),
             Proj&& proj = Proj())
         {
@@ -323,7 +323,7 @@ namespace hpx { namespace ranges {
         // clang-format on
         friend typename parallel::util::detail::algorithm_result<ExPolicy,
             RandomIt>::type
-        tag_fallback_dispatch(hpx::ranges::partial_sort_t, ExPolicy&& policy,
+        tag_fallback_invoke(hpx::ranges::partial_sort_t, ExPolicy&& policy,
             RandomIt first, RandomIt middle, Sent last, Comp&& comp = Comp(),
             Proj&& proj = Proj())
         {
@@ -349,7 +349,7 @@ namespace hpx { namespace ranges {
                 >
             )>
         // clang-format on
-        friend hpx::traits::range_iterator_t<Rng> tag_fallback_dispatch(
+        friend hpx::traits::range_iterator_t<Rng> tag_fallback_invoke(
             hpx::ranges::partial_sort_t, Rng&& rng,
             hpx::traits::range_iterator_t<Rng> middle,
             Compare&& comp = Compare(), Proj&& proj = Proj())
@@ -382,7 +382,7 @@ namespace hpx { namespace ranges {
         // clang-format on
         friend parallel::util::detail::algorithm_result_t<ExPolicy,
             hpx::traits::range_iterator_t<Rng>>
-        tag_fallback_dispatch(hpx::ranges::partial_sort_t, ExPolicy&& policy,
+        tag_fallback_invoke(hpx::ranges::partial_sort_t, ExPolicy&& policy,
             Rng&& rng, hpx::traits::range_iterator_t<Rng> middle,
             Compare&& comp = Compare(), Proj&& proj = Proj())
         {

libs/core/algorithms/include/hpx/parallel/container_algorithms/partial_sort_copy.hpp

@@ -360,12 +360,12 @@ namespace hpx { namespace ranges {
                 parallel::traits::is_projected_v<Proj2, RandIter> &&
                 parallel::traits::is_indirect_callable_v<
                     hpx::execution::sequenced_policy, Comp,
-                    parallel::traits::projected<Proj2, RandIter>,
-                    parallel::traits::projected<Proj2, RandIter>
+                    parallel::traits::projected<Proj1, InIter>,
+                    parallel::traits::projected<Proj1, InIter>
                 >
             )>
         // clang-format on
-        friend partial_sort_copy_result<InIter, RandIter> tag_fallback_dispatch(
+        friend partial_sort_copy_result<InIter, RandIter> tag_fallback_invoke(
             hpx::ranges::partial_sort_copy_t, InIter first, Sent1 last,
             RandIter r_first, Sent2 r_last, Comp&& comp = Comp(),
             Proj1&& proj1 = Proj1(), Proj2&& proj2 = Proj2())
@@ -400,16 +400,16 @@ namespace hpx { namespace ranges {
                 parallel::traits::is_projected_v<Proj2, RandIter> &&
                 parallel::traits::is_indirect_callable_v<
                     ExPolicy, Comp,
-                    parallel::traits::projected<Proj2, RandIter>,
-                    parallel::traits::projected<Proj2, RandIter>
+                    parallel::traits::projected<Proj1, FwdIter>,
+                    parallel::traits::projected<Proj1, FwdIter>
                 >
             )>
         // clang-format on
         friend typename parallel::util::detail::algorithm_result_t<ExPolicy,
             partial_sort_copy_result<FwdIter, RandIter>>
-        tag_fallback_dispatch(hpx::ranges::partial_sort_copy_t,
-            ExPolicy&& policy, FwdIter first, Sent1 last, RandIter r_first,
-            Sent2 r_last, Comp&& comp = Comp(), Proj1&& proj1 = Proj1(),
+        tag_fallback_invoke(hpx::ranges::partial_sort_copy_t, ExPolicy&& policy,
+            FwdIter first, Sent1 last, RandIter r_first, Sent2 r_last,
+            Comp&& comp = Comp(), Proj1&& proj1 = Proj1(),
             Proj2&& proj2 = Proj2())
         {
             static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
@@ -439,13 +439,13 @@ namespace hpx { namespace ranges {
                 parallel::traits::is_indirect_callable_v<
                     hpx::execution::sequenced_policy, Compare,
                     parallel::traits::projected_range<Proj1, Rng1>,
-                    parallel::traits::projected_range<Proj2, Rng2>
+                    parallel::traits::projected_range<Proj1, Rng1>
                 >
             )>
         // clang-format on
         friend partial_sort_copy_result<hpx::traits::range_iterator_t<Rng1>,
             hpx::traits::range_iterator_t<Rng2>>
-        tag_fallback_dispatch(hpx::ranges::partial_sort_copy_t, Rng1&& rng1,
+        tag_fallback_invoke(hpx::ranges::partial_sort_copy_t, Rng1&& rng1,
             Rng2&& rng2, Compare&& comp = Compare(), Proj1&& proj1 = Proj1(),
             Proj2&& proj2 = Proj2())
         {
@@ -482,17 +482,16 @@ namespace hpx { namespace ranges {
                 parallel::traits::is_indirect_callable_v<
                     ExPolicy, Compare,
                     parallel::traits::projected_range<Proj1, Rng1>,
-                    parallel::traits::projected_range<Proj2, Rng2>
+                    parallel::traits::projected_range<Proj1, Rng1>
                 >
             )>
         // clang-format on
         friend parallel::util::detail::algorithm_result_t<ExPolicy,
             partial_sort_copy_result<hpx::traits::range_iterator_t<Rng1>,
                 hpx::traits::range_iterator_t<Rng2>>>
-        tag_fallback_dispatch(hpx::ranges::partial_sort_copy_t,
-            ExPolicy&& policy, Rng1&& rng1, Rng2&& rng2,
-            Compare&& comp = Compare(), Proj1&& proj1 = Proj1(),
-            Proj2&& proj2 = Proj2())
+        tag_fallback_invoke(hpx::ranges::partial_sort_copy_t, ExPolicy&& policy,
+            Rng1&& rng1, Rng2&& rng2, Compare&& comp = Compare(),
+            Proj1&& proj1 = Proj1(), Proj2&& proj2 = Proj2())
         {
             using iterator_type1 = hpx::traits::range_iterator_t<Rng1>;
             using iterator_type2 = hpx::traits::range_iterator_t<Rng2>;

libs/core/algorithms/tests/unit/algorithms/partial_sort_copy.cpp

@@ -241,7 +241,7 @@ void test_partial_sort_copy2(IteratorTag)
     using compare_t = std::less<std::uint64_t>;
     std::list<std::uint64_t> lst;
     std::vector<std::uint64_t> A, B;
-    const uint32_t NELEM = 10000;
+    const uint32_t NELEM = 1000;
     A.reserve(NELEM);
     B.reserve(NELEM);
 
@@ -274,7 +274,7 @@ void test_partial_sort_copy2(ExPolicy policy, IteratorTag)
     using compare_t = std::less<std::uint64_t>;
     std::list<std::uint64_t> lst;
     std::vector<std::uint64_t> A, B;
-    const uint32_t NELEM = 10000;
+    const uint32_t NELEM = 1000;
     A.reserve(NELEM);
     B.reserve(NELEM);
 
@@ -307,7 +307,7 @@ void test_partial_sort_copy2_async(ExPolicy p, IteratorTag)
     using compare_t = std::less<std::uint64_t>;
     std::list<std::uint64_t> lst;
     std::vector<std::uint64_t> A, B;
-    const uint32_t NELEM = 10000;
+    const uint32_t NELEM = 1000;
     A.reserve(NELEM);
     B.reserve(NELEM);
 
@@ -397,7 +397,7 @@ void test_partial_sort_copy3(ExPolicy policy, IteratorTag)
     std::list<std::uint64_t> lst;
     std::mt19937 my_rand(0);
     std::vector<std::uint64_t> A, B, C;
-    const uint32_t NELEM = 10000;
+    const uint32_t NELEM = 1000;
     A.reserve(NELEM);
     B.reserve(NELEM);
     C.reserve(NELEM);
@@ -433,7 +433,7 @@ void test_partial_sort_copy3_async(ExPolicy p, IteratorTag)
     std::list<std::uint64_t> lst;
     std::mt19937 my_rand(0);
     std::vector<std::uint64_t> A, B, C;
-    const uint32_t NELEM = 10000;
+    const uint32_t NELEM = 1000;
     A.reserve(NELEM);
     B.reserve(NELEM);
     C.reserve(NELEM);

libs/core/algorithms/tests/unit/container_algorithms/partial_sort_range.cpp

@@ -45,7 +45,7 @@ void test_partial_sort_range_sent(IteratorTag)
     {
         B = A;
         hpx::ranges::partial_sort(B.begin(), B.begin() + i,
-            sentinel<std::int64_t>{SIZE}, compare_t());
+            sentinel<std::uint64_t>{SIZE}, compare_t());
 
         for (std::uint64_t j = 0; j < i; ++j)
         {
@@ -73,7 +73,7 @@ void test_partial_sort_range_sent(ExPolicy policy, IteratorTag)
     {
         B = A;
         hpx::ranges::partial_sort(policy, B.begin(), B.begin() + i,
-            sentinel<std::int64_t>{SIZE}, compare_t());
+            sentinel<std::uint64_t>{SIZE}, compare_t());
 
         for (std::uint64_t j = 0; j < i; ++j)
         {
@@ -101,7 +101,7 @@ void test_partial_sort_range_async_sent(ExPolicy p, IteratorTag)
     {
         B = A;
         auto result = hpx::ranges::partial_sort(p, B.begin(), B.begin() + i,
-            sentinel<std::int64_t>{SIZE}, compare_t());
+            sentinel<std::uint64_t>{SIZE}, compare_t());
         result.wait();
 
         for (std::uint64_t j = 0; j < i; ++j)