1// <algorithm> Forward declarations  -*- C++ -*-
2
3// Copyright (C) 2007-2014 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++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#if __cplusplus >= 201103L
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#if __cplusplus >= 201103L
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#if __cplusplus >= 201103L
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#if __cplusplus >= 201103L
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#if __cplusplus >= 201103L
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#if __cplusplus >= 201103L
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#if __cplusplus >= 201103L
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      __attribute__ ((warn_unused_result));
487
488  template<typename _FIter, typename _Predicate>
489    _FIter
490    remove_if(_FIter, _FIter, _Predicate)
491      __attribute__ ((warn_unused_result));
492
493  template<typename _IIter, typename _OIter, typename _Tp>
494    _OIter
495    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
496
497  template<typename _IIter, typename _OIter, typename _Predicate>
498    _OIter
499    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
500
501  // replace
502
503  template<typename _IIter, typename _OIter, typename _Tp>
504    _OIter
505    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
506
507  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
508    _OIter
509    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
510
511  // replace_if
512
513  template<typename _BIter>
514    void
515    reverse(_BIter, _BIter);
516
517  template<typename _BIter, typename _OIter>
518    _OIter
519    reverse_copy(_BIter, _BIter, _OIter);
520
521  template<typename _FIter>
522    void
523    rotate(_FIter, _FIter, _FIter);
524
525  template<typename _FIter, typename _OIter>
526    _OIter
527    rotate_copy(_FIter, _FIter, _FIter, _OIter);
528
529  // search
530  // search_n
531  // set_difference
532  // set_intersection
533  // set_symmetric_difference
534  // set_union
535
536#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
537  template<typename _RAIter, typename _UGenerator>
538    void
539    shuffle(_RAIter, _RAIter, _UGenerator&&);
540#endif
541
542  template<typename _RAIter>
543    void
544    sort_heap(_RAIter, _RAIter);
545
546  template<typename _RAIter, typename _Compare>
547    void
548    sort_heap(_RAIter, _RAIter, _Compare);
549
550  template<typename _BIter, typename _Predicate>
551    _BIter
552    stable_partition(_BIter, _BIter, _Predicate);
553
554  template<typename _Tp>
555    void
556    swap(_Tp&, _Tp&)
557#if __cplusplus >= 201103L
558    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
559	            is_nothrow_move_assignable<_Tp>>::value)
560#endif
561    ;
562
563  template<typename _Tp, size_t _Nm>
564    void
565    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
566#if __cplusplus >= 201103L
567    noexcept(noexcept(swap(*__a, *__b)))
568#endif
569    ;
570
571  template<typename _FIter1, typename _FIter2>
572    _FIter2
573    swap_ranges(_FIter1, _FIter1, _FIter2);
574
575  // transform
576
577  template<typename _FIter>
578    _FIter
579    unique(_FIter, _FIter)
580      __attribute__ ((warn_unused_result));
581
582  template<typename _FIter, typename _BinaryPredicate>
583    _FIter
584    unique(_FIter, _FIter, _BinaryPredicate)
585      __attribute__ ((warn_unused_result));
586
587  // unique_copy
588
589  template<typename _FIter, typename _Tp>
590    _FIter
591    upper_bound(_FIter, _FIter, const _Tp&);
592
593  template<typename _FIter, typename _Tp, typename _Compare>
594    _FIter
595    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
596
597_GLIBCXX_END_NAMESPACE_VERSION
598
599_GLIBCXX_BEGIN_NAMESPACE_ALGO
600
601  template<typename _FIter>
602    _FIter
603    adjacent_find(_FIter, _FIter);
604
605  template<typename _FIter, typename _BinaryPredicate>
606    _FIter
607    adjacent_find(_FIter, _FIter, _BinaryPredicate);
608
609  template<typename _IIter, typename _Tp>
610    typename iterator_traits<_IIter>::difference_type
611    count(_IIter, _IIter, const _Tp&);
612
613  template<typename _IIter, typename _Predicate>
614    typename iterator_traits<_IIter>::difference_type
615    count_if(_IIter, _IIter, _Predicate);
616
617  template<typename _IIter1, typename _IIter2>
618    bool
619    equal(_IIter1, _IIter1, _IIter2);
620
621  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
622    bool
623    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
624
625  template<typename _IIter, typename _Tp>
626    _IIter
627    find(_IIter, _IIter, const _Tp&);
628
629  template<typename _FIter1, typename _FIter2>
630    _FIter1
631    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
632
633  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
634    _FIter1
635    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
636
637  template<typename _IIter, typename _Predicate>
638    _IIter
639    find_if(_IIter, _IIter, _Predicate);
640
641  template<typename _IIter, typename _Funct>
642    _Funct
643    for_each(_IIter, _IIter, _Funct);
644
645  template<typename _FIter, typename _Generator>
646    void
647    generate(_FIter, _FIter, _Generator);
648
649  template<typename _OIter, typename _Size, typename _Generator>
650    _OIter
651    generate_n(_OIter, _Size, _Generator);
652
653  template<typename _IIter1, typename _IIter2>
654    bool
655    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
656
657  template<typename _IIter1, typename _IIter2, typename _Compare>
658    bool
659    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
660
661  template<typename _FIter>
662    _FIter
663    max_element(_FIter, _FIter);
664
665  template<typename _FIter, typename _Compare>
666    _FIter
667    max_element(_FIter, _FIter, _Compare);
668
669  template<typename _IIter1, typename _IIter2, typename _OIter>
670    _OIter
671    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
672
673  template<typename _IIter1, typename _IIter2, typename _OIter,
674	   typename _Compare>
675    _OIter
676    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
677
678  template<typename _FIter>
679    _FIter
680    min_element(_FIter, _FIter);
681
682  template<typename _FIter, typename _Compare>
683    _FIter
684    min_element(_FIter, _FIter, _Compare);
685
686  template<typename _IIter1, typename _IIter2>
687    pair<_IIter1, _IIter2>
688    mismatch(_IIter1, _IIter1, _IIter2);
689
690  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
691    pair<_IIter1, _IIter2>
692    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
693
694  template<typename _RAIter>
695    void
696    nth_element(_RAIter, _RAIter, _RAIter);
697
698  template<typename _RAIter, typename _Compare>
699    void
700    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
701
702  template<typename _RAIter>
703    void
704    partial_sort(_RAIter, _RAIter, _RAIter);
705
706  template<typename _RAIter, typename _Compare>
707    void
708    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
709
710  template<typename _BIter, typename _Predicate>
711    _BIter
712    partition(_BIter, _BIter, _Predicate);
713
714  template<typename _RAIter>
715    void
716    random_shuffle(_RAIter, _RAIter);
717
718  template<typename _RAIter, typename _Generator>
719    void
720    random_shuffle(_RAIter, _RAIter,
721#if __cplusplus >= 201103L
722		   _Generator&&);
723#else
724		   _Generator&);
725#endif
726
727  template<typename _FIter, typename _Tp>
728    void
729    replace(_FIter, _FIter, const _Tp&, const _Tp&);
730
731  template<typename _FIter, typename _Predicate, typename _Tp>
732    void
733    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
734
735  template<typename _FIter1, typename _FIter2>
736    _FIter1
737    search(_FIter1, _FIter1, _FIter2, _FIter2);
738
739  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
740    _FIter1
741    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
742
743  template<typename _FIter, typename _Size, typename _Tp>
744    _FIter
745    search_n(_FIter, _FIter, _Size, const _Tp&);
746
747  template<typename _FIter, typename _Size, typename _Tp,
748	   typename _BinaryPredicate>
749    _FIter
750    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
751
752  template<typename _IIter1, typename _IIter2, typename _OIter>
753    _OIter
754    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
755
756  template<typename _IIter1, typename _IIter2, typename _OIter,
757	   typename _Compare>
758    _OIter
759    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
760
761  template<typename _IIter1, typename _IIter2, typename _OIter>
762    _OIter
763    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
764
765  template<typename _IIter1, typename _IIter2, typename _OIter,
766	   typename _Compare>
767    _OIter
768    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
769
770  template<typename _IIter1, typename _IIter2, typename _OIter>
771    _OIter
772    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
773
774  template<typename _IIter1, typename _IIter2, typename _OIter,
775	   typename _Compare>
776    _OIter
777    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
778			     _OIter, _Compare);
779
780  template<typename _IIter1, typename _IIter2, typename _OIter>
781    _OIter
782    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
783
784  template<typename _IIter1, typename _IIter2, typename _OIter,
785	   typename _Compare>
786    _OIter
787    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
788
789  template<typename _RAIter>
790    void
791    sort(_RAIter, _RAIter);
792
793  template<typename _RAIter, typename _Compare>
794    void
795    sort(_RAIter, _RAIter, _Compare);
796
797  template<typename _RAIter>
798    void
799    stable_sort(_RAIter, _RAIter);
800
801  template<typename _RAIter, typename _Compare>
802    void
803    stable_sort(_RAIter, _RAIter, _Compare);
804
805  template<typename _IIter, typename _OIter, typename _UnaryOperation>
806    _OIter
807    transform(_IIter, _IIter, _OIter, _UnaryOperation);
808
809  template<typename _IIter1, typename _IIter2, typename _OIter,
810	   typename _BinaryOperation>
811    _OIter
812    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
813
814  template<typename _IIter, typename _OIter>
815    _OIter
816    unique_copy(_IIter, _IIter, _OIter);
817
818  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
819    _OIter
820    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
821
822_GLIBCXX_END_NAMESPACE_ALGO
823} // namespace std
824
825#ifdef _GLIBCXX_PARALLEL
826# include <parallel/algorithmfwd.h>
827#endif
828
829#endif
830
831