1// <algorithm> Forward declarations -*- C++ -*- 
2 
3// Copyright (C) 2007-2021 Free Software Foundation, Inc. 
4// 
5// This file is part of the GNU ISO C++ Library. This library is free 
6// software; you can redistribute it and/or modify it under the 
7// terms of the GNU General Public License as published by the 
8// Free Software Foundation; either version 3, or (at your option) 
9// any later version. 
10 
11// This library is distributed in the hope that it will be useful, 
12// but WITHOUT ANY WARRANTY; without even the implied warranty of 
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
14// GNU General Public License for more details. 
15 
16// Under Section 7 of GPL version 3, you are granted additional 
17// permissions described in the GCC Runtime Library Exception, version 
18// 3.1, as published by the Free Software Foundation. 
19 
20// You should have received a copy of the GNU General Public License and 
21// a copy of the GCC Runtime Library Exception along with this program; 
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 
23// <http://www.gnu.org/licenses/>. 
24 
25/** @file bits/algorithmfwd.h 
26 * This is an internal header file, included by other library headers. 
27 * Do not attempt to use it directly. @headername{algorithm} 
28 */ 
29 
30#ifndef _GLIBCXX_ALGORITHMFWD_H 
31#define _GLIBCXX_ALGORITHMFWD_H 1 
32 
33#pragma GCC system_header 
34 
35#include <bits/c++config.h> 
36#include <bits/stl_pair.h> 
37#include <bits/stl_iterator_base_types.h> 
38#if __cplusplus >= 201103L 
39#include <initializer_list> 
40#endif 
41 
42namespace std _GLIBCXX_VISIBILITY(default) 
43{ 
44_GLIBCXX_BEGIN_NAMESPACE_VERSION 
45 
46 /* 
47 adjacent_find 
48 all_of (C++11) 
49 any_of (C++11) 
50 binary_search 
51 clamp (C++17) 
52 copy 
53 copy_backward 
54 copy_if (C++11) 
55 copy_n (C++11) 
56 count 
57 count_if 
58 equal 
59 equal_range 
60 fill 
61 fill_n 
62 find 
63 find_end 
64 find_first_of 
65 find_if 
66 find_if_not (C++11) 
67 for_each 
68 generate 
69 generate_n 
70 includes 
71 inplace_merge 
72 is_heap (C++11) 
73 is_heap_until (C++11) 
74 is_partitioned (C++11) 
75 is_sorted (C++11) 
76 is_sorted_until (C++11) 
77 iter_swap 
78 lexicographical_compare 
79 lower_bound 
80 make_heap 
81 max 
82 max_element 
83 merge 
84 min 
85 min_element 
86 minmax (C++11) 
87 minmax_element (C++11) 
88 mismatch 
89 next_permutation 
90 none_of (C++11) 
91 nth_element 
92 partial_sort 
93 partial_sort_copy 
94 partition 
95 partition_copy (C++11) 
96 partition_point (C++11) 
97 pop_heap 
98 prev_permutation 
99 push_heap 
100 random_shuffle 
101 remove 
102 remove_copy 
103 remove_copy_if 
104 remove_if 
105 replace 
106 replace_copy 
107 replace_copy_if 
108 replace_if 
109 reverse 
110 reverse_copy 
111 rotate 
112 rotate_copy 
113 search 
114 search_n 
115 set_difference 
116 set_intersection 
117 set_symmetric_difference 
118 set_union 
119 shuffle (C++11) 
120 sort 
121 sort_heap 
122 stable_partition 
123 stable_sort 
124 swap 
125 swap_ranges 
126 transform 
127 unique 
128 unique_copy 
129 upper_bound 
130 */ 
131 
132 /** 
133 * @defgroup algorithms Algorithms 
134 * 
135 * Components for performing algorithmic operations. Includes 
136 * non-modifying sequence, modifying (mutating) sequence, sorting, 
137 * searching, merge, partition, heap, set, minima, maxima, and 
138 * permutation operations. 
139 */ 
140 
141 /** 
142 * @defgroup mutating_algorithms Mutating 
143 * @ingroup algorithms 
144 */ 
145 
146 /** 
147 * @defgroup non_mutating_algorithms Non-Mutating 
148 * @ingroup algorithms 
149 */ 
150 
151 /** 
152 * @defgroup sorting_algorithms Sorting 
153 * @ingroup algorithms 
154 */ 
155 
156 /** 
157 * @defgroup set_algorithms Set Operations 
158 * @ingroup sorting_algorithms 
159 * 
160 * These algorithms are common set operations performed on sequences 
161 * that are already sorted. The number of comparisons will be 
162 * linear. 
163 */ 
164 
165 /** 
166 * @defgroup binary_search_algorithms Binary Search 
167 * @ingroup sorting_algorithms 
168 * 
169 * These algorithms are variations of a classic binary search, and 
170 * all assume that the sequence being searched is already sorted. 
171 * 
172 * The number of comparisons will be logarithmic (and as few as 
173 * possible). The number of steps through the sequence will be 
174 * logarithmic for random-access iterators (e.g., pointers), and 
175 * linear otherwise. 
176 * 
177 * The LWG has passed Defect Report 270, which notes: <em>The 
178 * proposed resolution reinterprets binary search. Instead of 
179 * thinking about searching for a value in a sorted range, we view 
180 * that as an important special case of a more general algorithm: 
181 * searching for the partition point in a partitioned range. We 
182 * also add a guarantee that the old wording did not: we ensure that 
183 * the upper bound is no earlier than the lower bound, that the pair 
184 * returned by equal_range is a valid range, and that the first part 
185 * of that pair is the lower bound.</em> 
186 * 
187 * The actual effect of the first sentence is that a comparison 
188 * functor passed by the user doesn't necessarily need to induce a 
189 * strict weak ordering relation. Rather, it partitions the range. 
190 */ 
191 
192 // adjacent_find 
193 
194#if __cplusplus > 201703L 
195# define __cpp_lib_constexpr_algorithms 201806L 
196#endif 
197 
198#if __cplusplus >= 201103L 
199 template<typename _IIter, typename _Predicate> 
200 _GLIBCXX20_CONSTEXPR 
201 bool 
202 all_of(_IIter, _IIter, _Predicate); 
203 
204 template<typename _IIter, typename _Predicate> 
205 _GLIBCXX20_CONSTEXPR 
206 bool 
207 any_of(_IIter, _IIter, _Predicate); 
208#endif 
209 
210 template<typename _FIter, typename _Tp> 
211 _GLIBCXX20_CONSTEXPR 
212 bool 
213 binary_search(_FIter, _FIter, const _Tp&); 
214 
215 template<typename _FIter, typename _Tp, typename _Compare> 
216 _GLIBCXX20_CONSTEXPR 
217 bool 
218 binary_search(_FIter, _FIter, const _Tp&, _Compare); 
219 
220#if __cplusplus > 201402L 
221 template<typename _Tp> 
222 _GLIBCXX14_CONSTEXPR 
223 const _Tp& 
224 clamp(const _Tp&, const _Tp&, const _Tp&); 
225 
226 template<typename _Tp, typename _Compare> 
227 _GLIBCXX14_CONSTEXPR 
228 const _Tp& 
229 clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); 
230#endif 
231 
232 template<typename _IIter, typename _OIter> 
233 _GLIBCXX20_CONSTEXPR 
234 _OIter 
235 copy(_IIter, _IIter, _OIter); 
236 
237 template<typename _BIter1, typename _BIter2> 
238 _GLIBCXX20_CONSTEXPR 
239 _BIter2 
240 copy_backward(_BIter1, _BIter1, _BIter2); 
241 
242#if __cplusplus >= 201103L 
243 template<typename _IIter, typename _OIter, typename _Predicate> 
244 _GLIBCXX20_CONSTEXPR 
245 _OIter 
246 copy_if(_IIter, _IIter, _OIter, _Predicate); 
247 
248 template<typename _IIter, typename _Size, typename _OIter> 
249 _GLIBCXX20_CONSTEXPR 
250 _OIter 
251 copy_n(_IIter, _Size, _OIter); 
252#endif 
253 
254 // count 
255 // count_if 
256 
257 template<typename _FIter, typename _Tp> 
258 _GLIBCXX20_CONSTEXPR 
259 pair<_FIter, _FIter> 
260 equal_range(_FIter, _FIter, const _Tp&); 
261 
262 template<typename _FIter, typename _Tp, typename _Compare> 
263 _GLIBCXX20_CONSTEXPR 
264 pair<_FIter, _FIter> 
265 equal_range(_FIter, _FIter, const _Tp&, _Compare); 
266 
267 template<typename _FIter, typename _Tp> 
268 _GLIBCXX20_CONSTEXPR 
269 void 
270 fill(_FIter, _FIter, const _Tp&); 
271 
272 template<typename _OIter, typename _Size, typename _Tp> 
273 _GLIBCXX20_CONSTEXPR 
274 _OIter 
275 fill_n(_OIter, _Size, const _Tp&); 
276 
277 // find 
278 
279 template<typename _FIter1, typename _FIter2> 
280 _GLIBCXX20_CONSTEXPR 
281 _FIter1 
282 find_end(_FIter1, _FIter1, _FIter2, _FIter2); 
283 
284 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 
285 _GLIBCXX20_CONSTEXPR 
286 _FIter1 
287 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 
288 
289 // find_first_of 
290 // find_if 
291 
292#if __cplusplus >= 201103L 
293 template<typename _IIter, typename _Predicate> 
294 _GLIBCXX20_CONSTEXPR 
295 _IIter 
296 find_if_not(_IIter, _IIter, _Predicate); 
297#endif 
298 
299 // for_each 
300 // generate 
301 // generate_n 
302 
303 template<typename _IIter1, typename _IIter2> 
304 _GLIBCXX20_CONSTEXPR 
305 bool 
306 includes(_IIter1, _IIter1, _IIter2, _IIter2); 
307 
308 template<typename _IIter1, typename _IIter2, typename _Compare> 
309 _GLIBCXX20_CONSTEXPR 
310 bool 
311 includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 
312 
313 template<typename _BIter> 
314 void 
315 inplace_merge(_BIter, _BIter, _BIter); 
316 
317 template<typename _BIter, typename _Compare> 
318 void 
319 inplace_merge(_BIter, _BIter, _BIter, _Compare); 
320 
321#if __cplusplus >= 201103L 
322 template<typename _RAIter> 
323 _GLIBCXX20_CONSTEXPR 
324 bool 
325 is_heap(_RAIter, _RAIter); 
326 
327 template<typename _RAIter, typename _Compare> 
328 _GLIBCXX20_CONSTEXPR 
329 bool 
330 is_heap(_RAIter, _RAIter, _Compare); 
331 
332 template<typename _RAIter> 
333 _GLIBCXX20_CONSTEXPR 
334 _RAIter 
335 is_heap_until(_RAIter, _RAIter); 
336 
337 template<typename _RAIter, typename _Compare> 
338 _GLIBCXX20_CONSTEXPR 
339 _RAIter 
340 is_heap_until(_RAIter, _RAIter, _Compare); 
341 
342 template<typename _IIter, typename _Predicate> 
343 _GLIBCXX20_CONSTEXPR 
344 bool 
345 is_partitioned(_IIter, _IIter, _Predicate); 
346 
347 template<typename _FIter1, typename _FIter2> 
348 _GLIBCXX20_CONSTEXPR 
349 bool 
350 is_permutation(_FIter1, _FIter1, _FIter2); 
351 
352 template<typename _FIter1, typename _FIter2, 
353 typename _BinaryPredicate> 
354 _GLIBCXX20_CONSTEXPR 
355 bool 
356 is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); 
357 
358 template<typename _FIter> 
359 _GLIBCXX20_CONSTEXPR 
360 bool 
361 is_sorted(_FIter, _FIter); 
362 
363 template<typename _FIter, typename _Compare> 
364 _GLIBCXX20_CONSTEXPR 
365 bool 
366 is_sorted(_FIter, _FIter, _Compare); 
367 
368 template<typename _FIter> 
369 _GLIBCXX20_CONSTEXPR 
370 _FIter 
371 is_sorted_until(_FIter, _FIter); 
372 
373 template<typename _FIter, typename _Compare> 
374 _GLIBCXX20_CONSTEXPR 
375 _FIter 
376 is_sorted_until(_FIter, _FIter, _Compare); 
377#endif 
378 
379 template<typename _FIter1, typename _FIter2> 
380 _GLIBCXX20_CONSTEXPR 
381 void 
382 iter_swap(_FIter1, _FIter2); 
383 
384 template<typename _FIter, typename _Tp> 
385 _GLIBCXX20_CONSTEXPR 
386 _FIter 
387 lower_bound(_FIter, _FIter, const _Tp&); 
388 
389 template<typename _FIter, typename _Tp, typename _Compare> 
390 _GLIBCXX20_CONSTEXPR 
391 _FIter 
392 lower_bound(_FIter, _FIter, const _Tp&, _Compare); 
393 
394 template<typename _RAIter> 
395 _GLIBCXX20_CONSTEXPR 
396 void 
397 make_heap(_RAIter, _RAIter); 
398 
399 template<typename _RAIter, typename _Compare> 
400 _GLIBCXX20_CONSTEXPR 
401 void 
402 make_heap(_RAIter, _RAIter, _Compare); 
403 
404 template<typename _Tp> 
405 _GLIBCXX14_CONSTEXPR 
406 const _Tp& 
407 max(const _Tp&, const _Tp&); 
408 
409 template<typename _Tp, typename _Compare> 
410 _GLIBCXX14_CONSTEXPR 
411 const _Tp& 
412 max(const _Tp&, const _Tp&, _Compare); 
413 
414 // max_element 
415 // merge 
416 
417 template<typename _Tp> 
418 _GLIBCXX14_CONSTEXPR 
419 const _Tp& 
420 min(const _Tp&, const _Tp&); 
421 
422 template<typename _Tp, typename _Compare> 
423 _GLIBCXX14_CONSTEXPR 
424 const _Tp& 
425 min(const _Tp&, const _Tp&, _Compare); 
426 
427 // min_element 
428 
429#if __cplusplus >= 201103L 
430 template<typename _Tp> 
431 _GLIBCXX14_CONSTEXPR 
432 pair<const _Tp&, const _Tp&> 
433 minmax(const _Tp&, const _Tp&); 
434 
435 template<typename _Tp, typename _Compare> 
436 _GLIBCXX14_CONSTEXPR 
437 pair<const _Tp&, const _Tp&> 
438 minmax(const _Tp&, const _Tp&, _Compare); 
439 
440 template<typename _FIter> 
441 _GLIBCXX14_CONSTEXPR 
442 pair<_FIter, _FIter> 
443 minmax_element(_FIter, _FIter); 
444 
445 template<typename _FIter, typename _Compare> 
446 _GLIBCXX14_CONSTEXPR 
447 pair<_FIter, _FIter> 
448 minmax_element(_FIter, _FIter, _Compare); 
449 
450 template<typename _Tp> 
451 _GLIBCXX14_CONSTEXPR 
452 _Tp 
453 min(initializer_list<_Tp>); 
454 
455 template<typename _Tp, typename _Compare> 
456 _GLIBCXX14_CONSTEXPR 
457 _Tp 
458 min(initializer_list<_Tp>, _Compare); 
459 
460 template<typename _Tp> 
461 _GLIBCXX14_CONSTEXPR 
462 _Tp 
463 max(initializer_list<_Tp>); 
464 
465 template<typename _Tp, typename _Compare> 
466 _GLIBCXX14_CONSTEXPR 
467 _Tp 
468 max(initializer_list<_Tp>, _Compare); 
469 
470 template<typename _Tp> 
471 _GLIBCXX14_CONSTEXPR 
472 pair<_Tp, _Tp> 
473 minmax(initializer_list<_Tp>); 
474 
475 template<typename _Tp, typename _Compare> 
476 _GLIBCXX14_CONSTEXPR 
477 pair<_Tp, _Tp> 
478 minmax(initializer_list<_Tp>, _Compare); 
479#endif 
480 
481 // mismatch 
482 
483 template<typename _BIter> 
484 _GLIBCXX20_CONSTEXPR 
485 bool 
486 next_permutation(_BIter, _BIter); 
487 
488 template<typename _BIter, typename _Compare> 
489 _GLIBCXX20_CONSTEXPR 
490 bool 
491 next_permutation(_BIter, _BIter, _Compare); 
492 
493#if __cplusplus >= 201103L 
494 template<typename _IIter, typename _Predicate> 
495 _GLIBCXX20_CONSTEXPR 
496 bool 
497 none_of(_IIter, _IIter, _Predicate); 
498#endif 
499 
500 // nth_element 
501 // partial_sort 
502 
503 template<typename _IIter, typename _RAIter> 
504 _GLIBCXX20_CONSTEXPR 
505 _RAIter 
506 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); 
507 
508 template<typename _IIter, typename _RAIter, typename _Compare> 
509 _GLIBCXX20_CONSTEXPR 
510 _RAIter 
511 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); 
512 
513 // partition 
514 
515#if __cplusplus >= 201103L 
516 template<typename _IIter, typename _OIter1, 
517 typename _OIter2, typename _Predicate> 
518 _GLIBCXX20_CONSTEXPR 
519 pair<_OIter1, _OIter2> 
520 partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); 
521 
522 template<typename _FIter, typename _Predicate> 
523 _GLIBCXX20_CONSTEXPR 
524 _FIter 
525 partition_point(_FIter, _FIter, _Predicate); 
526#endif 
527 
528 template<typename _RAIter> 
529 _GLIBCXX20_CONSTEXPR 
530 void 
531 pop_heap(_RAIter, _RAIter); 
532 
533 template<typename _RAIter, typename _Compare> 
534 _GLIBCXX20_CONSTEXPR 
535 void 
536 pop_heap(_RAIter, _RAIter, _Compare); 
537 
538 template<typename _BIter> 
539 _GLIBCXX20_CONSTEXPR 
540 bool 
541 prev_permutation(_BIter, _BIter); 
542 
543 template<typename _BIter, typename _Compare> 
544 _GLIBCXX20_CONSTEXPR 
545 bool 
546 prev_permutation(_BIter, _BIter, _Compare); 
547 
548 template<typename _RAIter> 
549 _GLIBCXX20_CONSTEXPR 
550 void 
551 push_heap(_RAIter, _RAIter); 
552 
553 template<typename _RAIter, typename _Compare> 
554 _GLIBCXX20_CONSTEXPR 
555 void 
556 push_heap(_RAIter, _RAIter, _Compare); 
557 
558 // random_shuffle 
559 
560 template<typename _FIter, typename _Tp> 
561 _GLIBCXX20_CONSTEXPR 
562 _FIter 
563 remove(_FIter, _FIter, const _Tp&); 
564 
565 template<typename _FIter, typename _Predicate> 
566 _GLIBCXX20_CONSTEXPR 
567 _FIter 
568 remove_if(_FIter, _FIter, _Predicate); 
569 
570 template<typename _IIter, typename _OIter, typename _Tp> 
571 _GLIBCXX20_CONSTEXPR 
572 _OIter 
573 remove_copy(_IIter, _IIter, _OIter, const _Tp&); 
574 
575 template<typename _IIter, typename _OIter, typename _Predicate> 
576 _GLIBCXX20_CONSTEXPR 
577 _OIter 
578 remove_copy_if(_IIter, _IIter, _OIter, _Predicate); 
579 
580 // replace 
581 
582 template<typename _IIter, typename _OIter, typename _Tp> 
583 _GLIBCXX20_CONSTEXPR 
584 _OIter 
585 replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); 
586 
587 template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp> 
588 _GLIBCXX20_CONSTEXPR 
589 _OIter 
590 replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); 
591 
592 // replace_if 
593 
594 template<typename _BIter> 
595 _GLIBCXX20_CONSTEXPR 
596 void 
597 reverse(_BIter, _BIter); 
598 
599 template<typename _BIter, typename _OIter> 
600 _GLIBCXX20_CONSTEXPR 
601 _OIter 
602 reverse_copy(_BIter, _BIter, _OIter); 
603 
604 inline namespace _V2 
605 { 
606 template<typename _FIter> 
607 _GLIBCXX20_CONSTEXPR 
608 _FIter 
609 rotate(_FIter, _FIter, _FIter); 
610 } 
611 
612 template<typename _FIter, typename _OIter> 
613 _GLIBCXX20_CONSTEXPR 
614 _OIter 
615 rotate_copy(_FIter, _FIter, _FIter, _OIter); 
616 
617 // search 
618 // search_n 
619 // set_difference 
620 // set_intersection 
621 // set_symmetric_difference 
622 // set_union 
623 
624#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 
625 template<typename _RAIter, typename _UGenerator> 
626 void 
627 shuffle(_RAIter, _RAIter, _UGenerator&&); 
628#endif 
629 
630 template<typename _RAIter> 
631 _GLIBCXX20_CONSTEXPR 
632 void 
633 sort_heap(_RAIter, _RAIter); 
634 
635 template<typename _RAIter, typename _Compare> 
636 _GLIBCXX20_CONSTEXPR 
637 void 
638 sort_heap(_RAIter, _RAIter, _Compare); 
639 
640 template<typename _BIter, typename _Predicate> 
641 _BIter 
642 stable_partition(_BIter, _BIter, _Predicate); 
643 
644#if __cplusplus < 201103L 
645 // For C++11 swap() is declared in <type_traits>. 
646 
647 template<typename _Tp, size_t _Nm> 
648 _GLIBCXX20_CONSTEXPR 
649 inline void 
650 swap(_Tp& __a, _Tp& __b); 
651 
652 template<typename _Tp, size_t _Nm> 
653 _GLIBCXX20_CONSTEXPR 
654 inline void 
655 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]); 
656#endif 
657 
658 template<typename _FIter1, typename _FIter2> 
659 _GLIBCXX20_CONSTEXPR 
660 _FIter2 
661 swap_ranges(_FIter1, _FIter1, _FIter2); 
662 
663 // transform 
664 
665 template<typename _FIter> 
666 _GLIBCXX20_CONSTEXPR 
667 _FIter 
668 unique(_FIter, _FIter); 
669 
670 template<typename _FIter, typename _BinaryPredicate> 
671 _GLIBCXX20_CONSTEXPR 
672 _FIter 
673 unique(_FIter, _FIter, _BinaryPredicate); 
674 
675 // unique_copy 
676 
677 template<typename _FIter, typename _Tp> 
678 _GLIBCXX20_CONSTEXPR 
679 _FIter 
680 upper_bound(_FIter, _FIter, const _Tp&); 
681 
682 template<typename _FIter, typename _Tp, typename _Compare> 
683 _GLIBCXX20_CONSTEXPR 
684 _FIter 
685 upper_bound(_FIter, _FIter, const _Tp&, _Compare); 
686 
687_GLIBCXX_BEGIN_NAMESPACE_ALGO 
688 
689 template<typename _FIter> 
690 _GLIBCXX20_CONSTEXPR 
691 _FIter 
692 adjacent_find(_FIter, _FIter); 
693 
694 template<typename _FIter, typename _BinaryPredicate> 
695 _GLIBCXX20_CONSTEXPR 
696 _FIter 
697 adjacent_find(_FIter, _FIter, _BinaryPredicate); 
698 
699 template<typename _IIter, typename _Tp> 
700 _GLIBCXX20_CONSTEXPR 
701 typename iterator_traits<_IIter>::difference_type 
702 count(_IIter, _IIter, const _Tp&); 
703 
704 template<typename _IIter, typename _Predicate> 
705 _GLIBCXX20_CONSTEXPR 
706 typename iterator_traits<_IIter>::difference_type 
707 count_if(_IIter, _IIter, _Predicate); 
708 
709 template<typename _IIter1, typename _IIter2> 
710 _GLIBCXX20_CONSTEXPR 
711 bool 
712 equal(_IIter1, _IIter1, _IIter2); 
713 
714 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 
715 _GLIBCXX20_CONSTEXPR 
716 bool 
717 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 
718 
719 template<typename _IIter, typename _Tp> 
720 _GLIBCXX20_CONSTEXPR 
721 _IIter 
722 find(_IIter, _IIter, const _Tp&); 
723 
724 template<typename _FIter1, typename _FIter2> 
725 _GLIBCXX20_CONSTEXPR 
726 _FIter1 
727 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); 
728 
729 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 
730 _GLIBCXX20_CONSTEXPR 
731 _FIter1 
732 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 
733 
734 template<typename _IIter, typename _Predicate> 
735 _GLIBCXX20_CONSTEXPR 
736 _IIter 
737 find_if(_IIter, _IIter, _Predicate); 
738 
739 template<typename _IIter, typename _Funct> 
740 _GLIBCXX20_CONSTEXPR 
741 _Funct 
742 for_each(_IIter, _IIter, _Funct); 
743 
744 template<typename _FIter, typename _Generator> 
745 _GLIBCXX20_CONSTEXPR 
746 void 
747 generate(_FIter, _FIter, _Generator); 
748 
749 template<typename _OIter, typename _Size, typename _Generator> 
750 _GLIBCXX20_CONSTEXPR 
751 _OIter 
752 generate_n(_OIter, _Size, _Generator); 
753 
754 template<typename _IIter1, typename _IIter2> 
755 _GLIBCXX20_CONSTEXPR 
756 bool 
757 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); 
758 
759 template<typename _IIter1, typename _IIter2, typename _Compare> 
760 _GLIBCXX20_CONSTEXPR 
761 bool 
762 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 
763 
764 template<typename _FIter> 
765 _GLIBCXX14_CONSTEXPR 
766 _FIter 
767 max_element(_FIter, _FIter); 
768 
769 template<typename _FIter, typename _Compare> 
770 _GLIBCXX14_CONSTEXPR 
771 _FIter 
772 max_element(_FIter, _FIter, _Compare); 
773 
774 template<typename _IIter1, typename _IIter2, typename _OIter> 
775 _GLIBCXX20_CONSTEXPR 
776 _OIter 
777 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
778 
779 template<typename _IIter1, typename _IIter2, typename _OIter, 
780 typename _Compare> 
781 _GLIBCXX20_CONSTEXPR 
782 _OIter 
783 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
784 
785 template<typename _FIter> 
786 _GLIBCXX14_CONSTEXPR 
787 _FIter 
788 min_element(_FIter, _FIter); 
789 
790 template<typename _FIter, typename _Compare> 
791 _GLIBCXX14_CONSTEXPR 
792 _FIter 
793 min_element(_FIter, _FIter, _Compare); 
794 
795 template<typename _IIter1, typename _IIter2> 
796 _GLIBCXX20_CONSTEXPR 
797 pair<_IIter1, _IIter2> 
798 mismatch(_IIter1, _IIter1, _IIter2); 
799 
800 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 
801 _GLIBCXX20_CONSTEXPR 
802 pair<_IIter1, _IIter2> 
803 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 
804 
805 template<typename _RAIter> 
806 _GLIBCXX20_CONSTEXPR 
807 void 
808 nth_element(_RAIter, _RAIter, _RAIter); 
809 
810 template<typename _RAIter, typename _Compare> 
811 _GLIBCXX20_CONSTEXPR 
812 void 
813 nth_element(_RAIter, _RAIter, _RAIter, _Compare); 
814 
815 template<typename _RAIter> 
816 _GLIBCXX20_CONSTEXPR 
817 void 
818 partial_sort(_RAIter, _RAIter, _RAIter); 
819 
820 template<typename _RAIter, typename _Compare> 
821 _GLIBCXX20_CONSTEXPR 
822 void 
823 partial_sort(_RAIter, _RAIter, _RAIter, _Compare); 
824 
825 template<typename _BIter, typename _Predicate> 
826 _GLIBCXX20_CONSTEXPR 
827 _BIter 
828 partition(_BIter, _BIter, _Predicate); 
829 
830 template<typename _RAIter> 
831 void 
832 random_shuffle(_RAIter, _RAIter); 
833 
834 template<typename _RAIter, typename _Generator> 
835 void 
836 random_shuffle(_RAIter, _RAIter, 
837#if __cplusplus >= 201103L 
838 _Generator&&); 
839#else 
840 _Generator&); 
841#endif 
842 
843 template<typename _FIter, typename _Tp> 
844 _GLIBCXX20_CONSTEXPR 
845 void 
846 replace(_FIter, _FIter, const _Tp&, const _Tp&); 
847 
848 template<typename _FIter, typename _Predicate, typename _Tp> 
849 _GLIBCXX20_CONSTEXPR 
850 void 
851 replace_if(_FIter, _FIter, _Predicate, const _Tp&); 
852 
853 template<typename _FIter1, typename _FIter2> 
854 _GLIBCXX20_CONSTEXPR 
855 _FIter1 
856 search(_FIter1, _FIter1, _FIter2, _FIter2); 
857 
858 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 
859 _GLIBCXX20_CONSTEXPR 
860 _FIter1 
861 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 
862 
863 template<typename _FIter, typename _Size, typename _Tp> 
864 _GLIBCXX20_CONSTEXPR 
865 _FIter 
866 search_n(_FIter, _FIter, _Size, const _Tp&); 
867 
868 template<typename _FIter, typename _Size, typename _Tp, 
869 typename _BinaryPredicate> 
870 _GLIBCXX20_CONSTEXPR 
871 _FIter 
872 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); 
873 
874 template<typename _IIter1, typename _IIter2, typename _OIter> 
875 _GLIBCXX20_CONSTEXPR 
876 _OIter 
877 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
878 
879 template<typename _IIter1, typename _IIter2, typename _OIter, 
880 typename _Compare> 
881 _GLIBCXX20_CONSTEXPR 
882 _OIter 
883 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
884 
885 template<typename _IIter1, typename _IIter2, typename _OIter> 
886 _GLIBCXX20_CONSTEXPR 
887 _OIter 
888 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
889 
890 template<typename _IIter1, typename _IIter2, typename _OIter, 
891 typename _Compare> 
892 _GLIBCXX20_CONSTEXPR 
893 _OIter 
894 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
895 
896 template<typename _IIter1, typename _IIter2, typename _OIter> 
897 _GLIBCXX20_CONSTEXPR 
898 _OIter 
899 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
900 
901 template<typename _IIter1, typename _IIter2, typename _OIter, 
902 typename _Compare> 
903 _GLIBCXX20_CONSTEXPR 
904 _OIter 
905 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
906 _OIter, _Compare); 
907 
908 template<typename _IIter1, typename _IIter2, typename _OIter> 
909 _GLIBCXX20_CONSTEXPR 
910 _OIter 
911 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
912 
913 template<typename _IIter1, typename _IIter2, typename _OIter, 
914 typename _Compare> 
915 _GLIBCXX20_CONSTEXPR 
916 _OIter 
917 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
918 
919 template<typename _RAIter> 
920 _GLIBCXX20_CONSTEXPR 
921 void 
922 sort(_RAIter, _RAIter); 
923 
924 template<typename _RAIter, typename _Compare> 
925 _GLIBCXX20_CONSTEXPR 
926 void 
927 sort(_RAIter, _RAIter, _Compare); 
928 
929 template<typename _RAIter> 
930 void 
931 stable_sort(_RAIter, _RAIter); 
932 
933 template<typename _RAIter, typename _Compare> 
934 void 
935 stable_sort(_RAIter, _RAIter, _Compare); 
936 
937 template<typename _IIter, typename _OIter, typename _UnaryOperation> 
938 _GLIBCXX20_CONSTEXPR 
939 _OIter 
940 transform(_IIter, _IIter, _OIter, _UnaryOperation); 
941 
942 template<typename _IIter1, typename _IIter2, typename _OIter, 
943 typename _BinaryOperation> 
944 _GLIBCXX20_CONSTEXPR 
945 _OIter 
946 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); 
947 
948 template<typename _IIter, typename _OIter> 
949 _GLIBCXX20_CONSTEXPR 
950 _OIter 
951 unique_copy(_IIter, _IIter, _OIter); 
952 
953 template<typename _IIter, typename _OIter, typename _BinaryPredicate> 
954 _GLIBCXX20_CONSTEXPR 
955 _OIter 
956 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); 
957 
958_GLIBCXX_END_NAMESPACE_ALGO 
959_GLIBCXX_END_NAMESPACE_VERSION 
960} // namespace std 
961 
962#ifdef _GLIBCXX_PARALLEL 
963# include <parallel/algorithmfwd.h> 
964#endif 
965 
966#endif 
967 
968