1// <algorithm> Forward declarations -*- C++ -*- 
2 
3// Copyright (C) 2007-2019 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 >= 201103L 
195 template<typename _IIter, typename _Predicate> 
196 bool 
197 all_of(_IIter, _IIter, _Predicate); 
198 
199 template<typename _IIter, typename _Predicate> 
200 bool 
201 any_of(_IIter, _IIter, _Predicate); 
202#endif 
203 
204 template<typename _FIter, typename _Tp> 
205 bool 
206 binary_search(_FIter, _FIter, const _Tp&); 
207 
208 template<typename _FIter, typename _Tp, typename _Compare> 
209 bool 
210 binary_search(_FIter, _FIter, const _Tp&, _Compare); 
211 
212#if __cplusplus > 201402L 
213 template<typename _Tp> 
214 _GLIBCXX14_CONSTEXPR 
215 const _Tp& 
216 clamp(const _Tp&, const _Tp&, const _Tp&); 
217 
218 template<typename _Tp, typename _Compare> 
219 _GLIBCXX14_CONSTEXPR 
220 const _Tp& 
221 clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); 
222#endif 
223 
224 template<typename _IIter, typename _OIter> 
225 _OIter 
226 copy(_IIter, _IIter, _OIter); 
227 
228 template<typename _BIter1, typename _BIter2> 
229 _BIter2 
230 copy_backward(_BIter1, _BIter1, _BIter2); 
231 
232#if __cplusplus >= 201103L 
233 template<typename _IIter, typename _OIter, typename _Predicate> 
234 _OIter 
235 copy_if(_IIter, _IIter, _OIter, _Predicate); 
236 
237 template<typename _IIter, typename _Size, typename _OIter> 
238 _OIter 
239 copy_n(_IIter, _Size, _OIter); 
240#endif 
241 
242 // count 
243 // count_if 
244 
245 template<typename _FIter, typename _Tp> 
246 pair<_FIter, _FIter> 
247 equal_range(_FIter, _FIter, const _Tp&); 
248 
249 template<typename _FIter, typename _Tp, typename _Compare> 
250 pair<_FIter, _FIter> 
251 equal_range(_FIter, _FIter, const _Tp&, _Compare); 
252 
253 template<typename _FIter, typename _Tp> 
254 void 
255 fill(_FIter, _FIter, const _Tp&); 
256 
257 template<typename _OIter, typename _Size, typename _Tp> 
258 _OIter 
259 fill_n(_OIter, _Size, const _Tp&); 
260 
261 // find 
262 
263 template<typename _FIter1, typename _FIter2> 
264 _FIter1 
265 find_end(_FIter1, _FIter1, _FIter2, _FIter2); 
266 
267 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 
268 _FIter1 
269 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 
270 
271 // find_first_of 
272 // find_if 
273 
274#if __cplusplus >= 201103L 
275 template<typename _IIter, typename _Predicate> 
276 _IIter 
277 find_if_not(_IIter, _IIter, _Predicate); 
278#endif 
279 
280 // for_each 
281 // generate 
282 // generate_n 
283 
284 template<typename _IIter1, typename _IIter2> 
285 bool 
286 includes(_IIter1, _IIter1, _IIter2, _IIter2); 
287 
288 template<typename _IIter1, typename _IIter2, typename _Compare> 
289 bool 
290 includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 
291 
292 template<typename _BIter> 
293 void 
294 inplace_merge(_BIter, _BIter, _BIter); 
295 
296 template<typename _BIter, typename _Compare> 
297 void 
298 inplace_merge(_BIter, _BIter, _BIter, _Compare); 
299 
300#if __cplusplus >= 201103L 
301 template<typename _RAIter> 
302 bool 
303 is_heap(_RAIter, _RAIter); 
304 
305 template<typename _RAIter, typename _Compare> 
306 bool 
307 is_heap(_RAIter, _RAIter, _Compare); 
308 
309 template<typename _RAIter> 
310 _RAIter 
311 is_heap_until(_RAIter, _RAIter); 
312 
313 template<typename _RAIter, typename _Compare> 
314 _RAIter 
315 is_heap_until(_RAIter, _RAIter, _Compare); 
316 
317 template<typename _IIter, typename _Predicate> 
318 bool 
319 is_partitioned(_IIter, _IIter, _Predicate); 
320 
321 template<typename _FIter1, typename _FIter2> 
322 bool 
323 is_permutation(_FIter1, _FIter1, _FIter2); 
324 
325 template<typename _FIter1, typename _FIter2, 
326 typename _BinaryPredicate> 
327 bool 
328 is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); 
329 
330 template<typename _FIter> 
331 bool 
332 is_sorted(_FIter, _FIter); 
333 
334 template<typename _FIter, typename _Compare> 
335 bool 
336 is_sorted(_FIter, _FIter, _Compare); 
337 
338 template<typename _FIter> 
339 _FIter 
340 is_sorted_until(_FIter, _FIter); 
341 
342 template<typename _FIter, typename _Compare> 
343 _FIter 
344 is_sorted_until(_FIter, _FIter, _Compare); 
345#endif 
346 
347 template<typename _FIter1, typename _FIter2> 
348 void 
349 iter_swap(_FIter1, _FIter2); 
350 
351 template<typename _FIter, typename _Tp> 
352 _FIter 
353 lower_bound(_FIter, _FIter, const _Tp&); 
354 
355 template<typename _FIter, typename _Tp, typename _Compare> 
356 _FIter 
357 lower_bound(_FIter, _FIter, const _Tp&, _Compare); 
358 
359 template<typename _RAIter> 
360 void 
361 make_heap(_RAIter, _RAIter); 
362 
363 template<typename _RAIter, typename _Compare> 
364 void 
365 make_heap(_RAIter, _RAIter, _Compare); 
366 
367 template<typename _Tp> 
368 _GLIBCXX14_CONSTEXPR 
369 const _Tp& 
370 max(const _Tp&, const _Tp&); 
371 
372 template<typename _Tp, typename _Compare> 
373 _GLIBCXX14_CONSTEXPR 
374 const _Tp& 
375 max(const _Tp&, const _Tp&, _Compare); 
376 
377 // max_element 
378 // merge 
379 
380 template<typename _Tp> 
381 _GLIBCXX14_CONSTEXPR 
382 const _Tp& 
383 min(const _Tp&, const _Tp&); 
384 
385 template<typename _Tp, typename _Compare> 
386 _GLIBCXX14_CONSTEXPR 
387 const _Tp& 
388 min(const _Tp&, const _Tp&, _Compare); 
389 
390 // min_element 
391 
392#if __cplusplus >= 201103L 
393 template<typename _Tp> 
394 _GLIBCXX14_CONSTEXPR 
395 pair<const _Tp&, const _Tp&> 
396 minmax(const _Tp&, const _Tp&); 
397 
398 template<typename _Tp, typename _Compare> 
399 _GLIBCXX14_CONSTEXPR 
400 pair<const _Tp&, const _Tp&> 
401 minmax(const _Tp&, const _Tp&, _Compare); 
402 
403 template<typename _FIter> 
404 _GLIBCXX14_CONSTEXPR 
405 pair<_FIter, _FIter> 
406 minmax_element(_FIter, _FIter); 
407 
408 template<typename _FIter, typename _Compare> 
409 _GLIBCXX14_CONSTEXPR 
410 pair<_FIter, _FIter> 
411 minmax_element(_FIter, _FIter, _Compare); 
412 
413 template<typename _Tp> 
414 _GLIBCXX14_CONSTEXPR 
415 _Tp 
416 min(initializer_list<_Tp>); 
417 
418 template<typename _Tp, typename _Compare> 
419 _GLIBCXX14_CONSTEXPR 
420 _Tp 
421 min(initializer_list<_Tp>, _Compare); 
422 
423 template<typename _Tp> 
424 _GLIBCXX14_CONSTEXPR 
425 _Tp 
426 max(initializer_list<_Tp>); 
427 
428 template<typename _Tp, typename _Compare> 
429 _GLIBCXX14_CONSTEXPR 
430 _Tp 
431 max(initializer_list<_Tp>, _Compare); 
432 
433 template<typename _Tp> 
434 _GLIBCXX14_CONSTEXPR 
435 pair<_Tp, _Tp> 
436 minmax(initializer_list<_Tp>); 
437 
438 template<typename _Tp, typename _Compare> 
439 _GLIBCXX14_CONSTEXPR 
440 pair<_Tp, _Tp> 
441 minmax(initializer_list<_Tp>, _Compare); 
442#endif 
443 
444 // mismatch 
445 
446 template<typename _BIter> 
447 bool 
448 next_permutation(_BIter, _BIter); 
449 
450 template<typename _BIter, typename _Compare> 
451 bool 
452 next_permutation(_BIter, _BIter, _Compare); 
453 
454#if __cplusplus >= 201103L 
455 template<typename _IIter, typename _Predicate> 
456 bool 
457 none_of(_IIter, _IIter, _Predicate); 
458#endif 
459 
460 // nth_element 
461 // partial_sort 
462 
463 template<typename _IIter, typename _RAIter> 
464 _RAIter 
465 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); 
466 
467 template<typename _IIter, typename _RAIter, typename _Compare> 
468 _RAIter 
469 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); 
470 
471 // partition 
472 
473#if __cplusplus >= 201103L 
474 template<typename _IIter, typename _OIter1, 
475 typename _OIter2, typename _Predicate> 
476 pair<_OIter1, _OIter2> 
477 partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); 
478 
479 template<typename _FIter, typename _Predicate> 
480 _FIter 
481 partition_point(_FIter, _FIter, _Predicate); 
482#endif 
483 
484 template<typename _RAIter> 
485 void 
486 pop_heap(_RAIter, _RAIter); 
487 
488 template<typename _RAIter, typename _Compare> 
489 void 
490 pop_heap(_RAIter, _RAIter, _Compare); 
491 
492 template<typename _BIter> 
493 bool 
494 prev_permutation(_BIter, _BIter); 
495 
496 template<typename _BIter, typename _Compare> 
497 bool 
498 prev_permutation(_BIter, _BIter, _Compare); 
499 
500 template<typename _RAIter> 
501 void 
502 push_heap(_RAIter, _RAIter); 
503 
504 template<typename _RAIter, typename _Compare> 
505 void 
506 push_heap(_RAIter, _RAIter, _Compare); 
507 
508 // random_shuffle 
509 
510 template<typename _FIter, typename _Tp> 
511 _FIter 
512 remove(_FIter, _FIter, const _Tp&); 
513 
514 template<typename _FIter, typename _Predicate> 
515 _FIter 
516 remove_if(_FIter, _FIter, _Predicate); 
517 
518 template<typename _IIter, typename _OIter, typename _Tp> 
519 _OIter 
520 remove_copy(_IIter, _IIter, _OIter, const _Tp&); 
521 
522 template<typename _IIter, typename _OIter, typename _Predicate> 
523 _OIter 
524 remove_copy_if(_IIter, _IIter, _OIter, _Predicate); 
525 
526 // replace 
527 
528 template<typename _IIter, typename _OIter, typename _Tp> 
529 _OIter 
530 replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); 
531 
532 template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp> 
533 _OIter 
534 replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); 
535 
536 // replace_if 
537 
538 template<typename _BIter> 
539 void 
540 reverse(_BIter, _BIter); 
541 
542 template<typename _BIter, typename _OIter> 
543 _OIter 
544 reverse_copy(_BIter, _BIter, _OIter); 
545 
546 inline namespace _V2 
547 { 
548 template<typename _FIter> 
549 _FIter 
550 rotate(_FIter, _FIter, _FIter); 
551 } 
552 
553 template<typename _FIter, typename _OIter> 
554 _OIter 
555 rotate_copy(_FIter, _FIter, _FIter, _OIter); 
556 
557 // search 
558 // search_n 
559 // set_difference 
560 // set_intersection 
561 // set_symmetric_difference 
562 // set_union 
563 
564#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 
565 template<typename _RAIter, typename _UGenerator> 
566 void 
567 shuffle(_RAIter, _RAIter, _UGenerator&&); 
568#endif 
569 
570 template<typename _RAIter> 
571 void 
572 sort_heap(_RAIter, _RAIter); 
573 
574 template<typename _RAIter, typename _Compare> 
575 void 
576 sort_heap(_RAIter, _RAIter, _Compare); 
577 
578 template<typename _BIter, typename _Predicate> 
579 _BIter 
580 stable_partition(_BIter, _BIter, _Predicate); 
581 
582#if __cplusplus < 201103L 
583 // For C++11 swap() is declared in <type_traits>. 
584 
585 template<typename _Tp, size_t _Nm> 
586 inline void 
587 swap(_Tp& __a, _Tp& __b); 
588 
589 template<typename _Tp, size_t _Nm> 
590 inline void 
591 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]); 
592#endif 
593 
594 template<typename _FIter1, typename _FIter2> 
595 _FIter2 
596 swap_ranges(_FIter1, _FIter1, _FIter2); 
597 
598 // transform 
599 
600 template<typename _FIter> 
601 _FIter 
602 unique(_FIter, _FIter); 
603 
604 template<typename _FIter, typename _BinaryPredicate> 
605 _FIter 
606 unique(_FIter, _FIter, _BinaryPredicate); 
607 
608 // unique_copy 
609 
610 template<typename _FIter, typename _Tp> 
611 _FIter 
612 upper_bound(_FIter, _FIter, const _Tp&); 
613 
614 template<typename _FIter, typename _Tp, typename _Compare> 
615 _FIter 
616 upper_bound(_FIter, _FIter, const _Tp&, _Compare); 
617 
618_GLIBCXX_BEGIN_NAMESPACE_ALGO 
619 
620 template<typename _FIter> 
621 _FIter 
622 adjacent_find(_FIter, _FIter); 
623 
624 template<typename _FIter, typename _BinaryPredicate> 
625 _FIter 
626 adjacent_find(_FIter, _FIter, _BinaryPredicate); 
627 
628 template<typename _IIter, typename _Tp> 
629 typename iterator_traits<_IIter>::difference_type 
630 count(_IIter, _IIter, const _Tp&); 
631 
632 template<typename _IIter, typename _Predicate> 
633 typename iterator_traits<_IIter>::difference_type 
634 count_if(_IIter, _IIter, _Predicate); 
635 
636 template<typename _IIter1, typename _IIter2> 
637 bool 
638 equal(_IIter1, _IIter1, _IIter2); 
639 
640 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 
641 bool 
642 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 
643 
644 template<typename _IIter, typename _Tp> 
645 _IIter 
646 find(_IIter, _IIter, const _Tp&); 
647 
648 template<typename _FIter1, typename _FIter2> 
649 _FIter1 
650 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); 
651 
652 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 
653 _FIter1 
654 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 
655 
656 template<typename _IIter, typename _Predicate> 
657 _IIter 
658 find_if(_IIter, _IIter, _Predicate); 
659 
660 template<typename _IIter, typename _Funct> 
661 _Funct 
662 for_each(_IIter, _IIter, _Funct); 
663 
664 template<typename _FIter, typename _Generator> 
665 void 
666 generate(_FIter, _FIter, _Generator); 
667 
668 template<typename _OIter, typename _Size, typename _Generator> 
669 _OIter 
670 generate_n(_OIter, _Size, _Generator); 
671 
672 template<typename _IIter1, typename _IIter2> 
673 bool 
674 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); 
675 
676 template<typename _IIter1, typename _IIter2, typename _Compare> 
677 bool 
678 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 
679 
680 template<typename _FIter> 
681 _GLIBCXX14_CONSTEXPR 
682 _FIter 
683 max_element(_FIter, _FIter); 
684 
685 template<typename _FIter, typename _Compare> 
686 _GLIBCXX14_CONSTEXPR 
687 _FIter 
688 max_element(_FIter, _FIter, _Compare); 
689 
690 template<typename _IIter1, typename _IIter2, typename _OIter> 
691 _OIter 
692 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
693 
694 template<typename _IIter1, typename _IIter2, typename _OIter, 
695 typename _Compare> 
696 _OIter 
697 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
698 
699 template<typename _FIter> 
700 _GLIBCXX14_CONSTEXPR 
701 _FIter 
702 min_element(_FIter, _FIter); 
703 
704 template<typename _FIter, typename _Compare> 
705 _GLIBCXX14_CONSTEXPR 
706 _FIter 
707 min_element(_FIter, _FIter, _Compare); 
708 
709 template<typename _IIter1, typename _IIter2> 
710 pair<_IIter1, _IIter2> 
711 mismatch(_IIter1, _IIter1, _IIter2); 
712 
713 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 
714 pair<_IIter1, _IIter2> 
715 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 
716 
717 template<typename _RAIter> 
718 void 
719 nth_element(_RAIter, _RAIter, _RAIter); 
720 
721 template<typename _RAIter, typename _Compare> 
722 void 
723 nth_element(_RAIter, _RAIter, _RAIter, _Compare); 
724 
725 template<typename _RAIter> 
726 void 
727 partial_sort(_RAIter, _RAIter, _RAIter); 
728 
729 template<typename _RAIter, typename _Compare> 
730 void 
731 partial_sort(_RAIter, _RAIter, _RAIter, _Compare); 
732 
733 template<typename _BIter, typename _Predicate> 
734 _BIter 
735 partition(_BIter, _BIter, _Predicate); 
736 
737 template<typename _RAIter> 
738 void 
739 random_shuffle(_RAIter, _RAIter); 
740 
741 template<typename _RAIter, typename _Generator> 
742 void 
743 random_shuffle(_RAIter, _RAIter, 
744#if __cplusplus >= 201103L 
745 _Generator&&); 
746#else 
747 _Generator&); 
748#endif 
749 
750 template<typename _FIter, typename _Tp> 
751 void 
752 replace(_FIter, _FIter, const _Tp&, const _Tp&); 
753 
754 template<typename _FIter, typename _Predicate, typename _Tp> 
755 void 
756 replace_if(_FIter, _FIter, _Predicate, const _Tp&); 
757 
758 template<typename _FIter1, typename _FIter2> 
759 _FIter1 
760 search(_FIter1, _FIter1, _FIter2, _FIter2); 
761 
762 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 
763 _FIter1 
764 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 
765 
766 template<typename _FIter, typename _Size, typename _Tp> 
767 _FIter 
768 search_n(_FIter, _FIter, _Size, const _Tp&); 
769 
770 template<typename _FIter, typename _Size, typename _Tp, 
771 typename _BinaryPredicate> 
772 _FIter 
773 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); 
774 
775 template<typename _IIter1, typename _IIter2, typename _OIter> 
776 _OIter 
777 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
778 
779 template<typename _IIter1, typename _IIter2, typename _OIter, 
780 typename _Compare> 
781 _OIter 
782 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
783 
784 template<typename _IIter1, typename _IIter2, typename _OIter> 
785 _OIter 
786 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
787 
788 template<typename _IIter1, typename _IIter2, typename _OIter, 
789 typename _Compare> 
790 _OIter 
791 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
792 
793 template<typename _IIter1, typename _IIter2, typename _OIter> 
794 _OIter 
795 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
796 
797 template<typename _IIter1, typename _IIter2, typename _OIter, 
798 typename _Compare> 
799 _OIter 
800 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
801 _OIter, _Compare); 
802 
803 template<typename _IIter1, typename _IIter2, typename _OIter> 
804 _OIter 
805 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 
806 
807 template<typename _IIter1, typename _IIter2, typename _OIter, 
808 typename _Compare> 
809 _OIter 
810 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 
811 
812 template<typename _RAIter> 
813 void 
814 sort(_RAIter, _RAIter); 
815 
816 template<typename _RAIter, typename _Compare> 
817 void 
818 sort(_RAIter, _RAIter, _Compare); 
819 
820 template<typename _RAIter> 
821 void 
822 stable_sort(_RAIter, _RAIter); 
823 
824 template<typename _RAIter, typename _Compare> 
825 void 
826 stable_sort(_RAIter, _RAIter, _Compare); 
827 
828 template<typename _IIter, typename _OIter, typename _UnaryOperation> 
829 _OIter 
830 transform(_IIter, _IIter, _OIter, _UnaryOperation); 
831 
832 template<typename _IIter1, typename _IIter2, typename _OIter, 
833 typename _BinaryOperation> 
834 _OIter 
835 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); 
836 
837 template<typename _IIter, typename _OIter> 
838 _OIter 
839 unique_copy(_IIter, _IIter, _OIter); 
840 
841 template<typename _IIter, typename _OIter, typename _BinaryPredicate> 
842 _OIter 
843 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); 
844 
845_GLIBCXX_END_NAMESPACE_ALGO 
846_GLIBCXX_END_NAMESPACE_VERSION 
847} // namespace std 
848 
849#ifdef _GLIBCXX_PARALLEL 
850# include <parallel/algorithmfwd.h> 
851#endif 
852 
853#endif 
854 
855