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