| 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 | |
| 38 | template <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 | |
| 65 | template <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 | |
| 88 | template <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 | |
| 102 | template <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 | |
| 120 | template <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 |
| 126 | reduce(_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 | |
| 133 | template <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> |
| 138 | reduce(_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 | |
| 149 | template <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 | |
| 179 | template <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 | |
| 206 | template <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 |
| 238 | template <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 | |
| 264 | template <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 | |
| 289 | template <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 | |
| 304 | template <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 | |