1// <algorithm> Forward declarations -*- C++ -*-
2
3// Copyright (C) 2007-2015 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++0x)
49 any_of (C++0x)
50 binary_search
51 copy
52 copy_backward
53 copy_if (C++0x)
54 copy_n (C++0x)
55 count
56 count_if
57 equal
58 equal_range
59 fill
60 fill_n
61 find
62 find_end
63 find_first_of
64 find_if
65 find_if_not (C++0x)
66 for_each
67 generate
68 generate_n
69 includes
70 inplace_merge
71 is_heap (C++0x)
72 is_heap_until (C++0x)
73 is_partitioned (C++0x)
74 is_sorted (C++0x)
75 is_sorted_until (C++0x)
76 iter_swap
77 lexicographical_compare
78 lower_bound
79 make_heap
80 max
81 max_element
82 merge
83 min
84 min_element
85 minmax (C++0x)
86 minmax_element (C++0x)
87 mismatch
88 next_permutation
89 none_of (C++0x)
90 nth_element
91 partial_sort
92 partial_sort_copy
93 partition
94 partition_copy (C++0x)
95 partition_point (C++0x)
96 pop_heap
97 prev_permutation
98 push_heap
99 random_shuffle
100 remove
101 remove_copy
102 remove_copy_if
103 remove_if
104 replace
105 replace_copy
106 replace_copy_if
107 replace_if
108 reverse
109 reverse_copy
110 rotate
111 rotate_copy
112 search
113 search_n
114 set_difference
115 set_intersection
116 set_symmetric_difference
117 set_union
118 shuffle (C++0x)
119 sort
120 sort_heap
121 stable_partition
122 stable_sort
123 swap
124 swap_ranges
125 transform
126 unique
127 unique_copy
128 upper_bound
129 */
130
131 /**
132 * @defgroup algorithms Algorithms
133 *
134 * Components for performing algorithmic operations. Includes
135 * non-modifying sequence, modifying (mutating) sequence, sorting,
136 * searching, merge, partition, heap, set, minima, maxima, and
137 * permutation operations.
138 */
139
140 /**
141 * @defgroup mutating_algorithms Mutating
142 * @ingroup algorithms
143 */
144
145 /**
146 * @defgroup non_mutating_algorithms Non-Mutating
147 * @ingroup algorithms
148 */
149
150 /**
151 * @defgroup sorting_algorithms Sorting
152 * @ingroup algorithms
153 */
154
155 /**
156 * @defgroup set_algorithms Set Operation
157 * @ingroup sorting_algorithms
158 *
159 * These algorithms are common set operations performed on sequences
160 * that are already sorted. The number of comparisons will be
161 * linear.
162 */
163
164 /**
165 * @defgroup binary_search_algorithms Binary Search
166 * @ingroup sorting_algorithms
167 *
168 * These algorithms are variations of a classic binary search, and
169 * all assume that the sequence being searched is already sorted.
170 *
171 * The number of comparisons will be logarithmic (and as few as
172 * possible). The number of steps through the sequence will be
173 * logarithmic for random-access iterators (e.g., pointers), and
174 * linear otherwise.
175 *
176 * The LWG has passed Defect Report 270, which notes: <em>The
177 * proposed resolution reinterprets binary search. Instead of
178 * thinking about searching for a value in a sorted range, we view
179 * that as an important special case of a more general algorithm:
180 * searching for the partition point in a partitioned range. We
181 * also add a guarantee that the old wording did not: we ensure that
182 * the upper bound is no earlier than the lower bound, that the pair
183 * returned by equal_range is a valid range, and that the first part
184 * of that pair is the lower bound.</em>
185 *
186 * The actual effect of the first sentence is that a comparison
187 * functor passed by the user doesn't necessarily need to induce a
188 * strict weak ordering relation. Rather, it partitions the range.
189 */
190
191 // adjacent_find
192
193#if __cplusplus >= 201103L
194 template<typename _IIter, typename _Predicate>
195 bool
196 all_of(_IIter, _IIter, _Predicate);
197
198 template<typename _IIter, typename _Predicate>
199 bool
200 any_of(_IIter, _IIter, _Predicate);
201#endif
202
203 template<typename _FIter, typename _Tp>
204 bool
205 binary_search(_FIter, _FIter, const _Tp&);
206
207 template<typename _FIter, typename _Tp, typename _Compare>
208 bool
209 binary_search(_FIter, _FIter, const _Tp&, _Compare);
210
211 template<typename _IIter, typename _OIter>
212 _OIter
213 copy(_IIter, _IIter, _OIter);
214
215 template<typename _BIter1, typename _BIter2>
216 _BIter2
217 copy_backward(_BIter1, _BIter1, _BIter2);
218
219#if __cplusplus >= 201103L
220 template<typename _IIter, typename _OIter, typename _Predicate>
221 _OIter
222 copy_if(_IIter, _IIter, _OIter, _Predicate);
223
224 template<typename _IIter, typename _Size, typename _OIter>
225 _OIter
226 copy_n(_IIter, _Size, _OIter);
227#endif
228
229 // count
230 // count_if
231
232 template<typename _FIter, typename _Tp>
233 pair<_FIter, _FIter>
234 equal_range(_FIter, _FIter, const _Tp&);
235
236 template<typename _FIter, typename _Tp, typename _Compare>
237 pair<_FIter, _FIter>
238 equal_range(_FIter, _FIter, const _Tp&, _Compare);
239
240 template<typename _FIter, typename _Tp>
241 void
242 fill(_FIter, _FIter, const _Tp&);
243
244 template<typename _OIter, typename _Size, typename _Tp>
245 _OIter
246 fill_n(_OIter, _Size, const _Tp&);
247
248 // find
249
250 template<typename _FIter1, typename _FIter2>
251 _FIter1
252 find_end(_FIter1, _FIter1, _FIter2, _FIter2);
253
254 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
255 _FIter1
256 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
257
258 // find_first_of
259 // find_if
260
261#if __cplusplus >= 201103L
262 template<typename _IIter, typename _Predicate>
263 _IIter
264 find_if_not(_IIter, _IIter, _Predicate);
265#endif
266
267 // for_each
268 // generate
269 // generate_n
270
271 template<typename _IIter1, typename _IIter2>
272 bool
273 includes(_IIter1, _IIter1, _IIter2, _IIter2);
274
275 template<typename _IIter1, typename _IIter2, typename _Compare>
276 bool
277 includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
278
279 template<typename _BIter>
280 void
281 inplace_merge(_BIter, _BIter, _BIter);
282
283 template<typename _BIter, typename _Compare>
284 void
285 inplace_merge(_BIter, _BIter, _BIter, _Compare);
286
287#if __cplusplus >= 201103L
288 template<typename _RAIter>
289 bool
290 is_heap(_RAIter, _RAIter);
291
292 template<typename _RAIter, typename _Compare>
293 bool
294 is_heap(_RAIter, _RAIter, _Compare);
295
296 template<typename _RAIter>
297 _RAIter
298 is_heap_until(_RAIter, _RAIter);
299
300 template<typename _RAIter, typename _Compare>
301 _RAIter
302 is_heap_until(_RAIter, _RAIter, _Compare);
303
304 template<typename _IIter, typename _Predicate>
305 bool
306 is_partitioned(_IIter, _IIter, _Predicate);
307
308 template<typename _FIter1, typename _FIter2>
309 bool
310 is_permutation(_FIter1, _FIter1, _FIter2);
311
312 template<typename _FIter1, typename _FIter2,
313 typename _BinaryPredicate>
314 bool
315 is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
316
317 template<typename _FIter>
318 bool
319 is_sorted(_FIter, _FIter);
320
321 template<typename _FIter, typename _Compare>
322 bool
323 is_sorted(_FIter, _FIter, _Compare);
324
325 template<typename _FIter>
326 _FIter
327 is_sorted_until(_FIter, _FIter);
328
329 template<typename _FIter, typename _Compare>
330 _FIter
331 is_sorted_until(_FIter, _FIter, _Compare);
332#endif
333
334 template<typename _FIter1, typename _FIter2>
335 void
336 iter_swap(_FIter1, _FIter2);
337
338 template<typename _FIter, typename _Tp>
339 _FIter
340 lower_bound(_FIter, _FIter, const _Tp&);
341
342 template<typename _FIter, typename _Tp, typename _Compare>
343 _FIter
344 lower_bound(_FIter, _FIter, const _Tp&, _Compare);
345
346 template<typename _RAIter>
347 void
348 make_heap(_RAIter, _RAIter);
349
350 template<typename _RAIter, typename _Compare>
351 void
352 make_heap(_RAIter, _RAIter, _Compare);
353
354 template<typename _Tp>
355 _GLIBCXX14_CONSTEXPR
356 const _Tp&
357 max(const _Tp&, const _Tp&);
358
359 template<typename _Tp, typename _Compare>
360 _GLIBCXX14_CONSTEXPR
361 const _Tp&
362 max(const _Tp&, const _Tp&, _Compare);
363
364 // max_element
365 // merge
366
367 template<typename _Tp>
368 _GLIBCXX14_CONSTEXPR
369 const _Tp&
370 min(const _Tp&, const _Tp&);
371
372 template<typename _Tp, typename _Compare>
373 _GLIBCXX14_CONSTEXPR
374 const _Tp&
375 min(const _Tp&, const _Tp&, _Compare);
376
377 // min_element
378
379#if __cplusplus >= 201103L
380 template<typename _Tp>
381 _GLIBCXX14_CONSTEXPR
382 pair<const _Tp&, const _Tp&>
383 minmax(const _Tp&, const _Tp&);
384
385 template<typename _Tp, typename _Compare>
386 _GLIBCXX14_CONSTEXPR
387 pair<const _Tp&, const _Tp&>
388 minmax(const _Tp&, const _Tp&, _Compare);
389
390 template<typename _FIter>
391 _GLIBCXX14_CONSTEXPR
392 pair<_FIter, _FIter>
393 minmax_element(_FIter, _FIter);
394
395 template<typename _FIter, typename _Compare>
396 _GLIBCXX14_CONSTEXPR
397 pair<_FIter, _FIter>
398 minmax_element(_FIter, _FIter, _Compare);
399
400 template<typename _Tp>
401 _GLIBCXX14_CONSTEXPR
402 _Tp
403 min(initializer_list<_Tp>);
404
405 template<typename _Tp, typename _Compare>
406 _GLIBCXX14_CONSTEXPR
407 _Tp
408 min(initializer_list<_Tp>, _Compare);
409
410 template<typename _Tp>
411 _GLIBCXX14_CONSTEXPR
412 _Tp
413 max(initializer_list<_Tp>);
414
415 template<typename _Tp, typename _Compare>
416 _GLIBCXX14_CONSTEXPR
417 _Tp
418 max(initializer_list<_Tp>, _Compare);
419
420 template<typename _Tp>
421 _GLIBCXX14_CONSTEXPR
422 pair<_Tp, _Tp>
423 minmax(initializer_list<_Tp>);
424
425 template<typename _Tp, typename _Compare>
426 _GLIBCXX14_CONSTEXPR
427 pair<_Tp, _Tp>
428 minmax(initializer_list<_Tp>, _Compare);
429#endif
430
431 // mismatch
432
433 template<typename _BIter>
434 bool
435 next_permutation(_BIter, _BIter);
436
437 template<typename _BIter, typename _Compare>
438 bool
439 next_permutation(_BIter, _BIter, _Compare);
440
441#if __cplusplus >= 201103L
442 template<typename _IIter, typename _Predicate>
443 bool
444 none_of(_IIter, _IIter, _Predicate);
445#endif
446
447 // nth_element
448 // partial_sort
449
450 template<typename _IIter, typename _RAIter>
451 _RAIter
452 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
453
454 template<typename _IIter, typename _RAIter, typename _Compare>
455 _RAIter
456 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
457
458 // partition
459
460#if __cplusplus >= 201103L
461 template<typename _IIter, typename _OIter1,
462 typename _OIter2, typename _Predicate>
463 pair<_OIter1, _OIter2>
464 partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
465
466 template<typename _FIter, typename _Predicate>
467 _FIter
468 partition_point(_FIter, _FIter, _Predicate);
469#endif
470
471 template<typename _RAIter>
472 void
473 pop_heap(_RAIter, _RAIter);
474
475 template<typename _RAIter, typename _Compare>
476 void
477 pop_heap(_RAIter, _RAIter, _Compare);
478
479 template<typename _BIter>
480 bool
481 prev_permutation(_BIter, _BIter);
482
483 template<typename _BIter, typename _Compare>
484 bool
485 prev_permutation(_BIter, _BIter, _Compare);
486
487 template<typename _RAIter>
488 void
489 push_heap(_RAIter, _RAIter);
490
491 template<typename _RAIter, typename _Compare>
492 void
493 push_heap(_RAIter, _RAIter, _Compare);
494
495 // random_shuffle
496
497 template<typename _FIter, typename _Tp>
498 _FIter
499 remove(_FIter, _FIter, const _Tp&);
500
501 template<typename _FIter, typename _Predicate>
502 _FIter
503 remove_if(_FIter, _FIter, _Predicate);
504
505 template<typename _IIter, typename _OIter, typename _Tp>
506 _OIter
507 remove_copy(_IIter, _IIter, _OIter, const _Tp&);
508
509 template<typename _IIter, typename _OIter, typename _Predicate>
510 _OIter
511 remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
512
513 // replace
514
515 template<typename _IIter, typename _OIter, typename _Tp>
516 _OIter
517 replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
518
519 template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
520 _OIter
521 replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
522
523 // replace_if
524
525 template<typename _BIter>
526 void
527 reverse(_BIter, _BIter);
528
529 template<typename _BIter, typename _OIter>
530 _OIter
531 reverse_copy(_BIter, _BIter, _OIter);
532
533 inline namespace _V2
534 {
535 template<typename _FIter>
536 _FIter
537 rotate(_FIter, _FIter, _FIter);
538 }
539
540 template<typename _FIter, typename _OIter>
541 _OIter
542 rotate_copy(_FIter, _FIter, _FIter, _OIter);
543
544 // search
545 // search_n
546 // set_difference
547 // set_intersection
548 // set_symmetric_difference
549 // set_union
550
551#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
552 template<typename _RAIter, typename _UGenerator>
553 void
554 shuffle(_RAIter, _RAIter, _UGenerator&&);
555#endif
556
557 template<typename _RAIter>
558 void
559 sort_heap(_RAIter, _RAIter);
560
561 template<typename _RAIter, typename _Compare>
562 void
563 sort_heap(_RAIter, _RAIter, _Compare);
564
565 template<typename _BIter, typename _Predicate>
566 _BIter
567 stable_partition(_BIter, _BIter, _Predicate);
568
569 template<typename _Tp>
570 void
571 swap(_Tp&, _Tp&)
572#if __cplusplus >= 201103L
573 noexcept(__and_<is_nothrow_move_constructible<_Tp>,
574 is_nothrow_move_assignable<_Tp>>::value)
575#endif
576 ;
577
578 template<typename _Tp, size_t _Nm>
579 void
580 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
581#if __cplusplus >= 201103L
582 noexcept(noexcept(swap(*__a, *__b)))
583#endif
584 ;
585
586 template<typename _FIter1, typename _FIter2>
587 _FIter2
588 swap_ranges(_FIter1, _FIter1, _FIter2);
589
590 // transform
591
592 template<typename _FIter>
593 _FIter
594 unique(_FIter, _FIter);
595
596 template<typename _FIter, typename _BinaryPredicate>
597 _FIter
598 unique(_FIter, _FIter, _BinaryPredicate);
599
600 // unique_copy
601
602 template<typename _FIter, typename _Tp>
603 _FIter
604 upper_bound(_FIter, _FIter, const _Tp&);
605
606 template<typename _FIter, typename _Tp, typename _Compare>
607 _FIter
608 upper_bound(_FIter, _FIter, const _Tp&, _Compare);
609
610_GLIBCXX_END_NAMESPACE_VERSION
611
612_GLIBCXX_BEGIN_NAMESPACE_ALGO
613
614 template<typename _FIter>
615 _FIter
616 adjacent_find(_FIter, _FIter);
617
618 template<typename _FIter, typename _BinaryPredicate>
619 _FIter
620 adjacent_find(_FIter, _FIter, _BinaryPredicate);
621
622 template<typename _IIter, typename _Tp>
623 typename iterator_traits<_IIter>::difference_type
624 count(_IIter, _IIter, const _Tp&);
625
626 template<typename _IIter, typename _Predicate>
627 typename iterator_traits<_IIter>::difference_type
628 count_if(_IIter, _IIter, _Predicate);
629
630 template<typename _IIter1, typename _IIter2>
631 bool
632 equal(_IIter1, _IIter1, _IIter2);
633
634 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
635 bool
636 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
637
638 template<typename _IIter, typename _Tp>
639 _IIter
640 find(_IIter, _IIter, const _Tp&);
641
642 template<typename _FIter1, typename _FIter2>
643 _FIter1
644 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
645
646 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
647 _FIter1
648 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
649
650 template<typename _IIter, typename _Predicate>
651 _IIter
652 find_if(_IIter, _IIter, _Predicate);
653
654 template<typename _IIter, typename _Funct>
655 _Funct
656 for_each(_IIter, _IIter, _Funct);
657
658 template<typename _FIter, typename _Generator>
659 void
660 generate(_FIter, _FIter, _Generator);
661
662 template<typename _OIter, typename _Size, typename _Generator>
663 _OIter
664 generate_n(_OIter, _Size, _Generator);
665
666 template<typename _IIter1, typename _IIter2>
667 bool
668 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
669
670 template<typename _IIter1, typename _IIter2, typename _Compare>
671 bool
672 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
673
674 template<typename _FIter>
675 _GLIBCXX14_CONSTEXPR
676 _FIter
677 max_element(_FIter, _FIter);
678
679 template<typename _FIter, typename _Compare>
680 _GLIBCXX14_CONSTEXPR
681 _FIter
682 max_element(_FIter, _FIter, _Compare);
683
684 template<typename _IIter1, typename _IIter2, typename _OIter>
685 _OIter
686 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
687
688 template<typename _IIter1, typename _IIter2, typename _OIter,
689 typename _Compare>
690 _OIter
691 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
692
693 template<typename _FIter>
694 _GLIBCXX14_CONSTEXPR
695 _FIter
696 min_element(_FIter, _FIter);
697
698 template<typename _FIter, typename _Compare>
699 _GLIBCXX14_CONSTEXPR
700 _FIter
701 min_element(_FIter, _FIter, _Compare);
702
703 template<typename _IIter1, typename _IIter2>
704 pair<_IIter1, _IIter2>
705 mismatch(_IIter1, _IIter1, _IIter2);
706
707 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
708 pair<_IIter1, _IIter2>
709 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
710
711 template<typename _RAIter>
712 void
713 nth_element(_RAIter, _RAIter, _RAIter);
714
715 template<typename _RAIter, typename _Compare>
716 void
717 nth_element(_RAIter, _RAIter, _RAIter, _Compare);
718
719 template<typename _RAIter>
720 void
721 partial_sort(_RAIter, _RAIter, _RAIter);
722
723 template<typename _RAIter, typename _Compare>
724 void
725 partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
726
727 template<typename _BIter, typename _Predicate>
728 _BIter
729 partition(_BIter, _BIter, _Predicate);
730
731 template<typename _RAIter>
732 void
733 random_shuffle(_RAIter, _RAIter);
734
735 template<typename _RAIter, typename _Generator>
736 void
737 random_shuffle(_RAIter, _RAIter,
738#if __cplusplus >= 201103L
739 _Generator&&);
740#else
741 _Generator&);
742#endif
743
744 template<typename _FIter, typename _Tp>
745 void
746 replace(_FIter, _FIter, const _Tp&, const _Tp&);
747
748 template<typename _FIter, typename _Predicate, typename _Tp>
749 void
750 replace_if(_FIter, _FIter, _Predicate, const _Tp&);
751
752 template<typename _FIter1, typename _FIter2>
753 _FIter1
754 search(_FIter1, _FIter1, _FIter2, _FIter2);
755
756 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
757 _FIter1
758 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
759
760 template<typename _FIter, typename _Size, typename _Tp>
761 _FIter
762 search_n(_FIter, _FIter, _Size, const _Tp&);
763
764 template<typename _FIter, typename _Size, typename _Tp,
765 typename _BinaryPredicate>
766 _FIter
767 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
768
769 template<typename _IIter1, typename _IIter2, typename _OIter>
770 _OIter
771 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
772
773 template<typename _IIter1, typename _IIter2, typename _OIter,
774 typename _Compare>
775 _OIter
776 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
777
778 template<typename _IIter1, typename _IIter2, typename _OIter>
779 _OIter
780 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
781
782 template<typename _IIter1, typename _IIter2, typename _OIter,
783 typename _Compare>
784 _OIter
785 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
786
787 template<typename _IIter1, typename _IIter2, typename _OIter>
788 _OIter
789 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
790
791 template<typename _IIter1, typename _IIter2, typename _OIter,
792 typename _Compare>
793 _OIter
794 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
795 _OIter, _Compare);
796
797 template<typename _IIter1, typename _IIter2, typename _OIter>
798 _OIter
799 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
800
801 template<typename _IIter1, typename _IIter2, typename _OIter,
802 typename _Compare>
803 _OIter
804 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
805
806 template<typename _RAIter>
807 void
808 sort(_RAIter, _RAIter);
809
810 template<typename _RAIter, typename _Compare>
811 void
812 sort(_RAIter, _RAIter, _Compare);
813
814 template<typename _RAIter>
815 void
816 stable_sort(_RAIter, _RAIter);
817
818 template<typename _RAIter, typename _Compare>
819 void
820 stable_sort(_RAIter, _RAIter, _Compare);
821
822 template<typename _IIter, typename _OIter, typename _UnaryOperation>
823 _OIter
824 transform(_IIter, _IIter, _OIter, _UnaryOperation);
825
826 template<typename _IIter1, typename _IIter2, typename _OIter,
827 typename _BinaryOperation>
828 _OIter
829 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
830
831 template<typename _IIter, typename _OIter>
832 _OIter
833 unique_copy(_IIter, _IIter, _OIter);
834
835 template<typename _IIter, typename _OIter, typename _BinaryPredicate>
836 _OIter
837 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
838
839_GLIBCXX_END_NAMESPACE_ALGO
840} // namespace std
841
842#ifdef _GLIBCXX_PARALLEL
843# include <parallel/algorithmfwd.h>
844#endif
845
846#endif
847
848