1// <algorithm> Forward declarations -*- C++ -*-
2
3// Copyright (C) 2007-2016 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#if __cplusplus < 201103L
570 // For C++11 swap() is declared in <type_traits>.
571
572 template<typename _Tp, size_t _Nm>
573 inline void
574 swap(_Tp& __a, _Tp& __b);
575
576 template<typename _Tp, size_t _Nm>
577 inline void
578 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
579#endif
580
581 template<typename _FIter1, typename _FIter2>
582 _FIter2
583 swap_ranges(_FIter1, _FIter1, _FIter2);
584
585 // transform
586
587 template<typename _FIter>
588 _FIter
589 unique(_FIter, _FIter);
590
591 template<typename _FIter, typename _BinaryPredicate>
592 _FIter
593 unique(_FIter, _FIter, _BinaryPredicate);
594
595 // unique_copy
596
597 template<typename _FIter, typename _Tp>
598 _FIter
599 upper_bound(_FIter, _FIter, const _Tp&);
600
601 template<typename _FIter, typename _Tp, typename _Compare>
602 _FIter
603 upper_bound(_FIter, _FIter, const _Tp&, _Compare);
604
605_GLIBCXX_END_NAMESPACE_VERSION
606
607_GLIBCXX_BEGIN_NAMESPACE_ALGO
608
609 template<typename _FIter>
610 _FIter
611 adjacent_find(_FIter, _FIter);
612
613 template<typename _FIter, typename _BinaryPredicate>
614 _FIter
615 adjacent_find(_FIter, _FIter, _BinaryPredicate);
616
617 template<typename _IIter, typename _Tp>
618 typename iterator_traits<_IIter>::difference_type
619 count(_IIter, _IIter, const _Tp&);
620
621 template<typename _IIter, typename _Predicate>
622 typename iterator_traits<_IIter>::difference_type
623 count_if(_IIter, _IIter, _Predicate);
624
625 template<typename _IIter1, typename _IIter2>
626 bool
627 equal(_IIter1, _IIter1, _IIter2);
628
629 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
630 bool
631 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
632
633 template<typename _IIter, typename _Tp>
634 _IIter
635 find(_IIter, _IIter, const _Tp&);
636
637 template<typename _FIter1, typename _FIter2>
638 _FIter1
639 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
640
641 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
642 _FIter1
643 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
644
645 template<typename _IIter, typename _Predicate>
646 _IIter
647 find_if(_IIter, _IIter, _Predicate);
648
649 template<typename _IIter, typename _Funct>
650 _Funct
651 for_each(_IIter, _IIter, _Funct);
652
653 template<typename _FIter, typename _Generator>
654 void
655 generate(_FIter, _FIter, _Generator);
656
657 template<typename _OIter, typename _Size, typename _Generator>
658 _OIter
659 generate_n(_OIter, _Size, _Generator);
660
661 template<typename _IIter1, typename _IIter2>
662 bool
663 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
664
665 template<typename _IIter1, typename _IIter2, typename _Compare>
666 bool
667 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
668
669 template<typename _FIter>
670 _GLIBCXX14_CONSTEXPR
671 _FIter
672 max_element(_FIter, _FIter);
673
674 template<typename _FIter, typename _Compare>
675 _GLIBCXX14_CONSTEXPR
676 _FIter
677 max_element(_FIter, _FIter, _Compare);
678
679 template<typename _IIter1, typename _IIter2, typename _OIter>
680 _OIter
681 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
682
683 template<typename _IIter1, typename _IIter2, typename _OIter,
684 typename _Compare>
685 _OIter
686 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
687
688 template<typename _FIter>
689 _GLIBCXX14_CONSTEXPR
690 _FIter
691 min_element(_FIter, _FIter);
692
693 template<typename _FIter, typename _Compare>
694 _GLIBCXX14_CONSTEXPR
695 _FIter
696 min_element(_FIter, _FIter, _Compare);
697
698 template<typename _IIter1, typename _IIter2>
699 pair<_IIter1, _IIter2>
700 mismatch(_IIter1, _IIter1, _IIter2);
701
702 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
703 pair<_IIter1, _IIter2>
704 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
705
706 template<typename _RAIter>
707 void
708 nth_element(_RAIter, _RAIter, _RAIter);
709
710 template<typename _RAIter, typename _Compare>
711 void
712 nth_element(_RAIter, _RAIter, _RAIter, _Compare);
713
714 template<typename _RAIter>
715 void
716 partial_sort(_RAIter, _RAIter, _RAIter);
717
718 template<typename _RAIter, typename _Compare>
719 void
720 partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
721
722 template<typename _BIter, typename _Predicate>
723 _BIter
724 partition(_BIter, _BIter, _Predicate);
725
726 template<typename _RAIter>
727 void
728 random_shuffle(_RAIter, _RAIter);
729
730 template<typename _RAIter, typename _Generator>
731 void
732 random_shuffle(_RAIter, _RAIter,
733#if __cplusplus >= 201103L
734 _Generator&&);
735#else
736 _Generator&);
737#endif
738
739 template<typename _FIter, typename _Tp>
740 void
741 replace(_FIter, _FIter, const _Tp&, const _Tp&);
742
743 template<typename _FIter, typename _Predicate, typename _Tp>
744 void
745 replace_if(_FIter, _FIter, _Predicate, const _Tp&);
746
747 template<typename _FIter1, typename _FIter2>
748 _FIter1
749 search(_FIter1, _FIter1, _FIter2, _FIter2);
750
751 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
752 _FIter1
753 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
754
755 template<typename _FIter, typename _Size, typename _Tp>
756 _FIter
757 search_n(_FIter, _FIter, _Size, const _Tp&);
758
759 template<typename _FIter, typename _Size, typename _Tp,
760 typename _BinaryPredicate>
761 _FIter
762 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
763
764 template<typename _IIter1, typename _IIter2, typename _OIter>
765 _OIter
766 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
767
768 template<typename _IIter1, typename _IIter2, typename _OIter,
769 typename _Compare>
770 _OIter
771 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
772
773 template<typename _IIter1, typename _IIter2, typename _OIter>
774 _OIter
775 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
776
777 template<typename _IIter1, typename _IIter2, typename _OIter,
778 typename _Compare>
779 _OIter
780 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
781
782 template<typename _IIter1, typename _IIter2, typename _OIter>
783 _OIter
784 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
785
786 template<typename _IIter1, typename _IIter2, typename _OIter,
787 typename _Compare>
788 _OIter
789 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
790 _OIter, _Compare);
791
792 template<typename _IIter1, typename _IIter2, typename _OIter>
793 _OIter
794 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
795
796 template<typename _IIter1, typename _IIter2, typename _OIter,
797 typename _Compare>
798 _OIter
799 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
800
801 template<typename _RAIter>
802 void
803 sort(_RAIter, _RAIter);
804
805 template<typename _RAIter, typename _Compare>
806 void
807 sort(_RAIter, _RAIter, _Compare);
808
809 template<typename _RAIter>
810 void
811 stable_sort(_RAIter, _RAIter);
812
813 template<typename _RAIter, typename _Compare>
814 void
815 stable_sort(_RAIter, _RAIter, _Compare);
816
817 template<typename _IIter, typename _OIter, typename _UnaryOperation>
818 _OIter
819 transform(_IIter, _IIter, _OIter, _UnaryOperation);
820
821 template<typename _IIter1, typename _IIter2, typename _OIter,
822 typename _BinaryOperation>
823 _OIter
824 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
825
826 template<typename _IIter, typename _OIter>
827 _OIter
828 unique_copy(_IIter, _IIter, _OIter);
829
830 template<typename _IIter, typename _OIter, typename _BinaryPredicate>
831 _OIter
832 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
833
834_GLIBCXX_END_NAMESPACE_ALGO
835} // namespace std
836
837#ifdef _GLIBCXX_PARALLEL
838# include <parallel/algorithmfwd.h>
839#endif
840
841#endif
842
843