std::__parallel(3)
💖 NAME 💖
std::__parallel — GNU parallel code, and the way it works is that it replaces standard behavior with parallel behavior. yes bestie, that's literally the whole plot 🫶
✨ SYNOPSIS ✨
🎀 Classes 🎀
struct _CRandNumber— a functor wrapper forstd::rand(). she's giving "one job, does it well" 💅
okay so that's the setup, and there's so much more coming — stay with me, we're not done yet 🌸
🦋 Functions 🦋
okay bestie, buckle UP 🎀 because this is the part where the page just starts hurling function templates at you. and there are so many of them. but here's the tea ☕ — they all follow the same iconic little pattern, so the second you clock it, you're basically fluent:
- there's a "real" overload that takes
random_access_iterator_tag(and sometimes a__gnu_parallel::_Parallelismargument too) — that's the one built to actually go parallel ✨ - there's a generic overload that takes some other
_IteratorTaginstead — that's the fallback vibe - and sometimes there's a bare version where the parameters don't even get names 🙈
and every single one of them ends in _switch. it's giving dispatch, it's giving "pick your iterator tag and I'll handle it", it's lowkey iconic 💅
🌀 __accumulate_switch
the accumulate squad. six of them. let's go 🫶
- the full-parallel one — random-access iterators, a real
__binary_op, and a__parallelism_tagto steer the whole thing:
template<typename __RAIter, typename _Tp, typename _BinaryOperation> _Tp
__accumulate_switch (__RAIter __begin, __RAIter __end, _Tp __init,
_BinaryOperation __binary_op, random_access_iterator_tag,
__gnu_parallel::_Parallelism __parallelism_tag)- generic iterator tag, binary op included:
template<typename _IIter, typename _Tp, typename _BinaryOperation,
typename _IteratorTag> _Tp __accumulate_switch (_IIter __begin,
_IIter __end, _Tp __init, _BinaryOperation __binary_op,
_IteratorTag)- generic iterator tag, no binary op, just vibes:
template<typename _IIter, typename _Tp, typename _IteratorTag> _Tp
__accumulate_switch (_IIter __begin, _IIter __end, _Tp __init,
_IteratorTag)- unnamed-parameter edition, with
_BinaryOper:
template<typename _IIter, typename _Tp, typename _BinaryOper, typename
_Tag> _Tp __accumulate_switch (_IIter, _IIter, _Tp, _BinaryOper,
_Tag)- unnamed-parameter edition, no
_BinaryOper:
template<typename _IIter, typename _Tp, typename _Tag> _Tp
__accumulate_switch (_IIter, _IIter, _Tp, _Tag)- and the unnamed-parameter random-access one, where
__parallelismdefaults to__gnu_parallel::parallel_unbalanced🌀:
template<typename _RAIter, typename _Tp, typename _BinaryOper> _Tp
__accumulate_switch (_RAIter, _RAIter, _Tp, _BinaryOper,
random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism=__gnu_parallel::parallel_unbalanced)🦋 __adjacent_difference_switch
four of these, and every one of them takes two iterator tags. yes bestie, two. we love a two-tag moment 🌈
- generic tags on both sides,
__bin_opin hand:
template<typename _IIter, typename _OutputIterator, typename
_BinaryOperation, typename _IteratorTag1, typename _IteratorTag2>
_OutputIterator __adjacent_difference_switch (_IIter __begin, _IIter
__end, _OutputIterator __result, _BinaryOperation __bin_op,
_IteratorTag1, _IteratorTag2)- both tags are random access, and there's a
__parallelism_tagin the mix:
template<typename _IIter, typename _OutputIterator, typename
_BinaryOperation> _OutputIterator __adjacent_difference_switch
(_IIter __begin, _IIter __end, _OutputIterator __result,
_BinaryOperation __bin_op, random_access_iterator_tag,
random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism_tag)- unnamed parameters,
_OIterand_BinaryOperstyle:
template<typename _IIter, typename _OIter, typename _BinaryOper,
typename _Tag1, typename _Tag2> _OIter __adjacent_difference_switch
(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2)- unnamed parameters again, random access on both ends, with
__parallelismdefaulting to__gnu_parallel::parallel_unbalanced:
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter
__adjacent_difference_switch (_IIter, _IIter, _OIter, _BinaryOper,
random_access_iterator_tag, random_access_iterator_tag,
__gnu_parallel::_Parallelism
__parallelism=__gnu_parallel::parallel_unbalanced)🌸 __adjacent_find_switch
seven whole overloads for finding adjacent stuff. she's thorough, okay? let her cook 🔥
_BiPredicate+_IterTag, unnamed:
template<typename _FIter, typename _BiPredicate, typename _IterTag>
_FIter __adjacent_find_switch (_FIter, _FIter, _BiPredicate,
_IterTag)_IterTagonly, unnamed:
template<typename _FIter, typename _IterTag> _FIter
__adjacent_find_switch (_FIter, _FIter, _IterTag)- now with named parameters,
_BinaryPredicate+_IteratorTag:
template<typename _FIterator, typename _BinaryPredicate, typename
_IteratorTag> _FIterator __adjacent_find_switch (_FIterator __begin,
_FIterator __end, _BinaryPredicate __pred, _IteratorTag)- named parameters, no predicate:
template<typename _FIterator, typename _IteratorTag> _FIterator
__adjacent_find_switch (_FIterator __begin, _FIterator __end,
_IteratorTag)- the random-access one with a predicate — no parallelism arg here, just
random_access_iterator_tag:
template<typename _RAIter, typename _BinaryPredicate> _RAIter
__adjacent_find_switch (_RAIter __begin, _RAIter __end,
_BinaryPredicate __pred, random_access_iterator_tag)- the random-access one, predicate-free:
template<typename _RAIter> _RAIter __adjacent_find_switch (_RAIter
__begin, _RAIter __end, random_access_iterator_tag)- and the unnamed-parameter random-access one with
_BiPredicate:
template<typename _RAIter, typename _BiPredicate> _RAIter
__adjacent_find_switch (_RAIter, _RAIter, _BiPredicate,
random_access_iterator_tag)🧚 __count_if_switch
counting things that match a predicate. three versions, and every one returns iterator_traits< _IIter >::difference_type (or _RAIter, same energy) — no cap, that's the return type, respect it 💜
- generic
_IteratorTag, named params:
template<typename _IIter, typename _Predicate, typename _IteratorTag>
iterator_traits< _IIter >::difference_type __count_if_switch (_IIter
__begin, _IIter __end, _Predicate __pred, _IteratorTag)- unnamed params,
_IterTag:
template<typename _IIter, typename _Predicate, typename _IterTag>
iterator_traits< _IIter >::difference_type __count_if_switch
(_IIter, _IIter, _Predicate, _IterTag)- the random-access one with a
__parallelism_tag:
template<typename _RAIter, typename _Predicate> iterator_traits< _RAIter
>::difference_type __count_if_switch (_RAIter __begin, _RAIter
__end, _Predicate __pred, random_access_iterator_tag,
__gnu_parallel::_Parallelism __parallelism_tag)⭐ __count_switch
same as above but counting a const _Tp &__value instead of running a predicate. three of them, go off 👑
- generic, named, with the value:
template<typename _IIter, typename _Tp, typename _IteratorTag>
iterator_traits< _IIter >::difference_type __count_switch (_IIter
__begin, _IIter __end, const _Tp &__value, _IteratorTag)- unnamed params, value unnamed too:
template<typename _IIter, typename _Tp, typename _IterTag>
iterator_traits< _IIter >::difference_type __count_switch (_IIter,
_IIter, const _Tp &, _IterTag)- random access +
__parallelism_tag:
template<typename _RAIter, typename _Tp> iterator_traits< _RAIter
>::difference_type __count_switch (_RAIter __begin, _RAIter __end,
const _Tp &__value, random_access_iterator_tag,
__gnu_parallel::_Parallelism __parallelism_tag)💫 __equal_switch
comparing two ranges. only two overloads, and both hand back a plain bool. short and sweet, we love to see it 🍓
- two generic iterator tags, full set of named params:
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IteratorTag1, typename _IteratorTag2> bool __equal_switch
(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
_Predicate __pred, _IteratorTag1, _IteratorTag2)- both sides random access:
template<typename _RAIter1, typename _RAIter2, typename _Predicate> bool
__equal_switch (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2
__begin2, _RAIter2 __end2, _Predicate __pred,
random_access_iterator_tag, random_access_iterator_tag)🌈 __find_first_of_switch
six overloads, and honestly? this family ate. look at all the tag combos 💅
_BinaryPredicate __comp+ two generic tags:
template<typename _IIter, typename _FIterator, typename
_BinaryPredicate, typename _IteratorTag1, typename _IteratorTag2>
_IIter __find_first_of_switch (_IIter __begin1, _IIter __end1,
_FIterator __begin2, _FIterator __end2, _BinaryPredicate __comp,
_IteratorTag1, _IteratorTag2)- same but with no predicate at all:
template<typename _IIter, typename _FIterator, typename _IteratorTag1,
typename _IteratorTag2> _IIter __find_first_of_switch (_IIter
__begin1, _IIter __end1, _FIterator __begin2, _FIterator __end2,
_IteratorTag1, _IteratorTag2)- unnamed params,
_BiPredicate,_IterTag1/_IterTag2:
template<typename _IIter, typename _FIter, typename _BiPredicate,
typename _IterTag1, typename _IterTag2> _IIter
__find_first_of_switch (_IIter, _IIter, _FIter, _FIter,
_BiPredicate, _IterTag1, _IterTag2)- unnamed params, no predicate:
template<typename _IIter, typename _FIter, typename _IterTag1, typename
_IterTag2> _IIter __find_first_of_switch (_IIter, _IIter, _FIter,
_FIter, _IterTag1, _IterTag2)- first range random access, second range keeps its own
_IteratorTag, with__comp:
template<typename _RAIter, typename _FIterator, typename
_BinaryPredicate, typename _IteratorTag> _RAIter
__find_first_of_switch (_RAIter __begin1, _RAIter __end1, _FIterator
__begin2, _FIterator __end2, _BinaryPredicate __comp,
random_access_iterator_tag, _IteratorTag)- and the unnamed-parameter version of that same mix:
template<typename _RAIter, typename _FIter, typename _BiPredicate,
typename _IterTag> _RAIter __find_first_of_switch (_RAIter, _RAIter,
_FIter, _FIter, _BiPredicate, random_access_iterator_tag, _IterTag)🎀 __find_if_switch
finding with a predicate. three overloads, all returning an _IIter (or _RAIter) — so you get the iterator back, not a bool. queen behaviour 👑
- generic tag, named:
template<typename _IIter, typename _Predicate, typename _IteratorTag>
_IIter __find_if_switch (_IIter __begin, _IIter __end, _Predicate
__pred, _IteratorTag)- unnamed,
_IterTag:
template<typename _IIter, typename _Predicate, typename _IterTag> _IIter
__find_if_switch (_IIter, _IIter, _Predicate, _IterTag)- random access:
template<typename _RAIter, typename _Predicate> _RAIter __find_if_switch
(_RAIter __begin, _RAIter __end, _Predicate __pred,
random_access_iterator_tag)🔍 __find_switch
the plain-find sibling of the above, looking for a const _Tp &__val instead. three of them, same energy 💖
- generic tag, named:
template<typename _IIter, typename _Tp, typename _IteratorTag> _IIter
__find_switch (_IIter __begin, _IIter __end, const _Tp &__val,
_IteratorTag)- unnamed everything:
template<typename _IIter, typename _Tp, typename _IterTag> _IIter
__find_switch (_IIter, _IIter, const _Tp &, _IterTag)- random access:
template<typename _RAIter, typename _Tp> _RAIter __find_switch (_RAIter
__begin, _RAIter __end, const _Tp &__val,
random_access_iterator_tag)✨ __for_each_switch
running a _Function over a range. three overloads, and the random-access one brings a __parallelism_tag to the party. main character energy, fr fr 🔥
- generic tag, named:
template<typename _IIter, typename _Function, typename _IteratorTag>
_Function __for_each_switch (_IIter __begin, _IIter __end, _Function
__f, _IteratorTag)- unnamed,
_IterTag:
template<typename _IIter, typename _Function, typename _IterTag>
_Function __for_each_switch (_IIter, _IIter, _Function, _IterTag)- random access +
__parallelism_tag:
template<typename _RAIter, typename _Function> _Function
__for_each_switch (_RAIter __begin, _RAIter __end, _Function __f,
random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism_tag)🧵 __generate_n_switch
generating n things. three overloads — and yes, the order of the named ones is a little quirky, we don't ask questions, we just respect it 🙈
- unnamed,
_OIter+_IterTag:
template<typename _OIter, typename _Size, typename _Generator, typename
_IterTag> _OIter __generate_n_switch (_OIter, _Size, _Generator,
_IterTag)- named,
_OutputIterator+_IteratorTag:
template<typename _OutputIterator, typename _Size, typename _Generator,
typename _IteratorTag> _OutputIterator __generate_n_switch
(_OutputIterator __begin, _Size __n, _Generator __gen, _IteratorTag)- random access +
__parallelism_tag:
template<typename _RAIter, typename _Size, typename _Generator> _RAIter
__generate_n_switch (_RAIter __begin, _Size __n, _Generator __gen,
random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism_tag)🪄 __generate_switch
same idea but for a whole range instead of n items. three overloads, and these ones return void — no return value, no notes 💀
- unnamed,
_FIter+_IterTag:
template<typename _FIter, typename _Generator, typename _IterTag> void
__generate_switch (_FIter, _FIter, _Generator, _IterTag)- named,
_FIterator+_IteratorTag:
template<typename _FIterator, typename _Generator, typename
_IteratorTag> void __generate_switch (_FIterator __begin, _FIterator
__end, _Generator __gen, _IteratorTag)- random access +
__parallelism_tag:
template<typename _RAIter, typename _Generator> void __generate_switch
(_RAIter __begin, _RAIter __end, _Generator __gen,
random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism_tag)🧮 __inner_product_switch
two binary functions, because one was simply not enough. three overloads, and the last one's __parallelism defaults to __gnu_parallel::parallel_unbalanced 🌸
- two generic tags, fully named,
__binary_op1and__binary_op2in the building:
template<typename _IIter1, typename _IIter2, typename _Tp, typename
_BinaryFunction1, typename _BinaryFunction2, typename _IteratorTag1,
typename _IteratorTag2> _Tp __inner_product_switch (_IIter1
__first1, _IIter1 __last1, _IIter2 __first2, _Tp __init,
_BinaryFunction1 __binary_op1, _BinaryFunction2 __binary_op2,
_IteratorTag1, _IteratorTag2)- unnamed-parameter edition:
template<typename _IIter1, typename _IIter2, typename _Tp, typename
_BinaryFunction1, typename _BinaryFunction2, typename _Tag1,
typename _Tag2> _Tp __inner_product_switch (_IIter1, _IIter1,
_IIter2, _Tp, _BinaryFunction1, _BinaryFunction2, _Tag1, _Tag2)- random access both sides, with the defaulted
__parallelism:
template<typename _RAIter1, typename _RAIter2, typename _Tp, typename
_BinaryFunction1, typename _BinaryFunction2> _Tp
__inner_product_switch (_RAIter1, _RAIter1, _RAIter2, _Tp,
_BinaryFunction1, _BinaryFunction2, random_access_iterator_tag,
random_access_iterator_tag,
__gnu_parallel::_Parallelism=__gnu_parallel::parallel_unbalanced)📚 __lexicographical_compare_switch
lexicographical comparison, predicate included, bool out. three overloads — and bestie, the last one is mid-sentence when this page cuts off 😭 so here's exactly what's on the page:
- two generic tags, named:
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IteratorTag1, typename _IteratorTag2> bool
__lexicographical_compare_switch (_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2, _Predicate __pred, _IteratorTag1,
_IteratorTag2)- unnamed-parameter edition:
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IterTag1, typename _IterTag2> bool
__lexicographical_compare_switch (_IIter1, _IIter1, _IIter2,
_IIter2, _Predicate, _IterTag1, _IterTag2)- random access, named — and then… that's where the page ends 💀:
template<typename _RAIter1, typename _RAIter2, typename _Predicate> bool
__lexicographical_compare_switch (_RAIter1 __begin1, _RAIter1
__end1, _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred,okay so bestie, what you're looking at here is the _switch era of the synopsis — a whole army of little dispatch girlies, all named __something_switch 💅 they all take the same-ish stuff you'd expect (your iterators, your predicates, your comparators) and then a tag at the end that says which kind of iterator you rolled up with. some of them also want a __gnu_parallel::_Parallelism __parallelism_tag and honestly, good for them.
the vibe: one name, several overloads. generic tag version for the generic girlies, _IteratorTag-flavoured version with actual parameter names, and a random_access_iterator_tag version for the fast lane. no cap, it's the same joke told 40 times and we're eating it up 🍓
🎀 __max_element_switch
first line is the tail end of an overload that started back in part 2, so don't @ me about it starting mid-thought 🙈
random_access_iterator_tag, random_access_iterator_tag)
template<typename _FIter, typename _Compare, typename _IterTag> _FIter
__max_element_switch (_FIter, _FIter, _Compare, _IterTag)
template<typename _FIterator, typename _Compare, typename _IteratorTag>
_FIterator __max_element_switch (_FIterator __begin, _FIterator
__end, _Compare __comp, _IteratorTag)
template<typename _RAIter, typename _Compare> _RAIter
__max_element_switch (_RAIter __begin, _RAIter __end, _Compare
__comp, random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism_tag)🔀 __merge_switch
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _Compare, typename _IteratorTag1, typename _IteratorTag2,
typename _IteratorTag3> _OutputIterator __merge_switch (_IIter1
__begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
_OutputIterator __result, _Compare __comp, _IteratorTag1,
_IteratorTag2, _IteratorTag3)
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _Compare> _OutputIterator __merge_switch (_IIter1 __begin1,
_IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator
__result, _Compare __comp, random_access_iterator_tag,
random_access_iterator_tag, random_access_iterator_tag)
template<typename _IIter1, typename _IIter2, typename _OIter, typename
_Compare, typename _IterTag1, typename _IterTag2, typename
_IterTag3> _OIter __merge_switch (_IIter1, _IIter1, _IIter2,
_IIter2, _OIter, _Compare, _IterTag1, _IterTag2, _IterTag3)
template<typename _IIter1, typename _IIter2, typename _OIter, typename
_Compare> _OIter __merge_switch (_IIter1, _IIter1, _IIter2, _IIter2,
_OIter, _Compare, random_access_iterator_tag,
random_access_iterator_tag, random_access_iterator_tag)💖 __min_element_switch
yes, she's the twin of __max_element_switch and yes, the parameter list is identical. iconic behaviour, no notes 👑
template<typename _FIter, typename _Compare, typename _IterTag> _FIter
__min_element_switch (_FIter, _FIter, _Compare, _IterTag)
template<typename _FIterator, typename _Compare, typename _IteratorTag>
_FIterator __min_element_switch (_FIterator __begin, _FIterator
__end, _Compare __comp, _IteratorTag)
template<typename _RAIter, typename _Compare> _RAIter
__min_element_switch (_RAIter __begin, _RAIter __end, _Compare
__comp, random_access_iterator_tag, __gnu_parallel::_Parallelism
__parallelism_tag)🦋 __mismatch_switch
the way this one returns pair< _IIter1, _IIter2 > — she's giving ✨two-for-one✨ and we're obsessed.
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IteratorTag1, typename _IteratorTag2> pair< _IIter1,
_IIter2 > __mismatch_switch (_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2, _Predicate __pred, _IteratorTag1,
_IteratorTag2)
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IteratorTag1, typename _IteratorTag2> pair< _IIter1,
_IIter2 > __mismatch_switch (_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _Predicate __pred, _IteratorTag1, _IteratorTag2)
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IterTag1, typename _IterTag2> pair< _IIter1, _IIter2 >
__mismatch_switch (_IIter1, _IIter1, _IIter2, _Predicate, _IterTag1,
_IterTag2)
template<typename _RAIter1, typename _RAIter2, typename _Predicate>
pair< _RAIter1, _RAIter2 > __mismatch_switch (_RAIter1 __begin1,
_RAIter1 __end1, _RAIter2 __begin2, _Predicate __pred,
random_access_iterator_tag, random_access_iterator_tag)
template<typename _RAIter1, typename _RAIter2, typename _Predicate>
pair< _RAIter1, _RAIter2 > __mismatch_switch (_RAIter1 __begin1,
_RAIter1 __end1, _RAIter2 __begin2, _RAIter2 __end2, _Predicate
__pred, random_access_iterator_tag, random_access_iterator_tag)🌸 __partial_sum_switch
four overloads, and the naming flips between _OutputIterator and _OIter depending on which one you're reading, plus _BinaryOperation vs _BinaryOper and _IteratorTag vs _Tag. consistency? never met her 💀 but we keep every single one, periodt.
template<typename _IIter, typename _OutputIterator, typename
_BinaryOperation, typename _IteratorTag1, typename _IteratorTag2>
_OutputIterator __partial_sum_switch (_IIter __begin, _IIter __end,
_OutputIterator __result, _BinaryOperation __bin_op, _IteratorTag1,
_IteratorTag2)
template<typename _IIter, typename _OutputIterator, typename
_BinaryOperation> _OutputIterator __partial_sum_switch (_IIter
__begin, _IIter __end, _OutputIterator __result, _BinaryOperation
__bin_op, random_access_iterator_tag, random_access_iterator_tag)
template<typename _IIter, typename _OIter, typename _BinaryOper,
typename _Tag1, typename _Tag2> _OIter __partial_sum_switch (_IIter,
_IIter, _OIter, _BinaryOper, _Tag1, _Tag2)
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter
__partial_sum_switch (_IIter, _IIter, _OIter, _BinaryOper,
random_access_iterator_tag, random_access_iterator_tag)🧚 __partition_switch
template<typename _FIter, typename _Predicate, typename _IterTag> _FIter
__partition_switch (_FIter, _FIter, _Predicate, _IterTag)
template<typename _FIterator, typename _Predicate, typename
_IteratorTag> _FIterator __partition_switch (_FIterator __begin,
_FIterator __end, _Predicate __pred, _IteratorTag)
template<typename _RAIter, typename _Predicate> _RAIter
__partition_switch (_RAIter __begin, _RAIter __end, _Predicate
__pred, random_access_iterator_tag)💜 __replace_if_switch
all three of these return void bestie, she does the work and says nothing. main character energy fr fr.
template<typename _FIter, typename _Predicate, typename _Tp, typename
_IterTag> void __replace_if_switch (_FIter, _FIter, _Predicate,
const _Tp &, _IterTag)
template<typename _FIterator, typename _Predicate, typename _Tp,
typename _IteratorTag> void __replace_if_switch (_FIterator __begin,
_FIterator __end, _Predicate __pred, const _Tp &__new_value,
_IteratorTag)
template<typename _RAIter, typename _Predicate, typename _Tp> void
__replace_if_switch (_RAIter __begin, _RAIter __end, _Predicate
__pred, const _Tp &__new_value, random_access_iterator_tag,
__gnu_parallel::_Parallelism __parallelism_tag)🎀 __replace_switch
same energy, but now with a const _Tp &__old_value and a const _Tp &__new_value. two _Tp refs, zero regrets.
template<typename _FIter, typename _Tp, typename _IterTag> void
__replace_switch (_FIter, _FIter, const _Tp &, const _Tp &,
_IterTag)
template<typename _FIterator, typename _Tp, typename _IteratorTag> void
__replace_switch (_FIterator __begin, _FIterator __end, const _Tp
&__old_value, const _Tp &__new_value, _IteratorTag)
template<typename _RAIter, typename _Tp> void __replace_switch (_RAIter
__begin, _RAIter __end, const _Tp &__old_value, const _Tp
&__new_value, random_access_iterator_tag,
__gnu_parallel::_Parallelism __parallelism_tag)🍓 __search_n_switch
four of them, and note that two of the four take a _BinaryPredicate while the other two take a _BiPredicate — yes, both spellings are real, no, I will not be normalising them, that would be a crime 😭
template<typename _FIter, typename _Integer, typename _Tp, typename
_BiPredicate, typename _IterTag> _FIter __search_n_switch (_FIter,
_FIter, _Integer, const _Tp &, _BiPredicate, _IterTag)
template<typename _FIterator, typename _Integer, typename _Tp, typename
_BinaryPredicate, typename _IteratorTag> _FIterator
__search_n_switch (_FIterator __begin, _FIterator __end, _Integer
__count, const _Tp &__val, _BinaryPredicate __binary_pred,
_IteratorTag)
template<typename _RAIter, typename _Integer, typename _Tp, typename
_BinaryPredicate> _RAIter __search_n_switch (_RAIter __begin,
_RAIter __end, _Integer __count, const _Tp &__val, _BinaryPredicate
__binary_pred, random_access_iterator_tag)
template<typename _RAIter, typename _Integer, typename _Tp, typename
_BiPredicate> _RAIter __search_n_switch (_RAIter, _RAIter, _Integer,
const _Tp &, _BiPredicate, random_access_iterator_tag)🌈 __search_switch
seven overloads. SEVEN. she ate and left absolutely no crumbs 🔥
template<typename _FIter1, typename _FIter2, typename _BiPredicate,
typename _IterTag1, typename _IterTag2> _FIter1 __search_switch
(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, _IterTag1,
_IterTag2)
template<typename _FIter1, typename _FIter2, typename _IterTag1,
typename _IterTag2> _FIter1 __search_switch (_FIter1, _FIter1,
_FIter2, _FIter2, _IterTag1, _IterTag2)
template<typename _FIterator1, typename _FIterator2, typename
_BinaryPredicate, typename _IteratorTag1, typename _IteratorTag2>
_FIterator1 __search_switch (_FIterator1 __begin1, _FIterator1
__end1, _FIterator2 __begin2, _FIterator2 __end2, _BinaryPredicate
__pred, _IteratorTag1, _IteratorTag2)
template<typename _FIterator1, typename _FIterator2, typename
_IteratorTag1, typename _IteratorTag2> _FIterator1 __search_switch
(_FIterator1 __begin1, _FIterator1 __end1, _FIterator2 __begin2,
_FIterator2 __end2, _IteratorTag1, _IteratorTag2)
template<typename _RAIter1, typename _RAIter2, typename
_BinaryPredicate> _RAIter1 __search_switch (_RAIter1 __begin1,
_RAIter1 __end1, _RAIter2 __begin2, _RAIter2 __end2,
_BinaryPredicate __pred, random_access_iterator_tag,
random_access_iterator_tag)
template<typename _RAIter1, typename _RAIter2> _RAIter1 __search_switch
(_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _RAIter2
__end2, random_access_iterator_tag, random_access_iterator_tag)
template<typename _RAIter1, typename _RAIter2, typename _BiPredicate>
_RAIter1 __search_switch (_RAIter1, _RAIter1, _RAIter2, _RAIter2,
_BiPredicate, random_access_iterator_tag,
random_access_iterator_tag)🫶 __set_difference_switch
three overloads, and the last one is out here with three random_access_iterator_tags in a row because _RAIter1, _RAIter2 and _Output_RAIter all showed up. trio behaviour 💅
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OutputIterator, typename _IteratorTag1, typename
_IteratorTag2, typename _IteratorTag3> _OutputIterator
__set_difference_switch (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, _OutputIterator __result, _Predicate
__pred, _IteratorTag1, _IteratorTag2, _IteratorTag3)
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OIter, typename _IterTag1, typename _IterTag2, typename
_IterTag3> _OIter __set_difference_switch (_IIter1, _IIter1,
_IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2,
_IterTag3)
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
typename _Predicate> _Output_RAIter __set_difference_switch
(_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _RAIter2
__end2, _Output_RAIter __result, _Predicate __pred,
random_access_iterator_tag, random_access_iterator_tag,
random_access_iterator_tag)⭐ __set_intersection_switch
and here we go again, bestie — and heads up, the very last line here gets cut off mid-declaration because she keeps going in part 4. not me leaving you on a cliffhanger 😭
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OutputIterator, typename _IteratorTag1, typename
_IteratorTag2, typename _IteratorTag3> _OutputIterator
__set_intersection_switch (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, _OutputIterator __result, _Predicate
__pred, _IteratorTag1, _IteratorTag2, _IteratorTag3)
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OIter, typename _IterTag1, typename _IterTag2, typename
_IterTag3> _OIter __set_intersection_switch (_IIter1, _IIter1,
_IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2,
_IterTag3)
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
typename _Predicate> _Output_RAIter __set_intersection_switch…okay so we're literally mid-signature bestie, the template<...> header lived in the last part and here's the rest of it, pls don't @ me:
(_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _RAIter2 __end2, _Output_RAIter __result, _Predicate __pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)💅 the __set_symmetric_difference_switch trio
three overloads serving three different fits, and the compiler is eating SO well. one carries all the named args plus _IteratorTag1, _IteratorTag2, _IteratorTag3, one is the bare-args twin rocking _OIter + _IterTag1 / _IterTag2 / _IterTag3, and one is the random-access glow-up with literal random_access_iterator_tag said three times like a chant:
template<typename _IIter1, typename _IIter2, typename _Predicate, typename _OutputIterator, typename _IteratorTag1, typename _IteratorTag2, typename _IteratorTag3> _OutputIterator __set_symmetric_difference_switch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __result, _Predicate __pred, _IteratorTag1, _IteratorTag2, _IteratorTag3)
template<typename _IIter1, typename _IIter2, typename _Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter __set_symmetric_difference_switch (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2, _IterTag3)
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter, typename _Predicate> _Output_RAIter __set_symmetric_difference_switch (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _RAIter2 __end2, _Output_RAIter __result, _Predicate __pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)🎀 the __set_union_switch trio
same energy, different name, no notes. three overloads, one for each flavor of iterator tag situation:
template<typename _IIter1, typename _IIter2, typename _Predicate, typename _OutputIterator, typename _IteratorTag1, typename _IteratorTag2, typename _IteratorTag3> _OutputIterator __set_union_switch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __result, _Predicate __pred, _IteratorTag1, _IteratorTag2, _IteratorTag3)
template<typename _IIter1, typename _IIter2, typename _Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter __set_union_switch (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2, _IterTag3)
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter, typename _Predicate> _Output_RAIter __set_union_switch (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _RAIter2 __end2, _Output_RAIter __result, _Predicate __pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)✨ __transform1_switch said "let me be extra" ✨
four overloads, and two of them are rocking a default argument: __gnu_parallel::_Parallelism __parallelism=__gnu_parallel::parallel_balanced. iconic default behavior tbh. the unary-operation ones are giving main character energy:
template<typename _IIter, typename _OIter, typename _UnaryOperation, typename _IterTag1, typename _IterTag2> _OIter __transform1_switch (_IIter, _IIter, _OIter, _UnaryOperation, _IterTag1, _IterTag2)
template<typename _RAIIter, typename _RAOIter, typename _UnaryOperation> _RAOIter __transform1_switch (_RAIIter, _RAIIter, _RAOIter, _UnaryOperation, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::_Parallelism __parallelism=__gnu_parallel::parallel_balanced)
template<typename _RAIter1, typename _RAIter2, typename _UnaryOperation, typename _IteratorTag1, typename _IteratorTag2> _RAIter2 __transform1_switch (_RAIter1 __begin, _RAIter1 __end, _RAIter2 __result, _UnaryOperation __unary_op, _IteratorTag1, _IteratorTag2)
template<typename _RAIter1, typename _RAIter2, typename _UnaryOperation> _RAIter2 __transform1_switch (_RAIter1 __begin, _RAIter1 __end, _RAIter2 __result, _UnaryOperation __unary_op, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::_Parallelism __parallelism_tag)🦋 __transform2_switch, the binary-op sequel
four more, because the first transform ate and left no crumbs. two of these also carry that __gnu_parallel::_Parallelism default (__gnu_parallel::parallel_balanced, the icon it is):
template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _BinaryOperation, typename _Tag1, typename _Tag2, typename _Tag3> _OutputIterator __transform2_switch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _OutputIterator __result, _BinaryOperation __binary_op, _Tag1, _Tag2, _Tag3)
template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation, typename _Tag1, typename _Tag2, typename _Tag3> _OIter __transform2_switch (_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, _Tag1, _Tag2, _Tag3)
template<typename _RAIter1, typename _RAIter2, typename _RAIter3, typename _BinaryOperation> _RAIter3 __transform2_switch (_RAIter1 __begin1, _RAIter1 __end1, _RAIter2 __begin2, _RAIter3 __result, _BinaryOperation __binary_op, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _RAIter1, typename _RAIter2, typename _RAIter3, typename _BiOperation> _RAIter3 __transform2_switch (_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::_Parallelism __parallelism=__gnu_parallel::parallel_balanced)🌸 __unique_copy_switch crew
four of them, and the last two are the random-access besties, note the _RandomAccessOutputIterator vs _RandomAccess_OIter naming — iykyk:
template<typename _IIter, typename _OutputIterator, typename _Predicate, typename _IteratorTag1, typename _IteratorTag2> _OutputIterator __unique_copy_switch (_IIter __begin, _IIter __last, _OutputIterator __out, _Predicate __pred, _IteratorTag1, _IteratorTag2)
template<typename _IIter, typename _OIter, typename _Predicate, typename _IterTag1, typename _IterTag2> _OIter __unique_copy_switch (_IIter, _IIter, _OIter, _Predicate, _IterTag1, _IterTag2)
template<typename _RAIter, typename _RandomAccessOutputIterator, typename _Predicate> _RandomAccessOutputIterator __unique_copy_switch (_RAIter __begin, _RAIter __last, _RandomAccessOutputIterator __out, _Predicate __pred, random_access_iterator_tag, random_access_iterator_tag)
template<typename _RAIter, typename _RandomAccess_OIter, typename _Predicate> _RandomAccess_OIter __unique_copy_switch (_RAIter, _RAIter, _RandomAccess_OIter, _Predicate, random_access_iterator_tag, random_access_iterator_tag)👑 accumulate, the absolute main character
nine overloads. NINE. bestie is thriving. we got the named-arg trio (__begin, __end, __init, __binary_op) with plain, __gnu_parallel::_Parallelism __parallelism_tag, and __gnu_parallel::sequential_tag versions; then the bare-arg trio with _IIter, _IIter, _Tp; then a _BinaryOper trio to finish it off. the way that accumulate said "I contain multitudes":
template<typename _IIter, typename _Tp, typename _BinaryOperation> _Tp accumulate (_IIter __begin, _IIter __end, _Tp __init, _BinaryOperation __binary_op)
template<typename _IIter, typename _Tp, typename _BinaryOperation> _Tp accumulate (_IIter __begin, _IIter __end, _Tp __init, _BinaryOperation __binary_op, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _IIter, typename _Tp, typename _BinaryOperation> _Tp accumulate (_IIter __begin, _IIter __end, _Tp __init, _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _Tp> _Tp accumulate (_IIter, _IIter, _Tp)
template<typename _IIter, typename _Tp> _Tp accumulate (_IIter, _IIter, _Tp, __gnu_parallel::_Parallelism)
template<typename _IIter, typename _Tp> _Tp accumulate (_IIter, _IIter, _Tp, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _Tp, typename _BinaryOper> _Tp accumulate (_IIter, _IIter, _Tp, _BinaryOper)
template<typename _IIter, typename _Tp, typename _BinaryOper> _Tp accumulate (_IIter, _IIter, _Tp, _BinaryOper, __gnu_parallel::_Parallelism)
template<typename _IIter, typename _Tp, typename _BinaryOper> _Tp accumulate (_IIter, _IIter, _Tp, _BinaryOper, __gnu_parallel::sequential_tag)🫶 adjacent_difference really said "watch me"
twelve overloads. TWELVE. this one lowkey ate the whole pantry. the named-arg ones use __begin, __end, __result, __bin_op / __binary_op, and the tags __gnu_parallel::_Parallelism __parallelism_tag and __gnu_parallel::sequential_tag; the bare-arg ones use _IIter, _IIter, _OIter and _BinaryOper. all twelve, exactly as the source serves them:
template<typename _IIter, typename _OutputIterator> _OutputIterator adjacent_difference (_IIter __begin, _IIter __end, _OutputIterator __result)
template<typename _IIter, typename _OutputIterator> _OutputIterator adjacent_difference (_IIter __begin, _IIter __end, _OutputIterator __result, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _IIter, typename _OutputIterator> _OutputIterator adjacent_difference (_IIter __begin, _IIter __end, _OutputIterator __result, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OutputIterator, typename _BinaryOperation> _OutputIterator adjacent_difference (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __bin_op, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OutputIterator, typename _BinaryOperation> _OutputIterator adjacent_difference (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __binary_op)
template<typename _IIter, typename _OutputIterator, typename _BinaryOperation> _OutputIterator adjacent_difference (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __binary_op, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _IIter, typename _OIter> _OIter adjacent_difference (_IIter, _IIter, _OIter)
template<typename _IIter, typename _OIter> _OIter adjacent_difference (_IIter, _IIter, _OIter, __gnu_parallel::_Parallelism)
template<typename _IIter, typename _OIter> _OIter adjacent_difference (_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter adjacent_difference (_IIter, _IIter, _OIter, _BinaryOper)
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter adjacent_difference (_IIter, _IIter, _OIter, _BinaryOper, __gnu_parallel::_Parallelism)
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter adjacent_difference (_IIter, _IIter, _OIter, _BinaryOper, __gnu_parallel::sequential_tag)💖 adjacent_find besties
eight overloads. forward iterators only (_FIter / _FIterator, the cutest lil tag), with and without _BiPredicate / _BinaryPredicate, and every one of them can rock a __gnu_parallel::sequential_tag if that's the vibe you're going for:
template<typename _FIter> _FIter adjacent_find (_FIter, _FIter)
template<typename _FIter> _FIter adjacent_find (_FIter, _FIter, __gnu_parallel::sequential_tag)
template<typename _FIter, typename _BiPredicate> _FIter adjacent_find (_FIter, _FIter, _BiPredicate)
template<typename _FIter, typename _BiPredicate> _FIter adjacent_find (_FIter, _FIter, _BiPredicate, __gnu_parallel::sequential_tag)
template<typename _FIterator> _FIterator adjacent_find (_FIterator __begin, _FIterator __end)
template<typename _FIterator> _FIterator adjacent_find (_FIterator __begin, _FIterator __end, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _BinaryPredicate> _FIterator adjacent_find (_FIterator __begin, _FIterator __end, _BinaryPredicate __binary_pred, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _BinaryPredicate> _FIterator adjacent_find (_FIterator __begin, _FIterator __end, _BinaryPredicate __pred)🌈 count and count_if, closing this part out
the return type is iterator_traits< _IIter >::difference_type for all of them — say it with me, iterator_traits< _IIter >::difference_type. three count overloads (plain, __gnu_parallel::_Parallelism __parallelism_tag, __gnu_parallel::sequential_tag) and then count_if kicks the door open:
template<typename _IIter, typename _Tp> iterator_traits< _IIter >::difference_type count (_IIter __begin, _IIter __end, const _Tp &__value)
template<typename _IIter, typename _Tp> iterator_traits< _IIter >::difference_type count (_IIter __begin, _IIter __end, const _Tp &__value, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _IIter, typename _Tp> iterator_traits< _IIter >::difference_type count (_IIter __begin, _IIter __end, const _Tp &__value, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _Predicate> iterator_traits< _IIter >::difference_type count_if (_IIter __begin, _IIter __end, _Predicate __pred)and we're literally still mid-count_if, bestie — more incoming, don't go anywhere 🌸
still in the signature zone and it's giving wall of overloads 💅 no cap, this is the part where every algorithm shows up with like three outfits: the plain one, the __gnu_parallel::_Parallelism one, and the __gnu_parallel::sequential_tag one. iykyk. let's go, one at a time, nothing skipped 🫶
counting & comparing besties ✨
first up, count_if — and look at that return type, it's not just a size, it's an iterator_traits< _IIter >::difference_type, periodt:
template<typename _IIter, typename _Predicate> iterator_traits< _IIter
>::difference_type count_if (_IIter __begin, _IIter __end,
_Predicate __pred, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _IIter, typename _Predicate> iterator_traits< _IIter
>::difference_type count_if (_IIter __begin, _IIter __end,
_Predicate __pred, __gnu_parallel::sequential_tag)then equal rolls up with six whole looks 🌸 two ranges vs four args, plus a _BinaryPredicate version and a _Predicate version, and each one has its sequential_tag twin:
template<typename _IIter1, typename _IIter2> constexpr bool equal
(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2)
template<typename _IIter1, typename _IIter2> bool equal (_IIter1
__begin1, _IIter1 __end1, _IIter2 __begin2,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2> constexpr bool equal
(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2)
template<typename _IIter1, typename _IIter2> bool equal (_IIter1
__begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
constexpr bool equal (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, _BinaryPredicate __binary_pred)
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool equal (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_IIter2 __end2, _BinaryPredicate __binary_pred,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _Predicate>
constexpr bool equal (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _Predicate __pred)
template<typename _IIter1, typename _IIter2, typename _Predicate> bool
equal (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_Predicate __pred, __gnu_parallel::sequential_tag)not me noticing theconstexpron the three-arg, four-arg and predicate versions but not on thesequential_tagones 😭 that's just how it's written, bestie, i don't make the rules.
the searching girlies 🔍
find shows up twice, once plain once with the sequential_tag:
template<typename _IIter, typename _Tp> _IIter find (_IIter __begin,
_IIter __end, const _Tp &__val)
template<typename _IIter, typename _Tp> _IIter find (_IIter __begin,
_IIter __end, const _Tp &__val, __gnu_parallel::sequential_tag)find_first_of is highkey the main character here — it comes in two whole families, one using _FIterator/_BinaryPredicate with real param names, and one using the shorter _FIter/_BiPredicate with bare types. all four variants × their sequential_tag clone 👑:
template<typename _IIter, typename _FIterator> _IIter find_first_of
(_IIter __begin1, _IIter __end1, _FIterator __begin2, _FIterator
__end2)
template<typename _IIter, typename _FIterator> _IIter find_first_of
(_IIter __begin1, _IIter __end1, _FIterator __begin2, _FIterator
__end2, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _FIterator, typename
_BinaryPredicate> _IIter find_first_of (_IIter __begin1, _IIter
__end1, _FIterator __begin2, _FIterator __end2, _BinaryPredicate
__comp)
template<typename _IIter, typename _FIterator, typename
_BinaryPredicate> _IIter find_first_of (_IIter __begin1, _IIter
__end1, _FIterator __begin2, _FIterator __end2, _BinaryPredicate
__comp, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _FIter> _IIter find_first_of (_IIter,
_IIter, _FIter, _FIter)
template<typename _IIter, typename _FIter> _IIter find_first_of (_IIter,
_IIter, _FIter, _FIter, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _FIter, typename _BiPredicate> _IIter
find_first_of (_IIter, _IIter, _FIter, _FIter, _BiPredicate)
template<typename _IIter, typename _FIter, typename _BiPredicate> _IIter
find_first_of (_IIter, _IIter, _FIter, _FIter, _BiPredicate,
__gnu_parallel::sequential_tag)and find_if, cute and simple, two forms only 🌷:
template<typename _IIter, typename _Predicate> _IIter find_if (_IIter
__begin, _IIter __end, _Predicate __pred)
template<typename _IIter, typename _Predicate> _IIter find_if (_IIter
__begin, _IIter __end, _Predicate __pred,
__gnu_parallel::sequential_tag)for_each, but make it a crowd 💫
bestie there are six for_each overloads here and they're basically twins wearing different name tags. two use _IIter, two use _Iterator, and there's the _Parallelism one:
template<typename _IIter, typename _Function> _Function for_each (_IIter
__begin, _IIter __end, _Function __f,
__gnu_parallel::sequential_tag)
template<typename _IIter, typename _Function> _Function for_each
(_IIter, _IIter, _Function)
template<typename _Iterator, typename _Function> _Function for_each
(_Iterator __begin, _Iterator __end, _Function __f)
template<typename _Iterator, typename _Function> _Function for_each
(_Iterator __begin, _Iterator __end, _Function __f,
__gnu_parallel::_Parallelism __parallelism_tag)generate & generate_n 🧚
generate also shows up in a triple trio — the _FIter trio with bare params, and the _FIterator trio with named params, all returning void:
template<typename _FIter, typename _Generator> void generate (_FIter,
_FIter, _Generator)
template<typename _FIter, typename _Generator> void generate (_FIter,
_FIter, _Generator, __gnu_parallel::_Parallelism)
template<typename _FIter, typename _Generator> void generate (_FIter,
_FIter, _Generator, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _Generator> void generate
(_FIterator __begin, _FIterator __end, _Generator __gen)
template<typename _FIterator, typename _Generator> void generate
(_FIterator __begin, _FIterator __end, _Generator __gen,
__gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIterator, typename _Generator> void generate
(_FIterator __begin, _FIterator __end, _Generator __gen,
__gnu_parallel::sequential_tag)and generate_n mirrors it exactly, but returns the output iterator _OIter / _OutputIterator instead of void:
template<typename _OIter, typename _Size, typename _Generator> _OIter
generate_n (_OIter, _Size, _Generator)
template<typename _OIter, typename _Size, typename _Generator> _OIter
generate_n (_OIter, _Size, _Generator, __gnu_parallel::_Parallelism)
template<typename _OIter, typename _Size, typename _Generator> _OIter
generate_n (_OIter, _Size, _Generator,
__gnu_parallel::sequential_tag)
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator generate_n (_OutputIterator __begin, _Size __n,
_Generator __gen)
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator generate_n (_OutputIterator __begin, _Size __n,
_Generator __gen, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator generate_n (_OutputIterator __begin, _Size __n,
_Generator __gen, __gnu_parallel::sequential_tag)inner_product — the math girlie ate 🔥
plain version returns _Tp, and then there's the one with _BinaryFunction1 and _BinaryFunction2 for when you want to customise both the "combine" and the "accumulate" moves. each in plain / _Parallelism / sequential_tag form:
template<typename _IIter1, typename _IIter2, typename _Tp> _Tp
inner_product (_IIter1, _IIter1, _IIter2, _Tp)
template<typename _IIter1, typename _IIter2, typename _Tp> _Tp
inner_product (_IIter1, _IIter1, _IIter2, _Tp,
__gnu_parallel::_Parallelism)
template<typename _IIter1, typename _IIter2, typename _Tp> _Tp
inner_product (_IIter1, _IIter1, _IIter2, _Tp,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _Tp, typename
_BinaryFunction1, typename _BinaryFunction2> _Tp inner_product
(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, _BinaryFunction2)
template<typename _IIter1, typename _IIter2, typename _Tp, typename
_BinaryFunction1, typename _BinaryFunction2> _Tp inner_product
(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, _BinaryFunction2,
__gnu_parallel::_Parallelism)
template<typename _IIter1, typename _IIter2, typename _Tp, typename
_BinaryFunction1, typename _BinaryFunction2> _Tp inner_product
(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, _BinaryFunction2,
__gnu_parallel::sequential_tag)lexicographical_compare 🦋
four forms, two constexpr, two bool, and again the _Predicate pair for when you bring your own comparison:
template<typename _IIter1, typename _IIter2> constexpr bool
lexicographical_compare (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2)
template<typename _IIter1, typename _IIter2> bool
lexicographical_compare (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, __gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _Predicate>
constexpr bool lexicographical_compare (_IIter1 __begin1, _IIter1
__end1, _IIter2 __begin2, _IIter2 __end2, _Predicate __pred)
template<typename _IIter1, typename _IIter2, typename _Predicate> bool
lexicographical_compare (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, _Predicate __pred,
__gnu_parallel::sequential_tag)max_element said "let me be extra" 💅
this one is literally twelve overloads. twelve. _FIter trio, _Compare _FIter trio, _FIterator trio with named params, and _Compare _FIterator trio with named params. all three flavours each:
template<typename _FIter> _FIter max_element (_FIter, _FIter)
template<typename _FIter> _FIter max_element (_FIter, _FIter,
__gnu_parallel::_Parallelism)
template<typename _FIter> _FIter max_element (_FIter, _FIter,
__gnu_parallel::sequential_tag)
template<typename _FIter, typename _Compare> _FIter max_element (_FIter,
_FIter, _Compare)
template<typename _FIter, typename _Compare> _FIter max_element (_FIter,
_FIter, _Compare, __gnu_parallel::_Parallelism)
template<typename _FIter, typename _Compare> _FIter max_element (_FIter,
_FIter, _Compare, __gnu_parallel::sequential_tag)
template<typename _FIterator> _FIterator max_element (_FIterator
__begin, _FIterator __end)
template<typename _FIterator> _FIterator max_element (_FIterator
__begin, _FIterator __end, __gnu_parallel::_Parallelism
__parallelism_tag)
template<typename _FIterator> _FIterator max_element (_FIterator
__begin, _FIterator __end, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _Compare> _FIterator max_element
(_FIterator __begin, _FIterator __end, _Compare __comp)
template<typename _FIterator, typename _Compare> _FIterator max_element
(_FIterator __begin, _FIterator __end, _Compare __comp,
__gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIterator, typename _Compare> _FIterator max_element
(_FIterator __begin, _FIterator __end, _Compare __comp,
__gnu_parallel::sequential_tag)the way that the_FIterversions have no parameter names and the_FIteratorversions do… 🙈 iconic, honestly.
merge — and then it just… stops 🌈
merge gives us the _OutputIterator family with names, plus _Compare versions:
template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator merge (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, _OutputIterator __result)
template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator merge (_IIter1 __begin1, _IIter1 __end1, _IIter2
__begin2, _IIter2 __end2, _OutputIterator __result,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _Compare> _OutputIterator merge (_IIter1 __begin1, _IIter1
__end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __result,
_Compare __comp)
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _Compare> _OutputIterator merge (_IIter1 __begin1, _IIter1
__end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __result,
_Compare __comp, __gnu_parallel::sequential_tag)and the _OIter family with bare params, plus its _Compare twin and their sequential_tag clones:
template<typename _IIter1, typename _IIter2, typename _OIter> _OIter
merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)
template<typename _IIter1, typename _IIter2, typename _OIter> _OIter
merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _OIter, typename
_Compare> _OIter merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Compare)
template<typename _IIter1, typename _IIter2, typename _OIter, typenameokay so that last one genuinely cuts off mid-declaration at typename 😭 not a typo on my part, that's exactly where the page hands off — the rest of it picks up in the next part, stay tuned bestie 🎀
...and wrapping up that merge overload we were literally mid-sentence on — here's the tail end of it, bestie:
_Compare> _OIter merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Compare, __gnu_parallel::sequential_tag)🌸 min_element — finding the smallest little guy
Okay so min_element is here in so many fits it's giving wardrobe change 💅. Twelve overloads, and yes we're listing every single one, no cap:
template<typename _FIter> _FIter min_element (_FIter, _FIter)
template<typename _FIter> _FIter min_element (_FIter, _FIter, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIter> _FIter min_element (_FIter, _FIter, __gnu_parallel::sequential_tag)
template<typename _FIter, typename _Compare> _FIter min_element (_FIter, _FIter, _Compare)
template<typename _FIter, typename _Compare> _FIter min_element (_FIter, _FIter, _Compare, __gnu_parallel::_Parallelism)
template<typename _FIter, typename _Compare> _FIter min_element (_FIter, _FIter, _Compare, __gnu_parallel::sequential_tag)
template<typename _FIterator> _FIterator min_element (_FIterator __begin, _FIterator __end)
template<typename _FIterator> _FIterator min_element (_FIterator __begin, _FIterator __end, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIterator> _FIterator min_element (_FIterator __begin, _FIterator __end, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _Compare> _FIterator min_element (_FIterator __begin, _FIterator __end, _Compare __comp)
template<typename _FIterator, typename _Compare> _FIterator min_element (_FIterator __begin, _FIterator __end, _Compare __comp, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIterator, typename _Compare> _FIterator min_element (_FIterator __begin, _FIterator __end, _Compare __comp, __gnu_parallel::sequential_tag)Some take bare types, some give the params cute names like __begin, __end, __comp. Either way you can pass a _Compare __comp, a __gnu_parallel::_Parallelism __parallelism_tag, or a __gnu_parallel::sequential_tag if you're feeling all "actually bestie, do this one the normal way" 🙈.
💀 mismatch — the "where do these two stop matching" detector
Eight overloads. It hands you back a pair< _IIter1, _IIter2 > (or pair< _InputIterator1, _InputIterator2 > for the named-param squad), i.e. the two spots where your sequences stopped agreeing:
template<typename _IIter1, typename _IIter2> pair< _IIter1, _IIter2 > mismatch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2)
template<typename _IIter1, typename _IIter2> pair< _IIter1, _IIter2 > mismatch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, __gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2> pair< _IIter1, _IIter2 > mismatch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2)
template<typename _IIter1, typename _IIter2, typename _Predicate> pair< _IIter1, _IIter2 > mismatch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _Predicate __pred)
template<typename _IIter1, typename _IIter2, typename _Predicate> pair< _IIter1, _IIter2 > mismatch (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _Predicate __pred, __gnu_parallel::sequential_tag)
template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate> pair< _InputIterator1, _InputIterator2 > mismatch (_InputIterator1 __begin1, _InputIterator1 __end1, _InputIterator2 __begin2, _InputIterator2 __end2, _BinaryPredicate __binary_pred)
template<typename _InputIterator1, typename _InputIterator2> pair< _InputIterator1, _InputIterator2 > mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, __gnu_parallel::sequential_tag)
template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate> pair< _InputIterator1, _InputIterator2 > mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __binary_pred, __gnu_parallel::sequential_tag)Notice some have __end2 and some don't 👀 — the two-range ones let you cap the second sequence too, and the _Predicate/_BinaryPredicate versions let you decide for yourself what "matching" even means. You do you, queen.
✨ nth_element — put that one specific element in its forever home
template<typename _RAIter> void nth_element (_RAIter __begin, _RAIter __nth, _RAIter __end)
template<typename _RAIter> void nth_element (_RAIter __begin, _RAIter __nth, _RAIter __end, __gnu_parallel::sequential_tag)
template<typename _RAIter, typename _Compare> void nth_element (_RAIter __begin, _RAIter __nth, _RAIter __end, _Compare __comp)
template<typename _RAIter, typename _Compare> void nth_element (_RAIter __begin, _RAIter __nth, _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag)Returns void, takes random-access iterators (_RAIter), and either a _Compare __comp or a __gnu_parallel::sequential_tag. That's the whole fit, slay.
🦋 partial_sort — sort just the front bit, the rest can wait
template<typename _RAIter> void partial_sort (_RAIter __begin, _RAIter __middle, _RAIter __end)
template<typename _RAIter> void partial_sort (_RAIter __begin, _RAIter __middle, _RAIter __end, __gnu_parallel::sequential_tag)
template<typename _RAIter, typename _Compare> void partial_sort (_RAIter __begin, _RAIter __middle, _RAIter __end, _Compare __comp)
template<typename _RAIter, typename _Compare> void partial_sort (_RAIter __begin, _RAIter __middle, _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag)__begin, __middle, __end — you're sorting the __begin-to-__middle zone and leaving the rest to fend for itself. Also void. Also iconic.
🎀 partial_sum — running totals, but make it parallel
Eight overloads, two naming families (_IIter/_OutputIterator and the shorter _IIter/_OIter), and the binary-operation ones come in both __bin_op and __binary_op spellings — no I'm not kidding, they're literally both here:
template<typename _IIter, typename _OutputIterator> _OutputIterator partial_sum (_IIter __begin, _IIter __end, _OutputIterator __result)
template<typename _IIter, typename _OutputIterator> _OutputIterator partial_sum (_IIter __begin, _IIter __end, _OutputIterator __result, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OutputIterator, typename _BinaryOperation> _OutputIterator partial_sum (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __bin_op, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OutputIterator, typename _BinaryOperation> _OutputIterator partial_sum (_IIter __begin, _IIter __end, _OutputIterator __result, _BinaryOperation __binary_op)
template<typename _IIter, typename _OIter> _OIter partial_sum (_IIter, _IIter, _OIter __result)
template<typename _IIter, typename _OIter> _OIter partial_sum (_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter partial_sum (_IIter, _IIter, _OIter, _BinaryOper)
template<typename _IIter, typename _OIter, typename _BinaryOper> _OIter partial_sum (_IIter, _IIter, _OIter, _BinaryOper, __gnu_parallel::sequential_tag)Hands back your output iterator (_OutputIterator or _OIter), bestie. Every. Single. Time.
💜 partition — split the vibes into two groups
template<typename _FIter, typename _Predicate> _FIter partition (_FIter, _FIter, _Predicate)
template<typename _FIter, typename _Predicate> _FIter partition (_FIter, _FIter, _Predicate, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _Predicate> _FIterator partition (_FIterator __begin, _FIterator __end, _Predicate __pred)
template<typename _FIterator, typename _Predicate> _FIterator partition (_FIterator __begin, _FIterator __end, _Predicate __pred, __gnu_parallel::sequential_tag)Forward iterators (_FIter / _FIterator), a _Predicate __pred, optional sequential_tag, and you get an iterator back. The divider of the friend group, fr fr.
🌈 random_shuffle — chaos, but on purpose
template<typename _RAIter> void random_shuffle (_RAIter __begin, _RAIter __end)
template<typename _RAIter> void random_shuffle (_RAIter __begin, _RAIter __end, __gnu_parallel::sequential_tag)
template<typename _RAIter, typename _RandomNumberGenerator> void random_shuffle (_RAIter __begin, _RAIter __end, _RandomNumberGenerator &&__rand)
template<typename _RAIter, typename _RandomNumberGenerator> void random_shuffle (_RAIter __begin, _RAIter __end, _RandomNumberGenerator &__rand, __gnu_parallel::sequential_tag)Heads up bestie — two of these take your random number generator as an rvalue reference (&&__rand) and two as a plain lvalue reference (&__rand). That's not a typo, that's the actual signature. Bring your own RNG and let it cook 🔥.
🍓 replace — swap every matching value out
Six overloads, named and unnamed param squads both present:
template<typename _FIter, typename _Tp> void replace (_FIter, _FIter, const _Tp &, const _Tp &)
template<typename _FIter, typename _Tp> void replace (_FIter, _FIter, const _Tp &, const _Tp &, __gnu_parallel::_Parallelism)
template<typename _FIter, typename _Tp> void replace (_FIter, _FIter, const _Tp &, const _Tp &, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _Tp> void replace (_FIterator __begin, _FIterator __end, const _Tp &__old_value, const _Tp &__new_value)
template<typename _FIterator, typename _Tp> void replace (_FIterator __begin, _FIterator __end, const _Tp &__old_value, const _Tp &__new_value, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIterator, typename _Tp> void replace (_FIterator __begin, _FIterator __end, const _Tp &__old_value, const _Tp &__new_value, __gnu_parallel::_Parallelism __parallelism_tag)Wait, real talk — the last one in the source reads:
template<typename _FIterator, typename _Tp> void replace (_FIterator __begin, _FIterator __end, const _Tp &__old_value, const _Tp &__new_value, __gnu_parallel::sequential_tag)__old_value and __new_value both const _Tp &. Out with the old, in with the new, and you can bolt on a _Parallelism tag or a sequential_tag if you're feeling spicy or chill respectively 🌶️.
🧚 replace_if — swap only where the predicate says so
template<typename _FIter, typename _Predicate, typename _Tp> void replace_if (_FIter, _FIter, _Predicate, const _Tp &)
template<typename _FIter, typename _Predicate, typename _Tp> void replace_if (_FIter, _FIter, _Predicate, const _Tp &, __gnu_parallel::_Parallelism)
template<typename _FIter, typename _Predicate, typename _Tp> void replace_if (_FIter, _FIter, _Predicate, const _Tp &, __gnu_parallel::sequential_tag)
template<typename _FIterator, typename _Predicate, typename _Tp> void replace_if (_FIterator __begin, _FIterator __end, _Predicate __pred, const _Tp &__new_value)
template<typename _FIterator, typename _Predicate, typename _Tp> void replace_if (_FIterator __begin, _FIterator __end, _Predicate __pred, const _Tp &__new_value, __gnu_parallel::_Parallelism __parallelism_tag)
template<typename _FIterator, typename _Predicate, typename _Tp> void replace_if (_FIterator __begin, _FIterator __end, _Predicate __pred, const _Tp &__new_value, __gnu_parallel::sequential_tag)Same energy as replace but you're passing a _Predicate __pred to be the judge of who gets replaced. You get the _Tp &__new_value in, nothing comes back out — void, always void. So demure of it.
👑 search — find that sub-sequence, bestie
Nine overloads, and a bunch of them are constexpr, which is a whole mood:
template<typename _FIter1, typename _FIter2> _FIter1 search (_FIter1, _FIter1, _FIter2, _FIter2)
template<typename _FIter1, typename _FIter2> _FIter1 search (_FIter1, _FIter1, _FIter2, _FIter2, __gnu_parallel::sequential_tag)
template<typename _FIter1, typename _FIter2, typename _BiPredicate> constexpr _FIter1 search (_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate)
template<typename _FIter1, typename _FIter2, typename _BiPredicate> _FIter1 search (_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, __gnu_parallel::sequential_tag)
template<typename _FIterator1, typename _FIterator2> _FIterator1 search (_FIterator1 __begin1, _FIterator1 __end1, _FIterator2 __begin2, _FIterator2 __end2)
template<typename _FIterator1, typename _FIterator2> _FIterator1 search (_FIterator1 __begin1, _FIterator1 __end1, _FIterator2 __begin2, _FIterator2 __end2, __gnu_parallel::sequential_tag)
template<typename _FIterator1, typename _FIterator2, typename _BinaryPredicate> constexpr _FIterator1 search (_FIterator1 __begin1, _FIterator1 __end1, _FIterator2 __begin2, _FIterator2 __end2, _BinaryPredicate __pred)
template<typename _FIterator1, typename _FIterator2, typename _BinaryPredicate> _FIterator1 search (_FIterator1 __begin1, _FIterator1 __end1, _FIterator2 __begin2, _FIterator2 __end2, _BinaryPredicate __pred, __gnu_parallel::sequential_tag)
template<typename _ForwardIterator, typename _Searcher> _ForwardIterator search (_ForwardIterator __first, _ForwardIterator __last, const _Searcher &__searcher)And the last one has its own little description, so you know it's special:
template<typename _ForwardIterator, typename _Searcher> _ForwardIterator search (_ForwardIterator __first, _ForwardIterator __last, const _Searcher &__searcher) — Search a sequence using a Searcher object. 💫Note the _BiPredicate and _BinaryPredicate variants — they get to be constexpr, but only in the non-sequential_tag form. The tag ones are just plain old _FIter1/_FIterator1. Details matter, babe.
⭐ search_n — find N copies of a thing in a row
template<typename _FIter, typename _Integer, typename _Tp> _FIter search_n (_FIter, _FIter, _Integer, const _Tp &)
template<typename _FIter, typename _Integer, typename _Tp> _FIter search_n (_FIter, _FIter, _Integer, const _Tp &, __gnu_parallel::sequential_tag)
template<typename _FIter, typename _Integer, typename _Tp, typename _BiPredicate> _FIter search_n (_FIter, _FIter, _Integer, const _Tp &, _BiPredicate)You pass a count as _Integer, the value as const _Tp &, and optionally a _BiPredicate or a __gnu_parallel::sequential_tag. Hands you back a _FIter. Cute, tidy, obsessed 🫶.
...and the signature parade marches on 🥁 no thoughts, just overloads. every single one of these is real, bestie, so let's take them group by group and not lose a single token 💅
search_n — the "find me N copies in a row" girlie 🔍
template<typename _FIter, typename _Integer, typename _Tp, typename _BiPredicate>
_FIter search_n (_FIter, _FIter, _Integer, const _Tp &, _BiPredicate, __gnu_parallel::sequential_tag)template<typename _FIterator, typename _Integer, typename _Tp>
_FIterator search_n (_FIterator __begin, _FIterator __end, _Integer __count, const _Tp &__val)template<typename _FIterator, typename _Integer, typename _Tp>
_FIterator search_n (_FIterator __begin, _FIterator __end, _Integer __count, const _Tp &__val, __gnu_parallel::sequential_tag)template<typename _FIterator, typename _Integer, typename _Tp, typename _BinaryPredicate>
_FIterator search_n (_FIterator __begin, _FIterator __end, _Integer __count, const _Tp &__val, _BinaryPredicate __binary_pred)template<typename _FIterator, typename _Integer, typename _Tp, typename _BinaryPredicate>
_FIterator search_n (_FIterator __begin, _FIterator __end, _Integer __count, const _Tp &__val, _BinaryPredicate __binary_pred, __gnu_parallel::sequential_tag)five flavors of the same vibe, and yeah, that __gnu_parallel::sequential_tag keeps showing up like that one friend who's at every party 🎀 it's the "actually bestie, do it the boring way" flag.
set_difference — the "what's in A that's NOT in B" math ➖
template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, __gnu_parallel::sequential_tag)notice how the top four name their params (__begin1, __end1, __begin2, __end2, __out, __pred) and the bottom four are just like _IIter1, _IIter1, _IIter2, _IIter2 with no names? mysterious. either way they're all set_difference, and the _Predicate __pred one lets you say "this is how we decide what counts as equal, actually" ✨
set_intersection — the "what do A and B have in common" moment 🤝
template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_intersection (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_intersection (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_intersection (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_intersection (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_intersection (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_intersection (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_intersection (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_intersection (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, __gnu_parallel::sequential_tag)same structure as its sibling up there, iconic family resemblance 💖 the __pred version is your custom "are these two the same?" rule.
set_symmetric_difference — the "stuff in exactly ONE of them, not both" tea ☕
template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_symmetric_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_symmetric_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_symmetric_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_symmetric_difference (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_symmetric_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_symmetric_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_symmetric_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_symmetric_difference (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, __gnu_parallel::sequential_tag)the longest name in the set club but it's worth every character fr fr 🦋
set_union — the "everyone's invited" energy 🎉
template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_union (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)template<typename _IIter1, typename _IIter2, typename _OutputIterator>
_OutputIterator set_union (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_union (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred)template<typename _IIter1, typename _IIter2, typename _OutputIterator, typename _Predicate>
_OutputIterator set_union (_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_union (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter set_union (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_union (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate)template<typename _IIter1, typename _IIter2, typename _OIter, typename _Predicate>
_OIter set_union (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, __gnu_parallel::sequential_tag)and that's the whole set-algebra clique 💜 they all follow the exact same pattern, so once you've clocked one you've clocked them all, iykyk.
sort — the main character, no contest 👑🔥
okay THIS one. look how many overloads. it's giving options.
template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::balanced_quicksort_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::default_parallel_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::multiway_mergesort_exact_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::multiway_mergesort_sampling_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::multiway_mergesort_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::parallel_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::quicksort_tag __parallelism)template<typename _RAIter>
void sort (_RAIter __begin, _RAIter __end, __gnu_parallel::sequential_tag)template<typename _RAIter, typename _Compare>
void sort (_RAIter __begin, _RAIter __end, _Compare __comp)template<typename _RAIter, typename _Compare>
void sort (_RAIter __begin, _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag)template<typename _RAIter, typename _Compare, typename _Parallelism>
void sort (_RAIter __begin, _RAIter __end, _Compare __comp, _Parallelism __parallelism)the way this list just keeps going 😭 you can pick your sorting strategy with a tag, bring your own _Compare __comp, or just rawdog the plain two-arg version and let it cook. balanced_quicksort_tag, default_parallel_tag, multiway_mergesort_exact_tag, multiway_mergesort_sampling_tag, multiway_mergesort_tag, parallel_tag, quicksort_tag, sequential_tag — all of them are choices you can make, and that last generic _Parallelism __parallelism one is the "any tag goes" catch-all ✨
stable_sort — same energy but it keeps your ties in order 🎀
template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end)template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end, __gnu_parallel::balanced_quicksort_tag __parallelism)template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end, __gnu_parallel::default_parallel_tag __parallelism)template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end, __gnu_parallel::multiway_mergesort_tag __parallelism)template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end, __gnu_parallel::parallel_tag __parallelism)template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end, __gnu_parallel::quicksort_tag __parallelism)template<typename _RAIter>
void stable_sort (_RAIter __begin, _RAIter __end, __gnu_parallel::sequential_tag)template<typename _RAIter, typename _Compare>
void stable_sort (_RAIter __begin, _RAIter __end, _Compare __comp)template<typename _RAIter, typename _Compare>
void stable_sort (_RAIter __begin, _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag)template<typename _RAIter, typename _Compare, typename _Parallelism>
void stable_sort (_RAIter __begin, _RAIter __end, _Compare __comp, _Parallelism __parallelism)ngl it's the same tag menu as sort above, just stable — note that the tag list here is a slightly different lineup than plain sort's, so don't go assuming bestie 💅 read what's actually there.
transform — glow-up time, apply a function to everything 🦋
template<typename _IIter, typename _OutputIterator, typename _UnaryOperation>
_OutputIterator transform (_IIter __begin, _IIter __end, _OutputIterator __result, _UnaryOperation __unary_op)and this next one is literally still loading in the source, so here's exactly what's there:
template<typename _IIter, typename _OutputIterator, typename _UnaryOperation> _OutputIterator transform (_IIter __begin, _IIter
__end, _OutputIterator __result, _UnaryOperation __unary_op,
__gnu_parallel::_Parallelism __parallelism_tag)
template<typename _IIter, typename _OutputIterator, typename
_UnaryOperation> _OutputIterator transform (_IIter __begin, _IIter
__end, _OutputIterator __result, _UnaryOperation __unary_op,
__gnu_parallel::sequential_tag)
template<typename _IIter, typename _OIter, typename _UnaryOperation>
_OIter transform (_IIter, _IIter, _OIter, _UnaryOperation)
template<typename _IIter, typename _OIter, typename _UnaryOperation>
_OIter transform (_IIter, _IIter, _OIter, _UnaryOperation,
__gnu_parallel::_Parallelism)
template<typename _IIter, typename _OIter, typename _UnaryOperation>
_OIter transform (_IIter, _IIter, _OIter, _UnaryOperation,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _BinaryOperation> _OutputIterator transform (_IIter1
__begin1, _IIter1 __end1, _IIter2 __begin2, _OutputIterator
__result, _BinaryOperation __binary_op)
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _BinaryOperation> _OutputIterator transform (_IIter1
__begin1, _IIter1 __end1, _IIter2 __begin2, _OutputIterator
__result, _BinaryOperation __binary_op, __gnu_parallel::_Parallelism
__parallelism_tag)
template<typename _IIter1, typename _IIter2, typename _OutputIterator,
typename _BinaryOperation> _OutputIterator transform (_IIter1
__begin1, _IIter1 __end1, _IIter2 __begin2, _OutputIterator
__result, _BinaryOperation __binary_op,
__gnu_parallel::sequential_tag)
template<typename _IIter1, typename _IIter2, typename _OIter, typename
_BiOperation> _OIter transform (_IIter1, _IIter1, _IIter2, _OIter,
_BiOperation)
template<typename _IIter1, typename _IIter2, typename _OIter, typename
_BiOperation> _OIter transform (_IIter1, _IIter1, _IIter2, _OIter,
_BiOperation, __gnu_parallel::_Parallelism)
template<typename _IIter1, typename _IIter2, typename _OIter, typename
_BiOperation> _OIter transform (_IIter1, _IIter1, _IIter2, _OIter,
_BiOperation, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OutputIterator> _OutputIterator
unique_copy (_IIter __begin1, _IIter __end1, _OutputIterator __out)
template<typename _IIter, typename _OutputIterator> _OutputIterator
unique_copy (_IIter __begin1, _IIter __end1, _OutputIterator __out,
__gnu_parallel::sequential_tag)
template<typename _IIter, typename _OutputIterator, typename _Predicate>
_OutputIterator unique_copy (_IIter __begin1, _IIter __end1,
_OutputIterator __out, _Predicate __pred)
template<typename _IIter, typename _OutputIterator, typename _Predicate>
_OutputIterator unique_copy (_IIter __begin1, _IIter __end1,
_OutputIterator __out, _Predicate __pred,
__gnu_parallel::sequential_tag)
template<typename _IIter, typename _OIter> _OIter unique_copy (_IIter,
_IIter, _OIter)
template<typename _IIter, typename _OIter> _OIter unique_copy (_IIter,
_IIter, _OIter, __gnu_parallel::sequential_tag)
template<typename _IIter, typename _OIter, typename _Predicate> _OIter
unique_copy (_IIter, _IIter, _OIter, _Predicate)
template<typename _IIter, typename _OIter, typename _Predicate> _OIter
unique_copy (_IIter, _IIter, _OIter, _Predicate,
__gnu_parallel::sequential_tag)🌈 Detailed Description 🌈
Okay so the whole vibe check on this page: it's the GNU parallel code, and it replaces standard behavior with parallel behavior. Periodt. 💅✨
✨ Function Documentation ✨
🌟 std::__parallel::search
template<typename _ForwardIterator, typename _Searcher> _ForwardIterator
std::__parallel::search (_ForwardIterator __first, _ForwardIterator
__last, const _Searcher & __searcher) [inline]Bestie, this one searches a sequence using a Searcher object. It's giving finder energy, fr fr. 🔍🦋
📋 Parameters 📋
__first— A forward iterator. 👈__last— A forward iterator. 👉__searcher— A callable object. 📞
🎁 Returns 🎁
__searcher(__first,__last).first— that's the whole return vibe. ✨
💖 Author 💖
Generated automatically by Doxygen for libstdc++ from the source code. 🤖💅
Brought to you by libstdc++ and std::__parallel(3) — no date listed, but it's timeless anyway. 💖✨
📦 where this page comes from
- arch rolling: gcc 16.2.1+r23+gd564253eb6c8-1 · GPL-3.0-or-later WITH GCC-exception-3.1 AND GFDL-1.3-or-later
- fedora 44: libstdc++-docs 16.0.1-0.10.fc44 · GPL-3.0-or-later AND LGPL-3.0-or-later AND (GPL-3.0-or-later WITH GCC-exception-3.1) AND (GPL-3.0-or-later WITH Texinfo-exception) AND (LGPL-2.1-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GNU-compiler-exception) AND BSL-1.0 AND GFDL-1.3-or-later AND Linux-man-pages-copyleft-2-para AND SunPro AND BSD-1-Clause AND BSD-2-Clause AND BSD-2-Clause-Views AND BSD-3-Clause AND BSD-4-Clause AND BSD-Source-Code AND Zlib AND MIT AND Apache-2.0 AND (Apache-2.0 WITH LLVM-Exception) AND ZPL-2.1 AND ISC AND LicenseRef-Fedora-Public-Domain AND HP-1986 AND curl AND Martin-Birgmeier AND HPND-Markus-Kuhn AND dtoa AND SMLNJ AND AMD-newlib AND OAR AND HPND-merchantability-variant AND HPND-Intel
- fedora 44: libstdc++-docs 16.2.1-2.fc44
- fedora 44: libstdc++-docs 16.2.1-3.fc44 · GPL-3.0-or-later AND LGPL-3.0-or-later AND (GPL-3.0-or-later WITH GCC-exception-3.1) AND (GPL-3.0-or-later WITH Texinfo-exception) AND (LGPL-2.1-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GCC-exception-2.0) AND (GPL-2.0-or-later WITH GNU-compiler-exception) AND BSL-1.0 AND GFDL-1.3-or-later AND Linux-man-pages-copyleft-2-para AND SunPro AND BSD-1-Clause AND BSD-2-Clause AND BSD-2-Clause-Views AND BSD-3-Clause AND BSD-4-Clause AND BSD-Source-Code AND Zlib AND MIT AND Apache-2.0 AND (Apache-2.0 WITH LLVM-Exception) AND ZPL-2.1 AND ISC AND LicenseRef-Fedora-Public-Domain AND HP-1986 AND curl AND Martin-Birgmeier AND HPND-Markus-Kuhn AND dtoa AND SMLNJ AND AMD-newlib AND OAR AND HPND-merchantability-variant AND HPND-Intel
- 💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on : a language model's rewrite of the original, under its terms