libstdc++
bits/algorithmfwd.h
Go to the documentation of this file.
1 // <algorithm> Forward declarations -*- C++ -*-
2 
3 // Copyright (C) 2007-2020 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 Operations
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 > 201703L
195 # define __cpp_lib_constexpr_algorithms 201806L
196 #endif
197 
198 #if __cplusplus >= 201103L
199  template<typename _IIter, typename _Predicate>
200  _GLIBCXX20_CONSTEXPR
201  bool
202  all_of(_IIter, _IIter, _Predicate);
203 
204  template<typename _IIter, typename _Predicate>
205  _GLIBCXX20_CONSTEXPR
206  bool
207  any_of(_IIter, _IIter, _Predicate);
208 #endif
209 
210  template<typename _FIter, typename _Tp>
211  _GLIBCXX20_CONSTEXPR
212  bool
213  binary_search(_FIter, _FIter, const _Tp&);
214 
215  template<typename _FIter, typename _Tp, typename _Compare>
216  _GLIBCXX20_CONSTEXPR
217  bool
218  binary_search(_FIter, _FIter, const _Tp&, _Compare);
219 
220 #if __cplusplus > 201402L
221  template<typename _Tp>
222  _GLIBCXX14_CONSTEXPR
223  const _Tp&
224  clamp(const _Tp&, const _Tp&, const _Tp&);
225 
226  template<typename _Tp, typename _Compare>
227  _GLIBCXX14_CONSTEXPR
228  const _Tp&
229  clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
230 #endif
231 
232  template<typename _IIter, typename _OIter>
233  _GLIBCXX20_CONSTEXPR
234  _OIter
235  copy(_IIter, _IIter, _OIter);
236 
237  template<typename _BIter1, typename _BIter2>
238  _GLIBCXX20_CONSTEXPR
239  _BIter2
240  copy_backward(_BIter1, _BIter1, _BIter2);
241 
242 #if __cplusplus >= 201103L
243  template<typename _IIter, typename _OIter, typename _Predicate>
244  _GLIBCXX20_CONSTEXPR
245  _OIter
246  copy_if(_IIter, _IIter, _OIter, _Predicate);
247 
248  template<typename _IIter, typename _Size, typename _OIter>
249  _GLIBCXX20_CONSTEXPR
250  _OIter
251  copy_n(_IIter, _Size, _OIter);
252 #endif
253 
254  // count
255  // count_if
256 
257  template<typename _FIter, typename _Tp>
258  _GLIBCXX20_CONSTEXPR
259  pair<_FIter, _FIter>
260  equal_range(_FIter, _FIter, const _Tp&);
261 
262  template<typename _FIter, typename _Tp, typename _Compare>
263  _GLIBCXX20_CONSTEXPR
264  pair<_FIter, _FIter>
265  equal_range(_FIter, _FIter, const _Tp&, _Compare);
266 
267  template<typename _FIter, typename _Tp>
268  _GLIBCXX20_CONSTEXPR
269  void
270  fill(_FIter, _FIter, const _Tp&);
271 
272  template<typename _OIter, typename _Size, typename _Tp>
273  _GLIBCXX20_CONSTEXPR
274  _OIter
275  fill_n(_OIter, _Size, const _Tp&);
276 
277  // find
278 
279  template<typename _FIter1, typename _FIter2>
280  _GLIBCXX20_CONSTEXPR
281  _FIter1
282  find_end(_FIter1, _FIter1, _FIter2, _FIter2);
283 
284  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
285  _GLIBCXX20_CONSTEXPR
286  _FIter1
287  find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
288 
289  // find_first_of
290  // find_if
291 
292 #if __cplusplus >= 201103L
293  template<typename _IIter, typename _Predicate>
294  _GLIBCXX20_CONSTEXPR
295  _IIter
296  find_if_not(_IIter, _IIter, _Predicate);
297 #endif
298 
299  // for_each
300  // generate
301  // generate_n
302 
303  template<typename _IIter1, typename _IIter2>
304  _GLIBCXX20_CONSTEXPR
305  bool
306  includes(_IIter1, _IIter1, _IIter2, _IIter2);
307 
308  template<typename _IIter1, typename _IIter2, typename _Compare>
309  _GLIBCXX20_CONSTEXPR
310  bool
311  includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
312 
313  template<typename _BIter>
314  void
315  inplace_merge(_BIter, _BIter, _BIter);
316 
317  template<typename _BIter, typename _Compare>
318  void
319  inplace_merge(_BIter, _BIter, _BIter, _Compare);
320 
321 #if __cplusplus >= 201103L
322  template<typename _RAIter>
323  _GLIBCXX20_CONSTEXPR
324  bool
325  is_heap(_RAIter, _RAIter);
326 
327  template<typename _RAIter, typename _Compare>
328  _GLIBCXX20_CONSTEXPR
329  bool
330  is_heap(_RAIter, _RAIter, _Compare);
331 
332  template<typename _RAIter>
333  _GLIBCXX20_CONSTEXPR
334  _RAIter
335  is_heap_until(_RAIter, _RAIter);
336 
337  template<typename _RAIter, typename _Compare>
338  _GLIBCXX20_CONSTEXPR
339  _RAIter
340  is_heap_until(_RAIter, _RAIter, _Compare);
341 
342  template<typename _IIter, typename _Predicate>
343  _GLIBCXX20_CONSTEXPR
344  bool
345  is_partitioned(_IIter, _IIter, _Predicate);
346 
347  template<typename _FIter1, typename _FIter2>
348  _GLIBCXX20_CONSTEXPR
349  bool
350  is_permutation(_FIter1, _FIter1, _FIter2);
351 
352  template<typename _FIter1, typename _FIter2,
353  typename _BinaryPredicate>
354  _GLIBCXX20_CONSTEXPR
355  bool
356  is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
357 
358  template<typename _FIter>
359  _GLIBCXX20_CONSTEXPR
360  bool
361  is_sorted(_FIter, _FIter);
362 
363  template<typename _FIter, typename _Compare>
364  _GLIBCXX20_CONSTEXPR
365  bool
366  is_sorted(_FIter, _FIter, _Compare);
367 
368  template<typename _FIter>
369  _GLIBCXX20_CONSTEXPR
370  _FIter
371  is_sorted_until(_FIter, _FIter);
372 
373  template<typename _FIter, typename _Compare>
374  _GLIBCXX20_CONSTEXPR
375  _FIter
376  is_sorted_until(_FIter, _FIter, _Compare);
377 #endif
378 
379  template<typename _FIter1, typename _FIter2>
380  _GLIBCXX20_CONSTEXPR
381  void
382  iter_swap(_FIter1, _FIter2);
383 
384  template<typename _FIter, typename _Tp>
385  _GLIBCXX20_CONSTEXPR
386  _FIter
387  lower_bound(_FIter, _FIter, const _Tp&);
388 
389  template<typename _FIter, typename _Tp, typename _Compare>
390  _GLIBCXX20_CONSTEXPR
391  _FIter
392  lower_bound(_FIter, _FIter, const _Tp&, _Compare);
393 
394  template<typename _RAIter>
395  _GLIBCXX20_CONSTEXPR
396  void
397  make_heap(_RAIter, _RAIter);
398 
399  template<typename _RAIter, typename _Compare>
400  _GLIBCXX20_CONSTEXPR
401  void
402  make_heap(_RAIter, _RAIter, _Compare);
403 
404  template<typename _Tp>
405  _GLIBCXX14_CONSTEXPR
406  const _Tp&
407  max(const _Tp&, const _Tp&);
408 
409  template<typename _Tp, typename _Compare>
410  _GLIBCXX14_CONSTEXPR
411  const _Tp&
412  max(const _Tp&, const _Tp&, _Compare);
413 
414  // max_element
415  // merge
416 
417  template<typename _Tp>
418  _GLIBCXX14_CONSTEXPR
419  const _Tp&
420  min(const _Tp&, const _Tp&);
421 
422  template<typename _Tp, typename _Compare>
423  _GLIBCXX14_CONSTEXPR
424  const _Tp&
425  min(const _Tp&, const _Tp&, _Compare);
426 
427  // min_element
428 
429 #if __cplusplus >= 201103L
430  template<typename _Tp>
431  _GLIBCXX14_CONSTEXPR
432  pair<const _Tp&, const _Tp&>
433  minmax(const _Tp&, const _Tp&);
434 
435  template<typename _Tp, typename _Compare>
436  _GLIBCXX14_CONSTEXPR
437  pair<const _Tp&, const _Tp&>
438  minmax(const _Tp&, const _Tp&, _Compare);
439 
440  template<typename _FIter>
441  _GLIBCXX14_CONSTEXPR
442  pair<_FIter, _FIter>
443  minmax_element(_FIter, _FIter);
444 
445  template<typename _FIter, typename _Compare>
446  _GLIBCXX14_CONSTEXPR
447  pair<_FIter, _FIter>
448  minmax_element(_FIter, _FIter, _Compare);
449 
450  template<typename _Tp>
451  _GLIBCXX14_CONSTEXPR
452  _Tp
453  min(initializer_list<_Tp>);
454 
455  template<typename _Tp, typename _Compare>
456  _GLIBCXX14_CONSTEXPR
457  _Tp
458  min(initializer_list<_Tp>, _Compare);
459 
460  template<typename _Tp>
461  _GLIBCXX14_CONSTEXPR
462  _Tp
463  max(initializer_list<_Tp>);
464 
465  template<typename _Tp, typename _Compare>
466  _GLIBCXX14_CONSTEXPR
467  _Tp
468  max(initializer_list<_Tp>, _Compare);
469 
470  template<typename _Tp>
471  _GLIBCXX14_CONSTEXPR
472  pair<_Tp, _Tp>
473  minmax(initializer_list<_Tp>);
474 
475  template<typename _Tp, typename _Compare>
476  _GLIBCXX14_CONSTEXPR
477  pair<_Tp, _Tp>
478  minmax(initializer_list<_Tp>, _Compare);
479 #endif
480 
481  // mismatch
482 
483  template<typename _BIter>
484  _GLIBCXX20_CONSTEXPR
485  bool
486  next_permutation(_BIter, _BIter);
487 
488  template<typename _BIter, typename _Compare>
489  _GLIBCXX20_CONSTEXPR
490  bool
491  next_permutation(_BIter, _BIter, _Compare);
492 
493 #if __cplusplus >= 201103L
494  template<typename _IIter, typename _Predicate>
495  _GLIBCXX20_CONSTEXPR
496  bool
497  none_of(_IIter, _IIter, _Predicate);
498 #endif
499 
500  // nth_element
501  // partial_sort
502 
503  template<typename _IIter, typename _RAIter>
504  _GLIBCXX20_CONSTEXPR
505  _RAIter
506  partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
507 
508  template<typename _IIter, typename _RAIter, typename _Compare>
509  _GLIBCXX20_CONSTEXPR
510  _RAIter
511  partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
512 
513  // partition
514 
515 #if __cplusplus >= 201103L
516  template<typename _IIter, typename _OIter1,
517  typename _OIter2, typename _Predicate>
518  _GLIBCXX20_CONSTEXPR
519  pair<_OIter1, _OIter2>
520  partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
521 
522  template<typename _FIter, typename _Predicate>
523  _GLIBCXX20_CONSTEXPR
524  _FIter
525  partition_point(_FIter, _FIter, _Predicate);
526 #endif
527 
528  template<typename _RAIter>
529  _GLIBCXX20_CONSTEXPR
530  void
531  pop_heap(_RAIter, _RAIter);
532 
533  template<typename _RAIter, typename _Compare>
534  _GLIBCXX20_CONSTEXPR
535  void
536  pop_heap(_RAIter, _RAIter, _Compare);
537 
538  template<typename _BIter>
539  _GLIBCXX20_CONSTEXPR
540  bool
541  prev_permutation(_BIter, _BIter);
542 
543  template<typename _BIter, typename _Compare>
544  _GLIBCXX20_CONSTEXPR
545  bool
546  prev_permutation(_BIter, _BIter, _Compare);
547 
548  template<typename _RAIter>
549  _GLIBCXX20_CONSTEXPR
550  void
551  push_heap(_RAIter, _RAIter);
552 
553  template<typename _RAIter, typename _Compare>
554  _GLIBCXX20_CONSTEXPR
555  void
556  push_heap(_RAIter, _RAIter, _Compare);
557 
558  // random_shuffle
559 
560  template<typename _FIter, typename _Tp>
561  _GLIBCXX20_CONSTEXPR
562  _FIter
563  remove(_FIter, _FIter, const _Tp&);
564 
565  template<typename _FIter, typename _Predicate>
566  _GLIBCXX20_CONSTEXPR
567  _FIter
568  remove_if(_FIter, _FIter, _Predicate);
569 
570  template<typename _IIter, typename _OIter, typename _Tp>
571  _GLIBCXX20_CONSTEXPR
572  _OIter
573  remove_copy(_IIter, _IIter, _OIter, const _Tp&);
574 
575  template<typename _IIter, typename _OIter, typename _Predicate>
576  _GLIBCXX20_CONSTEXPR
577  _OIter
578  remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
579 
580  // replace
581 
582  template<typename _IIter, typename _OIter, typename _Tp>
583  _GLIBCXX20_CONSTEXPR
584  _OIter
585  replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
586 
587  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
588  _GLIBCXX20_CONSTEXPR
589  _OIter
590  replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
591 
592  // replace_if
593 
594  template<typename _BIter>
595  _GLIBCXX20_CONSTEXPR
596  void
597  reverse(_BIter, _BIter);
598 
599  template<typename _BIter, typename _OIter>
600  _GLIBCXX20_CONSTEXPR
601  _OIter
602  reverse_copy(_BIter, _BIter, _OIter);
603 
604  inline namespace _V2
605  {
606  template<typename _FIter>
607  _GLIBCXX20_CONSTEXPR
608  _FIter
609  rotate(_FIter, _FIter, _FIter);
610  }
611 
612  template<typename _FIter, typename _OIter>
613  _GLIBCXX20_CONSTEXPR
614  _OIter
615  rotate_copy(_FIter, _FIter, _FIter, _OIter);
616 
617  // search
618  // search_n
619  // set_difference
620  // set_intersection
621  // set_symmetric_difference
622  // set_union
623 
624 #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
625  template<typename _RAIter, typename _UGenerator>
626  void
627  shuffle(_RAIter, _RAIter, _UGenerator&&);
628 #endif
629 
630  template<typename _RAIter>
631  _GLIBCXX20_CONSTEXPR
632  void
633  sort_heap(_RAIter, _RAIter);
634 
635  template<typename _RAIter, typename _Compare>
636  _GLIBCXX20_CONSTEXPR
637  void
638  sort_heap(_RAIter, _RAIter, _Compare);
639 
640  template<typename _BIter, typename _Predicate>
641  _BIter
642  stable_partition(_BIter, _BIter, _Predicate);
643 
644 #if __cplusplus < 201103L
645  // For C++11 swap() is declared in <type_traits>.
646 
647  template<typename _Tp, size_t _Nm>
648  _GLIBCXX20_CONSTEXPR
649  inline void
650  swap(_Tp& __a, _Tp& __b);
651 
652  template<typename _Tp, size_t _Nm>
653  _GLIBCXX20_CONSTEXPR
654  inline void
655  swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
656 #endif
657 
658  template<typename _FIter1, typename _FIter2>
659  _GLIBCXX20_CONSTEXPR
660  _FIter2
661  swap_ranges(_FIter1, _FIter1, _FIter2);
662 
663  // transform
664 
665  template<typename _FIter>
666  _GLIBCXX20_CONSTEXPR
667  _FIter
668  unique(_FIter, _FIter);
669 
670  template<typename _FIter, typename _BinaryPredicate>
671  _GLIBCXX20_CONSTEXPR
672  _FIter
673  unique(_FIter, _FIter, _BinaryPredicate);
674 
675  // unique_copy
676 
677  template<typename _FIter, typename _Tp>
678  _GLIBCXX20_CONSTEXPR
679  _FIter
680  upper_bound(_FIter, _FIter, const _Tp&);
681 
682  template<typename _FIter, typename _Tp, typename _Compare>
683  _GLIBCXX20_CONSTEXPR
684  _FIter
685  upper_bound(_FIter, _FIter, const _Tp&, _Compare);
686 
687 _GLIBCXX_BEGIN_NAMESPACE_ALGO
688 
689  template<typename _FIter>
690  _GLIBCXX20_CONSTEXPR
691  _FIter
692  adjacent_find(_FIter, _FIter);
693 
694  template<typename _FIter, typename _BinaryPredicate>
695  _GLIBCXX20_CONSTEXPR
696  _FIter
697  adjacent_find(_FIter, _FIter, _BinaryPredicate);
698 
699  template<typename _IIter, typename _Tp>
700  _GLIBCXX20_CONSTEXPR
701  typename iterator_traits<_IIter>::difference_type
702  count(_IIter, _IIter, const _Tp&);
703 
704  template<typename _IIter, typename _Predicate>
705  _GLIBCXX20_CONSTEXPR
706  typename iterator_traits<_IIter>::difference_type
707  count_if(_IIter, _IIter, _Predicate);
708 
709  template<typename _IIter1, typename _IIter2>
710  _GLIBCXX20_CONSTEXPR
711  bool
712  equal(_IIter1, _IIter1, _IIter2);
713 
714  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
715  _GLIBCXX20_CONSTEXPR
716  bool
717  equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
718 
719  template<typename _IIter, typename _Tp>
720  _GLIBCXX20_CONSTEXPR
721  _IIter
722  find(_IIter, _IIter, const _Tp&);
723 
724  template<typename _FIter1, typename _FIter2>
725  _GLIBCXX20_CONSTEXPR
726  _FIter1
727  find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
728 
729  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
730  _GLIBCXX20_CONSTEXPR
731  _FIter1
732  find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
733 
734  template<typename _IIter, typename _Predicate>
735  _GLIBCXX20_CONSTEXPR
736  _IIter
737  find_if(_IIter, _IIter, _Predicate);
738 
739  template<typename _IIter, typename _Funct>
740  _GLIBCXX20_CONSTEXPR
741  _Funct
742  for_each(_IIter, _IIter, _Funct);
743 
744  template<typename _FIter, typename _Generator>
745  _GLIBCXX20_CONSTEXPR
746  void
747  generate(_FIter, _FIter, _Generator);
748 
749  template<typename _OIter, typename _Size, typename _Generator>
750  _GLIBCXX20_CONSTEXPR
751  _OIter
752  generate_n(_OIter, _Size, _Generator);
753 
754  template<typename _IIter1, typename _IIter2>
755  _GLIBCXX20_CONSTEXPR
756  bool
757  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
758 
759  template<typename _IIter1, typename _IIter2, typename _Compare>
760  _GLIBCXX20_CONSTEXPR
761  bool
762  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
763 
764  template<typename _FIter>
765  _GLIBCXX14_CONSTEXPR
766  _FIter
767  max_element(_FIter, _FIter);
768 
769  template<typename _FIter, typename _Compare>
770  _GLIBCXX14_CONSTEXPR
771  _FIter
772  max_element(_FIter, _FIter, _Compare);
773 
774  template<typename _IIter1, typename _IIter2, typename _OIter>
775  _GLIBCXX20_CONSTEXPR
776  _OIter
777  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
778 
779  template<typename _IIter1, typename _IIter2, typename _OIter,
780  typename _Compare>
781  _GLIBCXX20_CONSTEXPR
782  _OIter
783  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
784 
785  template<typename _FIter>
786  _GLIBCXX14_CONSTEXPR
787  _FIter
788  min_element(_FIter, _FIter);
789 
790  template<typename _FIter, typename _Compare>
791  _GLIBCXX14_CONSTEXPR
792  _FIter
793  min_element(_FIter, _FIter, _Compare);
794 
795  template<typename _IIter1, typename _IIter2>
796  _GLIBCXX20_CONSTEXPR
797  pair<_IIter1, _IIter2>
798  mismatch(_IIter1, _IIter1, _IIter2);
799 
800  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
801  _GLIBCXX20_CONSTEXPR
802  pair<_IIter1, _IIter2>
803  mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
804 
805  template<typename _RAIter>
806  _GLIBCXX20_CONSTEXPR
807  void
808  nth_element(_RAIter, _RAIter, _RAIter);
809 
810  template<typename _RAIter, typename _Compare>
811  _GLIBCXX20_CONSTEXPR
812  void
813  nth_element(_RAIter, _RAIter, _RAIter, _Compare);
814 
815  template<typename _RAIter>
816  _GLIBCXX20_CONSTEXPR
817  void
818  partial_sort(_RAIter, _RAIter, _RAIter);
819 
820  template<typename _RAIter, typename _Compare>
821  _GLIBCXX20_CONSTEXPR
822  void
823  partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
824 
825  template<typename _BIter, typename _Predicate>
826  _GLIBCXX20_CONSTEXPR
827  _BIter
828  partition(_BIter, _BIter, _Predicate);
829 
830  template<typename _RAIter>
831  void
832  random_shuffle(_RAIter, _RAIter);
833 
834  template<typename _RAIter, typename _Generator>
835  void
836  random_shuffle(_RAIter, _RAIter,
837 #if __cplusplus >= 201103L
838  _Generator&&);
839 #else
840  _Generator&);
841 #endif
842 
843  template<typename _FIter, typename _Tp>
844  _GLIBCXX20_CONSTEXPR
845  void
846  replace(_FIter, _FIter, const _Tp&, const _Tp&);
847 
848  template<typename _FIter, typename _Predicate, typename _Tp>
849  _GLIBCXX20_CONSTEXPR
850  void
851  replace_if(_FIter, _FIter, _Predicate, const _Tp&);
852 
853  template<typename _FIter1, typename _FIter2>
854  _GLIBCXX20_CONSTEXPR
855  _FIter1
856  search(_FIter1, _FIter1, _FIter2, _FIter2);
857 
858  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
859  _GLIBCXX20_CONSTEXPR
860  _FIter1
861  search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
862 
863  template<typename _FIter, typename _Size, typename _Tp>
864  _GLIBCXX20_CONSTEXPR
865  _FIter
866  search_n(_FIter, _FIter, _Size, const _Tp&);
867 
868  template<typename _FIter, typename _Size, typename _Tp,
869  typename _BinaryPredicate>
870  _GLIBCXX20_CONSTEXPR
871  _FIter
872  search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
873 
874  template<typename _IIter1, typename _IIter2, typename _OIter>
875  _GLIBCXX20_CONSTEXPR
876  _OIter
877  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
878 
879  template<typename _IIter1, typename _IIter2, typename _OIter,
880  typename _Compare>
881  _GLIBCXX20_CONSTEXPR
882  _OIter
883  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
884 
885  template<typename _IIter1, typename _IIter2, typename _OIter>
886  _GLIBCXX20_CONSTEXPR
887  _OIter
888  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
889 
890  template<typename _IIter1, typename _IIter2, typename _OIter,
891  typename _Compare>
892  _GLIBCXX20_CONSTEXPR
893  _OIter
894  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
895 
896  template<typename _IIter1, typename _IIter2, typename _OIter>
897  _GLIBCXX20_CONSTEXPR
898  _OIter
899  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
900 
901  template<typename _IIter1, typename _IIter2, typename _OIter,
902  typename _Compare>
903  _GLIBCXX20_CONSTEXPR
904  _OIter
905  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
906  _OIter, _Compare);
907 
908  template<typename _IIter1, typename _IIter2, typename _OIter>
909  _GLIBCXX20_CONSTEXPR
910  _OIter
911  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
912 
913  template<typename _IIter1, typename _IIter2, typename _OIter,
914  typename _Compare>
915  _GLIBCXX20_CONSTEXPR
916  _OIter
917  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
918 
919  template<typename _RAIter>
920  _GLIBCXX20_CONSTEXPR
921  void
922  sort(_RAIter, _RAIter);
923 
924  template<typename _RAIter, typename _Compare>
925  _GLIBCXX20_CONSTEXPR
926  void
927  sort(_RAIter, _RAIter, _Compare);
928 
929  template<typename _RAIter>
930  void
931  stable_sort(_RAIter, _RAIter);
932 
933  template<typename _RAIter, typename _Compare>
934  void
935  stable_sort(_RAIter, _RAIter, _Compare);
936 
937  template<typename _IIter, typename _OIter, typename _UnaryOperation>
938  _GLIBCXX20_CONSTEXPR
939  _OIter
940  transform(_IIter, _IIter, _OIter, _UnaryOperation);
941 
942  template<typename _IIter1, typename _IIter2, typename _OIter,
943  typename _BinaryOperation>
944  _GLIBCXX20_CONSTEXPR
945  _OIter
946  transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
947 
948  template<typename _IIter, typename _OIter>
949  _GLIBCXX20_CONSTEXPR
950  _OIter
951  unique_copy(_IIter, _IIter, _OIter);
952 
953  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
954  _GLIBCXX20_CONSTEXPR
955  _OIter
956  unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
957 
958 _GLIBCXX_END_NAMESPACE_ALGO
959 _GLIBCXX_END_NAMESPACE_VERSION
960 } // namespace std
961 
962 #ifdef _GLIBCXX_PARALLEL
963 # include <parallel/algorithmfwd.h>
964 #endif
965 
966 #endif
967 
std::max
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:254
std::minmax
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:3325
std::min
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:230
std
ISO C++ entities toplevel namespace is std.