Index: include/pstl/internal/algorithm_fwd.h =================================================================== --- include/pstl/internal/algorithm_fwd.h +++ include/pstl/internal/algorithm_fwd.h @@ -24,25 +24,26 @@ template bool -brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, - /*__is_vector=*/std::false_type) noexcept; +__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, + /*__is_vector=*/std::false_type) noexcept; template bool -brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, - /*__is_vector=*/std::true_type) noexcept; +__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, + /*__is_vector=*/std::true_type) noexcept; template -bool pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, - /*parallel=*/std::false_type) noexcept; +bool +__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -bool pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, - /*parallel=*/std::true_type); +bool +__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, + /*parallel=*/std::true_type); #endif - #if 0 // TODO does this even need forwarding? template @@ -56,31 +57,35 @@ //------------------------------------------------------------------------ template -void brick_walk1(_ForwardIterator, _ForwardIterator, _Function, - /*vector=*/std::false_type) noexcept; +void __brick_walk1(_ForwardIterator, _ForwardIterator, _Function, + /*vector=*/std::false_type) noexcept; template -void brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function, - /*vector=*/std::true_type) noexcept; +void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function, + /*vector=*/std::true_type) noexcept; template -void pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, - /*parallel=*/std::false_type) noexcept; +void +__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, - /*parallel=*/std::true_type); +void +__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, + /*parallel=*/std::true_type); #endif template -void pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, - /*parallel=*/std::false_type) noexcept; +void +__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, - /*parallel=*/std::true_type); +void +__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, + /*parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -88,31 +93,35 @@ //------------------------------------------------------------------------ template -_ForwardIterator brick_walk1_n(_ForwardIterator, _Size, _Function, - /*_IsVectorTag=*/std::false_type); +_ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function, + /*_IsVectorTag=*/std::false_type); template -_RandomAccessIterator brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function, - /*vectorTag=*/std::true_type) noexcept; +_RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function, + /*vectorTag=*/std::true_type) noexcept; template -_ForwardIterator pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_ForwardIterator +__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_RandomAccessIterator pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector, - /*is_parallel=*/std::true_type); +template +_RandomAccessIterator +__pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector, + /*is_parallel=*/std::true_type); #endif template -_ForwardIterator pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick, - /*is_parallel=*/std::false_type) noexcept; +_ForwardIterator +__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_RandomAccessIterator pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick, - /*is_parallel=*/std::true_type); +_RandomAccessIterator +__pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -122,60 +131,70 @@ //------------------------------------------------------------------------ template -_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, - /*vector=*/std::false_type) noexcept; +_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, + /*vector=*/std::false_type) noexcept; template -_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, - /*vector=*/std::true_type) noexcept; +_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, + /*vector=*/std::true_type) noexcept; template -_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, - /*vector=*/std::false_type) noexcept; +_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, + /*vector=*/std::false_type) noexcept; template -_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, - /*vector=*/std::true_type) noexcept; +_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, + /*vector=*/std::true_type) noexcept; template -_ForwardIterator2 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, - /*parallel=*/std::false_type) noexcept; +_ForwardIterator2 +__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator2 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, - /*parallel=*/std::true_type); +_ForwardIterator2 +__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, + /*parallel=*/std::true_type); #endif -template -_ForwardIterator2 pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector, - /*parallel=*/std::false_type) noexcept; +template +_ForwardIterator2 +__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_RandomAccessIterator2 pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector, - /*parallel=*/std::true_type); +template +_RandomAccessIterator2 +__pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector, + /*parallel=*/std::true_type); #endif template -_ForwardIterator2 pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick, - /*parallel=*/std::false_type) noexcept; +_ForwardIterator2 +__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_RandomAccessIterator2 pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, - _Brick, - /*parallel=*/std::true_type); +_RandomAccessIterator2 +__pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _Brick, + /*parallel=*/std::true_type); #endif template -_ForwardIterator2 pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick, - /*parallel=*/std::false_type) noexcept; +_ForwardIterator2 +__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_RandomAccessIterator2 pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick, - /*parallel=*/std::true_type); +_RandomAccessIterator2 +__pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick, + /*parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -185,24 +204,27 @@ //------------------------------------------------------------------------ template -_ForwardIterator3 brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function, - /*vector=*/std::false_type) noexcept; +_ForwardIterator3 __brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function, + /*vector=*/std::false_type) noexcept; template -_RandomAccessIterator3 brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, - _RandomAccessIterator3, _Function, - /*vector=*/std::true_type) noexcept; +_RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator3, _Function, + /*vector=*/std::true_type) noexcept; -template -_ForwardIterator3 pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function, - _IsVector, - /*parallel=*/std::false_type) noexcept; +template +_ForwardIterator3 +__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, + _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_RandomAccessIterator3 pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, - _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type); +template +_RandomAccessIterator3 +__pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -210,21 +232,27 @@ //------------------------------------------------------------------------ template -bool brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, - /* IsVector = */ std::false_type) noexcept; +bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, + /* IsVector = */ std::false_type) noexcept; template -bool brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, - /* is_vector = */ std::true_type) noexcept; +bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, + /* is_vector = */ std::true_type) noexcept; -template -bool pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, _IsVector, - /* is_parallel = */ std::false_type) noexcept; +template +bool +__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, + _IsVector, + /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -bool pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, _IsVector, - /*is_parallel=*/std::true_type); +template +bool +__pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -232,21 +260,23 @@ //------------------------------------------------------------------------ template -_ForwardIterator brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate, - /*is_vector=*/std::false_type) noexcept; +_ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate, + /*is_vector=*/std::false_type) noexcept; template -_RandomAccessIterator brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate, - /*is_vector=*/std::true_type) noexcept; +_RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate, + /*is_vector=*/std::true_type) noexcept; template -_ForwardIterator pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_ForwardIterator +__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, - /*is_parallel=*/std::true_type); +_ForwardIterator +__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -254,25 +284,29 @@ //------------------------------------------------------------------------ template -_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, - /*__is_vector=*/std::false_type) noexcept; +_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::false_type) noexcept; template -_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, - /*__is_vector=*/std::true_type) noexcept; +_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::true_type) noexcept; -template -_ForwardIterator1 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +template +_ForwardIterator1 +__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_ForwardIterator1 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, _IsVector, - /*is_parallel=*/std::true_type) noexcept; +template +_ForwardIterator1 +__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -280,23 +314,27 @@ //------------------------------------------------------------------------ template -_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, - /*__is_vector=*/std::false_type) noexcept; +_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::false_type) noexcept; template -_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, - /*__is_vector=*/std::true_type) noexcept; +_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::true_type) noexcept; -template -_ForwardIterator1 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept; +template +_ForwardIterator1 +__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_ForwardIterator1 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept; +template +_ForwardIterator1 +__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -304,25 +342,29 @@ //------------------------------------------------------------------------ template -_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, - /*vector=*/std::false_type) noexcept; +_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*vector=*/std::false_type) noexcept; template -_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, - /*vector=*/std::true_type) noexcept; +_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*vector=*/std::true_type) noexcept; -template -_ForwardIterator1 pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +template +_ForwardIterator1 +__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_ForwardIterator1 pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _BinaryPredicate, _IsVector, - /*is_parallel=*/std::true_type) noexcept; +template +_ForwardIterator1 +__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -331,24 +373,28 @@ template _ForwardIterator -brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, - /*vector=*/std::false_type) noexcept; +__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, + /*vector=*/std::false_type) noexcept; template _ForwardIterator -brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, - /*vector=*/std::true_type) noexcept; +__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, + /*vector=*/std::true_type) noexcept; -template +template _ForwardIterator -pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, IsVector, - /*is_parallel=*/std::false_type) noexcept; +__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, + IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template +template _RandomAccessIterator -pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate, IsVector, - /*is_parallel=*/std::true_type) noexcept; +__pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, + _BinaryPredicate, IsVector, + /*is_parallel=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -356,97 +402,102 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator, - /*vector=*/std::false_type) noexcept; +_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, + /*vector=*/std::false_type) noexcept; template -_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator, - /*vector=*/std::true_type) noexcept; +_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, + /*vector=*/std::true_type) noexcept; //------------------------------------------------------------------------ // copy //------------------------------------------------------------------------ template -_OutputIterator brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator, - /*vector=*/std::false_type) noexcept; +_OutputIterator __brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator, + /*vector=*/std::false_type) noexcept; template -_OutputIterator brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, - /*vector=*/std::true_type) noexcept; +_OutputIterator __brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + /*vector=*/std::true_type) noexcept; //------------------------------------------------------------------------ // move //------------------------------------------------------------------------ template -_OutputIterator brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator, - /*vector=*/std::false_type) noexcept; +_OutputIterator __brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator, + /*vector=*/std::false_type) noexcept; template -_OutputIterator brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, - /*vector=*/std::true_type) noexcept; +_OutputIterator __brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + /*vector=*/std::true_type) noexcept; //------------------------------------------------------------------------ // swap_ranges //------------------------------------------------------------------------ template -_OutputIterator brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - /*vector=*/std::false_type) noexcept; +_OutputIterator +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept; template -_OutputIterator brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - /*vector=*/std::true_type) noexcept; +_OutputIterator +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept; //------------------------------------------------------------------------ // copy_if //------------------------------------------------------------------------ template -_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, - /*vector=*/std::false_type) noexcept; +_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, + /*vector=*/std::false_type) noexcept; template -_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, - /*vector=*/std::true_type) noexcept; +_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, + /*vector=*/std::true_type) noexcept; template std::pair<_DifferenceType, _DifferenceType> -brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate, - /*vector=*/std::false_type) noexcept; +__brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate, + /*vector=*/std::false_type) noexcept; template std::pair<_DifferenceType, _DifferenceType> -brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate, - /*vector=*/std::true_type) noexcept; +__brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate, + /*vector=*/std::true_type) noexcept; template void -brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*, - /*vector=*/std::false_type) noexcept; +__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*, + /*vector=*/std::false_type) noexcept; template void -brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict, - /*vector=*/std::true_type) noexcept; +__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict, + /*vector=*/std::true_type) noexcept; template void -brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*, - /*vector=*/std::false_type) noexcept; +__brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*, + /*vector=*/std::false_type) noexcept; template void -brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*, - /*vector=*/std::true_type) noexcept; +__brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*, + /*vector=*/std::true_type) noexcept; template -_OutputIterator pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector, - /*parallel=*/std::false_type) noexcept; +_OutputIterator +__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector, + /*parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate, - _IsVector, /*parallel=*/std::true_type); +template +_OutputIterator +__pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate, + _IsVector, /*parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -455,24 +506,24 @@ template typename std::iterator_traits<_ForwardIterator>::difference_type -brick_count(_ForwardIterator, _ForwardIterator, _Predicate, - /* is_vector = */ std::true_type) noexcept; + __brick_count(_ForwardIterator, _ForwardIterator, _Predicate, + /* is_vector = */ std::true_type) noexcept; template typename std::iterator_traits<_ForwardIterator>::difference_type -brick_count(_ForwardIterator, _ForwardIterator, _Predicate, - /* is_vector = */ std::false_type) noexcept; + __brick_count(_ForwardIterator, _ForwardIterator, _Predicate, + /* is_vector = */ std::false_type) noexcept; template typename std::iterator_traits<_ForwardIterator>::difference_type -pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, - /* is_parallel */ std::false_type, _IsVector) noexcept; +__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, + /* is_parallel */ std::false_type, _IsVector) noexcept; #if __PSTL_USE_PAR_POLICIES template typename std::iterator_traits<_ForwardIterator>::difference_type -pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, - /* is_parallel */ std::true_type, _IsVector); +__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, + /* is_parallel */ std::true_type, _IsVector); #endif //------------------------------------------------------------------------ @@ -480,21 +531,23 @@ //------------------------------------------------------------------------ template -_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, - /*is_vector=*/std::false_type) noexcept; +_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /*is_vector=*/std::false_type) noexcept; template -_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, - /*is_vector=*/std::true_type) noexcept; +_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /*is_vector=*/std::true_type) noexcept; template -_ForwardIterator pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_ForwardIterator +__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, - /*is_parallel=*/std::true_type) noexcept; +_ForwardIterator +__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -502,31 +555,33 @@ //------------------------------------------------------------------------ template -OutputIterator brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, - /*vector=*/std::false_type) noexcept; +OutputIterator __brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, + /*vector=*/std::false_type) noexcept; template -_OutputIterator brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate, - /*vector=*/std::true_type) noexcept; +_OutputIterator __brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate, + /*vector=*/std::true_type) noexcept; template -OutputIterator pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector, - /*parallel=*/std::false_type) noexcept; +OutputIterator __pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector, + /*parallel=*/std::false_type) noexcept; template _DifferenceType -brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, - /*vector=*/std::false_type) noexcept; +__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, + /*vector=*/std::false_type) noexcept; template _DifferenceType -brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, - /*vector=*/std::true_type) noexcept; +__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, + /*vector=*/std::true_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate, - _IsVector, /*parallel=*/std::true_type); +template +_OutputIterator +__pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + _BinaryPredicate, _IsVector, /*parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -534,29 +589,31 @@ //------------------------------------------------------------------------ template -void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, - /*__is_vector=*/std::false_type) noexcept; +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, + /*__is_vector=*/std::false_type) noexcept; template -void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, - /*__is_vector=*/std::true_type) noexcept; +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, + /*__is_vector=*/std::true_type) noexcept; template -void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, - /*is_vector=*/std::false_type) noexcept; +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + /*is_vector=*/std::false_type) noexcept; template -void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, - /*is_vector=*/std::true_type) noexcept; +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + /*is_vector=*/std::true_type) noexcept; template -void pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +void +__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, - /*is_parallel=*/std::true_type); +void +__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -564,21 +621,23 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, - /*is_vector=*/std::false_type) noexcept; +_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, + /*is_vector=*/std::false_type) noexcept; template -_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, - /*is_vector=*/std::true_type) noexcept; +_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, + /*is_vector=*/std::true_type) noexcept; template -_OutputIterator pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_OutputIterator +__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_OutputIterator pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, - /*is_parallel=*/std::true_type); +_OutputIterator +__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -586,21 +645,23 @@ //------------------------------------------------------------------------ template -_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, - /*is_vector=*/std::false_type) noexcept; +_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, + /*is_vector=*/std::false_type) noexcept; template -_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, - /*is_vector=*/std::true_type) noexcept; +_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, + /*is_vector=*/std::true_type) noexcept; template -_ForwardIterator pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_ForwardIterator +__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, - /*is_parallel=*/std::true_type); +_ForwardIterator +__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -608,21 +669,25 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, - /*__is_vector=*/std::false_type) noexcept; +_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + /*__is_vector=*/std::false_type) noexcept; template -_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, - /*__is_vector=*/std::true_type) noexcept; +_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + /*__is_vector=*/std::true_type) noexcept; template -_OutputIterator pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_OutputIterator +__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_OutputIterator pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector, - /*is_parallel=*/std::true_type); +_OutputIterator +__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -630,21 +695,23 @@ //------------------------------------------------------------------------ template -bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, - /*is_vector=*/std::false_type) noexcept; +bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::false_type) noexcept; template -bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, - /*is_vector=*/std::true_type) noexcept; +bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::true_type) noexcept; template -bool pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +bool +__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -bool pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, - /*is_parallel=*/std::true_type); +bool +__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -652,21 +719,23 @@ //------------------------------------------------------------------------ template -_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, - /*is_vector=*/std::false_type) noexcept; +_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::false_type) noexcept; template -_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, - /*is_vector=*/std::true_type) noexcept; +_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::true_type) noexcept; template -_ForwardIterator pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_ForwardIterator +__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, - /*is_parallel=*/std::true_type); +_ForwardIterator +__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -674,23 +743,25 @@ //------------------------------------------------------------------------ template -_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, - /*__is_vector=*/std::false_type) noexcept; +_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + /*__is_vector=*/std::false_type) noexcept; template -_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, - /*__is_vector=*/std::true_type) noexcept; +_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + /*__is_vector=*/std::true_type) noexcept; template -_BidirectionalIterator pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, - _IsVector, - /*is_parallelization=*/std::false_type) noexcept; +_BidirectionalIterator +__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + _IsVector, + /*is_parallelization=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_BidirectionalIterator pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, - _IsVector, - /*is_parallelization=*/std::true_type) noexcept; +_BidirectionalIterator +__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + _IsVector, + /*is_parallelization=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -698,46 +769,47 @@ //------------------------------------------------------------------------ template -std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, - _OutputIterator2, _UnaryPredicate, - /*is_vector=*/std::false_type) noexcept; +std::pair<_OutputIterator1, _OutputIterator2> + __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, + /*is_vector=*/std::false_type) noexcept; template -std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, - _OutputIterator2, _UnaryPredicate, - /*is_vector=*/std::true_type) noexcept; +std::pair<_OutputIterator1, _OutputIterator2> + __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, + /*is_vector=*/std::true_type) noexcept; -template +template std::pair<_OutputIterator1, _OutputIterator2> -pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, - _OutputIterator1, _OutputIterator2, - _UnaryPredicate, _IsVector, - /*is_parallelization=*/std::false_type) noexcept; +__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, + _UnaryPredicate, _IsVector, + /*is_parallelization=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template +template std::pair<_OutputIterator1, _OutputIterator2> -pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, - _OutputIterator1, _OutputIterator2, - _UnaryPredicate, _IsVector, - /*is_parallelization=*/std::true_type); +__pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, + _OutputIterator2, _UnaryPredicate, _IsVector, + /*is_parallelization=*/std::true_type); #endif //------------------------------------------------------------------------ // sort //------------------------------------------------------------------------ -template -void pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, - /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept; +template +void +__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, + /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, - /*is_parallel=*/std::true_type, - /*is_move_constructible=*/std::true_type); +void +__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, + /*is_parallel=*/std::true_type, + /*is_move_constructible=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -745,13 +817,17 @@ //------------------------------------------------------------------------ template -void pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, - /*is_parallel=*/std::false_type) noexcept; +void +__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector /*is_vector*/, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, - /*is_parallel=*/std::true_type); +void +__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector /*is_vector*/, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -759,13 +835,17 @@ //------------------------------------------------------------------------ template -void pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +void +__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, + _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /*is_parallel=*/std::true_type); +void +__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, + _Compare, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -773,15 +853,17 @@ //------------------------------------------------------------------------ template -_RandomAccessIterator pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, - _RandomAccessIterator, _Compare, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +_RandomAccessIterator +__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, + _RandomAccessIterator, _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_RandomAccessIterator pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, - _RandomAccessIterator, _Compare, _IsVector, - /*is_parallel=*/std::true_type); +_RandomAccessIterator +__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, + _RandomAccessIterator, _Compare, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -790,37 +872,41 @@ template _ForwardIterator -brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, - /* IsVector = */ std::true_type, bool) noexcept; +__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /* IsVector = */ std::true_type, bool) noexcept; template _ForwardIterator -brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, - /* IsVector = */ std::false_type, bool) noexcept; +__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /* IsVector = */ std::false_type, bool) noexcept; template _ForwardIterator -pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, - /* is_parallel */ std::false_type, _IsVector, bool) noexcept; +__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, + /* is_parallel */ std::false_type, _IsVector, bool) noexcept; #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate, - /* is_parallel */ std::true_type, _IsVector, bool); +__pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate, + /* is_parallel */ std::true_type, _IsVector, bool); #endif //------------------------------------------------------------------------ // nth_element //------------------------------------------------------------------------ template -void pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +void +__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /*is_parallel=*/std::true_type) noexcept; +void +__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector, + /*is_parallel=*/std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -828,46 +914,46 @@ //------------------------------------------------------------------------ template void -brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, - /* __is_vector = */ std::true_type) noexcept; +__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, + /* __is_vector = */ std::true_type) noexcept; template void -brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, - /* __is_vector = */ std::false_type) noexcept; +__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, + /* __is_vector = */ std::false_type) noexcept; template void -pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, - /*is_parallel=*/std::false_type, _IsVector) noexcept; +__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, + /*is_parallel=*/std::false_type, _IsVector) noexcept; #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, - /*is_parallel=*/std::true_type, _IsVector); +__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, + /*is_parallel=*/std::true_type, _IsVector); #endif template _OutputIterator -brick_fill_n(_OutputIterator, _Size, const _Tp&, - /* __is_vector = */ std::true_type) noexcept; +__brick_fill_n(_OutputIterator, _Size, const _Tp&, + /* __is_vector = */ std::true_type) noexcept; template _OutputIterator -brick_fill_n(_OutputIterator, _Size, const _Tp&, - /* __is_vector = */ std::false_type) noexcept; +__brick_fill_n(_OutputIterator, _Size, const _Tp&, + /* __is_vector = */ std::false_type) noexcept; template _OutputIterator -pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, - /*is_parallel=*/std::false_type, _IsVector) noexcept; +__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, + /*is_parallel=*/std::false_type, _IsVector) noexcept; #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, - /*is_parallel=*/std::true_type, _IsVector); +__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, + /*is_parallel=*/std::true_type, _IsVector); #endif //------------------------------------------------------------------------ @@ -875,60 +961,66 @@ //------------------------------------------------------------------------ template -void brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator, - /* is_vector = */ std::true_type) noexcept; +void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator, + /* is_vector = */ std::true_type) noexcept; template -void brick_generate(_ForwardIterator, _ForwardIterator, _Generator, - /* is_vector = */ std::false_type) noexcept; +void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator, + /* is_vector = */ std::false_type) noexcept; template -void pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, - /*is_parallel=*/std::false_type, _IsVector) noexcept; +void +__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, + /*is_parallel=*/std::false_type, _IsVector) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, - /*is_parallel=*/std::true_type, _IsVector); +_ForwardIterator +__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, + /*is_parallel=*/std::true_type, _IsVector); #endif template -OutputIterator brick_generate_n(OutputIterator, Size, _Generator, - /* is_vector = */ std::true_type) noexcept; +OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, + /* is_vector = */ std::true_type) noexcept; template -OutputIterator brick_generate_n(OutputIterator, Size, _Generator, - /* is_vector = */ std::false_type) noexcept; +OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, + /* is_vector = */ std::false_type) noexcept; template -OutputIterator pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, - /*is_parallel=*/std::false_type, _IsVector) noexcept; +OutputIterator +__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, + /*is_parallel=*/std::false_type, _IsVector) noexcept; #if __PSTL_USE_PAR_POLICIES template -OutputIterator pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, - /*is_parallel=*/std::true_type, _IsVector); +OutputIterator +__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, + /*is_parallel=*/std::true_type, _IsVector); #endif //------------------------------------------------------------------------ // remove //------------------------------------------------------------------------ template -_ForwardIterator brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, - /* __is_vector = */ std::false_type) noexcept; +_ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /* __is_vector = */ std::false_type) noexcept; template -_RandomAccessIterator brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate, - /* __is_vector = */ std::true_type) noexcept; +_RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate, + /* __is_vector = */ std::true_type) noexcept; template -_ForwardIterator pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, - /*is_parallel*/ std::false_type) noexcept; +_ForwardIterator +__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel*/ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_ForwardIterator pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, - /*is_parallel*/ std::true_type) noexcept; +_ForwardIterator +__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel*/ std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -936,25 +1028,28 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, - _Compare, - /* __is_vector = */ std::false_type) noexcept; +_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; template -_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, - _Compare, - /* __is_vector = */ std::true_type) noexcept; +_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; -template -_OutputIterator pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; +template +_OutputIterator +__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, - _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector, - /* is_parallel = */ std::true_type); +template +_OutputIterator +__pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type); #endif //------------------------------------------------------------------------ @@ -962,21 +1057,25 @@ //------------------------------------------------------------------------ template -void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, - /* __is_vector = */ std::false_type) noexcept; +void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; template -void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, - /* __is_vector = */ std::true_type) noexcept; +void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; template -void pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector, - /* is_parallel = */ std::false_type) noexcept; +void +__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -void pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector, - /*is_parallel=*/std::true_type); +void +__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + _Compare, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -984,13 +1083,17 @@ //------------------------------------------------------------------------ template -bool pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +bool +__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -bool pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector, - /*is_parallel=*/std::true_type); +bool +__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -998,23 +1101,27 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, - /*__is_vector=*/std::false_type) noexcept; +_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; template -_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, - /*__is_vector=*/std::true_type) noexcept; +_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; -template -_OutputIterator pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; +template +_OutputIterator +__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); +template +_OutputIterator +__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -1022,24 +1129,28 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, - /*__is_vector=*/std::false_type) noexcept; +_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; template -_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, - /*__is_vector=*/std::true_type) noexcept; +_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; -template -_OutputIterator pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +template +_OutputIterator +__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); +template +_OutputIterator +__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -1047,23 +1158,27 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, - /*__is_vector=*/std::false_type) noexcept; +_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; template -_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, - /*__is_vector=*/std::true_type) noexcept; +_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; -template -_OutputIterator pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; +template +_OutputIterator +__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); +template +_OutputIterator +__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -1071,25 +1186,29 @@ //------------------------------------------------------------------------ template -_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, - _ForwardIterator2, _OutputIterator, _Compare, - /*__is_vector=*/std::false_type) noexcept; +_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; template -_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, - _ForwardIterator2, _OutputIterator, _Compare, - /*__is_vector=*/std::true_type) noexcept; +_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; -template -_OutputIterator pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, - _ForwardIterator2, _OutputIterator, _Compare, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +template +_OutputIterator +__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, - _ForwardIterator2, _OutputIterator, _Compare, _IsVector, - /*is_parallel=*/std::true_type); +template +_OutputIterator +__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -1097,21 +1216,23 @@ //------------------------------------------------------------------------ template -_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, - /* __is_vector = */ std::false_type) noexcept; +_RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; template -_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, - /* __is_vector = */ std::true_type) noexcept; +_RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; template -_RandomAccessIterator pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /* is_parallel = */ std::false_type) noexcept; +_RandomAccessIterator +__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_RandomAccessIterator pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /* is_parallel = */ std::true_type) noexcept; +_RandomAccessIterator +__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -1119,21 +1240,23 @@ //------------------------------------------------------------------------ template -_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, - /* __is_vector = */ std::false_type) noexcept; +_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; template -_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, - /* __is_vector = */ std::true_type) noexcept; +_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; template -_ForwardIterator pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, - /* is_parallel = */ std::false_type) noexcept; +_ForwardIterator +__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -_RandomAccessIterator pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, - /* is_parallel = */ std::true_type); +_RandomAccessIterator +__pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type); #endif //------------------------------------------------------------------------ @@ -1141,27 +1264,23 @@ //------------------------------------------------------------------------ template -std::pair<_ForwardIterator, _ForwardIterator> -brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, - /* __is_vector = */ std::false_type) noexcept; +std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; template -std::pair<_ForwardIterator, _ForwardIterator> -brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, - /* __is_vector = */ std::true_type) noexcept; +std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; template std::pair<_ForwardIterator, _ForwardIterator> -pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, - _IsVector, - /* is_parallel = */ std::false_type) noexcept; +__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template std::pair<_ForwardIterator, _ForwardIterator> -pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, - _IsVector, - /* is_parallel = */ std::true_type); +__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type); #endif //------------------------------------------------------------------------ @@ -1169,27 +1288,27 @@ //------------------------------------------------------------------------ template -std::pair<_ForwardIterator1, _ForwardIterator2> -brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, - _ForwardIterator2, _Predicate, - /* __is_vector = */ std::false_type) noexcept; +std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1, + _ForwardIterator2, _ForwardIterator2, _Predicate, + /* __is_vector = */ std::false_type) noexcept; template -std::pair<_ForwardIterator1, _ForwardIterator2> -brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, - _ForwardIterator2, _Predicate, - /* __is_vector = */ std::true_type) noexcept; +std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1, + _ForwardIterator2, _ForwardIterator2, _Predicate, + /* __is_vector = */ std::true_type) noexcept; template std::pair<_ForwardIterator1, _ForwardIterator2> -pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, _IsVector, - /* is_parallel = */ std::false_type) noexcept; +__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Predicate, _IsVector, + /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template +template std::pair<_RandomAccessIterator1, _RandomAccessIterator2> -pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, - _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept; +__pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator2, _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept; #endif //------------------------------------------------------------------------ @@ -1197,21 +1316,25 @@ //------------------------------------------------------------------------ template -bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, - /* __is_vector = */ std::false_type) noexcept; +bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, + /* __is_vector = */ std::false_type) noexcept; template -bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, - /* __is_vector = */ std::true_type) noexcept; +bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, + /* __is_vector = */ std::true_type) noexcept; template -bool pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; +bool +__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template -bool pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, - _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept; +bool +__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept; #endif } // namespace internal Index: include/pstl/internal/algorithm_impl.h =================================================================== --- include/pstl/internal/algorithm_impl.h +++ include/pstl/internal/algorithm_impl.h @@ -36,38 +36,38 @@ template bool -brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, - /*__is_vector=*/std::false_type) noexcept +__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, + /*__is_vector=*/std::false_type) noexcept { return std::any_of(__first, __last, __pred); }; template bool -brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, - /*__is_vector=*/std::true_type) noexcept +__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, + /*__is_vector=*/std::true_type) noexcept { return unseq_backend::simd_or(__first, __last - __first, __pred); }; template bool -pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, - _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, + _IsVector __is_vector, /*parallel=*/std::false_type) noexcept { - return internal::brick_any_of(__first, __last, __pred, __is_vector); + return internal::__brick_any_of(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template bool -pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, - _IsVector __is_vector, /*parallel=*/std::true_type) +__pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, + _IsVector __is_vector, /*parallel=*/std::true_type) { return internal::except_handler([&]() { return internal::parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { - return internal::brick_any_of(__i, __j, __pred, __is_vector); + return internal::__brick_any_of(__i, __j, __pred, __is_vector); }); }); } @@ -92,39 +92,39 @@ //------------------------------------------------------------------------ template void -brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept +__brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept { std::for_each(__first, __last, __f); } template void -brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f, - /*vector=*/std::true_type) noexcept +__brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f, + /*vector=*/std::true_type) noexcept { unseq_backend::simd_walk_1(__first, __last - __first, __f); } template void -pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f, - _IsVector __is_vector, - /*parallel=*/std::false_type) noexcept +__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f, + _IsVector __is_vector, + /*parallel=*/std::false_type) noexcept { - internal::brick_walk1(__first, __last, __f, __is_vector); + internal::__brick_walk1(__first, __last, __f, __is_vector); } #if __PSTL_USE_PAR_POLICIES template void -pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f, - _IsVector __is_vector, - /*parallel=*/std::true_type) +__pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f, + _IsVector __is_vector, + /*parallel=*/std::true_type) { internal::except_handler([&]() { par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { - internal::brick_walk1(__i, __j, __f, __is_vector); + internal::__brick_walk1(__i, __j, __f, __is_vector); }); }); } @@ -132,8 +132,8 @@ template void -pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, - /*parallel=*/std::false_type) noexcept +__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, + /*parallel=*/std::false_type) noexcept { __brick(__first, __last); } @@ -141,8 +141,8 @@ #if __PSTL_USE_PAR_POLICIES template void -pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, - /*parallel=*/std::true_type) +__pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, + /*parallel=*/std::true_type) { internal::except_handler([&]() { par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, @@ -156,44 +156,44 @@ //------------------------------------------------------------------------ template _ForwardIterator -brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type) +__brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type) { return for_each_n_it_serial(__first, __n, [&__f](_ForwardIterator __it) { __f(*__it); }); // calling serial version } template _RandomAccessIterator -brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f, - /*vectorTag=*/std::true_type) noexcept +__brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f, + /*vectorTag=*/std::true_type) noexcept { return unseq_backend::simd_walk_1(__first, __n, __f); } template _ForwardIterator -pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return internal::brick_walk1_n(__first, __n, __f, __is_vector); + return internal::__brick_walk1_n(__first, __n, __f, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f, - _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f, + _IsVector __is_vector, + /*is_parallel=*/std::true_type) { - internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector, - std::true_type()); + internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector, + std::true_type()); return __first + __n; } #endif template _ForwardIterator -pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick, - /*is_parallel=*/std::false_type) noexcept +__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick, + /*is_parallel=*/std::false_type) noexcept { return __brick(__first, __n); } @@ -201,8 +201,8 @@ #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick, - /*is_parallel=*/std::true_type) +__pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick, + /*is_parallel=*/std::true_type) { return internal::except_handler([&]() { par_backend::parallel_for( @@ -220,8 +220,8 @@ //------------------------------------------------------------------------ template _ForwardIterator2 -brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, - /*vector=*/std::false_type) noexcept +__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::false_type) noexcept { for (; __first1 != __last1; ++__first1, ++__first2) __f(*__first1, *__first2); @@ -230,16 +230,16 @@ template _ForwardIterator2 -brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, - /*vector=*/std::true_type) noexcept +__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::true_type) noexcept { return unseq_backend::simd_walk_2(__first1, __last1 - __first1, __first2, __f); } template _ForwardIterator2 -brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, - /*vector=*/std::false_type) noexcept +__brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::false_type) noexcept { for (; __n > 0; --__n, ++__first1, ++__first2) __f(*__first1, *__first2); @@ -248,30 +248,30 @@ template _ForwardIterator2 -brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, - /*vector=*/std::true_type) noexcept +__brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::true_type) noexcept { return unseq_backend::simd_walk_2(__first1, __n, __first2, __f); } template _ForwardIterator2 -pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept { - return internal::brick_walk2(__first1, __last1, __first2, __f, __is_vector); + return internal::__brick_walk2(__first1, __last1, __first2, __f, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator2 -pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type) +__pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type) { return internal::except_handler([&]() { par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { - internal::brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector); + internal::__brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector); }); return __first2 + (__last1 - __first1); }); @@ -281,26 +281,26 @@ template _ForwardIterator2 -pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size n, _ForwardIterator2 __first2, _Function f, - _IsVector is_vector, /*parallel=*/std::false_type) noexcept +__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size n, _ForwardIterator2 __first2, _Function f, + _IsVector is_vector, /*parallel=*/std::false_type) noexcept { - return internal::brick_walk2_n(__first1, n, __first2, f, is_vector); + return internal::__brick_walk2_n(__first1, n, __first2, f, is_vector); } template _RandomAccessIterator2 -pattern_walk2_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size n, _RandomAccessIterator2 __first2, - _Function f, _IsVector is_vector, /*parallel=*/std::true_type) +__pattern_walk2_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size n, _RandomAccessIterator2 __first2, + _Function f, _IsVector is_vector, /*parallel=*/std::true_type) { - return internal::pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + n, __first2, f, - is_vector, std::true_type()); + return internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + n, __first2, f, + is_vector, std::true_type()); } template _ForwardIterator2 -pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept +__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept { return __brick(__first1, __last1, __first2); } @@ -308,8 +308,8 @@ #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator2 -pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, - _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) +__pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) { return except_handler([&]() { par_backend::parallel_for( @@ -325,8 +325,8 @@ #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator2 -pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n, - _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) +__pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n, + _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) { return except_handler([&]() { par_backend::parallel_for( @@ -341,8 +341,8 @@ template _ForwardIterator2 -pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, - _Brick __brick, /*parallel=*/std::false_type) noexcept +__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, + _Brick __brick, /*parallel=*/std::false_type) noexcept { return __brick(__first1, __n, __first2); } @@ -354,8 +354,8 @@ //------------------------------------------------------------------------ template _ForwardIterator3 -brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator3 __first3, _Function __f, /*vector=*/std::false_type) noexcept +__brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator3 __first3, _Function __f, /*vector=*/std::false_type) noexcept { for (; __first1 != __last1; ++__first1, ++__first2, ++__first3) __f(*__first1, *__first2, *__first3); @@ -364,8 +364,8 @@ template _RandomAccessIterator3 -brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, - _RandomAccessIterator3 __first3, _Function __f, /*vector=*/std::true_type) noexcept +__brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, + _RandomAccessIterator3 __first3, _Function __f, /*vector=*/std::true_type) noexcept { return unseq_backend::simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f); } @@ -373,26 +373,26 @@ template _ForwardIterator3 -pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept { - return internal::brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector); + return internal::__brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator3 -pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, - _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector, - /*parallel=*/std::true_type) +__pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector, + /*parallel=*/std::true_type) { return internal::except_handler([&]() { par_backend::parallel_for( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__f, __first1, __first2, __first3, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { - internal::brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f, - __is_vector); + internal::__brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f, + __is_vector); }); return __first3 + (__last1 - __first1); }); @@ -405,16 +405,16 @@ template bool -brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p, - /* IsVector = */ std::false_type) noexcept +__brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p, + /* IsVector = */ std::false_type) noexcept { return std::equal(__first1, __last1, __first2, __p); } template bool -brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, - _BinaryPredicate __p, /* is_vector = */ std::true_type) noexcept +__brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, + _BinaryPredicate __p, /* is_vector = */ std::true_type) noexcept { return unseq_backend::simd_first(__first1, __last1 - __first1, __first2, not_pred<_BinaryPredicate>(__p)).first == __last1; @@ -423,25 +423,25 @@ template bool -pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept { - return internal::brick_equal(__first1, __last1, __first2, __p, __is_vector); + return internal::__brick_equal(__first1, __last1, __first2, __p, __is_vector); } #if __PSTL_USE_PAR_POLICIES template bool -pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, - _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector, + /*is_parallel=*/std::true_type) { return internal::except_handler([&]() { return !internal::parallel_or( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { - return !brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector); + return !__brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector); }); }); } @@ -452,16 +452,16 @@ //------------------------------------------------------------------------ template _ForwardIterator -brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - /*is_vector=*/std::false_type) noexcept +__brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /*is_vector=*/std::false_type) noexcept { return std::find_if(__first, __last, __pred); } template _RandomAccessIterator -brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, - /*is_vector=*/std::true_type) noexcept +__brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, + /*is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType; return unseq_backend::simd_first( @@ -471,24 +471,24 @@ template _ForwardIterator -pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return internal::brick_find_if(__first, __last, __pred, __is_vector); + return internal::__brick_find_if(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + _IsVector __is_vector, + /*is_parallel=*/std::true_type) { return internal::except_handler([&]() { return internal::parallel_find(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { - return internal::brick_find_if(__i, __j, __pred, __is_vector); + return internal::__brick_find_if(__i, __j, __pred, __is_vector); }, std::less::difference_type>(), /*is_first=*/true); @@ -526,7 +526,7 @@ while (__first != __last && (__global_last - __first >= __n2)) { // find position of *s_first in [first, last) (it can be start of subsequence) - __first = internal::brick_find_if( + __first = internal::__brick_find_if( __first, __last, internal::equal_value_by_pred<_ValueType, _BinaryPredicate>(*__s_first, __pred), __is_vector); @@ -534,7 +534,7 @@ // then we can exit the loop (b_first == true) or keep the position // (b_first == false) if (__first != __last && (__global_last - __first >= __n2) && - internal::brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector)) + internal::__brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector)) { if (__b_first) { @@ -574,12 +574,12 @@ auto __unary_pred = internal::equal_value_by_pred<_Tp, _BinaryPredicate>(__value, __pred); while (__first != __last && (__global_last - __first >= __count)) { - __first = brick_find_if(__first, __last, __unary_pred, __is_vector); + __first = __brick_find_if(__first, __last, __unary_pred, __is_vector); // check that all of elements in [first+1, first+count) equal to value if (__first != __last && (__global_last - __first >= __count) && - !internal::brick_any_of(__first + 1, __first + __count, - internal::not_pred(__unary_pred), __is_vector)) + !internal::__brick_any_of(__first + 1, __first + __count, + internal::not_pred(__unary_pred), __is_vector)) { return __first; } @@ -597,16 +597,16 @@ template _ForwardIterator1 -brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept +__brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept { return std::find_end(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 -brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept +__brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept { return internal::find_subrange(__first, __last, __last, __s_first, __s_last, __pred, false, std::true_type()); } @@ -614,25 +614,25 @@ template _ForwardIterator1 -pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return internal::brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector); + return internal::__brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator1 -pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, - _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept +__pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept { if (__last - __first == __s_last - __s_first) { - const bool __res = internal::pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, - __pred, __is_vector, std::true_type()); + const bool __res = internal::__pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, + __pred, __is_vector, std::true_type()); return __res ? __first : __last; } else @@ -640,8 +640,7 @@ return except_handler([&]() { return internal::parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, - [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, - _ForwardIterator1 __j) { + [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector); }, std::greater::difference_type>(), /*is_first=*/false); @@ -655,16 +654,16 @@ //------------------------------------------------------------------------ template _ForwardIterator1 -brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept +__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept { return std::find_first_of(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 -brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept +__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept { return unseq_backend::simd_find_first_of(__first, __last, __s_first, __s_last, __pred); } @@ -672,26 +671,26 @@ template _ForwardIterator1 -pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, - _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector); + return internal::__brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator1 -pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, - _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept +__pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept { return except_handler([&]() { return internal::parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { - return internal::brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector); + return internal::__brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector); }, std::less::difference_type>(), /*is_first=*/true); }); @@ -703,16 +702,16 @@ //------------------------------------------------------------------------ template _ForwardIterator1 -brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept +__brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept { return std::search(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 -brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +__brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept { return internal::find_subrange(__first, __last, __last, __s_first, __s_last, __pred, true, std::true_type()); } @@ -720,25 +719,26 @@ template _ForwardIterator1 -pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, - _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return internal::brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector); + return internal::__brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator1 -pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, - _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, - /*is_parallel=*/std::true_type) noexcept +__pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, + /*is_parallel=*/std::true_type) noexcept { if (__last - __first == __s_last - __s_first) { - const bool __res = internal::pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, - __pred, __is_vector, std::true_type()); + const bool __res = internal::__pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, + __pred, __is_vector, std::true_type()); return __res ? __first : __last; } else @@ -760,16 +760,16 @@ //------------------------------------------------------------------------ template _ForwardIterator -brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, - _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept +__brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, + _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept { return std::search_n(__first, __last, __count, __value, __pred); } template _ForwardIterator -brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, - _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +__brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, + _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept { return internal::find_subrange(__first, __last, __last, __count, __value, __pred, std::true_type()); } @@ -777,27 +777,27 @@ template _ForwardIterator -pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count, - const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return internal::brick_search_n(__first, __last, __count, __value, __pred, __is_vector); + return internal::__brick_search_n(__first, __last, __count, __value, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Size __count, - const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, - /*is_parallel=*/std::true_type) noexcept +__pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::true_type) noexcept { if (__last - __first == __count) { const bool __result = - !internal::pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); }, - __is_vector, /*is_parallel*/ std::true_type()); + !internal::__pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); }, + __is_vector, /*is_parallel*/ std::true_type()); return __result ? __first : __last; } else @@ -820,14 +820,14 @@ template _OutputIterator -brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept +__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept { return std::copy_n(__first, __n, __result); } template _OutputIterator -brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::true_type) noexcept +__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::true_type) noexcept { return unseq_backend::simd_assign(__first, __n, __result, [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; }); @@ -838,16 +838,16 @@ //------------------------------------------------------------------------ template _OutputIterator -brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - /*vector=*/std::false_type) noexcept +__brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept { return std::copy(__first, __last, __result); } template _OutputIterator -brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, - /*vector=*/std::true_type) noexcept +__brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept { return unseq_backend::simd_assign( __first, __last - __first, __result, @@ -859,16 +859,16 @@ //------------------------------------------------------------------------ template _OutputIterator -brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - /*vector=*/std::false_type) noexcept +__brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept { return std::move(__first, __last, __result); } template _OutputIterator -brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, - /*vector=*/std::true_type) noexcept +__brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept { return unseq_backend::simd_assign( __first, __last - __first, __result, @@ -880,16 +880,16 @@ //------------------------------------------------------------------------ template _OutputIterator -brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - /*vector=*/std::false_type) noexcept +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept { return std::swap_ranges(__first, __last, __result); } template _OutputIterator -brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - /*vector=*/std::true_type) noexcept +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept { using std::iter_swap; return unseq_backend::simd_assign(__first, __last - __first, __result, @@ -901,16 +901,16 @@ //------------------------------------------------------------------------ template _OutputIterator -brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, - /*vector=*/std::false_type) noexcept +__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, + /*vector=*/std::false_type) noexcept { return std::copy_if(__first, __last, __result, __pred); } template _OutputIterator -brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, - /*vector=*/std::true_type) noexcept +__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, + /*vector=*/std::true_type) noexcept { #if (__PSTL_MONOTONIC_PRESENT) return unseq_backend::simd_copy_if(__first, __last - __first, __result, __pred); @@ -919,11 +919,11 @@ #endif } -// TODO: Try to use transform_reduce for combining brick_copy_if_phase1 on IsVector. +// TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector. template std::pair<_DifferenceType, _DifferenceType> -brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred, - /*vector=*/std::false_type) noexcept +__brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred, + /*vector=*/std::false_type) noexcept { auto __count_true = _DifferenceType(0); auto __size = __last - __first; @@ -944,8 +944,8 @@ template std::pair<_DifferenceType, _DifferenceType> -brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred, - /*vector=*/std::true_type) noexcept +__brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred, + /*vector=*/std::true_type) noexcept { auto __result = unseq_backend::simd_calc_mask_1(__first, __last - __first, __mask, __pred); return std::make_pair(__result, (__last - __first) - __result); @@ -953,8 +953,8 @@ template void -brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask, - _Assigner __assigner, /*vector=*/std::false_type) noexcept +__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask, + _Assigner __assigner, /*vector=*/std::false_type) noexcept { for (; __first != __last; ++__first, ++__mask) { @@ -968,20 +968,20 @@ template void -brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __restrict __mask, - _Assigner __assigner, /*vector=*/std::true_type) noexcept +__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + bool* __restrict __mask, _Assigner __assigner, /*vector=*/std::true_type) noexcept { #if (__PSTL_MONOTONIC_PRESENT) unseq_backend::simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner); #else - internal::brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type()); + internal::__brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type()); #endif } template void -brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, - _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::false_type) noexcept +__brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::false_type) noexcept { for (; __first != __last; ++__first, ++__mask) { @@ -1000,30 +1000,30 @@ template void -brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true, - _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept +__brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept { #if (__PSTL_MONOTONIC_PRESENT) unseq_backend::simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask); #else - internal::brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type()); + internal::__brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type()); #endif } template _OutputIterator -pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept { - return internal::brick_copy_if(__first, __last, __result, __pred, __is_vector); + return internal::__brick_copy_if(__first, __last, __result, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type) +__pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; const _DifferenceType __n = __last - __first; @@ -1036,22 +1036,22 @@ par_backend::parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), [=](_DifferenceType __i, _DifferenceType __len) { // Reduce - return brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, - __pred, __is_vector) + return __brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, + __pred, __is_vector) .first; }, std::plus<_DifferenceType>(), // Combine [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan - brick_copy_by_mask(__first + __i, __first + (__i + __len), __result + __initial, __mask + __i, - [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, - __is_vector); + __brick_copy_by_mask(__first + __i, __first + (__i + __len), __result + __initial, __mask + __i, + [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, + __is_vector); }, [&__m](_DifferenceType __total) { __m = __total; }); return __result + __m; }); } // trivial sequence - use serial algorithm - return brick_copy_if(__first, __last, __result, __pred, __is_vector); + return __brick_copy_if(__first, __last, __result, __pred, __is_vector); } #endif @@ -1060,40 +1060,40 @@ //------------------------------------------------------------------------ template typename std::iterator_traits<_ForwardIterator>::difference_type -brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - /* is_vector = */ std::true_type) noexcept +__brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_vector = */ std::true_type) noexcept { return unseq_backend::simd_count(__first, __last - __first, __pred); } template typename std::iterator_traits<_ForwardIterator>::difference_type -brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - /* is_vector = */ std::false_type) noexcept +__brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_vector = */ std::false_type) noexcept { return std::count_if(__first, __last, __pred); } template typename std::iterator_traits<_ForwardIterator>::difference_type -pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept +__pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept { - return brick_count(__first, __last, __pred, __is_vector); + return __brick_count(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template typename std::iterator_traits<_ForwardIterator>::difference_type -pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, - /* is_parallel */ std::true_type, _IsVector __is_vector) +__pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_parallel */ std::true_type, _IsVector __is_vector) { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; return except_handler([&]() { return par_backend::parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, _SizeType(0), [__pred, __is_vector](_ForwardIterator __begin, _ForwardIterator __end, _SizeType __value) -> _SizeType { - return __value + brick_count(__begin, __end, __pred, __is_vector); + return __value + __brick_count(__begin, __end, __pred, __is_vector); }, std::plus<_SizeType>()); }); @@ -1106,16 +1106,16 @@ template _ForwardIterator -brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - /*is_vector=*/std::false_type) noexcept +__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /*is_vector=*/std::false_type) noexcept { return std::unique(__first, __last, __pred); } template _ForwardIterator -brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - /*is_vector=*/std::true_type) noexcept +__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /*is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::unique(__first, __last, __pred); @@ -1123,14 +1123,14 @@ template _ForwardIterator -pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_unique(__first, __last, __pred, __is_vector); + return internal::__brick_unique(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES -// That function is shared between two algorithms - remove_if (pattern_remove_if) and unique (pattern unique). But a mask calculation is different. +// That function is shared between two algorithms - remove_if (__pattern_remove_if) and unique (pattern unique). But a mask calculation is different. // So, a caller passes _CalcMask brick into remove_elements. template _ForwardIterator @@ -1158,7 +1158,7 @@ } // find first iterator that should be removed bool* __result = - brick_find_if(__mask + __i, __mask + __j, [](bool __val) { return !__val; }, __is_vector); + __brick_find_if(__mask + __i, __mask + __j, [](bool __val) { return !__val; }, __is_vector); if (__result - __mask == __j) { return __local_min; @@ -1185,23 +1185,23 @@ par_backend::parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), [__mask, __is_vector](_DifferenceType __i, _DifferenceType __len) { - return brick_count(__mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector); + return __brick_count(__mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector); }, std::plus<_DifferenceType>(), [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { - brick_copy_by_mask(__first + __i, __first + __i + __len, __result + __initial, __mask + __i, - [](_ForwardIterator __x, _Tp* __z) { - invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); }, - [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); }); - }, - __is_vector); + __brick_copy_by_mask(__first + __i, __first + __i + __len, __result + __initial, __mask + __i, + [](_ForwardIterator __x, _Tp* __z) { + invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); }, + [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); }); + }, + __is_vector); }, [&__m](_DifferenceType __total) { __m = __total; }); // 3. Elements from result are moved to [first, last) par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m, [__result, __first, __is_vector](_Tp* __i, _Tp* __j) { - brick_move(__i, __j, __first + (__i - __result), __is_vector); + __brick_move(__i, __j, __first + (__i - __result), __is_vector); }); return __first + __m; }); @@ -1211,8 +1211,8 @@ #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept +__pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; @@ -1223,14 +1223,14 @@ if (__first + 1 == __last || __first + 2 == __last) { // Trivial sequence - use serial algorithm - return brick_unique(__first, __last, __pred, __is_vector); + return __brick_unique(__first, __last, __pred, __is_vector); } return remove_elements( std::forward<_ExecutionPolicy>(__exec), ++__first, __last, [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { - brick_walk3(__b, __e, __it - 1, __it, - [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); }, - __is_vector); + __brick_walk3(__b, __e, __it - 1, __it, + [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); }, + __is_vector); }, __is_vector); } @@ -1242,16 +1242,16 @@ template OutputIterator -brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred, - /*vector=*/std::false_type) noexcept +__brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred, + /*vector=*/std::false_type) noexcept { return std::unique_copy(__first, __last, __result, __pred); } template OutputIterator -brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result, - _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +__brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result, + _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept { #if (__PSTL_MONOTONIC_PRESENT) return unseq_backend::simd_unique_copy(__first, __last - __first, __result, __pred); @@ -1263,16 +1263,16 @@ template _OutputIterator -pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _BinaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +__pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _BinaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept { - return internal::brick_unique_copy(__first, __last, __result, __pred, __is_vector); + return internal::__brick_unique_copy(__first, __last, __result, __pred, __is_vector); } template _DifferenceType -brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, - _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept +__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, + _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept { _DifferenceType __count = 0; for (; __first != __last; ++__first, ++__mask) @@ -1285,8 +1285,8 @@ template _DifferenceType -brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, - _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, + _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept { return unseq_backend::simd_calc_mask_2(__first, __last - __first, __mask, __pred); } @@ -1295,9 +1295,9 @@ template _OutputIterator -pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector, - /*parallel=*/std::true_type) +__pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector, + /*parallel=*/std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; const _DifferenceType __n = __last - __first; @@ -1322,14 +1322,14 @@ ++__i; ++__extra; } - return brick_calc_mask_2<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, - __pred, __is_vector) + + return __brick_calc_mask_2<_DifferenceType>(__first + __i, __first + (__i + __len), + __mask + __i, __pred, __is_vector) + __extra; }, std::plus<_DifferenceType>(), // Combine [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan - // Phase 2 is same as for pattern_copy_if - internal::brick_copy_by_mask( + // Phase 2 is same as for __pattern_copy_if + internal::__brick_copy_by_mask( __first + __i, __first + (__i + __len), __result + __initial, __mask + __i, [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, __is_vector); }, @@ -1339,7 +1339,7 @@ } } // trivial sequence - use serial algorithm - return brick_unique_copy(__first, __last, __result, __pred, __is_vector); + return __brick_unique_copy(__first, __last, __result, __pred, __is_vector); } #endif @@ -1348,14 +1348,14 @@ //------------------------------------------------------------------------ template void -brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept { std::reverse(__first, __last); } template void -brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::true_type) noexcept +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType; @@ -1370,8 +1370,8 @@ // this brick is called in parallel version, so we can use iterator arithmetic template void -brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, - /*is_vector=*/std::false_type) noexcept +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, + /*is_vector=*/std::false_type) noexcept { for (--__d_last; __first != __last; ++__first, --__d_last) { @@ -1383,8 +1383,8 @@ // this brick is called in parallel version, so we can use iterator arithmetic template void -brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, - /*is_vector=*/std::true_type) noexcept +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, + /*is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType; @@ -1397,22 +1397,23 @@ template void -pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, _IsVector _is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, + _IsVector _is_vector, + /*is_parallel=*/std::false_type) noexcept { - brick_reverse(__first, __last, _is_vector); + __brick_reverse(__first, __last, _is_vector); } #if __PSTL_USE_PAR_POLICIES template void -pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, - _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _IsVector __is_vector, /*is_parallel=*/std::true_type) { par_backend::parallel_for( std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2, [__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) { - brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector); + __brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector); }); } #endif @@ -1423,16 +1424,16 @@ template _OutputIterator -brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, - /*is_vector=*/std::false_type) noexcept +__brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, + /*is_vector=*/std::false_type) noexcept { return std::reverse_copy(__first, __last, __d_first); } template _OutputIterator -brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, - /*is_vector=*/std::true_type) noexcept +__brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, + /*is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType1; typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2; @@ -1443,24 +1444,24 @@ template _OutputIterator -pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, - _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_reverse_copy(__first, __last, __d_first, __is_vector); + return internal::__brick_reverse_copy(__first, __last, __d_first, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, - _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type) { auto __len = __last - __first; par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) { - brick_reverse_copy(__inner_first, __inner_last, - __d_first + (__len - (__inner_last - __first)), __is_vector); + __brick_reverse_copy(__inner_first, __inner_last, + __d_first + (__len - (__inner_last - __first)), __is_vector); }); return __d_first + __len; } @@ -1471,8 +1472,8 @@ //------------------------------------------------------------------------ template _ForwardIterator -brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - /*is_vector=*/std::false_type) noexcept +__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + /*is_vector=*/std::false_type) noexcept { #if __PSTL_CPP11_STD_ROTATE_BROKEN std::rotate(__first, __middle, __last); @@ -1484,8 +1485,8 @@ template _ForwardIterator -brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - /*is_vector=*/std::true_type) noexcept +__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + /*is_vector=*/std::true_type) noexcept { auto __n = __last - __first; auto __m = __middle - __first; @@ -1524,17 +1525,17 @@ template _ForwardIterator -pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_rotate(__first, __middle, __last, __is_vector); + return internal::__brick_rotate(__first, __middle, __last, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _IsVector __is_vector, /*is_parallel=*/std::true_type) { typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp; auto __n = __last - __first; @@ -1544,21 +1545,20 @@ par_backend::buffer<_Tp> __buf(__n - __m); return except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() { _Tp* __result = __buf.get(); - par_backend::parallel_for( - std::forward<_ExecutionPolicy>(__exec), __middle, __last, - [__middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { - brick_uninitialized_move(__b, __e, __result + (__b - __middle), __is_vector); - }); + par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last, + [__middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_uninitialized_move(__b, __e, __result + (__b - __middle), + __is_vector); + }); - par_backend::parallel_for( - std::forward<_ExecutionPolicy>(__exec), __first, __middle, - [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { - brick_move(__b, __e, __b + (__last - __middle), __is_vector); - }); + par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle, + [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_move(__b, __e, __b + (__last - __middle), __is_vector); + }); par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m), [__first, __result, __is_vector](_Tp* __b, _Tp* __e) { - brick_move(__b, __e, __first + (__b - __result), __is_vector); + __brick_move(__b, __e, __first + (__b - __result), __is_vector); }); return __first + (__last - __middle); @@ -1569,21 +1569,20 @@ par_backend::buffer<_Tp> __buf(__m); return except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() { _Tp* __result = __buf.get(); - par_backend::parallel_for( - std::forward<_ExecutionPolicy>(__exec), __first, __middle, - [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { - brick_uninitialized_move(__b, __e, __result + (__b - __first), __is_vector); - }); + par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle, + [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_uninitialized_move(__b, __e, __result + (__b - __first), __is_vector); + }); - par_backend::parallel_for( - std::forward<_ExecutionPolicy>(__exec), __middle, __last, - [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { - brick_move(__b, __e, __first + (__b - __middle), __is_vector); - }); + par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last, + [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_move(__b, __e, __first + (__b - __middle), __is_vector); + }); par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m, [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) { - brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)), __is_vector); + __brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)), + __is_vector); }); return __first + (__last - __middle); @@ -1598,54 +1597,54 @@ template _OutputIterator -brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - _OutputIterator __result, /*__is_vector=*/std::false_type) noexcept +__brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _OutputIterator __result, /*__is_vector=*/std::false_type) noexcept { return std::rotate_copy(__first, __middle, __last, __result); } template _OutputIterator -brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - _OutputIterator __result, /*__is_vector=*/std::true_type) noexcept +__brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _OutputIterator __result, /*__is_vector=*/std::true_type) noexcept { - _OutputIterator __res = brick_copy(__middle, __last, __result, std::true_type()); - return brick_copy(__first, __middle, __res, std::true_type()); + _OutputIterator __res = __brick_copy(__middle, __last, __result, std::true_type()); + return __brick_copy(__first, __middle, __res, std::true_type()); } template _OutputIterator -pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_rotate_copy(__first, __middle, __last, __result, __is_vector); + return internal::__brick_rotate_copy(__first, __middle, __last, __result, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, - _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector, + /*is_parallel=*/std::true_type) { par_backend::parallel_for( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__first, __last, __middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { if (__b > __middle) { - brick_copy(__b, __e, __result + (__b - __middle), __is_vector); + __brick_copy(__b, __e, __result + (__b - __middle), __is_vector); } else { _OutputIterator __new_result = __result + ((__last - __middle) + (__b - __first)); if (__e < __middle) { - brick_copy(__b, __e, __new_result, __is_vector); + __brick_copy(__b, __e, __new_result, __is_vector); } else { - brick_copy(__b, __middle, __new_result, __is_vector); - brick_copy(__middle, __e, __result, __is_vector); + __brick_copy(__b, __middle, __new_result, __is_vector); + __brick_copy(__middle, __e, __result, __is_vector); } } }); @@ -1659,16 +1658,16 @@ template bool -brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - /*is_vector=*/std::false_type) noexcept +__brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::false_type) noexcept { return std::is_partitioned(__first, __last, __pred); } template bool -brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - /*is_vector=*/std::true_type) noexcept +__brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; if (__first == __last) @@ -1694,17 +1693,17 @@ template bool -pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_is_partitioned(__first, __last, __pred, __is_vector); + return internal::__brick_is_partitioned(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template bool -pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, - _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) { if (__first == __last) { @@ -1748,11 +1747,11 @@ { // find first element that don't satisfy pred _ForwardIterator __x = - brick_find_if(__i + 1, __j, not_pred<_UnaryPredicate>(__pred), __is_vector); + __brick_find_if(__i + 1, __j, not_pred<_UnaryPredicate>(__pred), __is_vector); if (__x != __j) { // find first element after "x" that satisfy pred - _ForwardIterator __y = brick_find_if(__x + 1, __j, __pred, __is_vector); + _ForwardIterator __y = __brick_find_if(__x + 1, __j, __pred, __is_vector); // if it was found then range isn't partitioned by pred if (__y != __j) { @@ -1772,7 +1771,7 @@ { // if first element doesn't satisfy pred // then we should find the first element that satisfy pred. // If we found it then range isn't partitioned by pred - if (brick_find_if(__i + 1, __j, __pred, __is_vector) != __j) + if (__brick_find_if(__i + 1, __j, __pred, __is_vector) != __j) { return __broken; } @@ -1805,16 +1804,16 @@ template _ForwardIterator -brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - /*is_vector=*/std::false_type) noexcept +__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::false_type) noexcept { return std::partition(__first, __last, __pred); } template _ForwardIterator -brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - /*is_vector=*/std::true_type) noexcept +__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::partition(__first, __last, __pred); @@ -1822,17 +1821,17 @@ template _ForwardIterator -pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_partition(__first, __last, __pred, __is_vector); + return internal::__brick_partition(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) { // partitioned range: elements before pivot satisfy pred (true part), @@ -1848,8 +1847,7 @@ _PartitionRange __init{__last, __last, __last}; // lambda for merging two partitioned ranges to one partitioned range - auto __reductor = [&__exec, __is_vector](_PartitionRange __val1, - _PartitionRange __val2) -> _PartitionRange { + auto __reductor = [&__exec, __is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange { auto __size1 = __val1.__end - __val1.__pivot; auto __size2 = __val2.__pivot - __val2.__begin; auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin); @@ -1866,7 +1864,7 @@ par_backend::parallel_for( std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size1, [__val1, __val2, __size1, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { - brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector); + __brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector); }); return {__new_begin, __val2.__pivot - __size1, __val2.__end}; } @@ -1876,23 +1874,24 @@ par_backend::parallel_for( std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size2, [__val1, __val2, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { - brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector); + __brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector); }); return {__new_begin, __val1.__pivot + __size2, __val2.__end}; } }; - _PartitionRange __result = par_backend::parallel_reduce( - std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, - [__pred, __is_vector, __reductor](_ForwardIterator __i, _ForwardIterator __j, - _PartitionRange __value) -> _PartitionRange { - //1. serial partition - _ForwardIterator __pivot = brick_partition(__i, __j, __pred, __is_vector); - - // 2. merging of two ranges (left and right respectively) - return __reductor(__value, {__i, __pivot, __j}); - }, - __reductor); + _PartitionRange __result = + par_backend::parallel_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, + [__pred, __is_vector, __reductor](_ForwardIterator __i, _ForwardIterator __j, + _PartitionRange __value) -> _PartitionRange { + //1. serial partition + _ForwardIterator __pivot = + __brick_partition(__i, __j, __pred, __is_vector); + + // 2. merging of two ranges (left and right respectively) + return __reductor(__value, {__i, __pivot, __j}); + }, + __reductor); return __result.__pivot; }); } @@ -1904,16 +1903,16 @@ template _BidirectionalIterator -brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, - /*__is_vector=*/std::false_type) noexcept +__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, + /*__is_vector=*/std::false_type) noexcept { return std::stable_partition(__first, __last, __pred); } template _BidirectionalIterator -brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, - /*__is_vector=*/std::true_type) noexcept +__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, + /*__is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::stable_partition(__first, __last, __pred); @@ -1921,17 +1920,19 @@ template _BidirectionalIterator -pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, - _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept +__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, + /*is_parallelization=*/std::false_type) noexcept { - return internal::brick_stable_partition(__first, __last, __pred, __is_vector); + return internal::__brick_stable_partition(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _BidirectionalIterator -pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, - _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallelization=*/std::true_type) noexcept +__pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, + /*is_parallelization=*/std::true_type) noexcept { // partitioned range: elements before pivot satisfy pred (true part), // elements after pivot don't satisfy pred (false part) @@ -1946,8 +1947,7 @@ _PartitionRange __init{__last, __last, __last}; // lambda for merging two partitioned ranges to one partitioned range - auto __reductor = [__is_vector](_PartitionRange __val1, - _PartitionRange __val2) -> _PartitionRange { + auto __reductor = [__is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange { auto __size1 = __val1.__end - __val1.__pivot; auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin); @@ -1960,7 +1960,7 @@ // then we should swap the false part of left range and last part of true part of right range else { - brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector); + __brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector); return {__new_begin, __val2.__pivot - __size1, __val2.__end}; } }; @@ -1970,7 +1970,7 @@ [&__pred, __is_vector, __reductor](_BidirectionalIterator __i, _BidirectionalIterator __j, _PartitionRange __value) -> _PartitionRange { //1. serial stable_partition - _BidirectionalIterator __pivot = brick_stable_partition(__i, __j, __pred, __is_vector); + _BidirectionalIterator __pivot = __brick_stable_partition(__i, __j, __pred, __is_vector); // 2. merging of two ranges (left and right respectively) return __reductor(__value, {__i, __pivot, __j}); @@ -1987,16 +1987,16 @@ template std::pair<_OutputIterator1, _OutputIterator2> -brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, - _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::false_type) noexcept +__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::false_type) noexcept { return std::partition_copy(__first, __last, __out_true, __out_false, __pred); } template std::pair<_OutputIterator1, _OutputIterator2> -brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, - _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept +__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept { #if (__PSTL_MONOTONIC_PRESENT) return unseq_backend::simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred); @@ -2008,20 +2008,20 @@ template std::pair<_OutputIterator1, _OutputIterator2> -pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, - _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept +__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept { - return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); + return internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template std::pair<_OutputIterator1, _OutputIterator2> -pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallelization=*/std::true_type) +__pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallelization=*/std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef std::pair<_DifferenceType, _DifferenceType> _ReturnType; @@ -2036,23 +2036,23 @@ par_backend::parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, std::make_pair(_DifferenceType(0), _DifferenceType(0)), [=](_DifferenceType __i, _DifferenceType __len) { // Reduce - return internal::brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), - __mask + __i, __pred, __is_vector); + return internal::__brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), + __mask + __i, __pred, __is_vector); }, [](const _ReturnType& __x, const _ReturnType& __y) -> _ReturnType { return std::make_pair(__x.first + __y.first, __x.second + __y.second); }, // Combine [=](_DifferenceType __i, _DifferenceType __len, _ReturnType __initial) { // Scan - internal::brick_partition_by_mask(__first + __i, __first + (__i + __len), - __out_true + __initial.first, __out_false + __initial.second, - __mask + __i, __is_vector); + internal::__brick_partition_by_mask(__first + __i, __first + (__i + __len), + __out_true + __initial.first, + __out_false + __initial.second, __mask + __i, __is_vector); }, [&__m](_ReturnType __total) { __m = __total; }); return std::make_pair(__out_true + __m.first, __out_false + __m.second); }); } // trivial sequence - use serial algorithm - return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); + return internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); } #endif @@ -2063,8 +2063,8 @@ template void -pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, - _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept +__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept { std::sort(__first, __last, __comp); } @@ -2072,8 +2072,8 @@ #if __PSTL_USE_PAR_POLICIES template void -pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, - _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type) +__pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type) { except_handler([&]() { par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, @@ -2090,8 +2090,8 @@ template void -pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, - _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept +__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept { std::stable_sort(__first, __last, __comp); } @@ -2099,8 +2099,8 @@ #if __PSTL_USE_PAR_POLICIES template void -pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type) +__pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type) { internal::except_handler([&]() { par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, @@ -2116,8 +2116,9 @@ template void -pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle, - _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::false_type) noexcept +__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept { std::partial_sort(__first, __middle, __last, __comp); } @@ -2125,8 +2126,8 @@ #if __PSTL_USE_PAR_POLICIES template void -pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, - _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type) +__pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type) { const auto __n = __middle - __first; except_handler([&]() { @@ -2149,9 +2150,9 @@ template _RandomAccessIterator -pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, - _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector, - /*is_parallel=*/std::false_type) noexcept +__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept { return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp); } @@ -2159,9 +2160,9 @@ #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, - _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, - _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, + _IsVector __is_vector, /*is_parallel=*/std::true_type) { if (__last == __first || __d_last == __d_first) { @@ -2181,7 +2182,7 @@ // 1. Copy elements from input to output #if !__PSTL_ICC_18_OMP_SIMD_BROKEN - brick_copy(__i1, __j1, __i, __is_vector); + __brick_copy(__i1, __j1, __i, __is_vector); #else std::copy(__i1, __j1, __i); #endif @@ -2219,7 +2220,7 @@ // 3. Move elements from temporary buffer to output par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2, [__r, __d_first, __is_vector](_T1* __i, _T1* __j) { - brick_move(__i, __j, __d_first + (__i - __r), __is_vector); + __brick_move(__i, __j, __d_first + (__i - __r), __is_vector); }); return __d_first + __n2; } @@ -2232,34 +2233,34 @@ //------------------------------------------------------------------------ template _ForwardIterator -brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - /* IsVector = */ std::true_type, bool __or_semantic) noexcept +__brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /* IsVector = */ std::true_type, bool __or_semantic) noexcept { return unseq_backend::simd_adjacent_find(__first, __last, __pred, __or_semantic); } template _ForwardIterator -brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - /* IsVector = */ std::false_type, bool __or_semantic) noexcept +__brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /* IsVector = */ std::false_type, bool __or_semantic) noexcept { return std::adjacent_find(__first, __last, __pred); } template _ForwardIterator -pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, - /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept +__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept { - return internal::brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic); + return internal::__brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic); } #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector, - bool __or_semantic) +__pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector, + bool __or_semantic) { if (__last - __first < 2) return __last; @@ -2288,7 +2289,7 @@ //correct the global result iterator if the "brick" returns a local "__last" const _RandomAccessIterator __res = - internal::brick_adjacent_find(__begin, __end, __pred, __is_vector, __or_semantic); + internal::__brick_adjacent_find(__begin, __end, __pred, __is_vector, __or_semantic); if (__res < __end) __value = __res; } @@ -2308,8 +2309,9 @@ template void -pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth, - _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::false_type) noexcept +__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept { std::nth_element(__first, __nth, __last, __comp); } @@ -2317,9 +2319,9 @@ #if __PSTL_USE_PAR_POLICIES template void -pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, - _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, - /*is_parallel=*/std::true_type) noexcept +__pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, + /*is_parallel=*/std::true_type) noexcept { if (__first == __last || __nth == __last) { @@ -2331,9 +2333,9 @@ _RandomAccessIterator __x; do { - __x = pattern_partition(std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, - [&__comp, __first](const _Tp& __x) { return __comp(__x, *__first); }, __is_vector, - /*is_parallel=*/std::true_type()); + __x = __pattern_partition(std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, + [&__comp, __first](const _Tp& __x) { return __comp(__x, *__first); }, __is_vector, + /*is_parallel=*/std::true_type()); --__x; if (__x != __first) { @@ -2367,38 +2369,38 @@ //------------------------------------------------------------------------ template void -brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, - /* __is_vector = */ std::true_type) noexcept +__brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /* __is_vector = */ std::true_type) noexcept { unseq_backend::simd_fill_n(__first, __last - __first, __value); } template void -brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, - /* __is_vector = */ std::false_type) noexcept +__brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /* __is_vector = */ std::false_type) noexcept { std::fill(__first, __last, __value); } template void -pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, - /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +__pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept { - internal::brick_fill(__first, __last, __value, __is_vector); + internal::__brick_fill(__first, __last, __value, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, - /*is_parallel=*/std::true_type, _IsVector __is_vector) +__pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /*is_parallel=*/std::true_type, _IsVector __is_vector) { return except_handler([&__exec, __first, __last, &__value, __is_vector]() { par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { - internal::brick_fill(__begin, __end, __value, __is_vector); + internal::__brick_fill(__begin, __end, __value, __is_vector); }); return __last; }); @@ -2407,33 +2409,33 @@ template _OutputIterator -brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept +__brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept { return unseq_backend::simd_fill_n(__first, __count, __value); } template _OutputIterator -brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept +__brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept { return std::fill_n(__first, __count, __value); } template _OutputIterator -pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value, - /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept { - return internal::brick_fill_n(__first, __count, __value, __is_vector); + return internal::__brick_fill_n(__first, __count, __value, __is_vector); } template _OutputIterator -pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value, - /*is_parallel=*/std::true_type, _IsVector __is_vector) +__pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value, + /*is_parallel=*/std::true_type, _IsVector __is_vector) { - return internal::pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value, - std::true_type(), __is_vector); + return internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value, + std::true_type(), __is_vector); } //------------------------------------------------------------------------ @@ -2441,38 +2443,38 @@ //------------------------------------------------------------------------ template void -brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g, - /* is_vector = */ std::true_type) noexcept +__brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g, + /* is_vector = */ std::true_type) noexcept { unseq_backend::simd_generate_n(__first, __last - __first, __g); } template void -brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g, - /* is_vector = */ std::false_type) noexcept +__brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g, + /* is_vector = */ std::false_type) noexcept { std::generate(__first, __last, __g); } template void -pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, - /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +__pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept { - internal::brick_generate(__first, __last, __g, __is_vector); + internal::__brick_generate(__first, __last, __g, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, - /*is_parallel=*/std::true_type, _IsVector __is_vector) +__pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, + /*is_parallel=*/std::true_type, _IsVector __is_vector) { return internal::except_handler([&]() { par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { - internal::brick_generate(__begin, __end, __g, __is_vector); + internal::__brick_generate(__begin, __end, __g, __is_vector); }); return __last; }); @@ -2481,36 +2483,36 @@ template OutputIterator -brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept +__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept { return unseq_backend::simd_generate_n(__first, __count, __g); } template OutputIterator -brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept +__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept { return std::generate_n(__first, __count, __g); } template _OutputIterator -pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g, - /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +__pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept { - return internal::brick_generate_n(__first, __count, __g, __is_vector); + return internal::__brick_generate_n(__first, __count, __g, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g, - /*is_parallel=*/std::true_type, _IsVector __is_vector) +__pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g, + /*is_parallel=*/std::true_type, _IsVector __is_vector) { static_assert(internal::is_random_access_iterator<_OutputIterator>::value, "Pattern-brick error. Should be a random access iterator."); - return internal::pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g, - std::true_type(), __is_vector); + return internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g, + std::true_type(), __is_vector); } #endif @@ -2520,16 +2522,16 @@ template _ForwardIterator -brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - /* __is_vector = */ std::false_type) noexcept +__brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /* __is_vector = */ std::false_type) noexcept { return std::remove_if(__first, __last, __pred); } template _RandomAccessIterator -brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred, - /* __is_vector = */ std::true_type) noexcept +__brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred, + /* __is_vector = */ std::true_type) noexcept { #if __PSTL_MONOTONIC_PRESENT return unseq_backend::simd_remove_if(__first, __last - __first, __pred); @@ -2540,32 +2542,33 @@ template _ForwardIterator -pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept +__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept { - return internal::brick_remove_if(__first, __last, __pred, __is_vector); + return internal::__brick_remove_if(__first, __last, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator -pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, - _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept +__pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; if (__first == __last || __first + 1 == __last) { // Trivial sequence - use serial algorithm - return brick_remove_if(__first, __last, __pred, __is_vector); + return __brick_remove_if(__first, __last, __pred, __is_vector); } - return remove_elements( - std::forward<_ExecutionPolicy>(__exec), __first, __last, - [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { - brick_walk2(__b, __e, __it, [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, __is_vector); - }, - __is_vector); + return remove_elements(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { + __brick_walk2(__b, __e, __it, + [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, + __is_vector); + }, + __is_vector); } #endif @@ -2575,18 +2578,18 @@ template _OutputIterator -brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, - /* __is_vector = */ std::false_type) noexcept +__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept { return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); } template _OutputIterator -brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, - /* __is_vector = */ std::true_type) noexcept +__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); @@ -2595,26 +2598,26 @@ template _OutputIterator -pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector, - /* is_parallel = */ std::false_type) noexcept +__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector, + /* is_parallel = */ std::false_type) noexcept { - return internal::brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector); + return internal::__brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, - _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first, - _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) +__pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) { par_backend::parallel_merge( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp, [__is_vector](_RandomAccessIterator1 __f1, _RandomAccessIterator1 __l1, _RandomAccessIterator2 __f2, _RandomAccessIterator2 __l2, _OutputIterator __f3, - _Compare __comp) { return brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); }); + _Compare __comp) { return __brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); }); return __d_first + (__last1 - __first1) + (__last2 - __first2); } #endif @@ -2624,16 +2627,16 @@ //------------------------------------------------------------------------ template void -brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, - _Compare __comp, /* __is_vector = */ std::false_type) noexcept +__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, + _Compare __comp, /* __is_vector = */ std::false_type) noexcept { std::inplace_merge(__first, __middle, __last, __comp); } template void -brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, - _Compare __comp, /* __is_vector = */ std::true_type) noexcept +__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, + _Compare __comp, /* __is_vector = */ std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial") std::inplace_merge(__first, __middle, __last, __comp); @@ -2641,19 +2644,19 @@ template void -pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle, - _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, - /* is_parallel = */ std::false_type) noexcept +__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, + /* is_parallel = */ std::false_type) noexcept { - internal::brick_inplace_merge(__first, __middle, __last, __comp, __is_vector); + internal::__brick_inplace_merge(__first, __middle, __last, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template void -pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, - _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, + /*is_parallel=*/std::true_type) { if (__first == __last || __first == __middle || __middle == __last) { @@ -2670,7 +2673,7 @@ }; auto __move_sequences = [](_BidirectionalIterator __first1, _BidirectionalIterator __last1, _Tp* __first2) { - return brick_uninitialized_move(__first1, __last1, __first2, _IsVector()); + return __brick_uninitialized_move(__first1, __last1, __first2, _IsVector()); }; par_backend::parallel_merge( @@ -2685,7 +2688,7 @@ }); par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n, [__r, __first, __is_vector](_Tp* __i, _Tp* __j) { - brick_move(__i, __j, __first + (__i - __r), __is_vector); + __brick_move(__i, __j, __first + (__i - __r), __is_vector); }); }); } @@ -2697,9 +2700,9 @@ template bool -pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector, - /*is_parallel=*/std::false_type) noexcept +__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept { return std::includes(__first1, __last1, __first2, __last2, __comp); } @@ -2707,9 +2710,9 @@ #if __PSTL_USE_PAR_POLICIES template bool -pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, + /*is_parallel=*/std::true_type) { if (__first2 >= __last2) return true; @@ -2795,8 +2798,8 @@ _DifferenceType __m{}; auto __scan = [=](_DifferenceType, _DifferenceType, const _SetRange& __s) { // Scan if (!__s.empty()) - brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos, - __is_vector); + __brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos, + __is_vector); }; par_backend::parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n1, _SetRange{0, 0, 0}, //-1, 0}, @@ -2855,7 +2858,7 @@ #endif #if __PSTL_USE_PAR_POLICIES -//a shared parallel pattern for 'pattern_set_union' and 'pattern_set_symmetric_difference' +//a shared parallel pattern for '__pattern_set_union' and '__pattern_set_symmetric_difference' template _OutputIterator @@ -2869,21 +2872,21 @@ const auto __n2 = __last2 - __first2; auto copy_range1 = [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { - return brick_copy(__begin, __end, __res, __is_vector); + return __brick_copy(__begin, __end, __res, __is_vector); }; auto copy_range2 = [__is_vector](_ForwardIterator2 __begin, _ForwardIterator2 __end, _OutputIterator __res) { - return brick_copy(__begin, __end, __res, __is_vector); + return __brick_copy(__begin, __end, __res, __is_vector); }; // {1} {}: parallel copying just first sequence if (__n2 == 0) - return pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1, - std::true_type()); + return __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1, + std::true_type()); // {} {2}: parallel copying justmake second sequence if (__n1 == 0) - return pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2, - std::true_type()); + return __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2, + std::true_type()); // testing whether the sequences are intersected _ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp); @@ -2893,12 +2896,12 @@ //{1} < {2}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2 par_backend::parallel_invoke(std::forward<_ExecutionPolicy>(__exec), [=] { - pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, - __result, copy_range1, std::true_type()); + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, + __last1, __result, copy_range1, std::true_type()); }, [=] { - pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, - __result + __n1, copy_range2, std::true_type()); + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, + __last2, __result + __n1, copy_range2, std::true_type()); }); return __result + __n1 + __n2; } @@ -2911,12 +2914,12 @@ //{2} < {1}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2 par_backend::parallel_invoke(std::forward<_ExecutionPolicy>(__exec), [=] { - pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, - __result, copy_range2, std::true_type()); + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, + __last2, __result, copy_range2, std::true_type()); }, [=] { - pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, - __result + __n2, copy_range1, std::true_type()); + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, + __last1, __result + __n2, copy_range1, std::true_type()); }); return __result + __n1 + __n2; } @@ -2930,8 +2933,8 @@ std::forward<_ExecutionPolicy>(__exec), //do parallel copying of [first1; left_bound_seq_1) [=] { - pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or, - copy_range1, std::true_type()); + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or, + copy_range1, std::true_type()); }, [=, &__result] { __result = parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, @@ -2952,8 +2955,8 @@ std::forward<_ExecutionPolicy>(__exec), //do parallel copying of [first2; left_bound_seq_2) [=] { - pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or, - copy_range2, std::true_type()); + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or, + copy_range2, std::true_type()); }, [=, &__result] { __result = parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, @@ -2976,18 +2979,18 @@ template _OutputIterator -brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::false_type) noexcept +__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept { return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator -brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::true_type) noexcept +__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); @@ -2996,20 +2999,21 @@ template _OutputIterator -pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return internal::brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); + return internal::__brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - _IsVector __is_vector, /*__is_parallel=*/std::true_type) +__pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + _IsVector __is_vector, /*__is_parallel=*/std::true_type) { const auto __n1 = __last1 - __first1; @@ -3036,18 +3040,18 @@ template _OutputIterator -brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::false_type) noexcept +__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept { return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator -brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::true_type) noexcept +__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); @@ -3056,20 +3060,20 @@ template _OutputIterator -pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, - _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); + return internal::__brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, - _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) { typedef typename std::iterator_traits<_OutputIterator>::value_type _T; typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; @@ -3133,18 +3137,18 @@ template _OutputIterator -brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::false_type) noexcept +__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept { return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator -brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::true_type) noexcept +__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); @@ -3153,20 +3157,20 @@ template _OutputIterator -pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); + return internal::__brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) { typedef typename std::iterator_traits<_OutputIterator>::value_type _T; typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; @@ -3180,10 +3184,10 @@ // {1} \ {}: parallel copying just first sequence if (__n2 == 0) - return pattern_walk2_brick( + return __pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { - return brick_copy(__begin, __end, __res, __is_vector); + return __brick_copy(__begin, __end, __res, __is_vector); }, std::true_type()); @@ -3191,10 +3195,10 @@ _ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp); //{1} < {2}: seq 2 is wholly greater than seq 1, so, parallel copying just first sequence if (__left_bound_seq_1 == __last1) - return pattern_walk2_brick( + return __pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { - return brick_copy(__begin, __end, __res, __is_vector); + return __brick_copy(__begin, __end, __res, __is_vector); }, std::true_type()); @@ -3202,10 +3206,10 @@ _ForwardIterator2 __left_bound_seq_2 = lower_bound(__first2, __last2, *__first1, __comp); //{2} < {1}: seq 1 is wholly greater than seq 2, so, parallel copying just first sequence if (__left_bound_seq_2 == __last2) - return pattern_walk2_brick( + return __pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { - return brick_copy(__begin, __end, __res, __is_vector); + return __brick_copy(__begin, __end, __res, __is_vector); }, std::true_type()); @@ -3229,18 +3233,18 @@ template _OutputIterator -brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::false_type) noexcept +__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept { return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator -brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, - /*__is_vector=*/std::true_type) noexcept +__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept { __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); @@ -3249,21 +3253,21 @@ template _OutputIterator -pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, - _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp, - __is_vector); + return internal::__brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp, + __is_vector); } #if __PSTL_USE_PAR_POLICIES template _OutputIterator -pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, - _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) { const auto __n1 = __last1 - __first1; @@ -3290,16 +3294,16 @@ template _RandomAccessIterator -brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, - /* __is_vector = */ std::false_type) noexcept +__brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept { return std::is_heap_until(__first, __last, __comp); } template _RandomAccessIterator -brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, - /* __is_vector = */ std::true_type) noexcept +__brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept { if (__last - __first < 2) return __last; @@ -3311,10 +3315,10 @@ template _RandomAccessIterator -pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, - _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept { - return internal::brick_is_heap_until(__first, __last, __comp, __is_vector); + return internal::__brick_is_heap_until(__first, __last, __comp, __is_vector); } template @@ -3346,8 +3350,8 @@ #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept +__pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept { if (__last - __first < 2) return __last; @@ -3369,16 +3373,16 @@ template _ForwardIterator -brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - /* __is_vector = */ std::false_type) noexcept +__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept { return std::min_element(__first, __last, __comp); } template _ForwardIterator -brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - /* __is_vector = */ std::true_type) noexcept +__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept { #if __PSTL_UDR_PRESENT return unseq_backend::simd_min_element(__first, __last - __first, __comp); @@ -3389,17 +3393,17 @@ template _ForwardIterator -pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept { - return internal::brick_min_element(__first, __last, __comp, __is_vector); + return internal::__brick_min_element(__first, __last, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _RandomAccessIterator -pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) +__pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) { if (__first == __last) return __last; @@ -3409,7 +3413,7 @@ std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, __first, [=](_RandomAccessIterator __begin, _RandomAccessIterator __end, _RandomAccessIterator __init) -> _RandomAccessIterator { - const _RandomAccessIterator subresult = brick_min_element(__begin, __end, __comp, __is_vector); + const _RandomAccessIterator subresult = __brick_min_element(__begin, __end, __comp, __is_vector); return internal::cmp_iterators_by_values(__init, subresult, __comp); }, [=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator { @@ -3425,16 +3429,16 @@ template std::pair<_ForwardIterator, _ForwardIterator> -brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - /* __is_vector = */ std::false_type) noexcept +__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept { return std::minmax_element(__first, __last, __comp); } template std::pair<_ForwardIterator, _ForwardIterator> -brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - /* __is_vector = */ std::true_type) noexcept +__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept { #if __PSTL_UDR_PRESENT return unseq_backend::simd_minmax_element(__first, __last - __first, __comp); @@ -3445,17 +3449,17 @@ template std::pair<_ForwardIterator, _ForwardIterator> -pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept { - return internal::brick_minmax_element(__first, __last, __comp, __is_vector); + return internal::__brick_minmax_element(__first, __last, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template std::pair<_ForwardIterator, _ForwardIterator> -pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, - _IsVector __is_vector, /* is_parallel = */ std::true_type) +__pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::true_type) { if (__first == __last) return std::make_pair(__first, __first); @@ -3466,7 +3470,7 @@ return par_backend::parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, std::make_pair(__first, __first), [=](_ForwardIterator __begin, _ForwardIterator __end, _Result __init) -> _Result { - const _Result __subresult = brick_minmax_element(__begin, __end, __comp, __is_vector); + const _Result __subresult = __brick_minmax_element(__begin, __end, __comp, __is_vector); return std::make_pair(internal::cmp_iterators_by_values(__subresult.first, __init.first, __comp), internal::cmp_iterators_by_values(__init.second, __subresult.second, internal::not_pred<_Compare>(__comp))); @@ -3500,16 +3504,16 @@ template std::pair<_ForwardIterator1, _ForwardIterator2> -brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::false_type) noexcept +__brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::false_type) noexcept { return internal::mismatch_serial(__first1, __last1, __first2, __last2, __pred); } template std::pair<_ForwardIterator1, _ForwardIterator2> -brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::true_type) noexcept +__brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::true_type) noexcept { auto __n = std::min(__last1 - __first1, __last2 - __first2); return unseq_backend::simd_first(__first1, __n, __first2, not_pred<_Predicate>(__pred)); @@ -3517,28 +3521,28 @@ template std::pair<_ForwardIterator1, _ForwardIterator2> -pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector, - /* is_parallel = */ std::false_type) noexcept +__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector, + /* is_parallel = */ std::false_type) noexcept { - return internal::brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector); + return internal::__brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector); } #if __PSTL_USE_PAR_POLICIES template std::pair<_RandomAccessIterator1, _RandomAccessIterator2> -pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, - _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred, - _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept +__pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred, + _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept { return internal::except_handler([&]() { auto __n = std::min(__last1 - __first1, __last2 - __first2); auto __result = internal::parallel_find( std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, [__first1, __first2, __pred, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { - return internal::brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), - __pred, __is_vector) + return internal::__brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), + __pred, __is_vector) .first; }, std::less::difference_type>(), /*is_first=*/true); @@ -3553,16 +3557,17 @@ template bool -brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::false_type) noexcept +__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept { return std::lexicographical_compare(__first1, __last1, __first2, __last2, __comp); } template bool -brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, - _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::true_type) noexcept +__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::true_type) noexcept { if (__first2 == __last2) { // if second sequence is empty @@ -3597,19 +3602,19 @@ template bool -pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, - _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept { - return internal::brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector); + return internal::__brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector); } #if __PSTL_USE_PAR_POLICIES template bool -pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, - _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept +__pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept { if (__first2 == __last2) { // if second sequence is empty @@ -3629,11 +3634,11 @@ auto __result = internal::parallel_find( std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, [__first1, __first2, &__comp, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { - return brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), - [&__comp](const _RefType1 __x, const _RefType2 __y) { - return !__comp(__x, __y) && !__comp(__y, __x); - }, - __is_vector) + return __brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), + [&__comp](const _RefType1 __x, const _RefType2 __y) { + return !__comp(__x, __y) && !__comp(__y, __x); + }, + __is_vector) .first; }, std::less::difference_type>(), /*is_first=*/true); Index: include/pstl/internal/glue_algorithm_impl.h =================================================================== --- include/pstl/internal/glue_algorithm_impl.h +++ include/pstl/internal/glue_algorithm_impl.h @@ -27,9 +27,10 @@ any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { using namespace __pstl; - return internal::pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + return internal::__pattern_any_of( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } // [alg.all_of] @@ -58,9 +59,9 @@ for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f) { using namespace __pstl; - internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f, - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f, + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -68,7 +69,7 @@ for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f) { using namespace __pstl; - return internal::pattern_walk1_n( + return internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __f, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -81,7 +82,7 @@ find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { using namespace __pstl; - return internal::pattern_find_if( + return internal::__pattern_find_if( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -110,7 +111,7 @@ _ForwardIterator2 __s_last, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_find_end( + return internal::__pattern_find_end( std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -132,7 +133,7 @@ _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_find_first_of( + return internal::__pattern_find_first_of( std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -154,7 +155,7 @@ { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; using namespace __pstl; - return internal::pattern_adjacent_find( + return internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<_ValueType>(), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false); @@ -165,7 +166,7 @@ adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_adjacent_find( + return internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false); @@ -183,10 +184,10 @@ { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; using namespace __pstl; - return internal::pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [&__value](const _ValueType& __x) { return __value == __x; }, - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + return internal::__pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value](const _ValueType& __x) { return __value == __x; }, + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -195,9 +196,9 @@ count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { using namespace __pstl; - return internal::pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + return internal::__pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } // [alg.search] @@ -208,7 +209,7 @@ _ForwardIterator2 __s_last, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_search( + return internal::__pattern_search( std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -229,7 +230,7 @@ const _Tp& __value, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_search_n( + return internal::__pattern_search_n( std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -254,10 +255,10 @@ const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); - return internal::pattern_walk2_brick( + return internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) { - return internal::brick_copy(__begin, __end, __res, __is_vector); + return internal::__brick_copy(__begin, __end, __res, __is_vector); }, internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } @@ -270,10 +271,10 @@ const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); - return internal::pattern_walk2_brick_n( + return internal::__pattern_walk2_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [__is_vector](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res) { - return internal::brick_copy_n(__begin, __sz, __res, __is_vector); + return internal::__brick_copy_n(__begin, __sz, __res, __is_vector); }, internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } @@ -284,7 +285,7 @@ _Predicate __pred) { using namespace __pstl; - return internal::pattern_copy_if( + return internal::__pattern_copy_if( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -300,7 +301,7 @@ using namespace __pstl; typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2; - return internal::pattern_walk2( + return internal::__pattern_walk2( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, [](_ReferenceType1 __x, _ReferenceType2 __y) { using std::swap; @@ -320,7 +321,7 @@ typedef typename iterator_traits<_ForwardIterator1>::reference _InputType; typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType; using namespace __pstl; - return internal::pattern_walk2( + return internal::__pattern_walk2( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); }, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), @@ -337,7 +338,7 @@ typedef typename iterator_traits<_ForwardIterator2>::reference _Input2Type; typedef typename iterator_traits<_ForwardIterator>::reference _OutputType; using namespace __pstl; - return internal::pattern_walk3( + return internal::__pattern_walk3( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __result, [__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); }, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>( @@ -355,15 +356,15 @@ { using namespace __pstl; typedef typename iterator_traits<_ForwardIterator>::reference _ElementType; - internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [&__pred, &__new_value](_ElementType __elem) { - if (__pred(__elem)) - { - __elem = __new_value; - } - }, - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__pred, &__new_value](_ElementType __elem) { + if (__pred(__elem)) + { + __elem = __new_value; + } + }, + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -383,7 +384,7 @@ typedef typename iterator_traits<_ForwardIterator1>::reference _InputType; typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType; using namespace __pstl; - return internal::pattern_walk2( + return internal::__pattern_walk2( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; }, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), @@ -406,9 +407,9 @@ fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { using namespace __pstl; - internal::pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value, - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value, + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -419,9 +420,10 @@ return __first; using namespace __pstl; - return internal::pattern_fill_n(std::forward<_ExecutionPolicy>(__exec), __first, __count, __value, - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + return internal::__pattern_fill_n( + std::forward<_ExecutionPolicy>(__exec), __first, __count, __value, + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } // [alg.generate] @@ -430,9 +432,9 @@ generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g) { using namespace __pstl; - internal::pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __last, __g, - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __last, __g, + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -443,7 +445,7 @@ return __first; using namespace __pstl; - return internal::pattern_generate_n( + return internal::__pattern_generate_n( std::forward<_ExecutionPolicy>(__exec), __first, __count, __g, internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -474,7 +476,7 @@ remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) { using namespace __pstl; - return internal::pattern_remove_if( + return internal::__pattern_remove_if( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -495,9 +497,10 @@ unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + return internal::__pattern_unique( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -513,7 +516,7 @@ _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_unique_copy( + return internal::__pattern_unique_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -533,9 +536,10 @@ reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last) { using namespace __pstl; - internal::pattern_reverse(std::forward<_ExecutionPolicy>(__exec), __first, __last, - internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); + internal::__pattern_reverse( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); } template @@ -544,7 +548,7 @@ _ForwardIterator __d_first) { using namespace __pstl; - return internal::pattern_reverse_copy( + return internal::__pattern_reverse_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec)); @@ -557,9 +561,10 @@ rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) { using namespace __pstl; - return internal::pattern_rotate(std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); + return internal::__pattern_rotate( + std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template @@ -568,7 +573,7 @@ _ForwardIterator2 __result) { using namespace __pstl; - return internal::pattern_rotate_copy( + return internal::__pattern_rotate_copy( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -581,7 +586,7 @@ is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) { using namespace __pstl; - return internal::pattern_is_partitioned( + return internal::__pattern_is_partitioned( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -592,7 +597,7 @@ partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) { using namespace __pstl; - return internal::pattern_partition( + return internal::__pattern_partition( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -604,7 +609,7 @@ _UnaryPredicate __pred) { using namespace __pstl; - return internal::pattern_stable_partition( + return internal::__pattern_stable_partition( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); @@ -617,7 +622,7 @@ _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred) { using namespace __pstl; - return internal::pattern_partition_copy( + return internal::__pattern_partition_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, _ForwardIterator2>( __exec), @@ -633,7 +638,7 @@ { typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; using namespace __pstl; - return internal::pattern_sort( + return internal::__pattern_sort( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), @@ -655,7 +660,7 @@ stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; - return internal::pattern_stable_sort( + return internal::__pattern_stable_sort( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); @@ -677,7 +682,7 @@ _ForwardIterator2 __last2, _BinaryPredicate __pred) { using namespace __pstl; - return internal::pattern_mismatch( + return internal::__pattern_mismatch( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -718,9 +723,10 @@ _BinaryPredicate __p) { using namespace __pstl; - return internal::pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p, - internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec), - internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec)); + return internal::__pattern_equal( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p, + internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec), + internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec)); } template @@ -760,10 +766,10 @@ const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); - return internal::pattern_walk2_brick( + return internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) { - return internal::brick_move(__begin, __end, __res, __is_vector); + return internal::__brick_move(__begin, __end, __res, __is_vector); }, internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } @@ -776,7 +782,7 @@ _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; - internal::pattern_partial_sort( + internal::__pattern_partial_sort( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); @@ -799,7 +805,7 @@ _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp) { using namespace __pstl; - return internal::pattern_partial_sort_copy( + return internal::__pattern_partial_sort_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec)); @@ -820,7 +826,7 @@ is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; - const _ForwardIterator __res = internal::pattern_adjacent_find( + const _ForwardIterator __res = internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::internal::reorder_pred<_Compare>(__comp), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false); @@ -840,7 +846,7 @@ is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; - return internal::pattern_adjacent_find( + return internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, internal::reorder_pred<_Compare>(__comp), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), @@ -863,7 +869,7 @@ _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp) { using namespace __pstl; - return internal::pattern_merge( + return internal::__pattern_merge( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>( __exec), @@ -886,7 +892,7 @@ _BidirectionalIterator __last, _Compare __comp) { using namespace __pstl; - internal::pattern_inplace_merge( + internal::__pattern_inplace_merge( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); @@ -909,7 +915,7 @@ _ForwardIterator2 __last2, _Compare __comp) { using namespace __pstl; - return internal::pattern_includes( + return internal::__pattern_includes( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -933,7 +939,7 @@ _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; - return internal::pattern_set_union( + return internal::__pattern_set_union( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>( __exec), @@ -959,7 +965,7 @@ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; - return internal::pattern_set_intersection( + return internal::__pattern_set_intersection( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>( __exec), @@ -985,7 +991,7 @@ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; - return internal::pattern_set_difference( + return internal::__pattern_set_difference( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>( __exec), @@ -1012,7 +1018,7 @@ _Compare __comp) { using namespace __pstl; - return internal::pattern_set_symmetric_difference( + return internal::__pattern_set_symmetric_difference( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>( __exec), @@ -1035,7 +1041,7 @@ is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; - return internal::pattern_is_heap_until( + return internal::__pattern_is_heap_until( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); @@ -1071,7 +1077,7 @@ min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; - return internal::pattern_min_element( + return internal::__pattern_min_element( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -1107,7 +1113,7 @@ minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; - return internal::pattern_minmax_element( + return internal::__pattern_minmax_element( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -1129,7 +1135,7 @@ _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; - internal::pattern_nth_element( + internal::__pattern_nth_element( std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); @@ -1152,7 +1158,7 @@ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp) { using namespace __pstl; - return internal::pattern_lexicographical_compare( + return internal::__pattern_lexicographical_compare( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); Index: include/pstl/internal/glue_memory_impl.h =================================================================== --- include/pstl/internal/glue_memory_impl.h +++ include/pstl/internal/glue_memory_impl.h @@ -36,19 +36,19 @@ return internal::invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { - return internal::pattern_walk2_brick( + return internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) { - return internal::brick_copy(__begin, __end, __res, __is_vector); + return internal::__brick_copy(__begin, __end, __res, __is_vector); }, __is_parallel); }, [&]() { - return internal::pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, - [](_ReferenceType1 __val1, _ReferenceType2 __val2) { - ::new (std::addressof(__val2)) _ValueType2(__val1); - }, - __is_vector, __is_parallel); + return internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(__val1); + }, + __is_vector, __is_parallel); }); } @@ -70,19 +70,19 @@ return internal::invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { - return internal::pattern_walk2_brick_n( + return internal::__pattern_walk2_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) { - return internal::brick_copy_n(__begin, __sz, __res, __is_vector); + return internal::__brick_copy_n(__begin, __sz, __res, __is_vector); }, __is_parallel); }, [&]() { - return internal::pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, - [](_ReferenceType1 __val1, _ReferenceType2 __val2) { - ::new (std::addressof(__val2)) _ValueType2(__val1); - }, - __is_vector, __is_parallel); + return internal::__pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(__val1); + }, + __is_vector, __is_parallel); }); } @@ -106,19 +106,19 @@ return internal::invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { - return internal::pattern_walk2_brick( + return internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) { - return internal::brick_copy(__begin, __end, __res, __is_vector); + return internal::__brick_copy(__begin, __end, __res, __is_vector); }, __is_parallel); }, [&]() { - return internal::pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, - [](_ReferenceType1 __val1, _ReferenceType2 __val2) { - ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); - }, - __is_vector, __is_parallel); + return internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); + }, + __is_vector, __is_parallel); }); } @@ -140,19 +140,19 @@ return internal::invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { - return internal::pattern_walk2_brick_n( + return internal::__pattern_walk2_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) { - return internal::brick_copy_n(__begin, __sz, __res, __is_vector); + return internal::__brick_copy_n(__begin, __sz, __res, __is_vector); }, __is_parallel); }, [&]() { - return internal::pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, - [](_ReferenceType1 __val1, _ReferenceType2 __val2) { - ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); - }, - __is_vector, __is_parallel); + return internal::__pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); + }, + __is_vector, __is_parallel); }); } @@ -172,14 +172,14 @@ internal::invoke_if_else( std::is_arithmetic<_ValueType>(), [&]() { - internal::pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [&__value, &__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { - internal::brick_fill(__begin, __end, _ValueType(__value), __is_vector); - }, - __is_parallel); + internal::__pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value, &__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { + internal::__brick_fill(__begin, __end, _ValueType(__value), __is_vector); + }, + __is_parallel); }, [&]() { - internal::pattern_walk1( + internal::__pattern_walk1( std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector, __is_parallel); @@ -200,15 +200,15 @@ return internal::invoke_if_else( std::is_arithmetic<_ValueType>(), [&]() { - return internal::pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, - [&__value, &__is_vector](_ForwardIterator __begin, _Size __count) { - return internal::brick_fill_n(__begin, __count, - _ValueType(__value), __is_vector); - }, - __is_parallel); + return internal::__pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, + [&__value, &__is_vector](_ForwardIterator __begin, _Size __count) { + return internal::__brick_fill_n( + __begin, __count, _ValueType(__value), __is_vector); + }, + __is_parallel); }, [&]() { - return internal::pattern_walk1_n( + return internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, [&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector, __is_parallel); @@ -229,8 +229,8 @@ const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); internal::invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() { - internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, __is_parallel); + internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, __is_parallel); }); } @@ -248,9 +248,9 @@ return internal::invoke_if_else( std::is_trivially_destructible<_ValueType>(), [&]() { return std::next(__first, __n); }, [&]() { - return internal::pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, - [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, - __is_parallel); + return internal::__pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, + [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, + __is_parallel); }); } @@ -268,9 +268,9 @@ const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); internal::invoke_if_not(std::is_trivial<_ValueType>(), [&]() { - internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, - __is_parallel); + internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, + __is_parallel); }); } @@ -287,7 +287,7 @@ return internal::invoke_if_else(std::is_trivial<_ValueType>(), [&]() { return std::next(__first, __n); }, [&]() { - return internal::pattern_walk1_n( + return internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, __is_parallel); @@ -310,16 +310,16 @@ internal::invoke_if_else( std::is_trivial<_ValueType>(), [&]() { - internal::pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { - internal::brick_fill(__begin, __end, _ValueType(), __is_vector); - }, - __is_parallel); + internal::__pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { + internal::__brick_fill(__begin, __end, _ValueType(), __is_vector); + }, + __is_parallel); }, [&]() { - internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, - [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, - __is_vector, __is_parallel); + internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, + __is_vector, __is_parallel); }); } @@ -337,17 +337,17 @@ return internal::invoke_if_else( std::is_trivial<_ValueType>(), [&]() { - return internal::pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, - [__is_vector](_ForwardIterator __begin, _Size __count) { - return internal::brick_fill_n(__begin, __count, _ValueType(), - __is_vector); - }, - __is_parallel); + return internal::__pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, + [__is_vector](_ForwardIterator __begin, _Size __count) { + return internal::__brick_fill_n(__begin, __count, _ValueType(), + __is_vector); + }, + __is_parallel); }, [&]() { - return internal::pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, - [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, - __is_vector, __is_parallel); + return internal::__pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, + __is_vector, __is_parallel); }); } Index: include/pstl/internal/glue_numeric_impl.h =================================================================== --- include/pstl/internal/glue_numeric_impl.h +++ include/pstl/internal/glue_numeric_impl.h @@ -55,7 +55,7 @@ { typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType; using namespace __pstl; - return internal::pattern_transform_reduce( + return internal::__pattern_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, std::plus<_InputType>(), std::multiplies<_InputType>(), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), @@ -69,7 +69,7 @@ _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) { using namespace __pstl; - return internal::pattern_transform_reduce( + return internal::__pattern_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, __binary_op1, __binary_op2, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); @@ -81,7 +81,7 @@ _BinaryOperation __binary_op, _UnaryOperation __unary_op) { using namespace __pstl; - return internal::pattern_transform_reduce( + return internal::__pattern_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __unary_op, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); @@ -147,7 +147,7 @@ _UnaryOperation __unary_op) { using namespace __pstl; - return internal::pattern_transform_scan( + return internal::__pattern_transform_scan( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op, /*inclusive=*/std::false_type(), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), @@ -164,7 +164,7 @@ _Tp __init) { using namespace __pstl; - return internal::pattern_transform_scan( + return internal::__pattern_transform_scan( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op, /*inclusive=*/std::true_type(), internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), @@ -202,7 +202,7 @@ return __d_first; using namespace __pstl; - return internal::pattern_adjacent_difference( + return internal::__pattern_adjacent_difference( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __op, internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); Index: include/pstl/internal/memory_impl.h =================================================================== --- include/pstl/internal/memory_impl.h +++ include/pstl/internal/memory_impl.h @@ -25,7 +25,7 @@ template _OutputIterator -brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, +__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, /*vector=*/std::false_type) noexcept { typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType2; @@ -38,7 +38,7 @@ template _OutputIterator -brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, +__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, /*vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_OutputIterator>::value_type __ValueType2; Index: include/pstl/internal/numeric_fwd.h =================================================================== --- include/pstl/internal/numeric_fwd.h +++ include/pstl/internal/numeric_fwd.h @@ -23,30 +23,29 @@ //------------------------------------------------------------------------ template -_Tp -brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, - _BinaryOperation2, - /*__is_vector=*/std::true_type) noexcept; +_Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, + _BinaryOperation2, + /*__is_vector=*/std::true_type) noexcept; template -_Tp -brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, - _BinaryOperation2, - /*__is_vector=*/std::false_type) noexcept; +_Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, + _BinaryOperation2, + /*__is_vector=*/std::false_type) noexcept; -template +template _Tp -pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, - _BinaryOperation2, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, + _BinaryOperation1, _BinaryOperation2, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template +template _Tp -pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Tp, _BinaryOperation1, - _BinaryOperation2, _IsVector __is_vector, /*is_parallel=*/std::true_type); +__pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _Tp, _BinaryOperation1, _BinaryOperation2, _IsVector __is_vector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -54,25 +53,27 @@ //------------------------------------------------------------------------ template -_Tp -brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, - /*is_vector=*/std::true_type) noexcept; +_Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, + /*is_vector=*/std::true_type) noexcept; template -_Tp -brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, - /*is_vector=*/std::false_type) noexcept; +_Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, + /*is_vector=*/std::false_type) noexcept; -template +template _Tp -pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, + _UnaryOperation, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template +template _Tp -pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector, - /*is_parallel=*/std::true_type); +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, + _UnaryOperation, _IsVector, + /*is_parallel=*/std::true_type); #endif //------------------------------------------------------------------------ @@ -82,59 +83,62 @@ //------------------------------------------------------------------------ template -std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, - _UnaryOperation, _Tp, _BinaryOperation, - /*Inclusive*/ std::false_type) noexcept; +std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, + /*Inclusive*/ std::false_type) noexcept; template -std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, - _UnaryOperation, _Tp, _BinaryOperation, - /*Inclusive*/ std::true_type) noexcept; +std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, + /*Inclusive*/ std::true_type) noexcept; -template -_OutputIterator pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, - _BinaryOperation, _Inclusive, _IsVector, - /*is_parallel=*/std::false_type) noexcept; +template +_OutputIterator +__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, + _BinaryOperation, _Inclusive, _IsVector, + /*is_parallel=*/std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES template typename std::enable_if::value, _OutputIterator>::type -pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, - _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, - _Inclusive, _IsVector, /*is_parallel=*/std::true_type); +__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type); #endif - + #if __PSTL_USE_PAR_POLICIES template typename std::enable_if::value, _OutputIterator>::type -pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, - _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, - _Inclusive, _IsVector, /*is_parallel=*/std::true_type); +__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type); #endif - + //------------------------------------------------------------------------ // adjacent_difference //------------------------------------------------------------------------ template -_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, - /*is_vector*/ std::false_type) noexcept; +_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + /*is_vector*/ std::false_type) noexcept; template -_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, - /*is_vector*/ std::true_type) noexcept; +_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + /*is_vector*/ std::true_type) noexcept; -template -_OutputIterator pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, - _IsVector, /*is_parallel*/ std::false_type) noexcept; +template +_OutputIterator +__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + _IsVector, /*is_parallel*/ std::false_type) noexcept; #if __PSTL_USE_PAR_POLICIES -template -_OutputIterator pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, - _IsVector, /*is_parallel*/ std::true_type); +template +_OutputIterator +__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + _IsVector, /*is_parallel*/ std::true_type); #endif } // namespace internal Index: include/pstl/internal/numeric_impl.h =================================================================== --- include/pstl/internal/numeric_impl.h +++ include/pstl/internal/numeric_impl.h @@ -33,18 +33,18 @@ template _Tp -brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, - _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, - /*is_vector=*/std::false_type) noexcept +__brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, + _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, + /*is_vector=*/std::false_type) noexcept { return std::inner_product(__first1, __last1, __first2, __init, __binary_op1, __binary_op2); } template _Tp -brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, - _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, - /*is_vector=*/std::true_type) noexcept +__brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, + _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, + /*is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; return unseq_backend::simd_transform_reduce( @@ -55,21 +55,21 @@ template _Tp -pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, - _BinaryOperation2 __binary_op2, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, + _BinaryOperation2 __binary_op2, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector); + return __brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _Tp -pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, - _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, - _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, + _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type) { return internal::except_handler([&]() { return par_backend::parallel_transform_reduce( @@ -81,8 +81,8 @@ __binary_op1, // Combine [__first1, __first2, __binary_op1, __binary_op2, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp { - return internal::brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1, - __binary_op2, __is_vector); + return internal::__brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1, + __binary_op2, __is_vector); }); }); } @@ -94,8 +94,8 @@ template _Tp -brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, - _UnaryOperation __unary_op, /*is_vector=*/std::false_type) noexcept +__brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, + _UnaryOperation __unary_op, /*is_vector=*/std::false_type) noexcept { for (; __first != __last; ++__first) { @@ -106,8 +106,8 @@ template _Tp -brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, - _UnaryOperation __unary_op, /*is_vector=*/std::true_type) noexcept +__brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, + _UnaryOperation __unary_op, /*is_vector=*/std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType; return unseq_backend::simd_transform_reduce( @@ -118,27 +118,27 @@ template _Tp -pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, - _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, - /*is_parallel=*/std::false_type) noexcept +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept { - return brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector); + return __brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _Tp -pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, - _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, + /*is_parallel=*/std::true_type) { return except_handler([&]() { return par_backend::parallel_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__unary_op](_ForwardIterator __i) mutable { return __unary_op(*__i); }, __init, __binary_op, [__unary_op, __binary_op, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _Tp __init) { - return brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector); + return __brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector); }); }); } @@ -153,9 +153,9 @@ // Exclusive form template std::pair<_OutputIterator, _Tp> -brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, - /*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + /*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept { for (; __first != __last; ++__first, ++__result) { @@ -169,9 +169,9 @@ // Inclusive form template std::pair<_OutputIterator, _Tp> -brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, - /*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + /*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept { for (; __first != __last; ++__first, ++__result) { @@ -192,39 +192,39 @@ template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type -brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, - /*is_vector=*/std::true_type) noexcept +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, + /*is_vector=*/std::true_type) noexcept { #if (__PSTL_UDS_PRESENT) return unseq_backend::simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op, _Inclusive()); #else // We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive() value - return brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), - /*is_vector=*/std::false_type()); + return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), + /*is_vector=*/std::false_type()); #endif } template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type -brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, - /*is_vector=*/std::true_type) noexcept +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, + /*is_vector=*/std::true_type) noexcept { - return brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), - /*is_vector=*/std::false_type()); + return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), + /*is_vector=*/std::false_type()); } template _OutputIterator -pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, - _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, - _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept { - return internal::brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), - __is_vector) + return internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), + __is_vector) .first; } @@ -232,9 +232,9 @@ template typename std::enable_if::value, _OutputIterator>::type -pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, - _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; @@ -244,14 +244,14 @@ [__first, __unary_op](_DifferenceType __i) mutable { return __unary_op(__first[__i]); }, __init, __binary_op, [__first, __unary_op, __binary_op](_DifferenceType __i, _DifferenceType __j, _Tp __init) { - // Execute serial brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a commutative operation for the guarantee of correct scan. - return internal::brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op, - /*__is_vector*/ std::false_type()); + // Execute serial __brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a commutative operation for the guarantee of correct scan. + return internal::__brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op, + /*__is_vector*/ std::false_type()); }, [__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __j, _Tp __init) { - return internal::brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, __init, - __binary_op, _Inclusive(), __is_vector) + return internal::__brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, + __init, __binary_op, _Inclusive(), __is_vector) .second; }); return __result + (__last - __first); @@ -263,9 +263,9 @@ template typename std::enable_if::value, _OutputIterator>::type -pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, - _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, - _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) +__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; _DifferenceType __n = __last - __first; @@ -278,8 +278,8 @@ par_backend::parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, __init, [__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __len) { - return brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, __unary_op, _Tp{}, - __binary_op, _Inclusive(), __is_vector) + return __brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, __unary_op, _Tp{}, + __binary_op, _Inclusive(), __is_vector) .second; }, __binary_op, @@ -303,16 +303,16 @@ template _OutputIterator -brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first, - _BinaryOperation __op, /*is_vector*/ std::false_type) noexcept +__brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first, + _BinaryOperation __op, /*is_vector*/ std::false_type) noexcept { return std::adjacent_difference(__first, __last, __d_first, __op); } template _ForwardIterator2 -brick_adjacent_difference(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, - BinaryOperation __op, /*is_vector=*/std::true_type) noexcept +__brick_adjacent_difference(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, + BinaryOperation __op, /*is_vector=*/std::true_type) noexcept { assert(__first != __last); @@ -329,20 +329,20 @@ template _OutputIterator -pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, - _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector, - /*is_parallel*/ std::false_type) noexcept +__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector, + /*is_parallel*/ std::false_type) noexcept { - return internal::brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector); + return internal::__brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector); } #if __PSTL_USE_PAR_POLICIES template _ForwardIterator2 -pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, - _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector, - /*is_parallel=*/std::true_type) +__pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector, + /*is_parallel=*/std::true_type) { assert(__first != __last); typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1; @@ -352,11 +352,11 @@ par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last - 1, [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) { _ForwardIterator2 __d_b = __d_first + (__b - __first); - brick_walk3(__b, __e, __b + 1, __d_b + 1, - [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { - __z = __op(__y, __x); - }, - __is_vector); + __brick_walk3(__b, __e, __b + 1, __d_b + 1, + [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { + __z = __op(__y, __x); + }, + __is_vector); }); return __d_first + (__last - __first); }