1 // <algorithm> declarations  -*- C++ -*-
2 
3 // Copyright (C) 2007, 2008, 2009, 2010, 2011 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
39 #include <initializer_list>
40 #endif
41 
42 namespace 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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     const _Tp&
356     max(const _Tp&, const _Tp&);
357 
358   template<typename _Tp, typename _Compare>
359     const _Tp&
360     max(const _Tp&, const _Tp&, _Compare);
361 
362   // max_element
363   // merge
364 
365   template<typename _Tp>
366     const _Tp&
367     min(const _Tp&, const _Tp&);
368 
369   template<typename _Tp, typename _Compare>
370     const _Tp&
371     min(const _Tp&, const _Tp&, _Compare);
372 
373   // min_element
374 
375 #ifdef __GXX_EXPERIMENTAL_CXX0X__
376   template<typename _Tp>
377     pair<const _Tp&, const _Tp&>
378     minmax(const _Tp&, const _Tp&);
379 
380   template<typename _Tp, typename _Compare>
381     pair<const _Tp&, const _Tp&>
382     minmax(const _Tp&, const _Tp&, _Compare);
383 
384   template<typename _FIter>
385     pair<_FIter, _FIter>
386     minmax_element(_FIter, _FIter);
387 
388   template<typename _FIter, typename _Compare>
389     pair<_FIter, _FIter>
390     minmax_element(_FIter, _FIter, _Compare);
391 
392   template<typename _Tp>
393     _Tp
394     min(initializer_list<_Tp>);
395 
396   template<typename _Tp, typename _Compare>
397     _Tp
398     min(initializer_list<_Tp>, _Compare);
399 
400   template<typename _Tp>
401     _Tp
402     max(initializer_list<_Tp>);
403 
404   template<typename _Tp, typename _Compare>
405     _Tp
406     max(initializer_list<_Tp>, _Compare);
407 
408   template<typename _Tp>
409     pair<_Tp, _Tp>
410     minmax(initializer_list<_Tp>);
411 
412   template<typename _Tp, typename _Compare>
413     pair<_Tp, _Tp>
414     minmax(initializer_list<_Tp>, _Compare);
415 #endif
416 
417   // mismatch
418 
419   template<typename _BIter>
420     bool
421     next_permutation(_BIter, _BIter);
422 
423   template<typename _BIter, typename _Compare>
424     bool
425     next_permutation(_BIter, _BIter, _Compare);
426 
427 #ifdef __GXX_EXPERIMENTAL_CXX0X__
428   template<typename _IIter, typename _Predicate>
429     bool
430     none_of(_IIter, _IIter, _Predicate);
431 #endif
432 
433   // nth_element
434   // partial_sort
435 
436   template<typename _IIter, typename _RAIter>
437     _RAIter
438     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
439 
440   template<typename _IIter, typename _RAIter, typename _Compare>
441     _RAIter
442     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
443 
444   // partition
445 
446 #ifdef __GXX_EXPERIMENTAL_CXX0X__
447   template<typename _IIter, typename _OIter1,
448 	   typename _OIter2, typename _Predicate>
449     pair<_OIter1, _OIter2>
450     partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
451 
452   template<typename _FIter, typename _Predicate>
453     _FIter
454     partition_point(_FIter, _FIter, _Predicate);
455 #endif
456 
457   template<typename _RAIter>
458     void
459     pop_heap(_RAIter, _RAIter);
460 
461   template<typename _RAIter, typename _Compare>
462     void
463     pop_heap(_RAIter, _RAIter, _Compare);
464 
465   template<typename _BIter>
466     bool
467     prev_permutation(_BIter, _BIter);
468 
469   template<typename _BIter, typename _Compare>
470     bool
471     prev_permutation(_BIter, _BIter, _Compare);
472 
473   template<typename _RAIter>
474     void
475     push_heap(_RAIter, _RAIter);
476 
477   template<typename _RAIter, typename _Compare>
478     void
479     push_heap(_RAIter, _RAIter, _Compare);
480 
481   // random_shuffle
482 
483   template<typename _FIter, typename _Tp>
484     _FIter
485     remove(_FIter, _FIter, const _Tp&);
486 
487   template<typename _FIter, typename _Predicate>
488     _FIter
489     remove_if(_FIter, _FIter, _Predicate);
490 
491   template<typename _IIter, typename _OIter, typename _Tp>
492     _OIter
493     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
494 
495   template<typename _IIter, typename _OIter, typename _Predicate>
496     _OIter
497     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
498 
499   // replace
500 
501   template<typename _IIter, typename _OIter, typename _Tp>
502     _OIter
503     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
504 
505   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
506     _OIter
507     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
508 
509   // replace_if
510 
511   template<typename _BIter>
512     void
513     reverse(_BIter, _BIter);
514 
515   template<typename _BIter, typename _OIter>
516     _OIter
517     reverse_copy(_BIter, _BIter, _OIter);
518 
519   template<typename _FIter>
520     void
521     rotate(_FIter, _FIter, _FIter);
522 
523   template<typename _FIter, typename _OIter>
524     _OIter
525     rotate_copy(_FIter, _FIter, _FIter, _OIter);
526 
527   // search
528   // search_n
529   // set_difference
530   // set_intersection
531   // set_symmetric_difference
532   // set_union
533 
534 #if defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
535   template<typename _RAIter, typename _UGenerator>
536     void
537     shuffle(_RAIter, _RAIter, _UGenerator&&);
538 #endif
539 
540   template<typename _RAIter>
541     void
542     sort_heap(_RAIter, _RAIter);
543 
544   template<typename _RAIter, typename _Compare>
545     void
546     sort_heap(_RAIter, _RAIter, _Compare);
547 
548   template<typename _BIter, typename _Predicate>
549     _BIter
550     stable_partition(_BIter, _BIter, _Predicate);
551 
552   template<typename _Tp>
553     void
554     swap(_Tp&, _Tp&)
555 #ifdef __GXX_EXPERIMENTAL_CXX0X__
556     noexcept(__and_<is_nothrow_move_constructible<_Tp>,
557 	            is_nothrow_move_assignable<_Tp>>::value)
558 #endif
559     ;
560 
561   template<typename _Tp, size_t _Nm>
562     void
563     swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
564 #ifdef __GXX_EXPERIMENTAL_CXX0X__
565     noexcept(noexcept(swap(*__a, *__b)))
566 #endif
567     ;
568 
569   template<typename _FIter1, typename _FIter2>
570     _FIter2
571     swap_ranges(_FIter1, _FIter1, _FIter2);
572 
573   // transform
574 
575   template<typename _FIter>
576     _FIter
577     unique(_FIter, _FIter);
578 
579   template<typename _FIter, typename _BinaryPredicate>
580     _FIter
581     unique(_FIter, _FIter, _BinaryPredicate);
582 
583   // unique_copy
584 
585   template<typename _FIter, typename _Tp>
586     _FIter
587     upper_bound(_FIter, _FIter, const _Tp&);
588 
589   template<typename _FIter, typename _Tp, typename _Compare>
590     _FIter
591     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
592 
593 _GLIBCXX_END_NAMESPACE_VERSION
594 
595 _GLIBCXX_BEGIN_NAMESPACE_ALGO
596 
597   template<typename _FIter>
598     _FIter
599     adjacent_find(_FIter, _FIter);
600 
601   template<typename _FIter, typename _BinaryPredicate>
602     _FIter
603     adjacent_find(_FIter, _FIter, _BinaryPredicate);
604 
605   template<typename _IIter, typename _Tp>
606     typename iterator_traits<_IIter>::difference_type
607     count(_IIter, _IIter, const _Tp&);
608 
609   template<typename _IIter, typename _Predicate>
610     typename iterator_traits<_IIter>::difference_type
611     count_if(_IIter, _IIter, _Predicate);
612 
613   template<typename _IIter1, typename _IIter2>
614     bool
615     equal(_IIter1, _IIter1, _IIter2);
616 
617   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
618     bool
619     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
620 
621   template<typename _IIter, typename _Tp>
622     _IIter
623     find(_IIter, _IIter, const _Tp&);
624 
625   template<typename _FIter1, typename _FIter2>
626     _FIter1
627     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
628 
629   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
630     _FIter1
631     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
632 
633   template<typename _IIter, typename _Predicate>
634     _IIter
635     find_if(_IIter, _IIter, _Predicate);
636 
637   template<typename _IIter, typename _Funct>
638     _Funct
639     for_each(_IIter, _IIter, _Funct);
640 
641   template<typename _FIter, typename _Generator>
642     void
643     generate(_FIter, _FIter, _Generator);
644 
645   template<typename _OIter, typename _Size, typename _Generator>
646     _OIter
647     generate_n(_OIter, _Size, _Generator);
648 
649   template<typename _IIter1, typename _IIter2>
650     bool
651     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
652 
653   template<typename _IIter1, typename _IIter2, typename _Compare>
654     bool
655     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
656 
657   template<typename _FIter>
658     _FIter
659     max_element(_FIter, _FIter);
660 
661   template<typename _FIter, typename _Compare>
662     _FIter
663     max_element(_FIter, _FIter, _Compare);
664 
665   template<typename _IIter1, typename _IIter2, typename _OIter>
666     _OIter
667     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
668 
669   template<typename _IIter1, typename _IIter2, typename _OIter,
670 	   typename _Compare>
671     _OIter
672     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
673 
674   template<typename _FIter>
675     _FIter
676     min_element(_FIter, _FIter);
677 
678   template<typename _FIter, typename _Compare>
679     _FIter
680     min_element(_FIter, _FIter, _Compare);
681 
682   template<typename _IIter1, typename _IIter2>
683     pair<_IIter1, _IIter2>
684     mismatch(_IIter1, _IIter1, _IIter2);
685 
686   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
687     pair<_IIter1, _IIter2>
688     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
689 
690   template<typename _RAIter>
691     void
692     nth_element(_RAIter, _RAIter, _RAIter);
693 
694   template<typename _RAIter, typename _Compare>
695     void
696     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
697 
698   template<typename _RAIter>
699     void
700     partial_sort(_RAIter, _RAIter, _RAIter);
701 
702   template<typename _RAIter, typename _Compare>
703     void
704     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
705 
706   template<typename _BIter, typename _Predicate>
707     _BIter
708     partition(_BIter, _BIter, _Predicate);
709 
710   template<typename _RAIter>
711     void
712     random_shuffle(_RAIter, _RAIter);
713 
714   template<typename _RAIter, typename _Generator>
715     void
716     random_shuffle(_RAIter, _RAIter,
717 #ifdef __GXX_EXPERIMENTAL_CXX0X__
718 		   _Generator&&);
719 #else
720 		   _Generator&);
721 #endif
722 
723   template<typename _FIter, typename _Tp>
724     void
725     replace(_FIter, _FIter, const _Tp&, const _Tp&);
726 
727   template<typename _FIter, typename _Predicate, typename _Tp>
728     void
729     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
730 
731   template<typename _FIter1, typename _FIter2>
732     _FIter1
733     search(_FIter1, _FIter1, _FIter2, _FIter2);
734 
735   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
736     _FIter1
737     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
738 
739   template<typename _FIter, typename _Size, typename _Tp>
740     _FIter
741     search_n(_FIter, _FIter, _Size, const _Tp&);
742 
743   template<typename _FIter, typename _Size, typename _Tp,
744 	   typename _BinaryPredicate>
745     _FIter
746     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
747 
748   template<typename _IIter1, typename _IIter2, typename _OIter>
749     _OIter
750     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
751 
752   template<typename _IIter1, typename _IIter2, typename _OIter,
753 	   typename _Compare>
754     _OIter
755     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
756 
757   template<typename _IIter1, typename _IIter2, typename _OIter>
758     _OIter
759     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
760 
761   template<typename _IIter1, typename _IIter2, typename _OIter,
762 	   typename _Compare>
763     _OIter
764     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
765 
766   template<typename _IIter1, typename _IIter2, typename _OIter>
767     _OIter
768     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
769 
770   template<typename _IIter1, typename _IIter2, typename _OIter,
771 	   typename _Compare>
772     _OIter
773     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
774 			     _OIter, _Compare);
775 
776   template<typename _IIter1, typename _IIter2, typename _OIter>
777     _OIter
778     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
779 
780   template<typename _IIter1, typename _IIter2, typename _OIter,
781 	   typename _Compare>
782     _OIter
783     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
784 
785   template<typename _RAIter>
786     void
787     sort(_RAIter, _RAIter);
788 
789   template<typename _RAIter, typename _Compare>
790     void
791     sort(_RAIter, _RAIter, _Compare);
792 
793   template<typename _RAIter>
794     void
795     stable_sort(_RAIter, _RAIter);
796 
797   template<typename _RAIter, typename _Compare>
798     void
799     stable_sort(_RAIter, _RAIter, _Compare);
800 
801   template<typename _IIter, typename _OIter, typename _UnaryOperation>
802     _OIter
803     transform(_IIter, _IIter, _OIter, _UnaryOperation);
804 
805   template<typename _IIter1, typename _IIter2, typename _OIter,
806 	   typename _BinaryOperation>
807     _OIter
808     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
809 
810   template<typename _IIter, typename _OIter>
811     _OIter
812     unique_copy(_IIter, _IIter, _OIter);
813 
814   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
815     _OIter
816     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
817 
818 _GLIBCXX_END_NAMESPACE_ALGO
819 } // namespace std
820 
821 #ifdef _GLIBCXX_PARALLEL
822 # include <parallel/algorithmfwd.h>
823 #endif
824 
825 #endif
826 
827