1 // <algorithm> Forward declarations  -*- C++ -*-
2 
3 // Copyright (C) 2007-2018 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 
42 namespace 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