From Jason Turner

[algorithm.syn]

C++14 → C++17 58.2 KB 1030 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp0wp2xav1/{from.md → to.md} +1027 -0
tmp/tmp0wp2xav1/{from.md → to.md} RENAMED
@@ -0,0 +1,1027 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ## Header `<algorithm>` synopsis <a id="algorithm.syn">[[algorithm.syn]]</a>
2
+
3
+ ``` cpp
4
+ #include <initializer_list>
5
+
6
+ namespace std {
7
+ // [alg.nonmodifying], non-modifying sequence operations
8
+ // [alg.all_of], all of
9
+ template <class InputIterator, class Predicate>
10
+ bool all_of(InputIterator first, InputIterator last, Predicate pred);
11
+ template <class ExecutionPolicy, class ForwardIterator, class Predicate>
12
+ bool all_of(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
13
+ ForwardIterator first, ForwardIterator last, Predicate pred);
14
+
15
+ // [alg.any_of], any of
16
+ template <class InputIterator, class Predicate>
17
+ bool any_of(InputIterator first, InputIterator last, Predicate pred);
18
+ template <class ExecutionPolicy, class ForwardIterator, class Predicate>
19
+ bool any_of(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
20
+ ForwardIterator first, ForwardIterator last, Predicate pred);
21
+
22
+ // [alg.none_of], none of
23
+ template <class InputIterator, class Predicate>
24
+ bool none_of(InputIterator first, InputIterator last, Predicate pred);
25
+ template <class ExecutionPolicy, class ForwardIterator, class Predicate>
26
+ bool none_of(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
27
+ ForwardIterator first, ForwardIterator last, Predicate pred);
28
+
29
+ // [alg.foreach], for each
30
+ template<class InputIterator, class Function>
31
+ Function for_each(InputIterator first, InputIterator last, Function f);
32
+ template<class ExecutionPolicy, class ForwardIterator, class Function>
33
+ void for_each(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
34
+ ForwardIterator first, ForwardIterator last, Function f);
35
+ template<class InputIterator, class Size, class Function>
36
+ InputIterator for_each_n(InputIterator first, Size n, Function f);
37
+ template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
38
+ ForwardIterator for_each_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
39
+ ForwardIterator first, Size n, Function f);
40
+
41
+ // [alg.find], find
42
+ template<class InputIterator, class T>
43
+ InputIterator find(InputIterator first, InputIterator last,
44
+ const T& value);
45
+ template<class ExecutionPolicy, class ForwardIterator, class T>
46
+ ForwardIterator find(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
47
+ ForwardIterator first, ForwardIterator last,
48
+ const T& value);
49
+ template<class InputIterator, class Predicate>
50
+ InputIterator find_if(InputIterator first, InputIterator last,
51
+ Predicate pred);
52
+ template<class ExecutionPolicy, class ForwardIterator, class Predicate>
53
+ ForwardIterator find_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
54
+ ForwardIterator first, ForwardIterator last,
55
+ Predicate pred);
56
+ template<class InputIterator, class Predicate>
57
+ InputIterator find_if_not(InputIterator first, InputIterator last,
58
+ Predicate pred);
59
+ template<class ExecutionPolicy, class ForwardIterator, class Predicate>
60
+ ForwardIterator find_if_not(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
61
+ ForwardIterator first, ForwardIterator last,
62
+ Predicate pred);
63
+
64
+ // [alg.find.end], find end
65
+ template<class ForwardIterator1, class ForwardIterator2>
66
+ ForwardIterator1
67
+ find_end(ForwardIterator1 first1, ForwardIterator1 last1,
68
+ ForwardIterator2 first2, ForwardIterator2 last2);
69
+ template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
70
+ ForwardIterator1
71
+ find_end(ForwardIterator1 first1, ForwardIterator1 last1,
72
+ ForwardIterator2 first2, ForwardIterator2 last2,
73
+ BinaryPredicate pred);
74
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
75
+ ForwardIterator1
76
+ find_end(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
77
+ ForwardIterator1 first1, ForwardIterator1 last1,
78
+ ForwardIterator2 first2, ForwardIterator2 last2);
79
+ template<class ExecutionPolicy, class ForwardIterator1,
80
+ class ForwardIterator2, class BinaryPredicate>
81
+ ForwardIterator1
82
+ find_end(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
83
+ ForwardIterator1 first1, ForwardIterator1 last1,
84
+ ForwardIterator2 first2, ForwardIterator2 last2,
85
+ BinaryPredicate pred);
86
+
87
+ // [alg.find.first.of], find first
88
+ template<class InputIterator, class ForwardIterator>
89
+ InputIterator
90
+ find_first_of(InputIterator first1, InputIterator last1,
91
+ ForwardIterator first2, ForwardIterator last2);
92
+ template<class InputIterator, class ForwardIterator, class BinaryPredicate>
93
+ InputIterator
94
+ find_first_of(InputIterator first1, InputIterator last1,
95
+ ForwardIterator first2, ForwardIterator last2,
96
+ BinaryPredicate pred);
97
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
98
+ ForwardIterator1
99
+ find_first_of(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
100
+ ForwardIterator1 first1, ForwardIterator1 last1,
101
+ ForwardIterator2 first2, ForwardIterator2 last2);
102
+ template<class ExecutionPolicy, class ForwardIterator1,
103
+ class ForwardIterator2, class BinaryPredicate>
104
+ ForwardIterator1
105
+ find_first_of(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
106
+ ForwardIterator1 first1, ForwardIterator1 last1,
107
+ ForwardIterator2 first2, ForwardIterator2 last2,
108
+ BinaryPredicate pred);
109
+
110
+ // [alg.adjacent.find], adjacent find
111
+ template<class ForwardIterator>
112
+ ForwardIterator adjacent_find(ForwardIterator first,
113
+ ForwardIterator last);
114
+ template<class ForwardIterator, class BinaryPredicate>
115
+ ForwardIterator adjacent_find(ForwardIterator first,
116
+ ForwardIterator last,
117
+ BinaryPredicate pred);
118
+ template<class ExecutionPolicy, class ForwardIterator>
119
+ ForwardIterator adjacent_find(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
120
+ ForwardIterator first,
121
+ ForwardIterator last);
122
+ template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
123
+ ForwardIterator adjacent_find(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
124
+ ForwardIterator first,
125
+ ForwardIterator last,
126
+ BinaryPredicate pred);
127
+
128
+ // [alg.count], count
129
+ template<class InputIterator, class T>
130
+ typename iterator_traits<InputIterator>::difference_type
131
+ count(InputIterator first, InputIterator last, const T& value);
132
+ template<class ExecutionPolicy, class ForwardIterator, class T>
133
+ typename iterator_traits<ForwardIterator>::difference_type
134
+ count(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
135
+ ForwardIterator first, ForwardIterator last, const T& value);
136
+ template<class InputIterator, class Predicate>
137
+ typename iterator_traits<InputIterator>::difference_type
138
+ count_if(InputIterator first, InputIterator last, Predicate pred);
139
+ template<class ExecutionPolicy, class ForwardIterator, class Predicate>
140
+ typename iterator_traits<ForwardIterator>::difference_type
141
+ count_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
142
+ ForwardIterator first, ForwardIterator last, Predicate pred);
143
+
144
+ // [mismatch], mismatch
145
+ template<class InputIterator1, class InputIterator2>
146
+ pair<InputIterator1, InputIterator2>
147
+ mismatch(InputIterator1 first1, InputIterator1 last1,
148
+ InputIterator2 first2);
149
+ template<class InputIterator1, class InputIterator2, class BinaryPredicate>
150
+ pair<InputIterator1, InputIterator2>
151
+ mismatch(InputIterator1 first1, InputIterator1 last1,
152
+ InputIterator2 first2, BinaryPredicate pred);
153
+ template<class InputIterator1, class InputIterator2>
154
+ pair<InputIterator1, InputIterator2>
155
+ mismatch(InputIterator1 first1, InputIterator1 last1,
156
+ InputIterator2 first2, InputIterator2 last2);
157
+ template<class InputIterator1, class InputIterator2, class BinaryPredicate>
158
+ pair<InputIterator1, InputIterator2>
159
+ mismatch(InputIterator1 first1, InputIterator1 last1,
160
+ InputIterator2 first2, InputIterator2 last2,
161
+ BinaryPredicate pred);
162
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
163
+ pair<ForwardIterator1, ForwardIterator2>
164
+ mismatch(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
165
+ ForwardIterator1 first1, ForwardIterator1 last1,
166
+ ForwardIterator2 first2);
167
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
168
+ class BinaryPredicate>
169
+ pair<ForwardIterator1, ForwardIterator2>
170
+ mismatch(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
171
+ ForwardIterator1 first1, ForwardIterator1 last1,
172
+ ForwardIterator2 first2, BinaryPredicate pred);
173
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
174
+ pair<ForwardIterator1, ForwardIterator2>
175
+ mismatch(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
176
+ ForwardIterator1 first1, ForwardIterator1 last1,
177
+ ForwardIterator2 first2, ForwardIterator2 last2);
178
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
179
+ class BinaryPredicate>
180
+ pair<ForwardIterator1, ForwardIterator2>
181
+ mismatch(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
182
+ ForwardIterator1 first1, ForwardIterator1 last1,
183
+ ForwardIterator2 first2, ForwardIterator2 last2,
184
+ BinaryPredicate pred);
185
+
186
+ // [alg.equal], equal
187
+ template<class InputIterator1, class InputIterator2>
188
+ bool equal(InputIterator1 first1, InputIterator1 last1,
189
+ InputIterator2 first2);
190
+ template<class InputIterator1, class InputIterator2, class BinaryPredicate>
191
+ bool equal(InputIterator1 first1, InputIterator1 last1,
192
+ InputIterator2 first2, BinaryPredicate pred);
193
+ template<class InputIterator1, class InputIterator2>
194
+ bool equal(InputIterator1 first1, InputIterator1 last1,
195
+ InputIterator2 first2, InputIterator2 last2);
196
+ template<class InputIterator1, class InputIterator2, class BinaryPredicate>
197
+ bool equal(InputIterator1 first1, InputIterator1 last1,
198
+ InputIterator2 first2, InputIterator2 last2,
199
+ BinaryPredicate pred);
200
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
201
+ bool equal(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
202
+ ForwardIterator1 first1, ForwardIterator1 last1,
203
+ ForwardIterator2 first2);
204
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
205
+ class BinaryPredicate>
206
+ bool equal(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
207
+ ForwardIterator1 first1, ForwardIterator1 last1,
208
+ ForwardIterator2 first2, BinaryPredicate pred);
209
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
210
+ bool equal(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
211
+ ForwardIterator1 first1, ForwardIterator1 last1,
212
+ ForwardIterator2 first2, ForwardIterator2 last2);
213
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
214
+ class BinaryPredicate>
215
+ bool equal(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
216
+ ForwardIterator1 first1, ForwardIterator1 last1,
217
+ ForwardIterator2 first2, ForwardIterator2 last2,
218
+ BinaryPredicate pred);
219
+
220
+ // [alg.is_permutation], is permutation
221
+ template<class ForwardIterator1, class ForwardIterator2>
222
+ bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
223
+ ForwardIterator2 first2);
224
+ template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
225
+ bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
226
+ ForwardIterator2 first2, BinaryPredicate pred);
227
+
228
+ template<class ForwardIterator1, class ForwardIterator2>
229
+ bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
230
+ ForwardIterator2 first2, ForwardIterator2 last2);
231
+
232
+ template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
233
+ bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
234
+ ForwardIterator2 first2, ForwardIterator2 last2,
235
+ BinaryPredicate pred);
236
+
237
+ // [alg.search], search
238
+ template<class ForwardIterator1, class ForwardIterator2>
239
+ ForwardIterator1 search(
240
+ ForwardIterator1 first1, ForwardIterator1 last1,
241
+ ForwardIterator2 first2, ForwardIterator2 last2);
242
+ template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
243
+ ForwardIterator1 search(
244
+ ForwardIterator1 first1, ForwardIterator1 last1,
245
+ ForwardIterator2 first2, ForwardIterator2 last2,
246
+ BinaryPredicate pred);
247
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
248
+ ForwardIterator1 search(
249
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
250
+ ForwardIterator1 first1, ForwardIterator1 last1,
251
+ ForwardIterator2 first2, ForwardIterator2 last2);
252
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
253
+ class BinaryPredicate>
254
+ ForwardIterator1 search(
255
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
256
+ ForwardIterator1 first1, ForwardIterator1 last1,
257
+ ForwardIterator2 first2, ForwardIterator2 last2,
258
+ BinaryPredicate pred);
259
+ template<class ForwardIterator, class Size, class T>
260
+ ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
261
+ Size count, const T& value);
262
+ template<class ForwardIterator, class Size, class T, class BinaryPredicate>
263
+ ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
264
+ Size count, const T& value,
265
+ BinaryPredicate pred);
266
+ template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
267
+ ForwardIterator search_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
268
+ ForwardIterator first, ForwardIterator last,
269
+ Size count, const T& value);
270
+ template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
271
+ class BinaryPredicate>
272
+ ForwardIterator search_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
273
+ ForwardIterator first, ForwardIterator last,
274
+ Size count, const T& value,
275
+ BinaryPredicate pred);
276
+
277
+ template <class ForwardIterator, class Searcher>
278
+ ForwardIterator search(ForwardIterator first, ForwardIterator last,
279
+ const Searcher& searcher);
280
+
281
+ // [alg.modifying.operations], modifying sequence operations
282
+ // [alg.copy], copy
283
+ template<class InputIterator, class OutputIterator>
284
+ OutputIterator copy(InputIterator first, InputIterator last,
285
+ OutputIterator result);
286
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
287
+ ForwardIterator2 copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
288
+ ForwardIterator1 first, ForwardIterator1 last,
289
+ ForwardIterator2 result);
290
+ template<class InputIterator, class Size, class OutputIterator>
291
+ OutputIterator copy_n(InputIterator first, Size n,
292
+ OutputIterator result);
293
+ template<class ExecutionPolicy, class ForwardIterator1, class Size,
294
+ class ForwardIterator2>
295
+ ForwardIterator2 copy_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
296
+ ForwardIterator1 first, Size n,
297
+ ForwardIterator2 result);
298
+ template<class InputIterator, class OutputIterator, class Predicate>
299
+ OutputIterator copy_if(InputIterator first, InputIterator last,
300
+ OutputIterator result, Predicate pred);
301
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
302
+ class Predicate>
303
+ ForwardIterator2 copy_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
304
+ ForwardIterator1 first, ForwardIterator1 last,
305
+ ForwardIterator2 result, Predicate pred);
306
+ template<class BidirectionalIterator1, class BidirectionalIterator2>
307
+ BidirectionalIterator2 copy_backward(
308
+ BidirectionalIterator1 first, BidirectionalIterator1 last,
309
+ BidirectionalIterator2 result);
310
+
311
+ // [alg.move], move
312
+ template<class InputIterator, class OutputIterator>
313
+ OutputIterator move(InputIterator first, InputIterator last,
314
+ OutputIterator result);
315
+ template<class ExecutionPolicy, class ForwardIterator1,
316
+ class ForwardIterator2>
317
+ ForwardIterator2 move(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
318
+ ForwardIterator1 first, ForwardIterator1 last,
319
+ ForwardIterator2 result);
320
+ template<class BidirectionalIterator1, class BidirectionalIterator2>
321
+ BidirectionalIterator2 move_backward(
322
+ BidirectionalIterator1 first, BidirectionalIterator1 last,
323
+ BidirectionalIterator2 result);
324
+
325
+ // [alg.swap], swap
326
+ template<class ForwardIterator1, class ForwardIterator2>
327
+ ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
328
+ ForwardIterator2 first2);
329
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
330
+ ForwardIterator2 swap_ranges(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
331
+ ForwardIterator1 first1, ForwardIterator1 last1,
332
+ ForwardIterator2 first2);
333
+ template<class ForwardIterator1, class ForwardIterator2>
334
+ void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
335
+
336
+ // [alg.transform], transform
337
+ template<class InputIterator, class OutputIterator, class UnaryOperation>
338
+ OutputIterator transform(InputIterator first, InputIterator last,
339
+ OutputIterator result, UnaryOperation op);
340
+ template<class InputIterator1, class InputIterator2, class OutputIterator,
341
+ class BinaryOperation>
342
+ OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
343
+ InputIterator2 first2, OutputIterator result,
344
+ BinaryOperation binary_op);
345
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
346
+ class UnaryOperation>
347
+ ForwardIterator2 transform(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
348
+ ForwardIterator1 first, ForwardIterator1 last,
349
+ ForwardIterator2 result, UnaryOperation op);
350
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
351
+ class ForwardIterator, class BinaryOperation>
352
+ ForwardIterator transform(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
353
+ ForwardIterator1 first1, ForwardIterator1 last1,
354
+ ForwardIterator2 first2, ForwardIterator result,
355
+ BinaryOperation binary_op);
356
+
357
+ // [alg.replace], replace
358
+ template<class ForwardIterator, class T>
359
+ void replace(ForwardIterator first, ForwardIterator last,
360
+ const T& old_value, const T& new_value);
361
+ template<class ExecutionPolicy, class ForwardIterator, class T>
362
+ void replace(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
363
+ ForwardIterator first, ForwardIterator last,
364
+ const T& old_value, const T& new_value);
365
+ template<class ForwardIterator, class Predicate, class T>
366
+ void replace_if(ForwardIterator first, ForwardIterator last,
367
+ Predicate pred, const T& new_value);
368
+ template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T>
369
+ void replace_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
370
+ ForwardIterator first, ForwardIterator last,
371
+ Predicate pred, const T& new_value);
372
+ template<class InputIterator, class OutputIterator, class T>
373
+ OutputIterator replace_copy(InputIterator first, InputIterator last,
374
+ OutputIterator result,
375
+ const T& old_value, const T& new_value);
376
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
377
+ ForwardIterator2 replace_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
378
+ ForwardIterator1 first, ForwardIterator1 last,
379
+ ForwardIterator2 result,
380
+ const T& old_value, const T& new_value);
381
+ template<class InputIterator, class OutputIterator, class Predicate, class T>
382
+ OutputIterator replace_copy_if(InputIterator first, InputIterator last,
383
+ OutputIterator result,
384
+ Predicate pred, const T& new_value);
385
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
386
+ class Predicate, class T>
387
+ ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
388
+ ForwardIterator1 first, ForwardIterator1 last,
389
+ ForwardIterator2 result,
390
+ Predicate pred, const T& new_value);
391
+
392
+ // [alg.fill], fill
393
+ template<class ForwardIterator, class T>
394
+ void fill(ForwardIterator first, ForwardIterator last, const T& value);
395
+ template<class ExecutionPolicy, class ForwardIterator,
396
+ class T>
397
+ void fill(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
398
+ ForwardIterator first, ForwardIterator last, const T& value);
399
+ template<class OutputIterator, class Size, class T>
400
+ OutputIterator fill_n(OutputIterator first, Size n, const T& value);
401
+ template<class ExecutionPolicy, class ForwardIterator,
402
+ class Size, class T>
403
+ ForwardIterator fill_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
404
+ ForwardIterator first, Size n, const T& value);
405
+
406
+ // [alg.generate], generate
407
+ template<class ForwardIterator, class Generator>
408
+ void generate(ForwardIterator first, ForwardIterator last,
409
+ Generator gen);
410
+ template<class ExecutionPolicy, class ForwardIterator, class Generator>
411
+ void generate(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
412
+ ForwardIterator first, ForwardIterator last,
413
+ Generator gen);
414
+ template<class OutputIterator, class Size, class Generator>
415
+ OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
416
+ template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
417
+ ForwardIterator generate_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
418
+ ForwardIterator first, Size n, Generator gen);
419
+
420
+ // [alg.remove], remove
421
+ template<class ForwardIterator, class T>
422
+ ForwardIterator remove(ForwardIterator first, ForwardIterator last,
423
+ const T& value);
424
+ template<class ExecutionPolicy, class ForwardIterator, class T>
425
+ ForwardIterator remove(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
426
+ ForwardIterator first, ForwardIterator last,
427
+ const T& value);
428
+ template<class ForwardIterator, class Predicate>
429
+ ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
430
+ Predicate pred);
431
+ template<class ExecutionPolicy, class ForwardIterator, class Predicate>
432
+ ForwardIterator remove_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
433
+ ForwardIterator first, ForwardIterator last,
434
+ Predicate pred);
435
+ template<class InputIterator, class OutputIterator, class T>
436
+ OutputIterator remove_copy(InputIterator first, InputIterator last,
437
+ OutputIterator result, const T& value);
438
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
439
+ class T>
440
+ ForwardIterator2 remove_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
441
+ ForwardIterator1 first, ForwardIterator1 last,
442
+ ForwardIterator2 result, const T& value);
443
+ template<class InputIterator, class OutputIterator, class Predicate>
444
+ OutputIterator remove_copy_if(InputIterator first, InputIterator last,
445
+ OutputIterator result, Predicate pred);
446
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
447
+ class Predicate>
448
+ ForwardIterator2 remove_copy_if(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
449
+ ForwardIterator1 first, ForwardIterator1 last,
450
+ ForwardIterator2 result, Predicate pred);
451
+
452
+ // [alg.unique], unique
453
+ template<class ForwardIterator>
454
+ ForwardIterator unique(ForwardIterator first, ForwardIterator last);
455
+ template<class ForwardIterator, class BinaryPredicate>
456
+ ForwardIterator unique(ForwardIterator first, ForwardIterator last,
457
+ BinaryPredicate pred);
458
+ template<class ExecutionPolicy, class ForwardIterator>
459
+ ForwardIterator unique(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
460
+ ForwardIterator first, ForwardIterator last);
461
+ template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
462
+ ForwardIterator unique(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
463
+ ForwardIterator first, ForwardIterator last,
464
+ BinaryPredicate pred);
465
+ template<class InputIterator, class OutputIterator>
466
+ OutputIterator unique_copy(InputIterator first, InputIterator last,
467
+ OutputIterator result);
468
+ template<class InputIterator, class OutputIterator, class BinaryPredicate>
469
+ OutputIterator unique_copy(InputIterator first, InputIterator last,
470
+ OutputIterator result, BinaryPredicate pred);
471
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
472
+ ForwardIterator2 unique_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
473
+ ForwardIterator1 first, ForwardIterator1 last,
474
+ ForwardIterator2 result);
475
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
476
+ class BinaryPredicate>
477
+ ForwardIterator2 unique_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
478
+ ForwardIterator1 first, ForwardIterator1 last,
479
+ ForwardIterator2 result, BinaryPredicate pred);
480
+
481
+ // [alg.reverse], reverse
482
+ template<class BidirectionalIterator>
483
+ void reverse(BidirectionalIterator first, BidirectionalIterator last);
484
+ template<class ExecutionPolicy, class BidirectionalIterator>
485
+ void reverse(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
486
+ BidirectionalIterator first, BidirectionalIterator last);
487
+ template<class BidirectionalIterator, class OutputIterator>
488
+ OutputIterator reverse_copy(BidirectionalIterator first,
489
+ BidirectionalIterator last,
490
+ OutputIterator result);
491
+ template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
492
+ ForwardIterator reverse_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
493
+ BidirectionalIterator first,
494
+ BidirectionalIterator last,
495
+ ForwardIterator result);
496
+
497
+ // [alg.rotate], rotate
498
+ template<class ForwardIterator>
499
+ ForwardIterator rotate(ForwardIterator first,
500
+ ForwardIterator middle,
501
+ ForwardIterator last);
502
+ template<class ExecutionPolicy, class ForwardIterator>
503
+ ForwardIterator rotate(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
504
+ ForwardIterator first,
505
+ ForwardIterator middle,
506
+ ForwardIterator last);
507
+ template<class ForwardIterator, class OutputIterator>
508
+ OutputIterator rotate_copy(
509
+ ForwardIterator first, ForwardIterator middle,
510
+ ForwardIterator last, OutputIterator result);
511
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
512
+ ForwardIterator2 rotate_copy(
513
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
514
+ ForwardIterator1 first, ForwardIterator1 middle,
515
+ ForwardIterator1 last, ForwardIterator2 result);
516
+
517
+ // [alg.random.sample], sample
518
+ template<class PopulationIterator, class SampleIterator,
519
+ class Distance, class UniformRandomBitGenerator>
520
+ SampleIterator sample(PopulationIterator first, PopulationIterator last,
521
+ SampleIterator out, Distance n,
522
+ UniformRandomBitGenerator&& g);
523
+
524
+ // [alg.random.shuffle], shuffle
525
+ template<class RandomAccessIterator, class UniformRandomBitGenerator>
526
+ void shuffle(RandomAccessIterator first,
527
+ RandomAccessIterator last,
528
+ UniformRandomBitGenerator&& g);
529
+
530
+ // [alg.partitions], partitions
531
+ template <class InputIterator, class Predicate>
532
+ bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
533
+ template <class ExecutionPolicy, class ForwardIterator, class Predicate>
534
+ bool is_partitioned(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
535
+ ForwardIterator first, ForwardIterator last, Predicate pred);
536
+
537
+ template<class ForwardIterator, class Predicate>
538
+ ForwardIterator partition(ForwardIterator first,
539
+ ForwardIterator last,
540
+ Predicate pred);
541
+ template<class ExecutionPolicy, class ForwardIterator, class Predicate>
542
+ ForwardIterator partition(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
543
+ ForwardIterator first,
544
+ ForwardIterator last,
545
+ Predicate pred);
546
+ template<class BidirectionalIterator, class Predicate>
547
+ BidirectionalIterator stable_partition(BidirectionalIterator first,
548
+ BidirectionalIterator last,
549
+ Predicate pred);
550
+ template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
551
+ BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
552
+ BidirectionalIterator first,
553
+ BidirectionalIterator last,
554
+ Predicate pred);
555
+ template <class InputIterator, class OutputIterator1,
556
+ class OutputIterator2, class Predicate>
557
+ pair<OutputIterator1, OutputIterator2>
558
+ partition_copy(InputIterator first, InputIterator last,
559
+ OutputIterator1 out_true, OutputIterator2 out_false,
560
+ Predicate pred);
561
+ template <class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
562
+ class ForwardIterator2, class Predicate>
563
+ pair<ForwardIterator1, ForwardIterator2>
564
+ partition_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
565
+ ForwardIterator first, ForwardIterator last,
566
+ ForwardIterator1 out_true, ForwardIterator2 out_false,
567
+ Predicate pred);
568
+ template<class ForwardIterator, class Predicate>
569
+ ForwardIterator partition_point(ForwardIterator first,
570
+ ForwardIterator last,
571
+ Predicate pred);
572
+
573
+ // [alg.sorting], sorting and related operations
574
+ // [alg.sort], sorting
575
+ template<class RandomAccessIterator>
576
+ void sort(RandomAccessIterator first, RandomAccessIterator last);
577
+ template<class RandomAccessIterator, class Compare>
578
+ void sort(RandomAccessIterator first, RandomAccessIterator last,
579
+ Compare comp);
580
+ template<class ExecutionPolicy, class RandomAccessIterator>
581
+ void sort(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
582
+ RandomAccessIterator first, RandomAccessIterator last);
583
+ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
584
+ void sort(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
585
+ RandomAccessIterator first, RandomAccessIterator last,
586
+ Compare comp);
587
+
588
+ template<class RandomAccessIterator>
589
+ void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
590
+ template<class RandomAccessIterator, class Compare>
591
+ void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
592
+ Compare comp);
593
+ template<class ExecutionPolicy, class RandomAccessIterator>
594
+ void stable_sort(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
595
+ RandomAccessIterator first, RandomAccessIterator last);
596
+ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
597
+ void stable_sort(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
598
+ RandomAccessIterator first, RandomAccessIterator last,
599
+ Compare comp);
600
+
601
+ template<class RandomAccessIterator>
602
+ void partial_sort(RandomAccessIterator first,
603
+ RandomAccessIterator middle,
604
+ RandomAccessIterator last);
605
+ template<class RandomAccessIterator, class Compare>
606
+ void partial_sort(RandomAccessIterator first,
607
+ RandomAccessIterator middle,
608
+ RandomAccessIterator last, Compare comp);
609
+ template<class ExecutionPolicy, class RandomAccessIterator>
610
+ void partial_sort(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
611
+ RandomAccessIterator first,
612
+ RandomAccessIterator middle,
613
+ RandomAccessIterator last);
614
+ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
615
+ void partial_sort(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
616
+ RandomAccessIterator first,
617
+ RandomAccessIterator middle,
618
+ RandomAccessIterator last, Compare comp);
619
+ template<class InputIterator, class RandomAccessIterator>
620
+ RandomAccessIterator partial_sort_copy(
621
+ InputIterator first, InputIterator last,
622
+ RandomAccessIterator result_first,
623
+ RandomAccessIterator result_last);
624
+ template<class InputIterator, class RandomAccessIterator, class Compare>
625
+ RandomAccessIterator partial_sort_copy(
626
+ InputIterator first, InputIterator last,
627
+ RandomAccessIterator result_first,
628
+ RandomAccessIterator result_last,
629
+ Compare comp);
630
+ template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>
631
+ RandomAccessIterator partial_sort_copy(
632
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
633
+ ForwardIterator first, ForwardIterator last,
634
+ RandomAccessIterator result_first,
635
+ RandomAccessIterator result_last);
636
+ template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,
637
+ class Compare>
638
+ RandomAccessIterator partial_sort_copy(
639
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
640
+ ForwardIterator first, ForwardIterator last,
641
+ RandomAccessIterator result_first,
642
+ RandomAccessIterator result_last,
643
+ Compare comp);
644
+ template<class ForwardIterator>
645
+ bool is_sorted(ForwardIterator first, ForwardIterator last);
646
+ template<class ForwardIterator, class Compare>
647
+ bool is_sorted(ForwardIterator first, ForwardIterator last,
648
+ Compare comp);
649
+ template<class ExecutionPolicy, class ForwardIterator>
650
+ bool is_sorted(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
651
+ ForwardIterator first, ForwardIterator last);
652
+ template<class ExecutionPolicy, class ForwardIterator, class Compare>
653
+ bool is_sorted(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
654
+ ForwardIterator first, ForwardIterator last,
655
+ Compare comp);
656
+ template<class ForwardIterator>
657
+ ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last);
658
+ template<class ForwardIterator, class Compare>
659
+ ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last,
660
+ Compare comp);
661
+ template<class ExecutionPolicy, class ForwardIterator>
662
+ ForwardIterator is_sorted_until(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
663
+ ForwardIterator first, ForwardIterator last);
664
+ template<class ExecutionPolicy, class ForwardIterator, class Compare>
665
+ ForwardIterator is_sorted_until(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
666
+ ForwardIterator first, ForwardIterator last,
667
+ Compare comp);
668
+
669
+ // [alg.nth.element], Nth element
670
+ template<class RandomAccessIterator>
671
+ void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
672
+ RandomAccessIterator last);
673
+ template<class RandomAccessIterator, class Compare>
674
+ void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
675
+ RandomAccessIterator last, Compare comp);
676
+ template<class ExecutionPolicy, class RandomAccessIterator>
677
+ void nth_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
678
+ RandomAccessIterator first, RandomAccessIterator nth,
679
+ RandomAccessIterator last);
680
+ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
681
+ void nth_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
682
+ RandomAccessIterator first, RandomAccessIterator nth,
683
+ RandomAccessIterator last, Compare comp);
684
+
685
+ // [alg.binary.search], binary search
686
+ template<class ForwardIterator, class T>
687
+ ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
688
+ const T& value);
689
+ template<class ForwardIterator, class T, class Compare>
690
+ ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
691
+ const T& value, Compare comp);
692
+
693
+ template<class ForwardIterator, class T>
694
+ ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
695
+ const T& value);
696
+ template<class ForwardIterator, class T, class Compare>
697
+ ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
698
+ const T& value, Compare comp);
699
+
700
+ template<class ForwardIterator, class T>
701
+ pair<ForwardIterator, ForwardIterator>
702
+ equal_range(ForwardIterator first, ForwardIterator last,
703
+ const T& value);
704
+ template<class ForwardIterator, class T, class Compare>
705
+ pair<ForwardIterator, ForwardIterator>
706
+ equal_range(ForwardIterator first, ForwardIterator last,
707
+ const T& value, Compare comp);
708
+
709
+ template<class ForwardIterator, class T>
710
+ bool binary_search(ForwardIterator first, ForwardIterator last,
711
+ const T& value);
712
+ template<class ForwardIterator, class T, class Compare>
713
+ bool binary_search(ForwardIterator first, ForwardIterator last,
714
+ const T& value, Compare comp);
715
+
716
+ // [alg.merge], merge
717
+ template<class InputIterator1, class InputIterator2, class OutputIterator>
718
+ OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
719
+ InputIterator2 first2, InputIterator2 last2,
720
+ OutputIterator result);
721
+ template<class InputIterator1, class InputIterator2, class OutputIterator,
722
+ class Compare>
723
+ OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
724
+ InputIterator2 first2, InputIterator2 last2,
725
+ OutputIterator result, Compare comp);
726
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
727
+ class ForwardIterator>
728
+ ForwardIterator merge(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
729
+ ForwardIterator1 first1, ForwardIterator1 last1,
730
+ ForwardIterator2 first2, ForwardIterator2 last2,
731
+ ForwardIterator result);
732
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
733
+ class ForwardIterator, class Compare>
734
+ ForwardIterator merge(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
735
+ ForwardIterator1 first1, ForwardIterator1 last1,
736
+ ForwardIterator2 first2, ForwardIterator2 last2,
737
+ ForwardIterator result, Compare comp);
738
+
739
+ template<class BidirectionalIterator>
740
+ void inplace_merge(BidirectionalIterator first,
741
+ BidirectionalIterator middle,
742
+ BidirectionalIterator last);
743
+ template<class BidirectionalIterator, class Compare>
744
+ void inplace_merge(BidirectionalIterator first,
745
+ BidirectionalIterator middle,
746
+ BidirectionalIterator last, Compare comp);
747
+ template<class ExecutionPolicy, class BidirectionalIterator>
748
+ void inplace_merge(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
749
+ BidirectionalIterator first,
750
+ BidirectionalIterator middle,
751
+ BidirectionalIterator last);
752
+ template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
753
+ void inplace_merge(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
754
+ BidirectionalIterator first,
755
+ BidirectionalIterator middle,
756
+ BidirectionalIterator last, Compare comp);
757
+
758
+ // [alg.set.operations], set operations
759
+ template<class InputIterator1, class InputIterator2>
760
+ bool includes(InputIterator1 first1, InputIterator1 last1,
761
+ InputIterator2 first2, InputIterator2 last2);
762
+ template<class InputIterator1, class InputIterator2, class Compare>
763
+ bool includes(InputIterator1 first1, InputIterator1 last1,
764
+ InputIterator2 first2, InputIterator2 last2, Compare comp);
765
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
766
+ bool includes(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
767
+ ForwardIterator1 first1, ForwardIterator1 last1,
768
+ ForwardIterator2 first2, ForwardIterator2 last2);
769
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
770
+ class Compare>
771
+ bool includes(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
772
+ ForwardIterator1 first1, ForwardIterator1 last1,
773
+ ForwardIterator2 first2, ForwardIterator2 last2, Compare comp);
774
+
775
+ template<class InputIterator1, class InputIterator2, class OutputIterator>
776
+ OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
777
+ InputIterator2 first2, InputIterator2 last2,
778
+ OutputIterator result);
779
+ template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
780
+ OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
781
+ InputIterator2 first2, InputIterator2 last2,
782
+ OutputIterator result, Compare comp);
783
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
784
+ class ForwardIterator>
785
+ ForwardIterator set_union(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
786
+ ForwardIterator1 first1, ForwardIterator1 last1,
787
+ ForwardIterator2 first2, ForwardIterator2 last2,
788
+ ForwardIterator result);
789
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
790
+ class ForwardIterator, class Compare>
791
+ ForwardIterator set_union(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
792
+ ForwardIterator1 first1, ForwardIterator1 last1,
793
+ ForwardIterator2 first2, ForwardIterator2 last2,
794
+ ForwardIterator result, Compare comp);
795
+
796
+ template<class InputIterator1, class InputIterator2, class OutputIterator>
797
+ OutputIterator set_intersection(
798
+ InputIterator1 first1, InputIterator1 last1,
799
+ InputIterator2 first2, InputIterator2 last2,
800
+ OutputIterator result);
801
+ template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
802
+ OutputIterator set_intersection(
803
+ InputIterator1 first1, InputIterator1 last1,
804
+ InputIterator2 first2, InputIterator2 last2,
805
+ OutputIterator result, Compare comp);
806
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
807
+ class ForwardIterator>
808
+ ForwardIterator set_intersection(
809
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
810
+ ForwardIterator1 first1, ForwardIterator1 last1,
811
+ ForwardIterator2 first2, ForwardIterator2 last2,
812
+ ForwardIterator result);
813
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
814
+ class ForwardIterator, class Compare>
815
+ ForwardIterator set_intersection(
816
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
817
+ ForwardIterator1 first1, ForwardIterator1 last1,
818
+ ForwardIterator2 first2, ForwardIterator2 last2,
819
+ ForwardIterator result, Compare comp);
820
+
821
+ template<class InputIterator1, class InputIterator2, class OutputIterator>
822
+ OutputIterator set_difference(
823
+ InputIterator1 first1, InputIterator1 last1,
824
+ InputIterator2 first2, InputIterator2 last2,
825
+ OutputIterator result);
826
+ template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
827
+ OutputIterator set_difference(
828
+ InputIterator1 first1, InputIterator1 last1,
829
+ InputIterator2 first2, InputIterator2 last2,
830
+ OutputIterator result, Compare comp);
831
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
832
+ class ForwardIterator>
833
+ ForwardIterator set_difference(
834
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
835
+ ForwardIterator1 first1, ForwardIterator1 last1,
836
+ ForwardIterator2 first2, ForwardIterator2 last2,
837
+ ForwardIterator result);
838
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
839
+ class ForwardIterator, class Compare>
840
+ ForwardIterator set_difference(
841
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
842
+ ForwardIterator1 first1, ForwardIterator1 last1,
843
+ ForwardIterator2 first2, ForwardIterator2 last2,
844
+ ForwardIterator result, Compare comp);
845
+
846
+ template<class InputIterator1, class InputIterator2, class OutputIterator>
847
+ OutputIterator set_symmetric_difference(
848
+ InputIterator1 first1, InputIterator1 last1,
849
+ InputIterator2 first2, InputIterator2 last2,
850
+ OutputIterator result);
851
+ template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
852
+ OutputIterator set_symmetric_difference(
853
+ InputIterator1 first1, InputIterator1 last1,
854
+ InputIterator2 first2, InputIterator2 last2,
855
+ OutputIterator result, Compare comp);
856
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
857
+ class ForwardIterator>
858
+ ForwardIterator set_symmetric_difference(
859
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
860
+ ForwardIterator1 first1, ForwardIterator1 last1,
861
+ ForwardIterator2 first2, ForwardIterator2 last2,
862
+ ForwardIterator result);
863
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
864
+ class ForwardIterator, class Compare>
865
+ ForwardIterator set_symmetric_difference(
866
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
867
+ ForwardIterator1 first1, ForwardIterator1 last1,
868
+ ForwardIterator2 first2, ForwardIterator2 last2,
869
+ ForwardIterator result, Compare comp);
870
+
871
+ // [alg.heap.operations], heap operations
872
+ template<class RandomAccessIterator>
873
+ void push_heap(RandomAccessIterator first, RandomAccessIterator last);
874
+ template<class RandomAccessIterator, class Compare>
875
+ void push_heap(RandomAccessIterator first, RandomAccessIterator last,
876
+ Compare comp);
877
+
878
+ template<class RandomAccessIterator>
879
+ void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
880
+ template<class RandomAccessIterator, class Compare>
881
+ void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
882
+ Compare comp);
883
+
884
+ template<class RandomAccessIterator>
885
+ void make_heap(RandomAccessIterator first, RandomAccessIterator last);
886
+ template<class RandomAccessIterator, class Compare>
887
+ void make_heap(RandomAccessIterator first, RandomAccessIterator last,
888
+ Compare comp);
889
+
890
+ template<class RandomAccessIterator>
891
+ void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
892
+ template<class RandomAccessIterator, class Compare>
893
+ void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
894
+ Compare comp);
895
+
896
+ template<class RandomAccessIterator>
897
+ bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
898
+ template<class RandomAccessIterator, class Compare>
899
+ bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
900
+ template<class ExecutionPolicy, class RandomAccessIterator>
901
+ bool is_heap(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
902
+ RandomAccessIterator first, RandomAccessIterator last);
903
+ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
904
+ bool is_heap(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
905
+ RandomAccessIterator first, RandomAccessIterator last, Compare comp);
906
+ template<class RandomAccessIterator>
907
+ RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
908
+ template<class RandomAccessIterator, class Compare>
909
+ RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
910
+ Compare comp);
911
+ template<class ExecutionPolicy, class RandomAccessIterator>
912
+ RandomAccessIterator is_heap_until(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
913
+ RandomAccessIterator first, RandomAccessIterator last);
914
+ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
915
+ RandomAccessIterator is_heap_until(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
916
+ RandomAccessIterator first, RandomAccessIterator last,
917
+ Compare comp);
918
+
919
+ // [alg.min.max], minimum and maximum
920
+ template<class T> constexpr const T& min(const T& a, const T& b);
921
+ template<class T, class Compare>
922
+ constexpr const T& min(const T& a, const T& b, Compare comp);
923
+ template<class T>
924
+ constexpr T min(initializer_list<T> t);
925
+ template<class T, class Compare>
926
+ constexpr T min(initializer_list<T> t, Compare comp);
927
+
928
+ template<class T> constexpr const T& max(const T& a, const T& b);
929
+ template<class T, class Compare>
930
+ constexpr const T& max(const T& a, const T& b, Compare comp);
931
+ template<class T>
932
+ constexpr T max(initializer_list<T> t);
933
+ template<class T, class Compare>
934
+ constexpr T max(initializer_list<T> t, Compare comp);
935
+
936
+ template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
937
+ template<class T, class Compare>
938
+ constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
939
+ template<class T>
940
+ constexpr pair<T, T> minmax(initializer_list<T> t);
941
+ template<class T, class Compare>
942
+ constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
943
+
944
+ template<class ForwardIterator>
945
+ constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
946
+ template<class ForwardIterator, class Compare>
947
+ constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
948
+ Compare comp);
949
+ template<class ExecutionPolicy, class ForwardIterator>
950
+ ForwardIterator min_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
951
+ ForwardIterator first, ForwardIterator last);
952
+ template<class ExecutionPolicy, class ForwardIterator, class Compare>
953
+ ForwardIterator min_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
954
+ ForwardIterator first, ForwardIterator last,
955
+ Compare comp);
956
+ template<class ForwardIterator>
957
+ constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
958
+ template<class ForwardIterator, class Compare>
959
+ constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
960
+ Compare comp);
961
+ template<class ExecutionPolicy, class ForwardIterator>
962
+ ForwardIterator max_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
963
+ ForwardIterator first, ForwardIterator last);
964
+ template<class ExecutionPolicy, class ForwardIterator, class Compare>
965
+ ForwardIterator max_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
966
+ ForwardIterator first, ForwardIterator last,
967
+ Compare comp);
968
+ template<class ForwardIterator>
969
+ constexpr pair<ForwardIterator, ForwardIterator>
970
+ minmax_element(ForwardIterator first, ForwardIterator last);
971
+ template<class ForwardIterator, class Compare>
972
+ constexpr pair<ForwardIterator, ForwardIterator>
973
+ minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
974
+ template<class ExecutionPolicy, class ForwardIterator>
975
+ pair<ForwardIterator, ForwardIterator>
976
+ minmax_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
977
+ ForwardIterator first, ForwardIterator last);
978
+ template<class ExecutionPolicy, class ForwardIterator, class Compare>
979
+ pair<ForwardIterator, ForwardIterator>
980
+ minmax_element(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
981
+ ForwardIterator first, ForwardIterator last, Compare comp);
982
+
983
+ // [alg.clamp], bounded value
984
+ template<class T>
985
+ constexpr const T& clamp(const T& v, const T& lo, const T& hi);
986
+ template<class T, class Compare>
987
+ constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp);
988
+
989
+ // [alg.lex.comparison], lexicographical comparison
990
+ template<class InputIterator1, class InputIterator2>
991
+ bool lexicographical_compare(
992
+ InputIterator1 first1, InputIterator1 last1,
993
+ InputIterator2 first2, InputIterator2 last2);
994
+ template<class InputIterator1, class InputIterator2, class Compare>
995
+ bool lexicographical_compare(
996
+ InputIterator1 first1, InputIterator1 last1,
997
+ InputIterator2 first2, InputIterator2 last2,
998
+ Compare comp);
999
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
1000
+ bool lexicographical_compare(
1001
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
1002
+ ForwardIterator1 first1, ForwardIterator1 last1,
1003
+ ForwardIterator2 first2, ForwardIterator2 last2);
1004
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
1005
+ class Compare>
1006
+ bool lexicographical_compare(
1007
+ ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
1008
+ ForwardIterator1 first1, ForwardIterator1 last1,
1009
+ ForwardIterator2 first2, ForwardIterator2 last2,
1010
+ Compare comp);
1011
+
1012
+ // [alg.permutation.generators], permutations
1013
+ template<class BidirectionalIterator>
1014
+ bool next_permutation(BidirectionalIterator first,
1015
+ BidirectionalIterator last);
1016
+ template<class BidirectionalIterator, class Compare>
1017
+ bool next_permutation(BidirectionalIterator first,
1018
+ BidirectionalIterator last, Compare comp);
1019
+ template<class BidirectionalIterator>
1020
+ bool prev_permutation(BidirectionalIterator first,
1021
+ BidirectionalIterator last);
1022
+ template<class BidirectionalIterator, class Compare>
1023
+ bool prev_permutation(BidirectionalIterator first,
1024
+ BidirectionalIterator last, Compare comp);
1025
+ }
1026
+ ```
1027
+