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