llvm-project

History

Nikolas Klauser 06c6a5020f

This changes the algorithm to more efficiently skip ranges which cannot
match the needle for random access iterators. Specifically, we now
search for a mismatching element from the back of the subrange we want
to check. When a mismatch occurs we can directly start one after the
mismatched element, since there cannot possibly be a matching subrange
starting between the start of the subrange we checked and the mismatched
element (since all elements have to be equal). The algorithm also
remembers the subrange which was already match as being equal and
doesn't try to compare it a second time, reducing the time spent in case
of a match.

```
Benchmark                                                       old             new    Difference    % Difference
---------------------------------------------------  --------------  --------------  ------------  --------------
rng::search_n(deque<int>)_(no_match)/1000                    458.33           14.22       -444.11         -96.90%
rng::search_n(deque<int>)_(no_match)/1024                    456.17           13.89       -442.28         -96.95%
rng::search_n(deque<int>)_(no_match)/1048576              453420.38           17.69    -453402.69        -100.00%
rng::search_n(deque<int>)_(no_match)/8192                   3566.08           17.60      -3548.49         -99.51%
rng::search_n(deque<int>,_pred)_(no_match)/1000              597.88           15.25       -582.63         -97.45%
rng::search_n(deque<int>,_pred)_(no_match)/1024              608.42           15.39       -593.03         -97.47%
rng::search_n(deque<int>,_pred)_(no_match)/1048576        594533.99           18.91    -594515.08        -100.00%
rng::search_n(deque<int>,_pred)_(no_match)/8192             4670.23           18.88      -4651.35         -99.60%
rng::search_n(list<int>)_(no_match)/1000                     733.72          730.22         -3.50          -0.48%
rng::search_n(list<int>)_(no_match)/1024                     759.93          753.10         -6.84          -0.90%
rng::search_n(list<int>)_(no_match)/1048576               833841.54       813483.75     -20357.79          -2.44%
rng::search_n(list<int>)_(no_match)/8192                    8352.18         8417.31         65.14           0.78%
rng::search_n(list<int>,_pred)_(no_match)/1000               776.79          789.72         12.93           1.66%
rng::search_n(list<int>,_pred)_(no_match)/1024               788.42          806.70         18.28           2.32%
rng::search_n(list<int>,_pred)_(no_match)/1048576         955536.40       982976.81      27440.41           2.87%
rng::search_n(list<int>,_pred)_(no_match)/8192              8874.02         8915.18         41.16           0.46%
rng::search_n(vector<int>)_(no_match)/1000                   212.69            3.79       -208.90         -98.22%
rng::search_n(vector<int>)_(no_match)/1024                   219.67            3.70       -215.96         -98.31%
rng::search_n(vector<int>)_(no_match)/1048576             209622.54            3.67    -209618.87        -100.00%
rng::search_n(vector<int>)_(no_match)/8192                  1643.80            3.83      -1639.98         -99.77%
rng::search_n(vector<int>,_pred)_(no_match)/1000             461.93            7.55       -454.38         -98.36%
rng::search_n(vector<int>,_pred)_(no_match)/1024             472.43            7.74       -464.69         -98.36%
rng::search_n(vector<int>,_pred)_(no_match)/1048576       546180.29            8.71    -546171.58        -100.00%
rng::search_n(vector<int>,_pred)_(no_match)/8192            3786.26            7.88      -3778.38         -99.79%
std::search_n(deque<int>)_(no_match)/1000                    455.53           14.19       -441.34         -96.88%
std::search_n(deque<int>)_(no_match)/1024                    459.79           13.98       -445.81         -96.96%
std::search_n(deque<int>)_(no_match)/1048576              449780.32           17.99    -449762.33        -100.00%
std::search_n(deque<int>)_(no_match)/8192                   3508.55           17.97      -3490.58         -99.49%
std::search_n(deque<int>,_pred)_(no_match)/1000              571.53           17.16       -554.37         -97.00%
std::search_n(deque<int>,_pred)_(no_match)/1024              584.43           17.09       -567.34         -97.08%
std::search_n(deque<int>,_pred)_(no_match)/1048576        581418.31           19.16    -581399.15        -100.00%
std::search_n(deque<int>,_pred)_(no_match)/8192             4661.97           19.36      -4642.61         -99.58%
std::search_n(list<int>)_(no_match)/1000                     722.45          710.39        -12.06          -1.67%
std::search_n(list<int>)_(no_match)/1024                     748.50          727.08        -21.42          -2.86%
std::search_n(list<int>)_(no_match)/1048576               821655.28       784520.12     -37135.16          -4.52%
std::search_n(list<int>)_(no_match)/8192                    7941.73         8002.05         60.32           0.76%
std::search_n(list<int>,_pred)_(no_match)/1000               766.59          786.31         19.72           2.57%
std::search_n(list<int>,_pred)_(no_match)/1024               785.92          804.43         18.51           2.35%
std::search_n(list<int>,_pred)_(no_match)/1048576         948252.76       969125.41      20872.65           2.20%
std::search_n(list<int>,_pred)_(no_match)/8192              8658.99         8825.71        166.72           1.93%
std::search_n(vector<int>)_(no_match)/1000                   210.36            3.47       -206.89         -98.35%
std::search_n(vector<int>)_(no_match)/1024                   217.60            4.13       -213.47         -98.10%
std::search_n(vector<int>)_(no_match)/1048576             209386.43            3.51    -209382.92        -100.00%
std::search_n(vector<int>)_(no_match)/8192                  1643.79            3.50      -1640.29         -99.79%
std::search_n(vector<int>,_pred)_(no_match)/1000             460.88            5.44       -455.45         -98.82%
std::search_n(vector<int>,_pred)_(no_match)/1024             475.36            5.43       -469.93         -98.86%
std::search_n(vector<int>,_pred)_(no_match)/1048576       682722.75            7.15    -682715.60        -100.00%
std::search_n(vector<int>,_pred)_(no_match)/8192            3779.95            5.43      -3774.52         -99.86%
Geomean                                                     4956.15           87.96      -4868.19         -98.23%
```

