libstdc++
bits/algorithmfwd.h
Go to the documentation of this file.
1 // <algorithm> Forward declarations -*- C++ -*-
2 
3 // Copyright (C) 2007-2023 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>
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 _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2)
605 
606  template<typename _FIter>
607  _GLIBCXX20_CONSTEXPR
608  _FIter
609  rotate(_FIter, _FIter, _FIter);
610 
611 _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
612 
613  template<typename _FIter, typename _OIter>
614  _GLIBCXX20_CONSTEXPR
615  _OIter
616  rotate_copy(_FIter, _FIter, _FIter, _OIter);
617 
618  // search
619  // search_n
620  // set_difference
621  // set_intersection
622  // set_symmetric_difference
623  // set_union
624 
625 #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
626  template<typename _RAIter, typename _UGenerator>
627  void
628  shuffle(_RAIter, _RAIter, _UGenerator&&);
629 #endif
630 
631  template<typename _RAIter>
632  _GLIBCXX20_CONSTEXPR
633  void
634  sort_heap(_RAIter, _RAIter);
635 
636  template<typename _RAIter, typename _Compare>
637  _GLIBCXX20_CONSTEXPR
638  void
639  sort_heap(_RAIter, _RAIter, _Compare);
640 
641 #if _GLIBCXX_HOSTED
642  template<typename _BIter, typename _Predicate>
643  _BIter
644  stable_partition(_BIter, _BIter, _Predicate);
645 #endif
646 
647 #if __cplusplus < 201103L
648  // For C++11 swap() is declared in <type_traits>.
649 
650  template<typename _Tp, size_t _Nm>
651  _GLIBCXX20_CONSTEXPR
652  inline void
653  swap(_Tp& __a, _Tp& __b);
654 
655  template<typename _Tp, size_t _Nm>
656  _GLIBCXX20_CONSTEXPR
657  inline void
658  swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
659 #endif
660 
661  template<typename _FIter1, typename _FIter2>
662  _GLIBCXX20_CONSTEXPR
663  _FIter2
664  swap_ranges(_FIter1, _FIter1, _FIter2);
665 
666  // transform
667 
668  template<typename _FIter>
669  _GLIBCXX20_CONSTEXPR
670  _FIter
671  unique(_FIter, _FIter);
672 
673  template<typename _FIter, typename _BinaryPredicate>
674  _GLIBCXX20_CONSTEXPR
675  _FIter
676  unique(_FIter, _FIter, _BinaryPredicate);
677 
678  // unique_copy
679 
680  template<typename _FIter, typename _Tp>
681  _GLIBCXX20_CONSTEXPR
682  _FIter
683  upper_bound(_FIter, _FIter, const _Tp&);
684 
685  template<typename _FIter, typename _Tp, typename _Compare>
686  _GLIBCXX20_CONSTEXPR
687  _FIter
688  upper_bound(_FIter, _FIter, const _Tp&, _Compare);
689 
690 _GLIBCXX_BEGIN_NAMESPACE_ALGO
691 
692  template<typename _FIter>
693  _GLIBCXX20_CONSTEXPR
694  _FIter
695  adjacent_find(_FIter, _FIter);
696 
697  template<typename _FIter, typename _BinaryPredicate>
698  _GLIBCXX20_CONSTEXPR
699  _FIter
700  adjacent_find(_FIter, _FIter, _BinaryPredicate);
701 
702  template<typename _IIter, typename _Tp>
703  _GLIBCXX20_CONSTEXPR
704  typename iterator_traits<_IIter>::difference_type
705  count(_IIter, _IIter, const _Tp&);
706 
707  template<typename _IIter, typename _Predicate>
708  _GLIBCXX20_CONSTEXPR
709  typename iterator_traits<_IIter>::difference_type
710  count_if(_IIter, _IIter, _Predicate);
711 
712  template<typename _IIter1, typename _IIter2>
713  _GLIBCXX20_CONSTEXPR
714  bool
715  equal(_IIter1, _IIter1, _IIter2);
716 
717  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
718  _GLIBCXX20_CONSTEXPR
719  bool
720  equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
721 
722  template<typename _IIter, typename _Tp>
723  _GLIBCXX20_CONSTEXPR
724  _IIter
725  find(_IIter, _IIter, const _Tp&);
726 
727  template<typename _FIter1, typename _FIter2>
728  _GLIBCXX20_CONSTEXPR
729  _FIter1
730  find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
731 
732  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
733  _GLIBCXX20_CONSTEXPR
734  _FIter1
735  find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
736 
737  template<typename _IIter, typename _Predicate>
738  _GLIBCXX20_CONSTEXPR
739  _IIter
740  find_if(_IIter, _IIter, _Predicate);
741 
742  template<typename _IIter, typename _Funct>
743  _GLIBCXX20_CONSTEXPR
744  _Funct
745  for_each(_IIter, _IIter, _Funct);
746 
747  template<typename _FIter, typename _Generator>
748  _GLIBCXX20_CONSTEXPR
749  void
750  generate(_FIter, _FIter, _Generator);
751 
752  template<typename _OIter, typename _Size, typename _Generator>
753  _GLIBCXX20_CONSTEXPR
754  _OIter
755  generate_n(_OIter, _Size, _Generator);
756 
757  template<typename _IIter1, typename _IIter2>
758  _GLIBCXX20_CONSTEXPR
759  bool
760  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
761 
762  template<typename _IIter1, typename _IIter2, typename _Compare>
763  _GLIBCXX20_CONSTEXPR
764  bool
765  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
766 
767  template<typename _FIter>
768  _GLIBCXX14_CONSTEXPR
769  _FIter
770  max_element(_FIter, _FIter);
771 
772  template<typename _FIter, typename _Compare>
773  _GLIBCXX14_CONSTEXPR
774  _FIter
775  max_element(_FIter, _FIter, _Compare);
776 
777  template<typename _IIter1, typename _IIter2, typename _OIter>
778  _GLIBCXX20_CONSTEXPR
779  _OIter
780  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
781 
782  template<typename _IIter1, typename _IIter2, typename _OIter,
783  typename _Compare>
784  _GLIBCXX20_CONSTEXPR
785  _OIter
786  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
787 
788  template<typename _FIter>
789  _GLIBCXX14_CONSTEXPR
790  _FIter
791  min_element(_FIter, _FIter);
792 
793  template<typename _FIter, typename _Compare>
794  _GLIBCXX14_CONSTEXPR
795  _FIter
796  min_element(_FIter, _FIter, _Compare);
797 
798  template<typename _IIter1, typename _IIter2>
799  _GLIBCXX20_CONSTEXPR
800  pair<_IIter1, _IIter2>
801  mismatch(_IIter1, _IIter1, _IIter2);
802 
803  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
804  _GLIBCXX20_CONSTEXPR
805  pair<_IIter1, _IIter2>
806  mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
807 
808  template<typename _RAIter>
809  _GLIBCXX20_CONSTEXPR
810  void
811  nth_element(_RAIter, _RAIter, _RAIter);
812 
813  template<typename _RAIter, typename _Compare>
814  _GLIBCXX20_CONSTEXPR
815  void
816  nth_element(_RAIter, _RAIter, _RAIter, _Compare);
817 
818  template<typename _RAIter>
819  _GLIBCXX20_CONSTEXPR
820  void
821  partial_sort(_RAIter, _RAIter, _RAIter);
822 
823  template<typename _RAIter, typename _Compare>
824  _GLIBCXX20_CONSTEXPR
825  void
826  partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
827 
828  template<typename _BIter, typename _Predicate>
829  _GLIBCXX20_CONSTEXPR
830  _BIter
831  partition(_BIter, _BIter, _Predicate);
832 
833 #if _GLIBCXX_HOSTED
834  template<typename _RAIter>
835  void
836  random_shuffle(_RAIter, _RAIter);
837 
838  template<typename _RAIter, typename _Generator>
839  void
840  random_shuffle(_RAIter, _RAIter,
841 #if __cplusplus >= 201103L
842  _Generator&&);
843 #else
844  _Generator&);
845 #endif
846 #endif // HOSTED
847 
848  template<typename _FIter, typename _Tp>
849  _GLIBCXX20_CONSTEXPR
850  void
851  replace(_FIter, _FIter, const _Tp&, const _Tp&);
852 
853  template<typename _FIter, typename _Predicate, typename _Tp>
854  _GLIBCXX20_CONSTEXPR
855  void
856  replace_if(_FIter, _FIter, _Predicate, const _Tp&);
857 
858  template<typename _FIter1, typename _FIter2>
859  _GLIBCXX20_CONSTEXPR
860  _FIter1
861  search(_FIter1, _FIter1, _FIter2, _FIter2);
862 
863  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
864  _GLIBCXX20_CONSTEXPR
865  _FIter1
866  search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
867 
868  template<typename _FIter, typename _Size, typename _Tp>
869  _GLIBCXX20_CONSTEXPR
870  _FIter
871  search_n(_FIter, _FIter, _Size, const _Tp&);
872 
873  template<typename _FIter, typename _Size, typename _Tp,
874  typename _BinaryPredicate>
875  _GLIBCXX20_CONSTEXPR
876  _FIter
877  search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
878 
879  template<typename _IIter1, typename _IIter2, typename _OIter>
880  _GLIBCXX20_CONSTEXPR
881  _OIter
882  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
883 
884  template<typename _IIter1, typename _IIter2, typename _OIter,
885  typename _Compare>
886  _GLIBCXX20_CONSTEXPR
887  _OIter
888  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
889 
890  template<typename _IIter1, typename _IIter2, typename _OIter>
891  _GLIBCXX20_CONSTEXPR
892  _OIter
893  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
894 
895  template<typename _IIter1, typename _IIter2, typename _OIter,
896  typename _Compare>
897  _GLIBCXX20_CONSTEXPR
898  _OIter
899  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
900 
901  template<typename _IIter1, typename _IIter2, typename _OIter>
902  _GLIBCXX20_CONSTEXPR
903  _OIter
904  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
905 
906  template<typename _IIter1, typename _IIter2, typename _OIter,
907  typename _Compare>
908  _GLIBCXX20_CONSTEXPR
909  _OIter
910  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
911  _OIter, _Compare);
912 
913  template<typename _IIter1, typename _IIter2, typename _OIter>
914  _GLIBCXX20_CONSTEXPR
915  _OIter
916  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
917 
918  template<typename _IIter1, typename _IIter2, typename _OIter,
919  typename _Compare>
920  _GLIBCXX20_CONSTEXPR
921  _OIter
922  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
923 
924  template<typename _RAIter>
925  _GLIBCXX20_CONSTEXPR
926  void
927  sort(_RAIter, _RAIter);
928 
929  template<typename _RAIter, typename _Compare>
930  _GLIBCXX20_CONSTEXPR
931  void
932  sort(_RAIter, _RAIter, _Compare);
933 
934  template<typename _RAIter>
935  void
936  stable_sort(_RAIter, _RAIter);
937 
938  template<typename _RAIter, typename _Compare>
939  void
940  stable_sort(_RAIter, _RAIter, _Compare);
941 
942  template<typename _IIter, typename _OIter, typename _UnaryOperation>
943  _GLIBCXX20_CONSTEXPR
944  _OIter
945  transform(_IIter, _IIter, _OIter, _UnaryOperation);
946 
947  template<typename _IIter1, typename _IIter2, typename _OIter,
948  typename _BinaryOperation>
949  _GLIBCXX20_CONSTEXPR
950  _OIter
951  transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
952 
953  template<typename _IIter, typename _OIter>
954  _GLIBCXX20_CONSTEXPR
955  _OIter
956  unique_copy(_IIter, _IIter, _OIter);
957 
958  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
959  _GLIBCXX20_CONSTEXPR
960  _OIter
961  unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
962 
963 _GLIBCXX_END_NAMESPACE_ALGO
964 _GLIBCXX_END_NAMESPACE_VERSION
965 } // namespace std
966 
967 #ifdef _GLIBCXX_PARALLEL
968 # include <parallel/algorithmfwd.h>
969 #endif
970 
971 #endif
972 
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition: any:429
constexpr const _Tp & clamp(const _Tp &, const _Tp &, const _Tp &)
Returns the value clamped between lo and hi.
Definition: stl_algo.h:3667
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:257
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:3330
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:233
ISO C++ entities toplevel namespace is std.