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