Fixes #129327

2026-01-08 11:26:08 +01:00

adjacent_find.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

all_of.h

[libc++] Forward std::all_of and std::none_of to std::any_of (#167670 )

2025-11-24 11:09:40 +01:00

any_of.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

binary_search.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

clamp.h

[libc++] Remove _LIBCPP_DISABLE_NODISCARD_EXTENSIONS and refactor the tests (#87094 )

2024-04-22 22:13:58 +02:00

comp_ref_type.h

[libc++] Put _LIBCPP_NODEBUG on all internal aliases (#118710 )

2025-01-08 11:12:59 -05:00

comp.h

Reapply "[libc++] Avoid constructing additional objects when using map::at" (#160738 ) (#161485 )

2025-10-02 11:15:33 +02:00

copy_backward.h

[libc++] Merge the segmented iterator code for {copy,move}_backward (#165160 )

2025-12-11 10:32:24 +01:00

copy_if.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

copy_move_common.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

copy_n.h

[libc++] Merge the implementations of ranges::copy_n and std::copy_n and fix vector::insert to assign (#157444 )

2025-11-27 15:50:50 +01:00

copy.h

[libc++][NFC] Use lambdas when calling a segmented iterator algorithm (#173345 )

2026-01-06 17:15:05 +01:00

count_if.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

count.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

equal_range.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

equal.h

[libc++] Refactor std::equal to forward to the 3-leg overload if the size of the ranges is known (#171585 )

2025-12-23 09:04:12 +01:00

fill_n.h

[libc++] Introduce __specialized_algorithms (#167295 )

2025-11-25 13:46:19 +01:00

fill.h

[libc++] Simplify most of the segmented iterator optimizations (#164797 )

2025-11-07 08:27:55 +01:00

find_end.h

[libc++] Add __find_end optimizations back (#171374 )

2025-12-11 09:46:37 +01:00

find_first_of.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

find_if_not.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

find_if.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

find_segment_if.h

…

find.h

[libc++][NFC] Use lambdas when calling a segmented iterator algorithm (#173345 )

2026-01-06 17:15:05 +01:00

for_each_n_segment.h

[libc++][NFC] Make __is_segmented_iterator a variable template (#149976 )

2025-07-25 16:27:34 +02:00

for_each_n.h

[libc++] Simplify most of the segmented iterator optimizations (#164797 )

2025-11-07 08:27:55 +01:00

for_each_segment.h

[libc++] Merge the segmented iterator code for {copy,move}_backward (#165160 )

2025-12-11 10:32:24 +01:00

for_each.h

[libc++] Optimize {std,ranges}::for_each for iterating over __trees (#164405 )

2025-12-12 09:05:51 +01:00

generate_n.h

[libcxx] Optimize rng::generate_n for segmented iterators (#165280 )

2025-10-28 22:22:26 +08:00

generate.h

[libcxx] Optimize std::generate for segmented iterators (#163006 )

2025-10-20 19:37:33 +08:00

half_positive.h

…

in_found_result.h

…

in_fun_result.h

…

in_in_out_result.h

…

in_in_result.h

…

in_out_out_result.h

…

in_out_result.h

…

includes.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

inplace_merge.h

[libc++] Implement part of P2562R1: constexpr std::inplace_merge (#129008 )

2025-03-19 07:42:23 +08:00

is_heap_until.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

is_heap.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

is_partitioned.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

is_permutation.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

is_sorted_until.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

is_sorted.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

iter_swap.h

…

iterator_operations.h

[libc++] Merge the implementations of ranges::copy_n and std::copy_n and fix vector::insert to assign (#157444 )

2025-11-27 15:50:50 +01:00

lexicographical_compare_three_way.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

lexicographical_compare.h

[libc++] Refactor __libcpp_is_trivially_equality_comparable to be a variable template (#173151 )

2025-12-22 10:04:47 +01:00

lower_bound.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

make_heap.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

make_projected.h

[libc++] Define an internal API for std::invoke and friends (#116637 )

2025-01-20 18:00:15 +01:00

max_element.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

max.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

merge.h

[libc++] Remove some unused includes (#120219 )

2024-12-18 21:10:27 +01:00

min_element.h

[libc++] Refactor ranges::{min, max, min_element, max_element} to use std::__min_element (#132418 )

2025-03-27 09:05:37 -04:00

min_max_result.h

…

min.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

minmax_element.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

minmax.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

mismatch.h

[libc++] Refactor __libcpp_is_trivially_equality_comparable to be a variable template (#173151 )

2025-12-22 10:04:47 +01:00

move_backward.h

[libc++] Merge the segmented iterator code for {copy,move}_backward (#165160 )

2025-12-11 10:32:24 +01:00

move.h

[libc++][NFC] Use lambdas when calling a segmented iterator algorithm (#173345 )

2026-01-06 17:15:05 +01:00

next_permutation.h

…

none_of.h

[libc++] Forward std::all_of and std::none_of to std::any_of (#167670 )

2025-11-24 11:09:40 +01:00

nth_element.h

…

out_value_result.h

[libc++] Implement ranges::iota (#68494 )

2025-04-05 13:46:11 +02:00

partial_sort_copy.h

[libc++] Improve the performance of std::make_heap a bit (#154092 )

2025-09-08 12:00:04 +02:00

partial_sort.h

[libc++] Improve the performance of std::make_heap a bit (#154092 )

2025-09-08 12:00:04 +02:00

partition_copy.h

…

partition_point.h

…

partition.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

pop_heap.h

[libc++][NFC] Merge is{,_nothrow,_trivially}{,_copy,_move,_default}{_assignable,_constructible} (#85308 )

2024-03-18 08:29:44 +01:00

prev_permutation.h

…

pstl.h

[libc++][pstl] Applied [[nodiscard]] (#174015 )

2026-01-05 17:39:43 +02:00

push_heap.h

[libc++][NFC] Merge is{,_nothrow,_trivially}{,_copy,_move,_default}{_assignable,_constructible} (#85308 )

2024-03-18 08:29:44 +01:00

radix_sort.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

ranges_adjacent_find.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

ranges_all_of.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

ranges_any_of.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

ranges_binary_search.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_clamp.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_contains_subrange.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_contains.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_copy_backward.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_copy_if.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

ranges_copy_n.h

[libc++] Merge the implementations of ranges::copy_n and std::copy_n and fix vector::insert to assign (#157444 )

2025-11-27 15:50:50 +01:00

ranges_copy.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

ranges_count_if.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

ranges_count.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_ends_with.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

ranges_equal_range.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_equal.h

[libc++] Refactor std::equal to forward to the 3-leg overload if the size of the ranges is known (#171585 )

2025-12-23 09:04:12 +01:00

ranges_fill_n.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

ranges_fill.h

[libc++] Optimize std::{,ranges}::{fill,fill_n} for segmented iterators (#132665 )

2025-10-17 07:41:24 +08:00

ranges_find_end.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_find_first_of.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_find_if_not.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_find_if.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_find_last.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

ranges_find.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_fold.h

[libc++][NFC] Rename fold.h to ranges_fold.h (#109696 )

2024-09-30 08:30:16 -04:00

ranges_for_each_n.h

[libc++] Optimize ranges::{for_each, for_each_n} for segmented iterators (#132896 )

2025-06-18 12:22:47 -04:00

ranges_for_each.h

[libc++] Optimize {std,ranges}::for_each for iterating over __trees (#164405 )

2025-12-12 09:05:51 +01:00

ranges_generate_n.h

[libcxx] Optimize rng::generate_n for segmented iterators (#165280 )

2025-10-28 22:22:26 +08:00

ranges_generate.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

ranges_includes.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_inplace_merge.h

[libc++] Implement part of P2562R1: constexpr ranges::inplace_merge (#131947 )

2025-03-20 01:59:32 +08:00

ranges_is_heap_until.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_is_heap.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_is_partitioned.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_is_permutation.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_is_sorted_until.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_is_sorted.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_iterator_concept.h

[libc++] Qualify calls to nullary functions like __throw_foo (#122465 )

2025-02-21 07:59:46 -05:00

ranges_lexicographical_compare.h

[libc++] Optimize lexicographical_compare (#65279 )

2024-08-04 10:02:43 +02:00

ranges_lower_bound.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_make_heap.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_max_element.h

[libc++] Refactor ranges::{min, max, min_element, max_element} to use std::__min_element (#132418 )

2025-03-27 09:05:37 -04:00

ranges_max.h

[libc++] Refactor ranges::{min, max, min_element, max_element} to use std::__min_element (#132418 )

2025-03-27 09:05:37 -04:00

ranges_merge.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_min_element.h

[libc++] Refactor ranges::{min, max, min_element, max_element} to use std::__min_element (#132418 )

2025-03-27 09:05:37 -04:00

ranges_min.h

[libc++] Refactor ranges::{min, max, min_element, max_element} to use std::__min_element (#132418 )

2025-03-27 09:05:37 -04:00

ranges_minmax_element.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_minmax.h

Reapply "[libc++] Simplify the implementation of std::sort a bit (#104902 )" (#114023 )

2024-10-30 11:51:55 +01:00

ranges_mismatch.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_move_backward.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_move.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_next_permutation.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_none_of.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_nth_element.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_partial_sort_copy.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_partial_sort.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_partition_copy.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_partition_point.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_partition.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

ranges_pop_heap.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_prev_permutation.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_push_heap.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_remove_copy_if.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_remove_copy.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_remove_if.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_remove.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_replace_copy_if.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_replace_copy.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_replace_if.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_replace.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_reverse_copy.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_reverse.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_rotate_copy.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_rotate.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_sample.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_search_n.h

[libc++] Optimize search_n (#171389 )

2026-01-08 11:26:08 +01:00

ranges_search.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_set_difference.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

ranges_set_intersection.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_set_symmetric_difference.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

ranges_set_union.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

ranges_shuffle.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_sort_heap.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_sort.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_stable_partition.h

[libc++] Implement part of P2562R1: constexpr ranges::stable_partition (#129839 )

2025-03-06 09:23:55 +08:00

ranges_stable_sort.h

[libc++] Implement part of P2562R1: constexpr ranges::stable_sort (#128860 )

2025-03-07 01:27:48 +08:00

ranges_starts_with.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_swap_ranges.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_transform.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_unique_copy.h

[libc++] Put _LIBCPP_NODEBUG on all internal aliases (#118710 )

2025-01-08 11:12:59 -05:00

ranges_unique.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

ranges_upper_bound.h

[libc++] Remove dedicated namespaces for ranges functions (#76543 )

2024-08-01 08:54:06 -04:00

remove_copy_if.h

…

remove_copy.h

…

remove_if.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

remove.h

[libc++][NFC] Use [[__nodiscard__]] unconditionally (#80454 )

2024-09-12 21:18:43 +02:00

replace_copy_if.h

…

replace_copy.h

…

replace_if.h

…

replace.h

…

reverse_copy.h

…

reverse.h

…

rotate_copy.h

…

rotate.h

[libc++] Optimize rotate (#120890 )

2025-12-23 10:18:43 +01:00

sample.h

…

search_n.h

[libc++] Optimize search_n (#171389 )

2026-01-08 11:26:08 +01:00

search.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

set_difference.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

set_intersection.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

set_symmetric_difference.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

set_union.h

[libc++] Remove _AlgPolicy from std::copy and algorithms using std::copy (#115887 )

2024-11-12 23:03:52 +01:00

shift_left.h

…

shift_right.h

…

shuffle.h

Revert "[libc++] Introduce ABI sensitive areas to avoid requiring _LIBCPP_HIDE_FROM_ABI everywhere (#131156 )" (#141756 )

2025-05-28 12:04:51 -04:00

sift_down.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

simd_utils.h

[libc++] Optimize num_get integral functions (#121795 )

2025-11-24 16:53:58 +01:00

sort_heap.h

[libc++][NFC] Merge is{,_nothrow,_trivially}{,_copy,_move,_default}{_assignable,_constructible} (#85308 )

2024-03-18 08:29:44 +01:00

sort.h

[libc++] Fix broken precondition of __bit_log2 (#155476 )

2025-08-28 18:07:59 -04:00

specialized_algorithms.h

[libc++][NFC] Use __specialized_algorithm for std::copy __bit_iterator specialization (#172270 )

2025-12-22 10:06:40 +01:00

stable_partition.h

[libc++] Implement part of P2562R1: constexpr std::stable_partition (#128868 )

2025-03-04 09:23:29 +08:00

stable_sort.h

[libc++] Make the naming of the iterator_traits aliases consistent (#161661 )

2025-10-07 14:42:11 +02:00

swap_ranges.h

[libc++] Optimize ranges::swap_ranges for vector<bool>::iterator (#121150 )

2025-03-04 17:15:36 -05:00

three_way_comp_ref_type.h

[libc++] Put _LIBCPP_NODEBUG on all internal aliases (#118710 )

2025-01-08 11:12:59 -05:00

transform.h

…

uniform_random_bit_generator_adaptor.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00

unique_copy.h

…

unique.h

[libc++] Forward more algorithms to the classic algorithms (#114674 )

2024-11-06 12:10:06 +01:00

unwrap_iter.h

[libc++] Put _LIBCPP_NODEBUG on all internal aliases (#118710 )

2025-01-08 11:12:59 -05:00

unwrap_range.h

…

upper_bound.h

[libc++][modules] Fix missing and incorrect includes (#108850 )

2024-09-16 15:06:20 -04:00