From c28614442ac9a6cfe618d38632e4c956baf02b15 Mon Sep 17 00:00:00 2001
From: Alexey Kukanov <alexey.kukanov@intel.com>
Date: Tue, 4 Feb 2025 00:35:29 +0100
Subject: [PATCH 1/4] Add 15 more parallel range algorithms

---
 .../parallel_api/parallel_range_api.rst       | 194 +++++++++++++++++-
 1 file changed, 192 insertions(+), 2 deletions(-)

diff --git a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
index 3bcc58bf9..11cf545ad 100644
--- a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
+++ b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
@@ -133,6 +133,18 @@ Element Search Operations
       std::ranges::borrowed_iterator_t<R>
         find_if_not (ExecutionPolicy&& pol, R&& r, Pred pred, Proj proj = {});
 
+    // find_first_of
+    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+             std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
+             typename Proj1 = std::identity, typename Proj2 = std::identity>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R1> && std::ranges::sized_range<R2> &&
+               std::indirectly_comparable< std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>,
+                                           Pred, Proj1, Proj2 >
+      std::ranges::borrowed_iterator_t<R1>
+        find_first_of (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
+                       Proj1 proj1 = {}, Proj2 proj2 = {});
+
     // adjacent_find
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               typename Proj = std::identity,
@@ -144,6 +156,54 @@ Element Search Operations
       std::ranges::borrowed_iterator_t<R>
         adjacent_find (ExecutionPolicy&& pol, R&& r, Pred pred = {}, Proj proj = {});
 
