Merge branch 'main' into add-partial-sort

dmitriy-sobolev · dmitriy-sobolev · commit 20a7058ab635 · 2025-10-24T18:51:10.000+01:00
diff --git a/requirements.txt b/requirements.txt
@@ -41,7 +41,7 @@ pydata-sphinx-theme==0.15.2
 pyenchant==3.2.2
 Pygments==2.17.2
 PyYAML==6.0.1
-requests==2.32.0
+requests==2.32.4
 six==1.16.0
 snowballstemmer==2.2.0
 soupsieve==2.5
@@ -62,5 +62,5 @@ sphinxcontrib-spelling==8.0.0
 sphinxcontrib-svg2pdfconverter==1.2.2
 sphinxmark==1.0.0
 typing_extensions==4.9.0
-urllib3==2.2.2
+urllib3==2.5.0
 virtualenv==20.26.6
diff --git a/source/elements/oneDPL/source/parallel_api.rst b/source/elements/oneDPL/source/parallel_api.rst
@@ -14,6 +14,9 @@ All those algorithms work with *C++ Standard aligned execution policies* and wit
 oneDPL also provides *parallel range algorithms*: variations of C++20 range-based algorithms
 that take a oneDPL execution policy.
 
+For all parallel algorithms (including ones with ranges) oneDPL implements list-initialization, where applicable,
+as described in `P2248R8`_ proposal that is accepted for C++26.
+
 Additionally, oneDPL provides wrapper functions for `SYCL`_ buffers, special iterators, and
 a set of non-standard parallel algorithms.
 
@@ -25,6 +28,7 @@ a set of non-standard parallel algorithms.
    parallel_api/iterators.rst
    parallel_api/algorithms.rst
    parallel_api/parallel_range_api.rst
-   
+
 .. _`C++ Standard`: https://isocpp.org/std/the-standard
 .. _`SYCL`: https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html
+.. _`P2248R8`: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html
diff --git a/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst b/source/elements/oneDPL/source/parallel_api/parallel_range_api.rst
@@ -288,7 +288,7 @@ Sequence Search and Comparison
   namespace oneapi::dpl::ranges {
 
     // equal
-    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+    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>> &&
@@ -299,7 +299,7 @@ Sequence Search and Comparison
                   Proj1 proj1 = {}, Proj2 proj2 = {});
 
     // mismatch
-    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+    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>> &&
@@ -312,7 +312,7 @@ Sequence Search and Comparison
                   Proj1 proj1 = {}, Proj2 proj2 = {});
 
     // find_end
-    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+    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>> &&
@@ -324,7 +324,7 @@ Sequence Search and Comparison
                   Proj1 proj1 = {}, Proj2 proj2 = {});
 
     // search
-    template<typename ExecutionPolicy, std::ranges::random_access_range R1,
+    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>> &&
@@ -336,7 +336,7 @@ Sequence Search and Comparison
                 Proj1 proj1 = {}, Proj2 proj2 = {});
 
     // search_n
-    template<typename ExecutionPolicy, std::ranges::random_access_range R,
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
              typename Pred = std::ranges::equal_to, typename Proj = std::identity,
              typename T = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>>
       requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
@@ -346,10 +346,21 @@ Sequence Search and Comparison
         search_n (ExecutionPolicy&& pol, R&& r, std::ranges::range_difference_t<R> count,
                   const T& value, Pred pred = {}, Proj proj = {});
 
+    // lexicographical_compare
+    template <typename ExecutionPolicy, std::ranges::random_access_range R1,
+              std::ranges::random_access_range R2, typename Proj1 = std::identity,
+              typename Proj2 = std::identity,
+              std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R1>, Proj1>,
+                                               std::projected<std::ranges::iterator_t<R2>, Proj2> >
+                    Comp = std::ranges::less>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R1> && std::ranges::sized_range<R2>
+      bool lexicographical_compare (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Comp comp = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});
   }
 
-Sorting and Merge
-+++++++++++++++++
+Sorting, Merge, and Heap Operations
++++++++++++++++++++++++++++++++++++
 
 .. code:: cpp
 
@@ -433,6 +444,34 @@ Sorting and Merge
         merge (ExecutionPolicy&& pol, R1&& r1, R2&& r2, OutR&& result, Comp comp = {},
                Proj1 proj1 = {}, Proj2 proj2 = {});
 
+    // inplace_merge
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              typename Comp = std::ranges::less, typename Proj = std::identity>
+      requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
+               std::ranges::sized_range<R> && std::sortable<std::ranges::iterator_t<R>, Comp, Proj>
+      std::ranges::borrowed_iterator_t<R>
+        inplace_merge (ExecutionPolicy&& pol, R&& r, std::ranges::iterator_t<R> middle,
+                       Comp comp = {}, Proj proj = {});
+
+    // is_heap
+    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>
+      bool is_heap (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
+    // is_heap_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_heap_until (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
+
   }
 
 Set operations
@@ -518,6 +557,7 @@ Set operations
                                                    std::ranges::borrowed_iterator_t<OutR>>
         set_symmetric_difference (ExecutionPolicy&& pol, R1&& r1, R2&& r2, OutR&& result,
                                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+
   }
 
 Copying Mutating Operations
@@ -560,6 +600,31 @@ Copying Mutating Operations
                                std::ranges::borrowed_iterator_t<OutR>>
         move (ExecutionPolicy&& pol, R&& r, OutR&& result);
 
