libstdc++
bits/algorithmfwd.h
Go to the documentation of this file.
1 // <algorithm> declarations -*- C++ -*-
2 
3 // Copyright (C) 2007, 2008, 2009 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>
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  sort
115  sort_heap
116  stable_partition
117  stable_sort
118  swap
119  swap_ranges
120  transform
121  unique
122  unique_copy
123  upper_bound
124  */
125 
126  /**
127  * @defgroup algorithms Algorithms
128  *
129  * Components for performing algorithmic operations. Includes
130  * non-modifying sequence, modifying (mutating) sequence, sorting,
131  * searching, merge, partition, heap, set, minima, maxima, and
132  * permutation operations.
133  */
134 
135  /**
136  * @defgroup mutating_algorithms Mutating Algorithms
137  * @ingroup algorithms
138  */
139 
140  /**
141  * @defgroup non_mutating_algorithms Non-Mutating Algorithms
142  * @ingroup algorithms
143  */
144 
145  /**
146  * @defgroup sorting_algorithms Sorting Algorithms
147  * @ingroup algorithms
148  */
149 
150  /**
151  * @defgroup set_algorithms Set Operation Algorithms
152  * @ingroup sorting_algorithms
153  *
154  * These algorithms are common set operations performed on sequences
155  * that are already sorted. The number of comparisons will be
156  * linear.
157  */
158 
159  /**
160  * @defgroup binary_search_algorithms Binary Search Algorithms
161  * @ingroup sorting_algorithms
162  *
163  * These algorithms are variations of a classic binary search, and
164  * all assume that the sequence being searched is already sorted.
165  *
166  * The number of comparisons will be logarithmic (and as few as
167  * possible). The number of steps through the sequence will be
168  * logarithmic for random-access iterators (e.g., pointers), and
169  * linear otherwise.
170  *
171  * The LWG has passed Defect Report 270, which notes: <em>The
172  * proposed resolution reinterprets binary search. Instead of
173  * thinking about searching for a value in a sorted range, we view
174  * that as an important special case of a more general algorithm:
175  * searching for the partition point in a partitioned range. We
176  * also add a guarantee that the old wording did not: we ensure that
177  * the upper bound is no earlier than the lower bound, that the pair
178  * returned by equal_range is a valid range, and that the first part
179  * of that pair is the lower bound.</em>
180  *
181  * The actual effect of the first sentence is that a comparison
182  * functor passed by the user doesn't necessarily need to induce a
183  * strict weak ordering relation. Rather, it partitions the range.
184  */
185 
186  // adjacent_find
187 
188 #ifdef __GXX_EXPERIMENTAL_CXX0X__
189  template<typename _IIter, typename _Predicate>
190  bool
191  all_of(_IIter, _IIter, _Predicate);
192 
193  template<typename _IIter, typename _Predicate>
194  bool
195  any_of(_IIter, _IIter, _Predicate);
196 #endif
197 
198  template<typename _FIter, typename _Tp>
199  bool
200  binary_search(_FIter, _FIter, const _Tp&);
201 
202  template<typename _FIter, typename _Tp, typename _Compare>
203  bool
204  binary_search(_FIter, _FIter, const _Tp&, _Compare);
205 
206  template<typename _IIter, typename _OIter>
207  _OIter
208  copy(_IIter, _IIter, _OIter);
209 
210  template<typename _BIter1, typename _BIter2>
211  _BIter2
212  copy_backward(_BIter1, _BIter1, _BIter2);
213 
214 #ifdef __GXX_EXPERIMENTAL_CXX0X__
215  template<typename _IIter, typename _OIter, typename _Predicate>
216  _OIter
217  copy_if(_IIter, _IIter, _OIter, _Predicate);
218 
219  template<typename _IIter, typename _Size, typename _OIter>
220  _OIter
221  copy_n(_IIter, _Size, _OIter);
222 #endif
223 
224  // count
225  // count_if
226 
227  template<typename _FIter, typename _Tp>
228  pair<_FIter, _FIter>
229  equal_range(_FIter, _FIter, const _Tp&);
230 
231  template<typename _FIter, typename _Tp, typename _Compare>
232  pair<_FIter, _FIter>
233  equal_range(_FIter, _FIter, const _Tp&, _Compare);
234 
235  template<typename _FIter, typename _Tp>
236  void
237  fill(_FIter, _FIter, const _Tp&);
238 
239 /*
240  XXX NB: return type different from ISO C++.
241  template<typename _OIter, typename _Size, typename _Tp>
242  void
243  fill_n(_OIter, _Size, const _Tp&);
244 */
245 
246  template<typename _OIter, typename _Size, typename _Tp>
247  _OIter
248  fill_n(_OIter, _Size, const _Tp&);
249 
250  // find
251 
252  template<typename _FIter1, typename _FIter2>
253  _FIter1
254  find_end(_FIter1, _FIter1, _FIter2, _FIter2);
255 
256  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
257  _FIter1
258  find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
259 
260  // find_first_of
261  // find_if
262 
263 #ifdef __GXX_EXPERIMENTAL_CXX0X__
264  template<typename _IIter, typename _Predicate>
265  _IIter
266  find_if_not(_IIter, _IIter, _Predicate);
267 #endif
268 
269  // for_each
270  // generate
271  // generate_n
272 
273  template<typename _IIter1, typename _IIter2>
274  bool
275  includes(_IIter1, _IIter1, _IIter2, _IIter2);
276 
277  template<typename _IIter1, typename _IIter2, typename _Compare>
278  bool
279  includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
280 
281  template<typename _BIter>
282  void
283  inplace_merge(_BIter, _BIter, _BIter);
284 
285  template<typename _BIter, typename _Compare>
286  void
287  inplace_merge(_BIter, _BIter, _BIter, _Compare);
288 
289 #ifdef __GXX_EXPERIMENTAL_CXX0X__
290  template<typename _RAIter>
291  bool
292  is_heap(_RAIter, _RAIter);
293 
294  template<typename _RAIter, typename _Compare>
295  bool
296  is_heap(_RAIter, _RAIter, _Compare);
297 
298  template<typename _RAIter>
299  _RAIter
300  is_heap_until(_RAIter, _RAIter);
301 
302  template<typename _RAIter, typename _Compare>
303  _RAIter
304  is_heap_until(_RAIter, _RAIter, _Compare);
305 
306  template<typename _IIter, typename _Predicate>
307  bool
308  is_partitioned(_IIter, _IIter, _Predicate);
309 
310  template<typename _FIter>
311  bool
312  is_sorted(_FIter, _FIter);
313 
314  template<typename _FIter, typename _Compare>
315  bool
316  is_sorted(_FIter, _FIter, _Compare);
317 
318  template<typename _FIter>
319  _FIter
320  is_sorted_until(_FIter, _FIter);
321 
322  template<typename _FIter, typename _Compare>
323  _FIter
324  is_sorted_until(_FIter, _FIter, _Compare);
325 #endif
326 
327  template<typename _FIter1, typename _FIter2>
328  void
329  iter_swap(_FIter1, _FIter2);
330 
331  template<typename _FIter, typename _Tp>
332  _FIter
333  lower_bound(_FIter, _FIter, const _Tp&);
334 
335  template<typename _FIter, typename _Tp, typename _Compare>
336  _FIter
337  lower_bound(_FIter, _FIter, const _Tp&, _Compare);
338 
339  template<typename _RAIter>
340  void
341  make_heap(_RAIter, _RAIter);
342 
343  template<typename _RAIter, typename _Compare>
344  void
345  make_heap(_RAIter, _RAIter, _Compare);
346 
347  template<typename _Tp>
348  const _Tp&
349  max(const _Tp&, const _Tp&);
350 
351  template<typename _Tp, typename _Compare>
352  const _Tp&
353  max(const _Tp&, const _Tp&, _Compare);
354 
355  // max_element
356  // merge
357 
358  template<typename _Tp>
359  const _Tp&
360  min(const _Tp&, const _Tp&);
361 
362  template<typename _Tp, typename _Compare>
363  const _Tp&
364  min(const _Tp&, const _Tp&, _Compare);
365 
366  // min_element
367 
368 #ifdef __GXX_EXPERIMENTAL_CXX0X__
369  template<typename _Tp>
370  pair<const _Tp&, const _Tp&>
371  minmax(const _Tp&, const _Tp&);
372 
373  template<typename _Tp, typename _Compare>
374  pair<const _Tp&, const _Tp&>
375  minmax(const _Tp&, const _Tp&, _Compare);
376 
377  template<typename _FIter>
378  pair<_FIter, _FIter>
379  minmax_element(_FIter, _FIter);
380 
381  template<typename _FIter, typename _Compare>
382  pair<_FIter, _FIter>
383  minmax_element(_FIter, _FIter, _Compare);
384 
385  template<typename _Tp>
386  _Tp
387  min(initializer_list<_Tp>);
388 
389  template<typename _Tp, typename _Compare>
390  _Tp
391  min(initializer_list<_Tp>, _Compare);
392 
393  template<typename _Tp>
394  _Tp
395  max(initializer_list<_Tp>);
396 
397  template<typename _Tp, typename _Compare>
398  _Tp
399  max(initializer_list<_Tp>, _Compare);
400 
401  template<typename _Tp>
402  pair<_Tp, _Tp>
403  minmax(initializer_list<_Tp>);
404 
405  template<typename _Tp, typename _Compare>
406  pair<_Tp, _Tp>
407  minmax(initializer_list<_Tp>, _Compare);
408 #endif
409 
410  // mismatch
411 
412  template<typename _BIter>
413  bool
414  next_permutation(_BIter, _BIter);
415 
416  template<typename _BIter, typename _Compare>
417  bool
418  next_permutation(_BIter, _BIter, _Compare);
419 
420 #ifdef __GXX_EXPERIMENTAL_CXX0X__
421  template<typename _IIter, typename _Predicate>
422  bool
423  none_of(_IIter, _IIter, _Predicate);
424 #endif
425 
426  // nth_element
427  // partial_sort
428 
429  template<typename _IIter, typename _RAIter>
430  _RAIter
431  partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
432 
433  template<typename _IIter, typename _RAIter, typename _Compare>
434  _RAIter
435  partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
436 
437  // partition
438 
439 #ifdef __GXX_EXPERIMENTAL_CXX0X__
440  template<typename _IIter, typename _OIter1,
441  typename _OIter2, typename _Predicate>
442  pair<_OIter1, _OIter2>
443  partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
444 
445  template<typename _FIter, typename _Predicate>
446  _FIter
447  partition_point(_FIter, _FIter, _Predicate);
448 #endif
449 
450  template<typename _RAIter>
451  void
452  pop_heap(_RAIter, _RAIter);
453 
454  template<typename _RAIter, typename _Compare>
455  void
456  pop_heap(_RAIter, _RAIter, _Compare);
457 
458  template<typename _BIter>
459  bool
460  prev_permutation(_BIter, _BIter);
461 
462  template<typename _BIter, typename _Compare>
463  bool
464  prev_permutation(_BIter, _BIter, _Compare);
465 
466  template<typename _RAIter>
467  void
468  push_heap(_RAIter, _RAIter);
469 
470  template<typename _RAIter, typename _Compare>
471  void
472  push_heap(_RAIter, _RAIter, _Compare);
473 
474  // random_shuffle
475 
476  template<typename _FIter, typename _Tp>
477  _FIter
478  remove(_FIter, _FIter, const _Tp&);
479 
480  template<typename _FIter, typename _Predicate>
481  _FIter
482  remove_if(_FIter, _FIter, _Predicate);
483 
484  template<typename _IIter, typename _OIter, typename _Tp>
485  _OIter
486  remove_copy(_IIter, _IIter, _OIter, const _Tp&);
487 
488  template<typename _IIter, typename _OIter, typename _Predicate>
489  _OIter
490  remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
491 
492  // replace
493 
494  template<typename _IIter, typename _OIter, typename _Tp>
495  _OIter
496  replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
497 
498  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
499  _OIter
500  replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
501 
502  // replace_if
503 
504  template<typename _BIter>
505  void
506  reverse(_BIter, _BIter);
507 
508  template<typename _BIter, typename _OIter>
509  _OIter
510  reverse_copy(_BIter, _BIter, _OIter);
511 
512  template<typename _FIter>
513  void
514  rotate(_FIter, _FIter, _FIter);
515 
516  template<typename _FIter, typename _OIter>
517  _OIter
518  rotate_copy(_FIter, _FIter, _FIter, _OIter);
519 
520  // search
521  // search_n
522  // set_difference
523  // set_intersection
524  // set_symmetric_difference
525  // set_union
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 /*
624  XXX NB: return type different from ISO C++.
625  template<typename _OIter, typename _Size, typename _Tp>
626  void
627  generate_n(_OIter, _Size, _Generator);
628 */
629 
630  template<typename _OIter, typename _Size, typename _Generator>
631  _OIter
632  generate_n(_OIter, _Size, _Generator);
633 
634  template<typename _IIter1, typename _IIter2>
635  bool
636  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
637 
638  template<typename _IIter1, typename _IIter2, typename _Compare>
639  bool
640  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
641 
642  template<typename _FIter>
643  _FIter
644  max_element(_FIter, _FIter);
645 
646  template<typename _FIter, typename _Compare>
647  _FIter
648  max_element(_FIter, _FIter, _Compare);
649 
650  template<typename _IIter1, typename _IIter2, typename _OIter>
651  _OIter
652  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
653 
654  template<typename _IIter1, typename _IIter2, typename _OIter,
655  typename _Compare>
656  _OIter
657  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
658 
659  template<typename _FIter>
660  _FIter
661  min_element(_FIter, _FIter);
662 
663  template<typename _FIter, typename _Compare>
664  _FIter
665  min_element(_FIter, _FIter, _Compare);
666 
667  template<typename _IIter1, typename _IIter2>
668  pair<_IIter1, _IIter2>
669  mismatch(_IIter1, _IIter1, _IIter2);
670 
671  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
672  pair<_IIter1, _IIter2>
673  mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
674 
675  template<typename _RAIter>
676  void
677  nth_element(_RAIter, _RAIter, _RAIter);
678 
679  template<typename _RAIter, typename _Compare>
680  void
681  nth_element(_RAIter, _RAIter, _RAIter, _Compare);
682 
683  template<typename _RAIter>
684  void
685  partial_sort(_RAIter, _RAIter, _RAIter);
686 
687  template<typename _RAIter, typename _Compare>
688  void
689  partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
690 
691  template<typename _BIter, typename _Predicate>
692  _BIter
693  partition(_BIter, _BIter, _Predicate);
694 
695  template<typename _RAIter>
696  void
697  random_shuffle(_RAIter, _RAIter);
698 
699  template<typename _RAIter, typename _Generator>
700  void
701  random_shuffle(_RAIter, _RAIter, _Generator&);
702 
703  template<typename _FIter, typename _Tp>
704  void
705  replace(_FIter, _FIter, const _Tp&, const _Tp&);
706 
707  template<typename _FIter, typename _Predicate, typename _Tp>
708  void
709  replace_if(_FIter, _FIter, _Predicate, const _Tp&);
710 
711  template<typename _FIter1, typename _FIter2>
712  _FIter1
713  search(_FIter1, _FIter1, _FIter2, _FIter2);
714 
715  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
716  _FIter1
717  search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
718 
719  template<typename _FIter, typename _Size, typename _Tp>
720  _FIter
721  search_n(_FIter, _FIter, _Size, const _Tp&);
722 
723  template<typename _FIter, typename _Size, typename _Tp,
724  typename _BinaryPredicate>
725  _FIter
726  search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
727 
728  template<typename _IIter1, typename _IIter2, typename _OIter>
729  _OIter
730  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
731 
732  template<typename _IIter1, typename _IIter2, typename _OIter,
733  typename _Compare>
734  _OIter
735  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
736 
737  template<typename _IIter1, typename _IIter2, typename _OIter>
738  _OIter
739  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
740 
741  template<typename _IIter1, typename _IIter2, typename _OIter,
742  typename _Compare>
743  _OIter
744  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
745 
746  template<typename _IIter1, typename _IIter2, typename _OIter>
747  _OIter
748  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
749 
750  template<typename _IIter1, typename _IIter2, typename _OIter,
751  typename _Compare>
752  _OIter
753  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
754  _OIter, _Compare);
755 
756  template<typename _IIter1, typename _IIter2, typename _OIter>
757  _OIter
758  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
759 
760  template<typename _IIter1, typename _IIter2, typename _OIter,
761  typename _Compare>
762  _OIter
763  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
764 
765  template<typename _RAIter>
766  void
767  sort(_RAIter, _RAIter);
768 
769  template<typename _RAIter, typename _Compare>
770  void
771  sort(_RAIter, _RAIter, _Compare);
772 
773  template<typename _RAIter>
774  void
775  stable_sort(_RAIter, _RAIter);
776 
777  template<typename _RAIter, typename _Compare>
778  void
779  stable_sort(_RAIter, _RAIter, _Compare);
780 
781  template<typename _IIter, typename _OIter, typename _UnaryOperation>
782  _OIter
783  transform(_IIter, _IIter, _OIter, _UnaryOperation);
784 
785  template<typename _IIter1, typename _IIter2, typename _OIter,
786  typename _BinaryOperation>
787  _OIter
788  transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
789 
790  template<typename _IIter, typename _OIter>
791  _OIter
792  unique_copy(_IIter, _IIter, _OIter);
793 
794  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
795  _OIter
796  unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
797 
798 _GLIBCXX_END_NESTED_NAMESPACE
799 
800 #ifdef _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL
801 # include <parallel/algorithmfwd.h>
802 #endif
803 
804 #endif
805 
bool is_sorted(_ForwardIterator __first, _ForwardIterator __last)
Definition: ext/algorithm:477
bool equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate)
Tests a range for element-wise equality.
Definition: stl_algobase.h:984
const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:209
const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:186
pair< _InputIterator, _OutputIterator > copy_n(_InputIterator __first, _Size __count, _OutputIterator __result)
Copies the range [first,first+count) into [result,result+count).
Definition: ext/algorithm:119
pair< const _Tp &, const _Tp & > minmax(const _Tp &, const _Tp &)
Determines min and max at once as an ordered pair.
Definition: stl_algo.h:3958
bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
Definition: ext/algorithm:433