+  }
+
+Minimum and Maximum
++++++++++++++++++++
+
+.. code:: cpp
+
+  // Defined in <oneapi/dpl/algorithm>
+
+  namespace oneapi::dpl::ranges {
+
+    // min
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
+                    Comp = std::ranges::less>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> &&
+               std::indirectly_copyable_storable< std::ranges::iterator_t<R>,
+                                                  std::ranges::range_value_t<R>* >
+      std::ranges::range_value_t<R>
+        min (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
+    // max
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
+                    Comp = std::ranges::less>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> &&
+               std::indirectly_copyable_storable< std::ranges::iterator_t<R>,
+                                                  std::ranges::range_value_t<R>* >
+      std::ranges::range_value_t<R>
+        max (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
+
+    // minmax
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
+                    Comp = std::ranges::less>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> &&
+               std::indirectly_copyable_storable< std::ranges::iterator_t<R>,
+                                                  std::ranges::range_value_t<R>* >
+      std::ranges::minmax_result<std::ranges::range_value_t<R>>
+        minmax (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
     // min_element
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               typename Proj = std::identity,
@@ -164,6 +224,16 @@ Element Search Operations
       std::ranges::borrowed_iterator_t<R>
         max_element (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
 
+    // minmax_element
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
+                    Comp = std::ranges::less>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R>
+      std::ranges::minmax_element_result<std::ranges::borrowed_iterator_t<R>>
+        minmax_element (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
   }
 
 Sequence Search and Comparison
@@ -186,6 +256,32 @@ Sequence Search and Comparison
       bool equal (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
 
+    // mismatch
+    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+             std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
+             typename Proj1 = std::identity, typename Proj2 = std::identity>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               (std::ranges::sized_range<R1> || std::ranges::sized_range<R2>) &&
+               std::indirectly_comparable< std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>,
+                                           Pred, Proj1, Proj2 >
+      std::ranges::mismatch_result<std::ranges::borrowed_iterator_t<R1>,
+                                   std::ranges::borrowed_iterator_t<R2>>
+        mismatch (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
+                  Proj1 proj1 = {}, Proj2 proj2 = {});
+                  
+
+    // find_end
+    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+             std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
+             typename Proj1 = std::identity, typename Proj2 = std::identity>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R1> && std::ranges::sized_range<R2> &&
+               std::indirectly_comparable< std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>,
+                                           Pred, Proj1, Proj2 >
+      std::ranges::borrowed_subrange_t<R1>
+        find_end (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
+                  Proj1 proj1 = {}, Proj2 proj2 = {});
+
     // search
     template<typename ExecutionPolicy, std::ranges::random_access_range R1,
              std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
@@ -245,6 +341,16 @@ Sorting and Merge
                std::ranges::sized_range<R>
       bool is_sorted (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
 
+    // is_sorted_until
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
+                    Comp = std::ranges::less>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R>
+      std::ranges::borrowed_iterator_t<R>
+        is_sorted_until (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
     // merge
     template <typename ExecutionPolicy, std::ranges::random_access_range R1,
               std::ranges::random_access_range R2, std::ranges::random_access_range OutR,
@@ -263,8 +369,8 @@ Sorting and Merge
 
   }
 
-Mutating Operations
-+++++++++++++++++++
+Copying Mutating Operations
++++++++++++++++++++++++++++
 
 .. code:: cpp
 
@@ -293,6 +399,16 @@ Mutating Operations
                                   std::ranges::borrowed_iterator_t<OutR>>
         copy_if (ExecutionPolicy&& pol, R&& r, OutR&& result, Pred pred, Proj proj = {});
 
+    // move
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              std::ranges::random_access_range OutR>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> && std::ranges::sized_range<OutR> &&
+               std::indirectly_movable<std::ranges::iterator_t<R>, std::ranges::iterator_t<OutR>>
+      std::ranges::move_result<std::ranges::borrowed_iterator_t<R>,
+                               std::ranges::borrowed_iterator_t<OutR>>
+        move (ExecutionPolicy&& pol, R&& r, OutR&& result);
+
     // transform (unary)
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               std::ranges::random_access_range OutR, std::copy_constructible Fn,
@@ -324,5 +440,79 @@ Mutating Operations
 
   }
 
+In-place Mutating Operations
+++++++++++++++++++++++++++++
+
+.. code:: cpp
+
+  // Defined in <oneapi/dpl/algorithm>
+
+  namespace oneapi::dpl::ranges {
+
+    // fill
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename T = std::ranges::range_value_t<R>>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> &&
+               std::indirectly_writable<std::ranges::iterator_t<R>, const T&>
+      std::ranges::borrowed_iterator_t<R>
+        fill (ExecutionPolicy&& pol, R&& r, const T& value);
+  
+    // generate
+    template <typename ExecutionPolicy, std::ranges::random_access_range R, std::copy_constructible F>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> && std::invocable<F&> &&
+               std::indirectly_writable<std::ranges::iterator_t<R>, std::invoke_result_t<F&>>
+      std::ranges::borrowed_iterator_t<R>
+        generate (ExecutionPolicy&& pol, R&& r, F gen);
+
+    // replace
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              typename T1 = std::projected_value_t<std::ranges::iterator_t<R>, Proj>, typename T2 = T1>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> &&
+               std::indirectly_writable<std::ranges::iterator_t<R>, const T2&> &&
+               std::indirect_binary_predicate< std::ranges::equal_to,
+                                               std::projected<std::ranges::iterator_t<R>, Proj>,
+                                               const T1* >
+      std::ranges::borrowed_iterator_t<R>
+        replace (ExecutionPolicy&& pol, R&& r, const T1& old_value, const T2& new_value,
+                 Proj proj = {});
+
+    // replace_if
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              typename T = std::projected_value_t<std::ranges::iterator_t<R>, Proj>,
+              std::indirect_unary_predicate< std::projected<std::ranges::iterator_t<R>, Proj> > Pred>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> &&
+               std::indirectly_writable<std::ranges::iterator_t<R>, const T&>
+      std::ranges::borrowed_iterator_t<R>
+        replace_if (ExecutionPolicy&& pol, R&& r, Pred pred, const T& new_value, Proj proj = {});
+
+    // remove
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              typename T = std::projected_value_t<std::ranges::iterator_t<R>, Proj>>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> && std::permutable<std::ranges::iterator_t<R> &&
+               std::indirect_binary_predicate< std::ranges::equal_to,
+                                               std::projected<std::ranges::iterator_t<R>, Proj>,
+                                               const T* >
+      std::ranges::borrowed_subrange_t<R>
+        remove (ExecutionPolicy&& pol, R&& r, const T& value, Proj proj = {});
+
+    // remove_if
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Proj = std::identity,
+              std::indirect_unary_predicate< std::projected<std::ranges::iterator_t<R>, Proj> > Pred>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> && std::permutable<std::ranges::iterator_t<R>>
+      std::ranges::borrowed_subrange_t<R>
+        remove_if (ExecutionPolicy&& pol, R&& r, Pred pred, Proj proj = {});
+
+  }
+
 .. _`C++ Standard`: https://isocpp.org/std/the-standard
 .. _`SYCL`: https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html

From 005583b7b4b247970ed68169f697a7412d6c3493 Mon Sep 17 00:00:00 2001
From: Alexey Kukanov <alexey.kukanov@intel.com>
Date: Tue, 25 Mar 2025 21:45:47 +0100
Subject: [PATCH 2/4] Replace std::projected_value_t with an exposition-only
 template

---
 .../oneDPL/source/parallel_api/parallel_range_api.rst       | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
index 11cf545ad..a9b42b80f 100644
--- a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
+++ b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
@@ -469,7 +469,7 @@ In-place Mutating Operations
     // replace
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               typename Proj = std::identity,
-              typename T1 = std::projected_value_t<std::ranges::iterator_t<R>, Proj>, typename T2 = T1>
+              typename T1 = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>, typename T2 = T1>
       requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
                std::ranges::sized_range<R> &&
                std::indirectly_writable<std::ranges::iterator_t<R>, const T2&> &&
@@ -483,7 +483,7 @@ In-place Mutating Operations
     // replace_if
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               typename Proj = std::identity,
-              typename T = std::projected_value_t<std::ranges::iterator_t<R>, Proj>,
+              typename T = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>,
               std::indirect_unary_predicate< std::projected<std::ranges::iterator_t<R>, Proj> > Pred>
       requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
                std::ranges::sized_range<R> &&
@@ -494,7 +494,7 @@ In-place Mutating Operations
     // remove
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               typename Proj = std::identity,
-              typename T = std::projected_value_t<std::ranges::iterator_t<R>, Proj>>
+              typename T = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>>
       requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
                std::ranges::sized_range<R> && std::permutable<std::ranges::iterator_t<R> &&
                std::indirect_binary_predicate< std::ranges::equal_to,

From 580ac972ecea600eda5da4f9d641a93533b26462 Mon Sep 17 00:00:00 2001
From: Alexey Kukanov <alexey.kukanov@intel.com>
Date: Tue, 29 Apr 2025 18:08:38 +0200
Subject: [PATCH 3/4] Remove 'generate'

---
 .../oneDPL/source/parallel_api/parallel_range_api.rst     | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
index ec6e9f96c..2cefeeb2c 100644
--- a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
+++ b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
@@ -478,14 +478,6 @@ In-place Mutating Operations
       std::ranges::borrowed_iterator_t<R>
         fill (ExecutionPolicy&& pol, R&& r, const T& value);
   
-    // generate
-    template <typename ExecutionPolicy, std::ranges::random_access_range R, std::copy_constructible F>
-      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
-               std::ranges::sized_range<R> && std::invocable<F&> &&
-               std::indirectly_writable<std::ranges::iterator_t<R>, std::invoke_result_t<F&>>
-      std::ranges::borrowed_iterator_t<R>
-        generate (ExecutionPolicy&& pol, R&& r, F gen);
-
     // replace
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               typename Proj = std::identity,

From 03447fa0fc7e56c79053b33dd88c757added7a21 Mon Sep 17 00:00:00 2001
From: Alexey Kukanov <alexey.kukanov@intel.com>
Date: Tue, 29 Apr 2025 18:27:10 +0200
Subject: [PATCH 4/4] Cosmetic updates in the description of differences with
 C++ range algorithms

---
 .../oneDPL/source/parallel_api/parallel_range_api.rst         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
index 2cefeeb2c..d5a353e5d 100644
--- a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
+++ b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
@@ -20,7 +20,7 @@ predefined function objects which static function call operators have the requir
 The following differences to the standard C++ range algorithms apply:
 
 - Parallel range algorithms cannot be used in constant expressions.
-- The execution policy parameter is added.
+- The oneDPL execution policy parameter is added.
 - Output data sequences are defined as ranges, not iterators.
 - Both input and output ranges must support random access.
 - As a rule, both input and output ranges must be sized.
@@ -30,7 +30,7 @@ The following differences to the standard C++ range algorithms apply:
     [*Note*: An example of an infinite range is ``std::views::repeat`` with no bound. -- *end note*]
 
 - For algorithms with bounded output ranges, processing may not need to go over all the input data.
-  In that case, the returned value usually contains iterators pointing to the positions past the last elements
+  In that case, the returned value contains iterators pointing to the positions past the last elements
   processed according to the algorithm semantics.
 - ``for_each`` does not return its function object.