+    // remove_copy
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              std::ranges::random_access_range OutR, typename Proj = std::identity,
+              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::ranges::sized_range<OutR> &&
+               std::indirectly_copyable<std::ranges::iterator_t<R>, std::ranges::iterator_t<OutR>> &&
+               std::indirect_binary_predicate< std::ranges::equal_to,
+                                               std::projected<std::ranges::iterator_t<R>, Proj>,
+                                               const T* >
+      std::ranges::remove_copy_result<std::ranges::borrowed_iterator_t<R>,
+                                      std::ranges::borrowed_iterator_t<OutR>>
+        remove_copy (ExecutionPolicy&& pol, R&& r, OutR&& result, const T& value, Proj proj = {});
+
+    // remove_copy_if
+    template <typename ExecutionPolicy, std::ranges::random_access_range R,
+              std::ranges::random_access_range OutR, 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::ranges::sized_range<OutR> &&
+               std::indirectly_copyable<std::ranges::iterator_t<R>, std::ranges::iterator_t<OutR>>
+      std::ranges::remove_copy_if_result<std::ranges::borrowed_iterator_t<R>,
+                                         std::ranges::borrowed_iterator_t<OutR>>
+        remove_copy_if (ExecutionPolicy&& pol, R&& r, OutR&& result, Pred pred, Proj proj = {});
+
     // reverse_copy
     template <typename ExecutionPolicy, std::ranges::random_access_range R,
               std::ranges::random_access_range OutR>
diff --git a/source/elements/oneDPL/source/sycl_kernels_api.rst b/source/elements/oneDPL/source/sycl_kernels_api.rst
@@ -27,6 +27,7 @@ Supported Functionality
 - Engine class templates:
    - ``linear_congruential_engine``
    - ``subtract_with_carry_engine``
+   - ``philox_engine``
 - Engine adaptor class templates:
    - ``discard_block_engine``
 - Engines and engine adaptors with predefined parameters:
@@ -36,6 +37,8 @@ Supported Functionality
    - ``ranlux48_base``
    - ``ranlux24``
    - ``ranlux48``
+   - ``philox4x32``
+   - ``philox4x64``
 - Distribution class templates:
    - ``uniform_int_distribution``
    - ``uniform_real_distribution``
@@ -48,7 +51,11 @@ Supported Functionality
    - ``cauchy_distribution``
    - ``extreme_value_distribution``
 
-``linear_congruential_engine`` and ``subtract_with_carry_engine`` satisfy the uniform random bit generator requirements.
+.. note::
+   The ``philox_engine`` class template and the corresponding predefined engines match the respective API
+   in the working draft of the next C++ standard edition (C++26).
+
+``linear_congruential_engine``, ``subtract_with_carry_engine``, and ``philox_engine`` satisfy the uniform random bit generator requirements.
 
 Limitations
 -----------
@@ -82,7 +89,7 @@ The ``scalar_type`` is used instead of ``result_type`` in all contexts where a s
 Since ``scalar_type`` is the same as ``result_type`` except for template instantiations with ``sycl::vec``,
 class templates still meet the applicable requirements of the `C++ Standard`_.
 
-When instantiated with ``sycl::vec<Type,N>``, ``linear_congruential_engine`` and ``subtract_with_carry_engine`` may not
+When instantiated with ``sycl::vec<Type,N>``, ``linear_congruential_engine``, ``subtract_with_carry_engine``, and ``philox_engine`` may not
 formally satisfy the uniform random bit generator requirements defined by the `C++ Standard`_. Instead, the following
 alternative requirements apply: for an engine object ``g`` of type ``G``,
 
@@ -105,10 +112,12 @@ The following engines and engine adaptors with predefined parameters are defined
 .. code:: cpp
 
     template <int N>
-    using minstd_rand0_vec = linear_congruential_engine<sycl::vec<::std::uint_fast32_t, N>, 16807, 0, 2147483647>;
+    using minstd_rand0_vec =
+        linear_congruential_engine<sycl::vec<uint_fast32_t, N>, 16807, 0, 2147483647>;
 
     template <int N>
-    using minstd_rand_vec = linear_congruential_engine<sycl::vec<uint_fast32_t, N>, 48271, 0, 2147483647>;
+    using minstd_rand_vec =
+        linear_congruential_engine<sycl::vec<uint_fast32_t, N>, 48271, 0, 2147483647>;
 
     template <int N>
     using ranlux24_base_vec = subtract_with_carry_engine<sycl::vec<uint_fast32_t, N>, 24, 10, 24>;
@@ -122,6 +131,14 @@ The following engines and engine adaptors with predefined parameters are defined
     template <int N>
     using ranlux48_vec = discard_block_engine<ranlux48_base_vec<N>, 389, 11>;
 
+    template <int N>
+    using philox4x32_vec = philox_engine<sycl::vec<uint_fast32_t, N>, 32, 4, 10, 0xCD9E8D57,
+                                         0x9E3779B9, 0xD2511F53, 0xBB67AE85>;
+
+    template <int N>
+    using philox4x64_vec = philox_engine<sycl::vec<uint_fast64_t, N>, 64, 4, 10, 0xCA5A826395121157,
+                                         0x9E3779B97F4A7C15, 0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>;
+
 Except for producing a ``sycl::vec`` of random values per invocation, the behavior of these engines is equivalent to
 the corresponding scalar engines, as described in the following table:
 
@@ -151,7 +168,12 @@ the corresponding scalar engines, as described in the following table:
          * -     ``ranlux48_vec``
            -     ``ranlux48``
            -     1112339016
-
+         * -     ``philox4x32_vec``
+           -     ``philox4x32``
+           -     1955073260
+         * -     ``philox4x64_vec``
+           -     ``philox4x64``
+           -     3409172418970261260
 
 Function Objects
 ++++++++++++++++
