xref: /netbsd-src/external/gpl3/gcc.old/dist/libstdc++-v3/include/bits/algorithmfwd.h (revision 8feb0f0b7eaff0608f8350bbfa3098827b4bb91b)
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 
_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   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 
968