1// <algorithm> Forward declarations -*- C++ -*-
2
3// Copyright (C) 2007-2017 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 Operation
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_END_NAMESPACE_VERSION
619
620_GLIBCXX_BEGIN_NAMESPACE_ALGO
621
622 template<typename _FIter>
623 _FIter
624 adjacent_find(_FIter, _FIter);
625
626 template<typename _FIter, typename _BinaryPredicate>
627 _FIter
628 adjacent_find(_FIter, _FIter, _BinaryPredicate);
629
630 template<typename _IIter, typename _Tp>
631 typename iterator_traits<_IIter>::difference_type
632 count(_IIter, _IIter, const _Tp&);
633
634 template<typename _IIter, typename _Predicate>
635 typename iterator_traits<_IIter>::difference_type
636 count_if(_IIter, _IIter, _Predicate);
637
638 template<typename _IIter1, typename _IIter2>
639 bool
640 equal(_IIter1, _IIter1, _IIter2);
641
642 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
643 bool
644 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
645
646 template<typename _IIter, typename _Tp>
647 _IIter
648 find(_IIter, _IIter, const _Tp&);
649
650 template<typename _FIter1, typename _FIter2>
651 _FIter1
652 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
653
654 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
655 _FIter1
656 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
657
658 template<typename _IIter, typename _Predicate>
659 _IIter
660 find_if(_IIter, _IIter, _Predicate);
661
662 template<typename _IIter, typename _Funct>
663 _Funct
664 for_each(_IIter, _IIter, _Funct);
665
666 template<typename _FIter, typename _Generator>
667 void
668 generate(_FIter, _FIter, _Generator);
669
670 template<typename _OIter, typename _Size, typename _Generator>
671 _OIter
672 generate_n(_OIter, _Size, _Generator);
673
674 template<typename _IIter1, typename _IIter2>
675 bool
676 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
677
678 template<typename _IIter1, typename _IIter2, typename _Compare>
679 bool
680 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
681
682 template<typename _FIter>
683 _GLIBCXX14_CONSTEXPR
684 _FIter
685 max_element(_FIter, _FIter);
686
687 template<typename _FIter, typename _Compare>
688 _GLIBCXX14_CONSTEXPR
689 _FIter
690 max_element(_FIter, _FIter, _Compare);
691
692 template<typename _IIter1, typename _IIter2, typename _OIter>
693 _OIter
694 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
695
696 template<typename _IIter1, typename _IIter2, typename _OIter,
697 typename _Compare>
698 _OIter
699 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
700
701 template<typename _FIter>
702 _GLIBCXX14_CONSTEXPR
703 _FIter
704 min_element(_FIter, _FIter);
705
706 template<typename _FIter, typename _Compare>
707 _GLIBCXX14_CONSTEXPR
708 _FIter
709 min_element(_FIter, _FIter, _Compare);
710
711 template<typename _IIter1, typename _IIter2>
712 pair<_IIter1, _IIter2>
713 mismatch(_IIter1, _IIter1, _IIter2);
714
715 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
716 pair<_IIter1, _IIter2>
717 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
718
719 template<typename _RAIter>
720 void
721 nth_element(_RAIter, _RAIter, _RAIter);
722
723 template<typename _RAIter, typename _Compare>
724 void
725 nth_element(_RAIter, _RAIter, _RAIter, _Compare);
726
727 template<typename _RAIter>
728 void
729 partial_sort(_RAIter, _RAIter, _RAIter);
730
731 template<typename _RAIter, typename _Compare>
732 void
733 partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
734
735 template<typename _BIter, typename _Predicate>
736 _BIter
737 partition(_BIter, _BIter, _Predicate);
738
739 template<typename _RAIter>
740 void
741 random_shuffle(_RAIter, _RAIter);
742
743 template<typename _RAIter, typename _Generator>
744 void
745 random_shuffle(_RAIter, _RAIter,
746#if __cplusplus >= 201103L
747 _Generator&&);
748#else
749 _Generator&);
750#endif
751
752 template<typename _FIter, typename _Tp>
753 void
754 replace(_FIter, _FIter, const _Tp&, const _Tp&);
755
756 template<typename _FIter, typename _Predicate, typename _Tp>
757 void
758 replace_if(_FIter, _FIter, _Predicate, const _Tp&);
759
760 template<typename _FIter1, typename _FIter2>
761 _FIter1
762 search(_FIter1, _FIter1, _FIter2, _FIter2);
763
764 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
765 _FIter1
766 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
767
768 template<typename _FIter, typename _Size, typename _Tp>
769 _FIter
770 search_n(_FIter, _FIter, _Size, const _Tp&);
771
772 template<typename _FIter, typename _Size, typename _Tp,
773 typename _BinaryPredicate>
774 _FIter
775 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
776
777 template<typename _IIter1, typename _IIter2, typename _OIter>
778 _OIter
779 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
780
781 template<typename _IIter1, typename _IIter2, typename _OIter,
782 typename _Compare>
783 _OIter
784 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
785
786 template<typename _IIter1, typename _IIter2, typename _OIter>
787 _OIter
788 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
789
790 template<typename _IIter1, typename _IIter2, typename _OIter,
791 typename _Compare>
792 _OIter
793 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
794
795 template<typename _IIter1, typename _IIter2, typename _OIter>
796 _OIter
797 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
798
799 template<typename _IIter1, typename _IIter2, typename _OIter,
800 typename _Compare>
801 _OIter
802 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
803 _OIter, _Compare);
804
805 template<typename _IIter1, typename _IIter2, typename _OIter>
806 _OIter
807 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
808
809 template<typename _IIter1, typename _IIter2, typename _OIter,
810 typename _Compare>
811 _OIter
812 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
813
814 template<typename _RAIter>
815 void
816 sort(_RAIter, _RAIter);
817
818 template<typename _RAIter, typename _Compare>
819 void
820 sort(_RAIter, _RAIter, _Compare);
821
822 template<typename _RAIter>
823 void
824 stable_sort(_RAIter, _RAIter);
825
826 template<typename _RAIter, typename _Compare>
827 void
828 stable_sort(_RAIter, _RAIter, _Compare);
829
830 template<typename _IIter, typename _OIter, typename _UnaryOperation>
831 _OIter
832 transform(_IIter, _IIter, _OIter, _UnaryOperation);
833
834 template<typename _IIter1, typename _IIter2, typename _OIter,
835 typename _BinaryOperation>
836 _OIter
837 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
838
839 template<typename _IIter, typename _OIter>
840 _OIter
841 unique_copy(_IIter, _IIter, _OIter);
842
843 template<typename _IIter, typename _OIter, typename _BinaryPredicate>
844 _OIter
845 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
846
847_GLIBCXX_END_NAMESPACE_ALGO
848} // namespace std
849
850#ifdef _GLIBCXX_PARALLEL
851# include <parallel/algorithmfwd.h>
852#endif
853
854#endif
855
856