Skip to content

Commit 0d15166

Browse files
akukanovakukanov
authored
[oneDPL] Add more parallel range algorithms (#614)
1 parent 4f3aad1 commit 0d15166

File tree

1 file changed

+186
-4
lines changed

1 file changed

+186
-4
lines changed

‎source/elements/oneDPL/source/parallel_api/parallel_range_api.rst

Lines changed: 186 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ predefined function objects which static function call operators have the requir
2020
The following differences to the standard C++ range algorithms apply:
2121

2222
- Parallel range algorithms cannot be used in constant expressions.
23-
- The execution policy parameter is added.
23+
- The oneDPL execution policy parameter is added.
2424
- Output data sequences are defined as ranges, not iterators.
2525
- Both input and output ranges must support random access.
2626
- 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:
3030
[*Note*: An example of an infinite range is ``std::views::repeat`` with no bound. -- *end note*]
3131

3232
- For algorithms with bounded output ranges, processing may not need to go over all the input data.
33-
In that case, the returned value usually contains iterators pointing to the positions past the last elements
33+
In that case, the returned value contains iterators pointing to the positions past the last elements
3434
processed according to the algorithm semantics.
3535
- ``for_each`` does not return its function object.
3636

@@ -153,6 +153,18 @@ Element Search Operations
153153
std::ranges::borrowed_iterator_t<R>
154154
find_if_not (ExecutionPolicy&& pol, R&& r, Pred pred, Proj proj = {});
155155
156+
// find_first_of
157+
template<typename ExecutionPolicy, std::ranges::random_access_range R1,
158+
std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
159+
typename Proj1 = std::identity, typename Proj2 = std::identity>
160+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
161+
std::ranges::sized_range<R1> && std::ranges::sized_range<R2> &&
162+
std::indirectly_comparable< std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>,
163+
Pred, Proj1, Proj2 >
164+
std::ranges::borrowed_iterator_t<R1>
165+
find_first_of (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
166+
Proj1 proj1 = {}, Proj2 proj2 = {});
167+
156168
// adjacent_find
157169
template <typename ExecutionPolicy, std::ranges::random_access_range R,
158170
typename Proj = std::identity,
@@ -164,6 +176,54 @@ Element Search Operations
164176
std::ranges::borrowed_iterator_t<R>
165177
adjacent_find (ExecutionPolicy&& pol, R&& r, Pred pred = {}, Proj proj = {});
166178
179+
}
180+
181+
Minimum and Maximum
182+
+++++++++++++++++++
183+
184+
.. code:: cpp
185+
186+
// Defined in <oneapi/dpl/algorithm>
187+
188+
namespace oneapi::dpl::ranges {
189+
190+
// min
191+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
192+
typename Proj = std::identity,
193+
std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
194+
Comp = std::ranges::less>
195+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
196+
std::ranges::sized_range<R> &&
197+
std::indirectly_copyable_storable< std::ranges::iterator_t<R>,
198+
std::ranges::range_value_t<R>* >
199+
std::ranges::range_value_t<R>
200+
min (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
201+
202+
// max
203+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
204+
typename Proj = std::identity,
205+
std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
206+
Comp = std::ranges::less>
207+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
208+
std::ranges::sized_range<R> &&
209+
std::indirectly_copyable_storable< std::ranges::iterator_t<R>,
210+
std::ranges::range_value_t<R>* >
211+
std::ranges::range_value_t<R>
212+
max (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
213+
214+
215+
// minmax
216+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
217+
typename Proj = std::identity,
218+
std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
219+
Comp = std::ranges::less>
220+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
221+
std::ranges::sized_range<R> &&
222+
std::indirectly_copyable_storable< std::ranges::iterator_t<R>,
223+
std::ranges::range_value_t<R>* >
224+
std::ranges::minmax_result<std::ranges::range_value_t<R>>
225+
minmax (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
226+
167227
// min_element
168228
template <typename ExecutionPolicy, std::ranges::random_access_range R,
169229
typename Proj = std::identity,
@@ -184,6 +244,16 @@ Element Search Operations
184244
std::ranges::borrowed_iterator_t<R>
185245
max_element (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
186246
247+
// minmax_element
248+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
249+
typename Proj = std::identity,
250+
std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
251+
Comp = std::ranges::less>
252+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
253+
std::ranges::sized_range<R>
254+
std::ranges::minmax_element_result<std::ranges::borrowed_iterator_t<R>>
255+
minmax_element (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
256+
187257
}
188258
189259
Sequence Search and Comparison
@@ -206,6 +276,32 @@ Sequence Search and Comparison
206276
bool equal (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
207277
Proj1 proj1 = {}, Proj2 proj2 = {});
208278
279+
// mismatch
280+
template<typename ExecutionPolicy, std::ranges::random_access_range R1,
281+
std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
282+
typename Proj1 = std::identity, typename Proj2 = std::identity>
283+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
284+
(std::ranges::sized_range<R1> || std::ranges::sized_range<R2>) &&
285+
std::indirectly_comparable< std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>,
286+
Pred, Proj1, Proj2 >
287+
std::ranges::mismatch_result<std::ranges::borrowed_iterator_t<R1>,
288+
std::ranges::borrowed_iterator_t<R2>>
289+
mismatch (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
290+
Proj1 proj1 = {}, Proj2 proj2 = {});
291+
292+
293+
// find_end
294+
template<typename ExecutionPolicy, std::ranges::random_access_range R1,
295+
std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
296+
typename Proj1 = std::identity, typename Proj2 = std::identity>
297+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
298+
std::ranges::sized_range<R1> && std::ranges::sized_range<R2> &&
299+
std::indirectly_comparable< std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>,
300+
Pred, Proj1, Proj2 >
301+
std::ranges::borrowed_subrange_t<R1>
302+
find_end (ExecutionPolicy&& pol, R1&& r1, R2&& r2, Pred pred = {},
303+
Proj1 proj1 = {}, Proj2 proj2 = {});
304+
209305
// search
210306
template<typename ExecutionPolicy, std::ranges::random_access_range R1,
211307
std::ranges::random_access_range R2, typename Pred = std::ranges::equal_to,
@@ -265,6 +361,16 @@ Sorting and Merge
265361
std::ranges::sized_range<R>
266362
bool is_sorted (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
267363
364+
// is_sorted_until
365+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
366+
typename Proj = std::identity,
367+
std::indirect_strict_weak_order< std::projected<std::ranges::iterator_t<R>, Proj> >
368+
Comp = std::ranges::less>
369+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
370+
std::ranges::sized_range<R>
371+
std::ranges::borrowed_iterator_t<R>
372+
is_sorted_until (ExecutionPolicy&& pol, R&& r, Comp comp = {}, Proj proj = {});
373+
268374
// merge
269375
template <typename ExecutionPolicy, std::ranges::random_access_range R1,
270376
std::ranges::random_access_range R2, std::ranges::random_access_range OutR,
@@ -283,8 +389,8 @@ Sorting and Merge
283389
284390
}
285391
286-
Mutating Operations
287-
+++++++++++++++++++
392+
Copying Mutating Operations
393+
+++++++++++++++++++++++++++
288394

289395
.. code:: cpp
290396
@@ -313,6 +419,16 @@ Mutating Operations
313419
std::ranges::borrowed_iterator_t<OutR>>
314420
copy_if (ExecutionPolicy&& pol, R&& r, OutR&& result, Pred pred, Proj proj = {});
315421
422+
// move
423+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
424+
std::ranges::random_access_range OutR>
425+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
426+
std::ranges::sized_range<R> && std::ranges::sized_range<OutR> &&
427+
std::indirectly_movable<std::ranges::iterator_t<R>, std::ranges::iterator_t<OutR>>
428+
std::ranges::move_result<std::ranges::borrowed_iterator_t<R>,
429+
std::ranges::borrowed_iterator_t<OutR>>
430+
move (ExecutionPolicy&& pol, R&& r, OutR&& result);
431+
316432
// transform (unary)
317433
template <typename ExecutionPolicy, std::ranges::random_access_range R,
318434
std::ranges::random_access_range OutR, std::copy_constructible Fn,
@@ -344,5 +460,71 @@ Mutating Operations
344460
345461
}
346462
463+
In-place Mutating Operations
464+
++++++++++++++++++++++++++++
465+
466+
.. code:: cpp
467+
468+
// Defined in <oneapi/dpl/algorithm>
469+
470+
namespace oneapi::dpl::ranges {
471+
472+
// fill
473+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
474+
typename T = std::ranges::range_value_t<R>>
475+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
476+
std::ranges::sized_range<R> &&
477+
std::indirectly_writable<std::ranges::iterator_t<R>, const T&>
478+
std::ranges::borrowed_iterator_t<R>
479+
fill (ExecutionPolicy&& pol, R&& r, const T& value);
480+
481+
// replace
482+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
483+
typename Proj = std::identity,
484+
typename T1 = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>, typename T2 = T1>
485+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
486+
std::ranges::sized_range<R> &&
487+
std::indirectly_writable<std::ranges::iterator_t<R>, const T2&> &&
488+
std::indirect_binary_predicate< std::ranges::equal_to,
489+
std::projected<std::ranges::iterator_t<R>, Proj>,
490+
const T1* >
491+
std::ranges::borrowed_iterator_t<R>
492+
replace (ExecutionPolicy&& pol, R&& r, const T1& old_value, const T2& new_value,
493+
Proj proj = {});
494+
495+
// replace_if
496+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
497+
typename Proj = std::identity,
498+
typename T = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>,
499+
std::indirect_unary_predicate< std::projected<std::ranges::iterator_t<R>, Proj> > Pred>
500+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
501+
std::ranges::sized_range<R> &&
502+
std::indirectly_writable<std::ranges::iterator_t<R>, const T&>
503+
std::ranges::borrowed_iterator_t<R>
504+
replace_if (ExecutionPolicy&& pol, R&& r, Pred pred, const T& new_value, Proj proj = {});
505+
506+
// remove
507+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
508+
typename Proj = std::identity,
509+
typename T = /*projected-value-type*/<std::ranges::iterator_t<R>, Proj>>
510+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
511+
std::ranges::sized_range<R> && std::permutable<std::ranges::iterator_t<R> &&
512+
std::indirect_binary_predicate< std::ranges::equal_to,
513+
std::projected<std::ranges::iterator_t<R>, Proj>,
514+
const T* >
515+
std::ranges::borrowed_subrange_t<R>
516+
remove (ExecutionPolicy&& pol, R&& r, const T& value, Proj proj = {});
517+
518+
// remove_if
519+
template <typename ExecutionPolicy, std::ranges::random_access_range R,
520+
typename Proj = std::identity,
521+
std::indirect_unary_predicate< std::projected<std::ranges::iterator_t<R>, Proj> > Pred>
522+
requires oneapi::dpl::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> &&
523+
std::ranges::sized_range<R> && std::permutable<std::ranges::iterator_t<R>>
524+
std::ranges::borrowed_subrange_t<R>
525+
remove_if (ExecutionPolicy&& pol, R&& r, Pred pred, Proj proj = {});
526+
527+
}
528+
347529
.. _`C++ Standard`: https://isocpp.org/std/the-standard
348530
.. _`SYCL`: https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html

0 commit comments

Comments
 (0)