1// <algorithm> declarations  -*- C++ -*-
2
3// Copyright (C) 2007, 2008, 2009, 2010 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 *  You should not attempt to use it directly.
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#include <initializer_list>
39
40_GLIBCXX_BEGIN_NAMESPACE(std)
41
42  /*
43    adjacent_find
44    all_of (C++0x)
45    any_of (C++0x)
46    binary_search
47    copy
48    copy_backward
49    copy_if (C++0x)
50    copy_n (C++0x)
51    count
52    count_if
53    equal
54    equal_range
55    fill
56    fill_n
57    find
58    find_end
59    find_first_of
60    find_if
61    find_if_not (C++0x)
62    for_each
63    generate
64    generate_n
65    includes
66    inplace_merge
67    is_heap (C++0x)
68    is_heap_until (C++0x)
69    is_partitioned (C++0x)
70    is_sorted (C++0x)
71    is_sorted_until (C++0x)
72    iter_swap
73    lexicographical_compare
74    lower_bound
75    make_heap
76    max
77    max_element
78    merge
79    min
80    min_element
81    minmax (C++0x)
82    minmax_element (C++0x)
83    mismatch
84    next_permutation
85    none_of (C++0x)
86    nth_element
87    partial_sort
88    partial_sort_copy
89    partition
90    partition_copy (C++0x)
91    partition_point (C++0x)
92    pop_heap
93    prev_permutation
94    push_heap
95    random_shuffle
96    remove
97    remove_copy
98    remove_copy_if
99    remove_if
100    replace
101    replace_copy
102    replace_copy_if
103    replace_if
104    reverse
105    reverse_copy
106    rotate
107    rotate_copy
108    search
109    search_n
110    set_difference
111    set_intersection
112    set_symmetric_difference
113    set_union
114    shuffle (C++0x)
115    sort
116    sort_heap
117    stable_partition
118    stable_sort
119    swap
120    swap_ranges
121    transform
122    unique
123    unique_copy
124    upper_bound
125  */
126
127  /**
128   * @defgroup algorithms Algorithms
129   *
130   * Components for performing algorithmic operations. Includes
131   * non-modifying sequence, modifying (mutating) sequence, sorting,
132   * searching, merge, partition, heap, set, minima, maxima, and
133   * permutation operations.
134   */
135
136  /**
137   * @defgroup mutating_algorithms Mutating
138   * @ingroup algorithms
139   */
140
141  /**
142   * @defgroup non_mutating_algorithms Non-Mutating
143   * @ingroup algorithms
144   */
145
146  /**
147   * @defgroup sorting_algorithms Sorting
148   * @ingroup algorithms
149   */
150
151  /**
152   * @defgroup set_algorithms Set Operation
153   * @ingroup sorting_algorithms
154   *
155   * These algorithms are common set operations performed on sequences
156   * that are already sorted. The number of comparisons will be
157   * linear.
158   */
159
160  /**
161   * @defgroup binary_search_algorithms Binary Search
162   * @ingroup sorting_algorithms
163   *
164   * These algorithms are variations of a classic binary search, and
165   * all assume that the sequence being searched is already sorted.
166   *
167   * The number of comparisons will be logarithmic (and as few as
168   * possible).  The number of steps through the sequence will be
169   * logarithmic for random-access iterators (e.g., pointers), and
170   * linear otherwise.
171   *
172   * The LWG has passed Defect Report 270, which notes: <em>The
173   * proposed resolution reinterprets binary search. Instead of
174   * thinking about searching for a value in a sorted range, we view
175   * that as an important special case of a more general algorithm:
176   * searching for the partition point in a partitioned range.  We
177   * also add a guarantee that the old wording did not: we ensure that
178   * the upper bound is no earlier than the lower bound, that the pair
179   * returned by equal_range is a valid range, and that the first part
180   * of that pair is the lower bound.</em>
181   *
182   * The actual effect of the first sentence is that a comparison
183   * functor passed by the user doesn't necessarily need to induce a
184   * strict weak ordering relation.  Rather, it partitions the range.
185   */
186
187  // adjacent_find
188
189#ifdef __GXX_EXPERIMENTAL_CXX0X__
190  template<typename _IIter, typename _Predicate>
191    bool
192    all_of(_IIter, _IIter, _Predicate);
193
194  template<typename _IIter, typename _Predicate>
195    bool
196    any_of(_IIter, _IIter, _Predicate);
197#endif
198
199  template<typename _FIter, typename _Tp>
200    bool
201    binary_search(_FIter, _FIter, const _Tp&);
202
203  template<typename _FIter, typename _Tp, typename _Compare>
204    bool
205    binary_search(_FIter, _FIter, const _Tp&, _Compare);
206
207  template<typename _IIter, typename _OIter>
208    _OIter
209    copy(_IIter, _IIter, _OIter);
210
211  template<typename _BIter1, typename _BIter2>
212    _BIter2
213    copy_backward(_BIter1, _BIter1, _BIter2);
214
215#ifdef __GXX_EXPERIMENTAL_CXX0X__
216  template<typename _IIter, typename _OIter, typename _Predicate>
217    _OIter
218    copy_if(_IIter, _IIter, _OIter, _Predicate);
219
220  template<typename _IIter, typename _Size, typename _OIter>
221    _OIter
222    copy_n(_IIter, _Size, _OIter);
223#endif
224
225  // count
226  // count_if
227
228  template<typename _FIter, typename _Tp>
229    pair<_FIter, _FIter>
230    equal_range(_FIter, _FIter, const _Tp&);
231
232  template<typename _FIter, typename _Tp, typename _Compare>
233    pair<_FIter, _FIter>
234    equal_range(_FIter, _FIter, const _Tp&, _Compare);
235
236  template<typename _FIter, typename _Tp>
237    void
238    fill(_FIter, _FIter, const _Tp&);
239
240  template<typename _OIter, typename _Size, typename _Tp>
241    _OIter
242    fill_n(_OIter, _Size, const _Tp&);
243
244  // find
245
246  template<typename _FIter1, typename _FIter2>
247    _FIter1
248    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
249
250  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
251    _FIter1
252    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
253
254  // find_first_of
255  // find_if
256
257#ifdef __GXX_EXPERIMENTAL_CXX0X__
258  template<typename _IIter, typename _Predicate>
259    _IIter
260    find_if_not(_IIter, _IIter, _Predicate);
261#endif
262
263  // for_each
264  // generate
265  // generate_n
266
267  template<typename _IIter1, typename _IIter2>
268    bool
269    includes(_IIter1, _IIter1, _IIter2, _IIter2);
270
271  template<typename _IIter1, typename _IIter2, typename _Compare>
272    bool
273    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
274
275  template<typename _BIter>
276    void
277    inplace_merge(_BIter, _BIter, _BIter);
278
279  template<typename _BIter, typename _Compare>
280    void
281    inplace_merge(_BIter, _BIter, _BIter, _Compare);
282
283#ifdef __GXX_EXPERIMENTAL_CXX0X__
284  template<typename _RAIter>
285    bool
286    is_heap(_RAIter, _RAIter);
287
288  template<typename _RAIter, typename _Compare>
289    bool
290    is_heap(_RAIter, _RAIter, _Compare);
291
292  template<typename _RAIter>
293    _RAIter
294    is_heap_until(_RAIter, _RAIter);
295
296  template<typename _RAIter, typename _Compare>
297    _RAIter
298    is_heap_until(_RAIter, _RAIter, _Compare);
299
300  template<typename _IIter, typename _Predicate>
301    bool
302    is_partitioned(_IIter, _IIter, _Predicate);
303
304  template<typename _FIter>
305    bool
306    is_sorted(_FIter, _FIter);
307
308  template<typename _FIter, typename _Compare>
309    bool
310    is_sorted(_FIter, _FIter, _Compare);
311
312  template<typename _FIter>
313    _FIter
314    is_sorted_until(_FIter, _FIter);
315
316  template<typename _FIter, typename _Compare>
317    _FIter
318    is_sorted_until(_FIter, _FIter, _Compare);
319#endif
320
321  template<typename _FIter1, typename _FIter2>
322    void
323    iter_swap(_FIter1, _FIter2);
324
325  template<typename _FIter, typename _Tp>
326    _FIter
327    lower_bound(_FIter, _FIter, const _Tp&);
328
329  template<typename _FIter, typename _Tp, typename _Compare>
330    _FIter
331    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
332
333  template<typename _RAIter>
334    void
335    make_heap(_RAIter, _RAIter);
336
337  template<typename _RAIter, typename _Compare>
338    void
339    make_heap(_RAIter, _RAIter, _Compare);
340
341  template<typename _Tp>
342    const _Tp&
343    max(const _Tp&, const _Tp&);
344
345  template<typename _Tp, typename _Compare>
346    const _Tp&
347    max(const _Tp&, const _Tp&, _Compare);
348
349  // max_element
350  // merge
351
352  template<typename _Tp>
353    const _Tp&
354    min(const _Tp&, const _Tp&);
355
356  template<typename _Tp, typename _Compare>
357    const _Tp&
358    min(const _Tp&, const _Tp&, _Compare);
359
360  // min_element
361
362#ifdef __GXX_EXPERIMENTAL_CXX0X__
363  template<typename _Tp>
364    pair<const _Tp&, const _Tp&>
365    minmax(const _Tp&, const _Tp&);
366
367  template<typename _Tp, typename _Compare>
368    pair<const _Tp&, const _Tp&>
369    minmax(const _Tp&, const _Tp&, _Compare);
370
371  template<typename _FIter>
372    pair<_FIter, _FIter>
373    minmax_element(_FIter, _FIter);
374
375  template<typename _FIter, typename _Compare>
376    pair<_FIter, _FIter>
377    minmax_element(_FIter, _FIter, _Compare);
378
379  template<typename _Tp>
380    _Tp
381    min(initializer_list<_Tp>);
382
383  template<typename _Tp, typename _Compare>
384    _Tp
385    min(initializer_list<_Tp>, _Compare);
386
387  template<typename _Tp>
388    _Tp
389    max(initializer_list<_Tp>);
390
391  template<typename _Tp, typename _Compare>
392    _Tp
393    max(initializer_list<_Tp>, _Compare);
394
395  template<typename _Tp>
396    pair<_Tp, _Tp>
397    minmax(initializer_list<_Tp>);
398
399  template<typename _Tp, typename _Compare>
400    pair<_Tp, _Tp>
401    minmax(initializer_list<_Tp>, _Compare);
402#endif
403
404  // mismatch
405
406  template<typename _BIter>
407    bool
408    next_permutation(_BIter, _BIter);
409
410  template<typename _BIter, typename _Compare>
411    bool
412    next_permutation(_BIter, _BIter, _Compare);
413
414#ifdef __GXX_EXPERIMENTAL_CXX0X__
415  template<typename _IIter, typename _Predicate>
416    bool
417    none_of(_IIter, _IIter, _Predicate);
418#endif
419
420  // nth_element
421  // partial_sort
422
423  template<typename _IIter, typename _RAIter>
424    _RAIter
425    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
426
427  template<typename _IIter, typename _RAIter, typename _Compare>
428    _RAIter
429    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
430
431  // partition
432
433#ifdef __GXX_EXPERIMENTAL_CXX0X__
434  template<typename _IIter, typename _OIter1,
435	   typename _OIter2, typename _Predicate>
436    pair<_OIter1, _OIter2>
437    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
438
439  template<typename _FIter, typename _Predicate>
440    _FIter
441    partition_point(_FIter, _FIter, _Predicate);
442#endif
443
444  template<typename _RAIter>
445    void
446    pop_heap(_RAIter, _RAIter);
447
448  template<typename _RAIter, typename _Compare>
449    void
450    pop_heap(_RAIter, _RAIter, _Compare);
451
452  template<typename _BIter>
453    bool
454    prev_permutation(_BIter, _BIter);
455
456  template<typename _BIter, typename _Compare>
457    bool
458    prev_permutation(_BIter, _BIter, _Compare);
459
460  template<typename _RAIter>
461    void
462    push_heap(_RAIter, _RAIter);
463
464  template<typename _RAIter, typename _Compare>
465    void
466    push_heap(_RAIter, _RAIter, _Compare);
467
468  // random_shuffle
469
470  template<typename _FIter, typename _Tp>
471    _FIter
472    remove(_FIter, _FIter, const _Tp&);
473
474  template<typename _FIter, typename _Predicate>
475    _FIter
476    remove_if(_FIter, _FIter, _Predicate);
477
478  template<typename _IIter, typename _OIter, typename _Tp>
479    _OIter
480    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
481
482  template<typename _IIter, typename _OIter, typename _Predicate>
483    _OIter
484    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
485
486  // replace
487
488  template<typename _IIter, typename _OIter, typename _Tp>
489    _OIter
490    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
491
492  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
493    _OIter
494    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
495
496  // replace_if
497
498  template<typename _BIter>
499    void
500    reverse(_BIter, _BIter);
501
502  template<typename _BIter, typename _OIter>
503    _OIter
504    reverse_copy(_BIter, _BIter, _OIter);
505
506  template<typename _FIter>
507    void
508    rotate(_FIter, _FIter, _FIter);
509
510  template<typename _FIter, typename _OIter>
511    _OIter
512    rotate_copy(_FIter, _FIter, _FIter, _OIter);
513
514  // search
515  // search_n
516  // set_difference
517  // set_intersection
518  // set_symmetric_difference
519  // set_union
520
521#if defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
522  template<typename _RAIter, typename _UGenerator>
523    void
524    shuffle(_RAIter, _RAIter, _UGenerator&);
525#endif
526
527  template<typename _RAIter>
528    void
529    sort_heap(_RAIter, _RAIter);
530
531  template<typename _RAIter, typename _Compare>
532    void
533    sort_heap(_RAIter, _RAIter, _Compare);
534
535  template<typename _BIter, typename _Predicate>
536    _BIter
537    stable_partition(_BIter, _BIter, _Predicate);
538
539  template<typename _Tp>
540    void
541    swap(_Tp&, _Tp&);
542
543  template<typename _Tp, size_t _Nm>
544    void
545    swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);
546
547  template<typename _FIter1, typename _FIter2>
548    _FIter2
549    swap_ranges(_FIter1, _FIter1, _FIter2);
550
551  // transform
552
553  template<typename _FIter>
554    _FIter
555    unique(_FIter, _FIter);
556
557  template<typename _FIter, typename _BinaryPredicate>
558    _FIter
559    unique(_FIter, _FIter, _BinaryPredicate);
560
561  // unique_copy
562
563  template<typename _FIter, typename _Tp>
564    _FIter
565    upper_bound(_FIter, _FIter, const _Tp&);
566
567  template<typename _FIter, typename _Tp, typename _Compare>
568    _FIter
569    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
570
571_GLIBCXX_END_NAMESPACE
572
573_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
574
575  template<typename _FIter>
576    _FIter
577    adjacent_find(_FIter, _FIter);
578
579  template<typename _FIter, typename _BinaryPredicate>
580    _FIter
581    adjacent_find(_FIter, _FIter, _BinaryPredicate);
582
583  template<typename _IIter, typename _Tp>
584    typename iterator_traits<_IIter>::difference_type
585    count(_IIter, _IIter, const _Tp&);
586
587  template<typename _IIter, typename _Predicate>
588    typename iterator_traits<_IIter>::difference_type
589    count_if(_IIter, _IIter, _Predicate);
590
591  template<typename _IIter1, typename _IIter2>
592    bool
593    equal(_IIter1, _IIter1, _IIter2);
594
595  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
596    bool
597    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
598
599  template<typename _IIter, typename _Tp>
600    _IIter
601    find(_IIter, _IIter, const _Tp&);
602
603  template<typename _FIter1, typename _FIter2>
604    _FIter1
605    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
606
607  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
608    _FIter1
609    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
610
611  template<typename _IIter, typename _Predicate>
612    _IIter
613    find_if(_IIter, _IIter, _Predicate);
614
615  template<typename _IIter, typename _Funct>
616    _Funct
617    for_each(_IIter, _IIter, _Funct);
618
619  template<typename _FIter, typename _Generator>
620    void
621    generate(_FIter, _FIter, _Generator);
622
623  template<typename _OIter, typename _Size, typename _Generator>
624    _OIter
625    generate_n(_OIter, _Size, _Generator);
626
627  template<typename _IIter1, typename _IIter2>
628    bool
629    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
630
631  template<typename _IIter1, typename _IIter2, typename _Compare>
632    bool
633    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
634
635  template<typename _FIter>
636    _FIter
637    max_element(_FIter, _FIter);
638
639  template<typename _FIter, typename _Compare>
640    _FIter
641    max_element(_FIter, _FIter, _Compare);
642
643  template<typename _IIter1, typename _IIter2, typename _OIter>
644    _OIter
645    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
646
647  template<typename _IIter1, typename _IIter2, typename _OIter,
648	   typename _Compare>
649    _OIter
650    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
651
652  template<typename _FIter>
653    _FIter
654    min_element(_FIter, _FIter);
655
656  template<typename _FIter, typename _Compare>
657    _FIter
658    min_element(_FIter, _FIter, _Compare);
659
660  template<typename _IIter1, typename _IIter2>
661    pair<_IIter1, _IIter2>
662    mismatch(_IIter1, _IIter1, _IIter2);
663
664  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
665    pair<_IIter1, _IIter2>
666    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
667
668  template<typename _RAIter>
669    void
670    nth_element(_RAIter, _RAIter, _RAIter);
671
672  template<typename _RAIter, typename _Compare>
673    void
674    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
675
676  template<typename _RAIter>
677    void
678    partial_sort(_RAIter, _RAIter, _RAIter);
679
680  template<typename _RAIter, typename _Compare>
681    void
682    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
683
684  template<typename _BIter, typename _Predicate>
685    _BIter
686    partition(_BIter, _BIter, _Predicate);
687
688  template<typename _RAIter>
689    void
690    random_shuffle(_RAIter, _RAIter);
691
692  template<typename _RAIter, typename _Generator>
693    void
694    random_shuffle(_RAIter, _RAIter,
695#ifdef __GXX_EXPERIMENTAL_CXX0X__
696		   _Generator&&);
697#else
698		   _Generator&);
699#endif
700
701  template<typename _FIter, typename _Tp>
702    void
703    replace(_FIter, _FIter, const _Tp&, const _Tp&);
704
705  template<typename _FIter, typename _Predicate, typename _Tp>
706    void
707    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
708
709  template<typename _FIter1, typename _FIter2>
710    _FIter1
711    search(_FIter1, _FIter1, _FIter2, _FIter2);
712
713  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
714    _FIter1
715    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
716
717  template<typename _FIter, typename _Size, typename _Tp>
718    _FIter
719    search_n(_FIter, _FIter, _Size, const _Tp&);
720
721  template<typename _FIter, typename _Size, typename _Tp,
722	   typename _BinaryPredicate>
723    _FIter
724    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
725
726  template<typename _IIter1, typename _IIter2, typename _OIter>
727    _OIter
728    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
729
730  template<typename _IIter1, typename _IIter2, typename _OIter,
731	   typename _Compare>
732    _OIter
733    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
734
735  template<typename _IIter1, typename _IIter2, typename _OIter>
736    _OIter
737    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
738
739  template<typename _IIter1, typename _IIter2, typename _OIter,
740	   typename _Compare>
741    _OIter
742    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
743
744  template<typename _IIter1, typename _IIter2, typename _OIter>
745    _OIter
746    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
747
748  template<typename _IIter1, typename _IIter2, typename _OIter,
749	   typename _Compare>
750    _OIter
751    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
752			     _OIter, _Compare);
753
754  template<typename _IIter1, typename _IIter2, typename _OIter>
755    _OIter
756    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
757
758  template<typename _IIter1, typename _IIter2, typename _OIter,
759	   typename _Compare>
760    _OIter
761    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
762
763  template<typename _RAIter>
764    void
765    sort(_RAIter, _RAIter);
766
767  template<typename _RAIter, typename _Compare>
768    void
769    sort(_RAIter, _RAIter, _Compare);
770
771  template<typename _RAIter>
772    void
773    stable_sort(_RAIter, _RAIter);
774
775  template<typename _RAIter, typename _Compare>
776    void
777    stable_sort(_RAIter, _RAIter, _Compare);
778
779  template<typename _IIter, typename _OIter, typename _UnaryOperation>
780    _OIter
781    transform(_IIter, _IIter, _OIter, _UnaryOperation);
782
783  template<typename _IIter1, typename _IIter2, typename _OIter,
784	   typename _BinaryOperation>
785    _OIter
786    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
787
788  template<typename _IIter, typename _OIter>
789    _OIter
790    unique_copy(_IIter, _IIter, _OIter);
791
792  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
793    _OIter
794    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
795
796_GLIBCXX_END_NESTED_NAMESPACE
797
798#ifdef _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL
799# include <parallel/algorithmfwd.h>
800#endif
801
802#endif
803
804