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 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_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