libstdc++
bits/algorithmfwd.h
Go to the documentation of this file.
1 // <algorithm> Forward 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 
std::max
const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:216
std
ISO C++ entities toplevel namespace is std.
std::minmax
pair< const _Tp &, const _Tp & > minmax(const _Tp &, const _Tp &)
Determines min and max at once as an ordered pair.
Definition: stl_algo.h:4039
std::swap
void swap(_Tp &, _Tp &) noexcept(__and_< is_nothrow_move_constructible< _Tp >, is_nothrow_move_assignable< _Tp >>::value)
Swaps two values.
Definition: move.h:166
std::min
const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:193