CeresEngine 0.2.0
A game development framework
Loading...
Searching...
No Matches
BinaryAlgorithm.hpp
Go to the documentation of this file.
1//
2// CeresEngine - A game development framework
3//
4// Created by Rogiel Sulzbach.
5// Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
6//
7
8#pragma once
9
10#include "Partitioner.hpp"
11
12#include "CeresEngine/Foundation/Traits/is_indirectly_binary_invocable.hpp"
13#include "CeresEngine/Foundation/Traits/is_input_range.hpp"
14#include "CeresEngine/Foundation/Traits/range_value.hpp"
15
16#include <numeric>
17
18namespace CeresEngine {
19
26 template<class Derived> class BinaryAlgorithmFunctor {
27 public:
29 template<class E, class P, class I, class S, class T, class Fun = std::plus<>>
30 requires(
31 // clang-format off
32 traits::is_executor_v<E> &&
33 traits::is_partitioner_v<P, I, S> &&
34 traits::is_input_iterator_v<I> &&
35 traits::is_sentinel_for_v<S, I> &&
36 std::is_same_v<traits::iter_value_t<I>, T> &&
37 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
38 std::is_copy_constructible_v<Fun>
39 // clang-format on
40 ) constexpr decltype(auto) parallel(const E& executor, P p, I first, S last, T i, Fun f = std::plus<>()) const {
41 if(std::is_constant_evaluated()) {
42 return Derived().run(make_inline_executor(), HalvePartitioner(1), first, last, i, std::move(f));
43 } else {
44 return Derived().run(executor, p, first, last, i, std::move(f));
45 }
46 }
47
49 template<class E, class P, class I, class S, class T, class Fun = std::plus<>>
50 requires(
51 // clang-format off
52 traits::is_executor_v<E> &&
53 traits::is_partitioner_v<P, I, S> &&
54 traits::is_input_iterator_v<I> &&
55 traits::is_sentinel_for_v<S, I> &&
56 std::is_same_v<traits::iter_value_t<I>, T> &&
57 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
58 std::is_copy_constructible_v<Fun>
59 // clang-format on
60 ) constexpr decltype(auto)
61 operator()(const E& executor, P p, I first, S last, T i, Fun f = std::plus<>()) const {
62 return parallel(executor, p, first, last, i, std::move(f));
63 }
64
66 template<class E, class P, class I, class S, class Fun = std::plus<>>
67 requires(
68 // clang-format off
69 traits::is_executor_v<E> &&
70 traits::is_partitioner_v<P, I, S> &&
71 traits::is_input_iterator_v<I> &&
72 traits::is_sentinel_for_v<S, I> &&
73 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
74 std::is_copy_constructible_v<Fun>
75 // clang-format on
76 ) constexpr decltype(auto) parallel(const E& executor, P p, I first, S last, Fun f = std::plus<>()) const {
77 if(first == last) {
78 return traits::iter_value_t<I>{};
79 }
80
81 if(std::is_constant_evaluated()) {
82 return Derived().run(make_inline_executor(), HalvePartitioner(1), std::next(first), last, *first, std::move(f));
83 } else {
84 return Derived().run(executor, p, std::next(first), last, *first, std::move(f));
85 }
86 }
87
89 template<class E, class P, class I, class S, class Fun = std::plus<>>
90 requires(
91 // clang-format off
92 traits::is_executor_v<E> &&
93 traits::is_partitioner_v<P, I, S> &&
94 traits::is_input_iterator_v<I> &&
95 traits::is_sentinel_for_v<S, I> &&
96 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
97 std::is_copy_constructible_v<Fun>
98 // clang-format on
99 ) constexpr decltype(auto)
100 operator()(const E& executor, P p, I first, S last, Fun f = std::plus<>()) const {
101 return parallel(executor, p, first, last, std::move(f));
102 }
103
105 template<class E, class P, class R, class T, class Fun = std::plus<>>
106 requires(
107 // clang-format off
108 traits::is_executor_v<E> &&
109 traits::is_range_partitioner_v<P,R> &&
110 traits::is_input_range_v<R> &&
111 std::is_same_v<traits::range_value_t<R>, T> &&
112 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
113 std::is_copy_constructible_v<Fun>
114 // clang-format on
115 ) constexpr decltype(auto) parallel(const E& executor, P p, R&& r, T i, Fun f = std::plus<>()) const {
116 if(std::is_constant_evaluated()) {
117 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), i, std::move(f));
118 } else {
119 return operator()(executor, p, std::begin(r), std::end(r), i, std::move(f));
120 }
121 }
122
124 template<class E, class P, class R, class T, class Fun = std::plus<>>
125 requires(
126 // clang-format off
127 traits::is_executor_v<E> &&
128 traits::is_range_partitioner_v<P,R> &&
129 traits::is_input_range_v<R> &&
130 std::is_same_v<traits::range_value_t<R>, T> &&
131 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
132 std::is_copy_constructible_v<Fun>
133 // clang-format on
134 ) constexpr decltype(auto)
135 operator()(const E& executor, P p, R&& r, T i, Fun f = std::plus<>()) const {
136 return parallel(executor, p, r, std::move(i), std::move(f));
137 }
138
140 template<class E, class P, class R, class Fun = std::plus<>>
141 requires(
142 // clang-format off
143 traits::is_executor_v<E> &&
144 traits::is_range_partitioner_v<P, R> &&
145 traits::is_input_range_v<R> &&
146 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
147 std::is_copy_constructible_v<Fun>
148 // clang-format on
149 ) constexpr decltype(auto) parallel(const E& executor, P p, R&& r, Fun f = std::plus<>()) const {
150 if(std::is_constant_evaluated()) {
151 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
152 } else {
153 return operator()(executor, p, std::begin(r), std::end(r), std::move(f));
154 }
155 }
156
158 template<class E, class P, class R, class Fun = std::plus<>>
159 requires(
160 // clang-format off
161 traits::is_executor_v<E> &&
162 traits::is_range_partitioner_v<P, R> &&
163 traits::is_input_range_v<R> &&
164 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
165 std::is_copy_constructible_v<Fun>
166 // clang-format on
167 ) constexpr decltype(auto)
168 operator()(const E& executor, P p, R&& r, Fun f = std::plus<>()) const {
169 return parallel(executor, p, std::forward<R>(r), std::move(f));
170 }
171
173 template<class P, class I, class S, class T, class Fun = std::plus<>>
174 requires(
175 // clang-format off
176 traits::is_partitioner_v< P, I, S> &&
177 traits::is_input_iterator_v<I> &&
178 traits::is_sentinel_for_v<S, I> &&
179 std::is_same_v<traits::iter_value_t<I>, T> &&
180 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
181 std::is_copy_constructible_v<Fun>
182 // clang-format on
183 ) constexpr decltype(auto) parallel(P p, I first, S last, T i, Fun f = std::plus<>()) const {
184 if(std::is_constant_evaluated()) {
185 return Derived{}.run(make_inline_executor(), HalvePartitioner(1), first, last, i, std::move(f));
186 } else {
187 return Derived{}.run(make_default_executor(), p, first, last, i, std::move(f));
188 }
189 }
190
192 template<class P, class I, class S, class Fun = std::plus<>>
193 requires(
194 // clang-format off
195 traits::is_partitioner_v<P,I,S> &&
196 traits::is_input_iterator_v<I> &&
197 traits::is_sentinel_for_v<S, I> &&
198 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
199 std::is_copy_constructible_v<Fun>
200 // clang-format on
201 ) constexpr decltype(auto) parallel(P p, I first, S last, Fun f = std::plus<>()) const {
202 if(std::is_constant_evaluated()) {
203 return operator()(make_inline_executor(), HalvePartitioner(1), first, last, std::move(f));
204 } else {
205 return operator()(make_default_executor(), p, first, last, std::move(f));
206 }
207 }
208
210 template<class P, class R, class T, class Fun = std::plus<>>
211 requires(
212 // clang-format off
213 traits::is_range_partitioner_v<P,R> &&
214 traits::is_input_range_v<R> &&
215 std::is_same_v<traits::range_value_t<R>, T> &&
216 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
217 std::is_copy_constructible_v<Fun>
218 // clang-format on
219 ) constexpr decltype(auto) parallel(P p, R&& r, T i, Fun f = std::plus<>()) const {
220 if(std::is_constant_evaluated()) {
221 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), i, std::move(f));
222 } else {
223 return operator()(make_default_executor(), p, std::begin(r), std::end(r), i, std::move(f));
224 }
225 }
226
228 template<class P, class R, class Fun = std::plus<>>
229 requires(
230 // clang-format off
231 traits::is_range_partitioner_v<P, R> &&
232 traits::is_input_range_v<R> &&
233 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
234 std::is_copy_constructible_v<Fun>
235 // clang-format on
236 ) constexpr decltype(auto) parallel(P p, R&& r, Fun f = std::plus<>()) const {
237 if(std::is_constant_evaluated()) {
238 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
239 } else {
240 return operator()(make_default_executor(), p, std::begin(r), std::end(r), std::move(f));
241 }
242 }
243
245 template<class E, class I, class S, class T, class Fun = std::plus<>>
246 requires(
247 // clang-format off
248 traits::is_executor_v<E> &&
249 traits::is_input_iterator_v<I> &&
250 traits::is_sentinel_for_v<S, I> &&
251 std::is_same_v<traits::iter_value_t<I>, T> &&
252 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
253 std::is_copy_constructible_v<Fun>
254 // clang-format on
255 ) constexpr decltype(auto) parallel(const E& executor, I first, S last, T i, Fun f = std::plus<>()) const {
256 if(std::is_constant_evaluated()) {
257 return operator()(make_inline_executor(), HalvePartitioner(1), first, last, i, std::move(f));
258 } else {
259 return operator()(executor, make_default_partitioner(executor, first, last), first, last, i, std::move(f));
260 }
261 }
262
264 template<class E, class I, class S, class T, class Fun = std::plus<>>
265 requires(
266 // clang-format off
267 traits::is_executor_v<E> &&
268 traits::is_input_iterator_v<I> &&
269 traits::is_sentinel_for_v<S, I> &&
270 std::is_same_v<traits::iter_value_t<I>, T> &&
271 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
272 std::is_copy_constructible_v<Fun>
273 // clang-format on
274 ) constexpr decltype(auto)
275 operator()(const E& executor, I first, S last, T i, Fun f = std::plus<>()) const {
276 return parallel(executor, first, last, std::move(i), std::move(f));
277 }
278
280 template<class E, class I, class S, class Fun = std::plus<>>
281 requires(
282 // clang-format off
283 traits::is_executor_v<E> &&
284 traits::is_input_iterator_v<I> &&
285 traits::is_sentinel_for_v<S, I> &&
286 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
287 std::is_copy_constructible_v<Fun>
288 // clang-format on
289 ) constexpr decltype(auto) parallel(const E& executor, I first, S last, Fun f = std::plus<>()) const {
290 if(std::is_constant_evaluated()) {
291 return operator()(make_inline_executor(), HalvePartitioner(1), first, last, std::move(f));
292 } else {
293 return operator()(executor, make_default_partitioner(executor, first, last), first, last, std::move(f));
294 }
295 }
296
298 template<class E, class I, class S, class Fun = std::plus<>>
299 requires(
300 // clang-format off
301 traits::is_executor_v<E> &&
302 traits::is_input_iterator_v<I> &&
303 traits::is_sentinel_for_v<S, I> &&
304 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
305 std::is_copy_constructible_v<Fun>
306 // clang-format on
307 ) constexpr decltype(auto)
308 operator()(const E& executor, I first, S last, Fun f = std::plus<>()) const {
309 return parallel(executor, first, last, std::move(f));
310 }
311
313 template<class E, class R, class T, class Fun = std::plus<>>
314 requires(
315 // clang-format off
316 traits::is_executor_v<E> &&
317 traits::is_input_range_v<R> &&
318 std::is_same_v<traits::range_value_t<R>, T> &&
319 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
320 std::is_copy_constructible_v<Fun>
321 // clang-format on
322 ) constexpr decltype(auto) parallel(const E& executor, R&& r, T i, Fun f = std::plus<>()) const {
323 if(std::is_constant_evaluated()) {
324 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), i, std::move(f));
325 } else {
326 return operator()(executor, make_default_partitioner(executor, r), std::begin(r), std::end(r), i, std::move(f));
327 }
328 }
329
331 template<class E, class R, class T, class Fun = std::plus<>>
332 requires(
333 // clang-format off
334 traits::is_executor_v<E> &&
335 traits::is_input_range_v<R> &&
336 std::is_same_v<traits::range_value_t<R>, T> &&
337 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
338 std::is_copy_constructible_v<Fun>
339 // clang-format on
340 ) constexpr decltype(auto)
341 operator()(const E& executor, R&& r, T i, Fun f = std::plus<>()) const {
342 return parallel(executor, std::forward<R>(r), std::move(i), std::move(f));
343 }
344
346 template<class E, class R, class Fun = std::plus<>>
347 requires(
348 // clang-format off
349 traits::is_executor_v<E> &&
350 traits::is_input_range_v<R> &&
351 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
352 std::is_copy_constructible_v<Fun>
353 // clang-format on
354 ) constexpr decltype(auto) parallel(const E& executor, R&& r, Fun f = std::plus<>()) const {
355 if(std::is_constant_evaluated()) {
356 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
357 } else {
358 return operator()(executor, make_default_partitioner(executor, r), std::begin(r), std::end(r), std::move(f));
359 }
360 }
361
363 template<class E, class R, class Fun = std::plus<>>
364 requires(
365 // clang-format off
366 traits::is_executor_v<E> &&
367 traits::is_input_range_v<R> &&
368 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
369 std::is_copy_constructible_v<Fun>
370 // clang-format on
371 ) constexpr decltype(auto)
372 operator()(const E& executor, R&& r, Fun f = std::plus<>()) const {
373 return parallel(executor, std::forward<R>(r), std::move(f));
374 }
375
377 template<class I, class S, class T, class Fun = std::plus<>>
378 requires(
379 // clang-format off
380 traits::is_input_iterator_v<I> &&
381 traits::is_sentinel_for_v<S, I> &&
382 std::is_same_v<traits::iter_value_t<I>, T> &&
383 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
384 std::is_copy_constructible_v<Fun>
385 // clang-format on
386 ) constexpr decltype(auto) parallel(I first, S last, T i, Fun f = std::plus<>()) const {
387 if(std::is_constant_evaluated()) {
388 return operator()(make_inline_executor(), HalvePartitioner(1), first, last, i, std::move(f));
389 } else {
390 return operator()(make_default_executor(), make_default_partitioner(first, last), first, last, i, std::move(f));
391 }
392 }
393
395 template<class I, class S, class T, class Fun = std::plus<>>
396 requires(
397 // clang-format off
398 traits::is_input_iterator_v<I> &&
399 traits::is_sentinel_for_v<S, I> &&
400 std::is_same_v<traits::iter_value_t<I>, T> &&
401 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
402 std::is_copy_constructible_v<Fun>
403 // clang-format on
404 ) constexpr decltype(auto)
405 operator()(I first, S last, T i, Fun f = std::plus<>()) const {
406 return Derived{}.run(first, last, i, std::move(f));
407 }
408
411 template<class I, class S, class Fun = std::plus<>>
412 requires(
413 // clang-format off
414 traits::is_input_iterator_v<I> &&
415 traits::is_sentinel_for_v<S, I> &&
416 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
417 std::is_copy_constructible_v<Fun>
418 // clang-format on
419 ) constexpr decltype(auto) parallel(I first, S last, Fun f = std::plus<>()) const {
420 if(std::is_constant_evaluated()) {
421 return operator()(make_inline_executor(), HalvePartitioner(1), first, last, std::move(f));
422 } else {
423 return operator()(make_default_executor(), make_default_partitioner(first, last), first, last, std::move(f));
424 }
425 }
426
429 template<class I, class S, class Fun = std::plus<>>
430 requires(
431 // clang-format off
432 traits::is_input_iterator_v<I> &&
433 traits::is_sentinel_for_v<S, I> &&
434 traits::is_indirectly_binary_invocable_v<Fun, I, I> &&
435 std::is_copy_constructible_v<Fun>
436 // clang-format on
437 ) constexpr decltype(auto)
438 operator()(I first, S last, Fun f = std::plus<>()) const {
439 return operator()(first, last, std::move(f));
440 }
441
443 template<class R, class T, class Fun = std::plus<>>
444 requires(
445 // clang-format off
446 traits::is_input_range_v<R> &&
447 std::is_same_v<traits::range_value_t<R>, T> &&
448 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
449 std::is_copy_constructible_v<Fun>
450 // clang-format on
451 ) constexpr decltype(auto) parallel(R&& r, T i, Fun f = std::plus<>()) const {
452 if(std::is_constant_evaluated()) {
453 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), i, std::move(f));
454 } else {
455 return operator()(make_default_executor(), make_default_partitioner(r), std::begin(r), std::end(r), i, std::move(f));
456 }
457 }
458
460 template<class R, class T, class Fun = std::plus<>>
461 requires(
462 // clang-format off
463 traits::is_input_range_v<R> &&
464 std::is_same_v<traits::range_value_t<R>, T> &&
465 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
466 std::is_copy_constructible_v<Fun>
467 // clang-format on
468 ) constexpr decltype(auto)
469 operator()(R&& r, T i, Fun f = std::plus<>()) const {
470 return Derived{}.run(std::begin(r), std::end(r), i, std::move(f));
471 }
472
474 template<class R, class Fun = std::plus<>>
475 requires(
476 // clang-format off
477 traits::is_input_range_v<R> &&
478 traits::is_indirectly_binary_invocable_v<Fun, traits::iterator_t<R>, traits::iterator_t<R>> &&
479 std::is_copy_constructible_v<Fun>
480 // clang-format on
481 ) constexpr decltype(auto)
482 operator()(R&& r, Fun f = std::plus<>()) const {
483 if(std::is_constant_evaluated()) {
484 return operator()(make_inline_executor(), HalvePartitioner(1), std::begin(r), std::end(r), std::move(f));
485 } else {
486 return operator()(make_default_executor(), make_default_partitioner(r), std::begin(r), std::end(r), std::move(f));
487 }
488 }
489 };
490
491} // namespace CeresEngine
Partitioner.hpp
A partitioner is a light callable object that takes a pair of iterators and returns the middle of the...
CeresEngine::BinaryAlgorithmFunctor
Binary algorithm overloads.
Definition BinaryAlgorithm.hpp:26
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, P p, I first, S last, Fun f=std::plus<>()) const
Overload for default init value.
Definition BinaryAlgorithm.hpp:76
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(R &&r, T i, Fun f=std::plus<>()) const
Overload for Ranges / default executor / default partitioner.
Definition BinaryAlgorithm.hpp:469
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, R &&r, Fun f=std::plus<>()) const
Overload for Ranges / default partitioner / default init value.
Definition BinaryAlgorithm.hpp:354
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, I first, S last, T i, Fun f=std::plus<>()) const
Overload for Iterators / default partitioner.
Definition BinaryAlgorithm.hpp:255
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, R &&r, Fun f=std::plus<>()) const
Overload for Ranges / default partitioner / default init value.
Definition BinaryAlgorithm.hpp:372
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(I first, S last, T i, Fun f=std::plus<>()) const
Overload for Iterators / default executor / default partitioner.
Definition BinaryAlgorithm.hpp:386
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, P p, I first, S last, T i, Fun f=std::plus<>()) const
Complete overload.
Definition BinaryAlgorithm.hpp:61
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, P p, R &&r, T i, Fun f=std::plus<>()) const
Overload for Ranges.
Definition BinaryAlgorithm.hpp:115
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, P p, R &&r, Fun f=std::plus<>()) const
Definition BinaryAlgorithm.hpp:168
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, I first, S last, T i, Fun f=std::plus<>()) const
Definition BinaryAlgorithm.hpp:275
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, P p, I first, S last, T i, Fun f=std::plus<>()) const
Complete overload.
Definition BinaryAlgorithm.hpp:40
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, I first, S last, Fun f=std::plus<>()) const
Overload for Iterators / default partitioner / default init value.
Definition BinaryAlgorithm.hpp:289
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, P p, I first, S last, Fun f=std::plus<>()) const
Definition BinaryAlgorithm.hpp:100
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, R &&r, T i, Fun f=std::plus<>()) const
Overload for Ranges / default partitioner.
Definition BinaryAlgorithm.hpp:322
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(I first, S last, Fun f=std::plus<>()) const
Iterators / default executor / default partitioner / default init value.
Definition BinaryAlgorithm.hpp:419
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(const E &executor, P p, R &&r, Fun f=std::plus<>()) const
Overload for Ranges / default init value.
Definition BinaryAlgorithm.hpp:149
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(I first, S last, T i, Fun f=std::plus<>()) const
Overload for Iterators / default executor / default partitioner.
Definition BinaryAlgorithm.hpp:405
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(P p, R &&r, T i, Fun f=std::plus<>()) const
Overload for Ranges / default parallel executor.
Definition BinaryAlgorithm.hpp:219
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(I first, S last, Fun f=std::plus<>()) const
Iterators / default executor / default partitioner / default init value.
Definition BinaryAlgorithm.hpp:438
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, I first, S last, Fun f=std::plus<>()) const
Definition BinaryAlgorithm.hpp:308
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(P p, R &&r, Fun f=std::plus<>()) const
Overload for Ranges / default parallel executor / default init value.
Definition BinaryAlgorithm.hpp:236
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(R &&r, T i, Fun f=std::plus<>()) const
Overload for Ranges / default executor / default partitioner.
Definition BinaryAlgorithm.hpp:451
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(P p, I first, S last, T i, Fun f=std::plus<>()) const
Overload for Iterators / default parallel executor.
Definition BinaryAlgorithm.hpp:183
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(R &&r, Fun f=std::plus<>()) const
Ranges / default executor / default partitioner / default init value.
Definition BinaryAlgorithm.hpp:482
CeresEngine::BinaryAlgorithmFunctor::parallel
constexpr decltype(auto) parallel(P p, I first, S last, Fun f=std::plus<>()) const
Overload for Iterators / default parallel executor / default init value.
Definition BinaryAlgorithm.hpp:201
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, P p, R &&r, T i, Fun f=std::plus<>()) const
Definition BinaryAlgorithm.hpp:135
CeresEngine::BinaryAlgorithmFunctor::operator()
constexpr decltype(auto) operator()(const E &executor, R &&r, T i, Fun f=std::plus<>()) const
Definition BinaryAlgorithm.hpp:341
CeresEngine::HalvePartitioner
The halve partitioner always splits the sequence into two parts of roughly equal size.
Definition Partitioner.hpp:37
is_indirectly_binary_invocable.hpp
is_input_range.hpp
CeresEngine::traits::iterator_t
typename iterator< T >::type iterator_t
A C++17 type trait equivalent to the C++20 iterator_t concept.
Definition iterator.hpp:27
CeresEngine::traits::iter_value_t
typename iter_value< T >::type iter_value_t
A C++17 type trait equivalent to the C++20 iter_value concept.
Definition iter_value.hpp:58
CeresEngine
Definition Application.hpp:19
CeresEngine::make_inline_executor
constexpr auto make_inline_executor()
An executor that runs anything inline.
Definition ExecutionContext.hpp:660
CeresEngine::make_default_executor
auto make_default_executor()
The default executor to be used when no other executor is provided.
Definition ExecutionContext.hpp:743
CeresEngine::hash
constexpr size_t hash(const T &v)
Generates a hash for the provided type.
Definition Hash.hpp:25
CeresEngine::make_default_partitioner
DefaultPartitioner make_default_partitioner(const size_t n, const std::size_t occupancy=hardware_concurrency())
Create an instance of the default partitioner with a reasonable grain size for n elements.
Definition Partitioner.hpp:97
range_value.hpp