1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___NUMERIC_PSTL_H
10#define _LIBCPP___NUMERIC_PSTL_H
11
12#include <__config>
13
14#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15# pragma GCC system_header
16#endif
17
18_LIBCPP_PUSH_MACROS
19#include <__undef_macros>
20
21#if _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
22
23# include <__execution/is_execution_policy.h>
24# include <__functional/identity.h>
25# include <__functional/operations.h>
26# include <__iterator/cpp17_iterator_concepts.h>
27# include <__iterator/iterator_traits.h>
28# include <__pstl/backend.h>
29# include <__pstl/dispatch.h>
30# include <__pstl/handle_exception.h>
31# include <__type_traits/enable_if.h>
32# include <__type_traits/remove_cvref.h>
33# include <__utility/forward.h>
34# include <__utility/move.h>
35
36_LIBCPP_BEGIN_NAMESPACE_STD
37
38template <class _ExecutionPolicy,
39 class _ForwardIterator1,
40 class _ForwardIterator2,
41 class _BinaryOperation,
42 class _Tp,
43 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
44 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
45_LIBCPP_HIDE_FROM_ABI _ForwardIterator2 inclusive_scan(
46 _ExecutionPolicy&& __policy,
47 _ForwardIterator1 __first,
48 _ForwardIterator1 __last,
49 _ForwardIterator2 __result,
50 _BinaryOperation __reduce,
51 _Tp __init) {
52 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "inclusive_scan requires ForwardIterators");
53 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "inclusive_scan requires ForwardIterators");
54 using _Implementation =
55 __pstl::__dispatch<__pstl::__inclusive_scan_init, __pstl::__current_configuration, _RawPolicy>;
56 return __pstl::__handle_exception<_Implementation>(
57 std::forward<_ExecutionPolicy>(__policy),
58 std::move(__first),
59 std::move(__last),
60 std::move(__result),
61 std::move(__reduce),
62 std::move(__init));
63}
64
65template <class _ExecutionPolicy,
66 class _ForwardIterator1,
67 class _ForwardIterator2,
68 class _BinaryOperation,
69 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
70 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
71_LIBCPP_HIDE_FROM_ABI _ForwardIterator2 inclusive_scan(
72 _ExecutionPolicy&& __policy,
73 _ForwardIterator1 __first,
74 _ForwardIterator1 __last,
75 _ForwardIterator2 __result,
76 _BinaryOperation __reduce) {
77 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "inclusive_scan requires ForwardIterators");
78 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "inclusive_scan requires ForwardIterators");
79 using _Implementation = __pstl::__dispatch<__pstl::__inclusive_scan, __pstl::__current_configuration, _RawPolicy>;
80 return __pstl::__handle_exception<_Implementation>(
81 std::forward<_ExecutionPolicy>(__policy),
82 std::move(__first),
83 std::move(__last),
84 std::move(__result),
85 std::move(__reduce));
86}
87
88template <class _ExecutionPolicy,
89 class _ForwardIterator1,
90 class _ForwardIterator2,
91 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
92 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
93_LIBCPP_HIDE_FROM_ABI _ForwardIterator2 inclusive_scan(
94 _ExecutionPolicy&& __policy, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) {
95 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "inclusive_scan requires ForwardIterators");
96 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "inclusive_scan requires ForwardIterators");
97 using _Implementation = __pstl::__dispatch<__pstl::__inclusive_scan, __pstl::__current_configuration, _RawPolicy>;
98 return __pstl::__handle_exception<_Implementation>(
99 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result), plus{});
100}
101
102template <class _ExecutionPolicy,
103 class _ForwardIterator,
104 class _Tp,
105 class _BinaryOperation,
106 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
107 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
108[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Tp reduce(
109 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __op) {
110 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
111 using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
112 return __pstl::__handle_exception<_Implementation>(
113 std::forward<_ExecutionPolicy>(__policy),
114 std::move(__first),
115 std::move(__last),
116 std::move(__init),
117 std::move(__op));
118}
119
120template <class _ExecutionPolicy,
121 class _ForwardIterator,
122 class _Tp,
123 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
124 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
125[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Tp
126reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp __init) {
127 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
128 using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
129 return __pstl::__handle_exception<_Implementation>(
130 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__init), plus{});
131}
132
133template <class _ExecutionPolicy,
134 class _ForwardIterator,
135 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
136 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
137[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __iterator_value_type<_ForwardIterator>
138reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
139 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
140 using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
141 return __pstl::__handle_exception<_Implementation>(
142 std::forward<_ExecutionPolicy>(__policy),
143 std::move(__first),
144 std::move(__last),
145 __iterator_value_type<_ForwardIterator>(),
146 plus{});
147}
148
149template <class _ExecutionPolicy,
150 class _ForwardIterator1,
151 class _ForwardIterator2,
152 class _BinaryOperation,
153 class _UnaryOperation,
154 class _Tp,
155 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
156 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
157_LIBCPP_HIDE_FROM_ABI _ForwardIterator2 transform_inclusive_scan(
158 _ExecutionPolicy&& __policy,
159 _ForwardIterator1 __first,
160 _ForwardIterator1 __last,
161 _ForwardIterator2 __result,
162 _BinaryOperation __reduce,
163 _UnaryOperation __transform,
164 _Tp __init) {
165 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform_inclusive_scan requires ForwardIterators");
166 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform_inclusive_scan requires ForwardIterators");
167 using _Implementation =
168 __pstl::__dispatch<__pstl::__transform_inclusive_scan_init, __pstl::__current_configuration, _RawPolicy>;
169 return __pstl::__handle_exception<_Implementation>(
170 std::forward<_ExecutionPolicy>(__policy),
171 std::move(__first),
172 std::move(__last),
173 std::move(__result),
174 std::move(__reduce),
175 std::move(__transform),
176 std::move(__init));
177}
178
179template <class _ExecutionPolicy,
180 class _ForwardIterator1,
181 class _ForwardIterator2,
182 class _BinaryOperation,
183 class _UnaryOperation,
184 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
185 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
186_LIBCPP_HIDE_FROM_ABI _ForwardIterator2 transform_inclusive_scan(
187 _ExecutionPolicy&& __policy,
188 _ForwardIterator1 __first,
189 _ForwardIterator1 __last,
190 _ForwardIterator2 __result,
191 _BinaryOperation __reduce,
192 _UnaryOperation __transform) {
193 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform_inclusive_scan requires ForwardIterators");
194 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform_inclusive_scan requires ForwardIterators");
195 using _Implementation =
196 __pstl::__dispatch<__pstl::__transform_inclusive_scan, __pstl::__current_configuration, _RawPolicy>;
197 return __pstl::__handle_exception<_Implementation>(
198 std::forward<_ExecutionPolicy>(__policy),
199 std::move(__first),
200 std::move(__last),
201 std::move(__result),
202 std::move(__reduce),
203 std::move(__transform));
204}
205
206template <class _ExecutionPolicy,
207 class _ForwardIterator1,
208 class _ForwardIterator2,
209 class _Tp,
210 class _BinaryOperation1,
211 class _BinaryOperation2,
212 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
213 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
214[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Tp transform_reduce(
215 _ExecutionPolicy&& __policy,
216 _ForwardIterator1 __first1,
217 _ForwardIterator1 __last1,
218 _ForwardIterator2 __first2,
219 _Tp __init,
220 _BinaryOperation1 __reduce,
221 _BinaryOperation2 __transform) {
222 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform_reduce requires ForwardIterators");
223 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform_reduce requires ForwardIterators");
224 using _Implementation =
225 __pstl::__dispatch<__pstl::__transform_reduce_binary, __pstl::__current_configuration, _RawPolicy>;
226 return __pstl::__handle_exception<_Implementation>(
227 std::forward<_ExecutionPolicy>(__policy),
228 std::move(__first1),
229 std::move(__last1),
230 std::move(__first2),
231 std::move(__init),
232 std::move(__reduce),
233 std::move(__transform));
234}
235
236// This overload doesn't get a customization point because it's trivial to detect (through e.g.
237// __desugars_to_v) when specializing the more general variant, which should always be preferred
238template <class _ExecutionPolicy,
239 class _ForwardIterator1,
240 class _ForwardIterator2,
241 class _Tp,
242 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
243 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
244[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Tp transform_reduce(
245 _ExecutionPolicy&& __policy,
246 _ForwardIterator1 __first1,
247 _ForwardIterator1 __last1,
248 _ForwardIterator2 __first2,
249 _Tp __init) {
250 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform_reduce requires ForwardIterators");
251 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform_reduce requires ForwardIterators");
252 using _Implementation =
253 __pstl::__dispatch<__pstl::__transform_reduce_binary, __pstl::__current_configuration, _RawPolicy>;
254 return __pstl::__handle_exception<_Implementation>(
255 std::forward<_ExecutionPolicy>(__policy),
256 std::move(__first1),
257 std::move(__last1),
258 std::move(__first2),
259 std::move(__init),
260 plus{},
261 multiplies{});
262}
263
264template <class _ExecutionPolicy,
265 class _ForwardIterator,
266 class _Tp,
267 class _BinaryOperation,
268 class _UnaryOperation,
269 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
270 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
271[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Tp transform_reduce(
272 _ExecutionPolicy&& __policy,
273 _ForwardIterator __first,
274 _ForwardIterator __last,
275 _Tp __init,
276 _BinaryOperation __reduce,
277 _UnaryOperation __transform) {
278 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform_reduce requires ForwardIterators");
279 using _Implementation = __pstl::__dispatch<__pstl::__transform_reduce, __pstl::__current_configuration, _RawPolicy>;
280 return __pstl::__handle_exception<_Implementation>(
281 std::forward<_ExecutionPolicy>(__policy),
282 std::move(__first),
283 std::move(__last),
284 std::move(__init),
285 std::move(__reduce),
286 std::move(__transform));
287}
288
289template <class _ExecutionPolicy,
290 class _ForwardIterator1,
291 class _ForwardIterator2,
292 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
293 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
294[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator2 adjacent_difference(
295 _ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
296 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "adjacent_difference requires ForwardIterators");
297 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "adjacent_difference requires ForwardIterators");
298 using _Implementation =
299 __pstl::__dispatch<__pstl::__adjacent_difference, __pstl::__current_configuration, _RawPolicy>;
300 return __pstl::__handle_exception<_Implementation>(
301 std::forward<_ExecutionPolicy>(__policy), std::move(__first1), std::move(__last1), std::move(__first2), minus{});
302}
303
304template <class _ExecutionPolicy,
305 class _ForwardIterator1,
306 class _ForwardIterator2,
307 class _BinaryOperation,
308 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
309 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
310[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator2 adjacent_difference(
311 _ExecutionPolicy&& __policy,
312 _ForwardIterator1 __first1,
313 _ForwardIterator1 __last1,
314 _ForwardIterator2 __first2,
315 _BinaryOperation __op) {
316 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "adjacent_difference requires ForwardIterators");
317 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "adjacent_difference requires ForwardIterators");
318 using _Implementation =
319 __pstl::__dispatch<__pstl::__adjacent_difference, __pstl::__current_configuration, _RawPolicy>;
320 return __pstl::__handle_exception<_Implementation>(
321 std::forward<_ExecutionPolicy>(__policy),
322 std::move(__first1),
323 std::move(__last1),
324 std::move(__first2),
325 std::move(__op));
326}
327
328_LIBCPP_END_NAMESPACE_STD
329
330#endif // _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
331
332_LIBCPP_POP_MACROS
333
334#endif // _LIBCPP___NUMERIC_PSTL_H
335