libstdc++

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