algorithmfwd.h revision 1.1.1.5 
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