visus
/
toolchain-gcc-arm-embedded
Наблюдаван 1
Харесван 0
Разклонения 0
Код Задачи 0 Заявки за сливане 0 Версии 0 Уики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Ревизии
1 Клон
Клон: main
Клонове Маркери
${ item.name }
Create branch ${ searchTerm }
от 'main'
${ noResults }
toolchain-gcc-arm-embedded/arm-none-eabi/include/c++/10.2.1/bits/algorithmfwd.h

968 lines
24KB
Директен файл Постоянна връзка Blame История 

  1. // <algorithm> Forward declarations  -*- C++ -*-

  2. 

  3. // Copyright (C) 2007-2020 Free Software Foundation, Inc.

  4. //

  5. // This file is part of the GNU ISO C++ Library.  This library is free

  6. // software; you can redistribute it and/or modify it under the

  7. // terms of the GNU General Public License as published by the

  8. // Free Software Foundation; either version 3, or (at your option)

  9. // any later version.

  10. 

  11. // This library is distributed in the hope that it will be useful,

  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14. // GNU General Public License for more details.

  15. 

  16. // Under Section 7 of GPL version 3, you are granted additional

  17. // permissions described in the GCC Runtime Library Exception, version

  18. // 3.1, as published by the Free Software Foundation.

  19. 

  20. // You should have received a copy of the GNU General Public License and

  21. // a copy of the GCC Runtime Library Exception along with this program;

  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

  23. // <http://www.gnu.org/licenses/>.

  24. 

  25. /** @file bits/algorithmfwd.h

  26.  *  This is an internal header file, included by other library headers.

  27.  *  Do not attempt to use it directly. @headername{algorithm}

  28.  */

  29. 

  30. #ifndef _GLIBCXX_ALGORITHMFWD_H

  31. #define _GLIBCXX_ALGORITHMFWD_H 1

  32. 

  33. #pragma GCC system_header

  34. 

  35. #include <bits/c++config.h>

  36. #include <bits/stl_pair.h>

  37. #include <bits/stl_iterator_base_types.h>

  38. #if __cplusplus >= 201103L

  39. #include <initializer_list>

  40. #endif

  41. 

  42. namespace std _GLIBCXX_VISIBILITY(default)

  43. {

  44. _GLIBCXX_BEGIN_NAMESPACE_VERSION

  45. 

  46.   /*

  47.     adjacent_find

  48.     all_of (C++11)

  49.     any_of (C++11)

  50.     binary_search

  51.     clamp (C++17)

  52.     copy

  53.     copy_backward

  54.     copy_if (C++11)

  55.     copy_n (C++11)

  56.     count

  57.     count_if

  58.     equal

  59.     equal_range

  60.     fill

  61.     fill_n

  62.     find

  63.     find_end

  64.     find_first_of

  65.     find_if

  66.     find_if_not (C++11)

  67.     for_each

  68.     generate

  69.     generate_n

  70.     includes

  71.     inplace_merge

  72.     is_heap (C++11)

  73.     is_heap_until (C++11)

  74.     is_partitioned (C++11)

  75.     is_sorted (C++11)

  76.     is_sorted_until (C++11)

  77.     iter_swap

  78.     lexicographical_compare

  79.     lower_bound

  80.     make_heap

  81.     max

  82.     max_element

  83.     merge

  84.     min

  85.     min_element

  86.     minmax (C++11)

  87.     minmax_element (C++11)

  88.     mismatch

  89.     next_permutation

  90.     none_of (C++11)

  91.     nth_element

  92.     partial_sort

  93.     partial_sort_copy

  94.     partition

  95.     partition_copy (C++11)

  96.     partition_point (C++11)

  97.     pop_heap

  98.     prev_permutation

  99.     push_heap

  100.     random_shuffle

  101.     remove

  102.     remove_copy

  103.     remove_copy_if

  104.     remove_if

  105.     replace

  106.     replace_copy

  107.     replace_copy_if

  108.     replace_if

  109.     reverse

  110.     reverse_copy

  111.     rotate

  112.     rotate_copy

  113.     search

  114.     search_n

  115.     set_difference

  116.     set_intersection

  117.     set_symmetric_difference

  118.     set_union

  119.     shuffle (C++11)

  120.     sort

  121.     sort_heap

  122.     stable_partition

  123.     stable_sort

  124.     swap

  125.     swap_ranges

  126.     transform

  127.     unique

  128.     unique_copy

  129.     upper_bound

  130.   */

  131. 

  132.   /**

  133.    * @defgroup algorithms Algorithms

  134.    *

  135.    * Components for performing algorithmic operations. Includes

  136.    * non-modifying sequence, modifying (mutating) sequence, sorting,

  137.    * searching, merge, partition, heap, set, minima, maxima, and

  138.    * permutation operations.

  139.    */

  140. 

  141.   /**

  142.    * @defgroup mutating_algorithms Mutating

  143.    * @ingroup algorithms

  144.    */

  145. 

  146.   /**

  147.    * @defgroup non_mutating_algorithms Non-Mutating

  148.    * @ingroup algorithms

  149.    */

  150. 

  151.   /**

  152.    * @defgroup sorting_algorithms Sorting

  153.    * @ingroup algorithms

  154.    */

  155. 

  156.   /**

  157.    * @defgroup set_algorithms Set Operations

  158.    * @ingroup sorting_algorithms

  159.    *

  160.    * These algorithms are common set operations performed on sequences

  161.    * that are already sorted. The number of comparisons will be

  162.    * linear.

  163.    */

  164. 

  165.   /**

  166.    * @defgroup binary_search_algorithms Binary Search

  167.    * @ingroup sorting_algorithms

  168.    *

  169.    * These algorithms are variations of a classic binary search, and

  170.    * all assume that the sequence being searched is already sorted.

  171.    *

  172.    * The number of comparisons will be logarithmic (and as few as

  173.    * possible).  The number of steps through the sequence will be

  174.    * logarithmic for random-access iterators (e.g., pointers), and

  175.    * linear otherwise.

  176.    *

  177.    * The LWG has passed Defect Report 270, which notes: <em>The

  178.    * proposed resolution reinterprets binary search. Instead of

  179.    * thinking about searching for a value in a sorted range, we view

  180.    * that as an important special case of a more general algorithm:

  181.    * searching for the partition point in a partitioned range.  We

  182.    * also add a guarantee that the old wording did not: we ensure that

  183.    * the upper bound is no earlier than the lower bound, that the pair

  184.    * returned by equal_range is a valid range, and that the first part

  185.    * of that pair is the lower bound.</em>

  186.    *

  187.    * The actual effect of the first sentence is that a comparison

  188.    * functor passed by the user doesn't necessarily need to induce a

  189.    * strict weak ordering relation.  Rather, it partitions the range.

  190.    */

  191. 

  192.   // adjacent_find

  193. 

  194. #if __cplusplus > 201703L

  195. #  define __cpp_lib_constexpr_algorithms 201806L

  196. #endif

  197. 

  198. #if __cplusplus >= 201103L

  199.   template<typename _IIter, typename _Predicate>

  200.     _GLIBCXX20_CONSTEXPR

  201.     bool

  202.     all_of(_IIter, _IIter, _Predicate);

  203. 

  204.   template<typename _IIter, typename _Predicate>

  205.     _GLIBCXX20_CONSTEXPR

  206.     bool

  207.     any_of(_IIter, _IIter, _Predicate);

  208. #endif

  209. 

  210.   template<typename _FIter, typename _Tp>

  211.     _GLIBCXX20_CONSTEXPR

  212.     bool

  213.     binary_search(_FIter, _FIter, const _Tp&);

  214. 

  215.   template<typename _FIter, typename _Tp, typename _Compare>

  216.     _GLIBCXX20_CONSTEXPR

  217.     bool

  218.     binary_search(_FIter, _FIter, const _Tp&, _Compare);

  219. 

  220. #if __cplusplus > 201402L

  221.   template<typename _Tp>

  222.     _GLIBCXX14_CONSTEXPR

  223.     const _Tp&

  224.     clamp(const _Tp&, const _Tp&, const _Tp&);

  225. 

  226.   template<typename _Tp, typename _Compare>

  227.     _GLIBCXX14_CONSTEXPR

  228.     const _Tp&

  229.     clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);

  230. #endif

  231. 

  232.   template<typename _IIter, typename _OIter>

  233.     _GLIBCXX20_CONSTEXPR

  234.     _OIter

  235.     copy(_IIter, _IIter, _OIter);

  236. 

  237.   template<typename _BIter1, typename _BIter2>

  238.     _GLIBCXX20_CONSTEXPR

  239.     _BIter2

  240.     copy_backward(_BIter1, _BIter1, _BIter2);

  241. 

  242. #if __cplusplus >= 201103L

  243.   template<typename _IIter, typename _OIter, typename _Predicate>

  244.     _GLIBCXX20_CONSTEXPR

  245.     _OIter

  246.     copy_if(_IIter, _IIter, _OIter, _Predicate);

  247. 

  248.   template<typename _IIter, typename _Size, typename _OIter>

  249.     _GLIBCXX20_CONSTEXPR

  250.     _OIter

  251.     copy_n(_IIter, _Size, _OIter);

  252. #endif

  253. 

  254.   // count

  255.   // count_if

  256. 

  257.   template<typename _FIter, typename _Tp>

  258.     _GLIBCXX20_CONSTEXPR

  259.     pair<_FIter, _FIter>

  260.     equal_range(_FIter, _FIter, const _Tp&);

  261. 

  262.   template<typename _FIter, typename _Tp, typename _Compare>

  263.     _GLIBCXX20_CONSTEXPR

  264.     pair<_FIter, _FIter>

  265.     equal_range(_FIter, _FIter, const _Tp&, _Compare);

  266. 

  267.   template<typename _FIter, typename _Tp>

  268.     _GLIBCXX20_CONSTEXPR

  269.     void

  270.     fill(_FIter, _FIter, const _Tp&);

  271. 

  272.   template<typename _OIter, typename _Size, typename _Tp>

  273.     _GLIBCXX20_CONSTEXPR

  274.     _OIter

  275.     fill_n(_OIter, _Size, const _Tp&);

  276. 

  277.   // find

  278. 

  279.   template<typename _FIter1, typename _FIter2>

  280.     _GLIBCXX20_CONSTEXPR

  281.     _FIter1

  282.     find_end(_FIter1, _FIter1, _FIter2, _FIter2);

  283. 

  284.   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>

  285.     _GLIBCXX20_CONSTEXPR

  286.     _FIter1

  287.     find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  288. 

  289.   // find_first_of

  290.   // find_if

  291. 

  292. #if __cplusplus >= 201103L

  293.   template<typename _IIter, typename _Predicate>

  294.     _GLIBCXX20_CONSTEXPR

  295.     _IIter

  296.     find_if_not(_IIter, _IIter, _Predicate);

  297. #endif

  298. 

  299.   // for_each

  300.   // generate

  301.   // generate_n

  302. 

  303.   template<typename _IIter1, typename _IIter2>

  304.     _GLIBCXX20_CONSTEXPR

  305.     bool

  306.     includes(_IIter1, _IIter1, _IIter2, _IIter2);

  307. 

  308.   template<typename _IIter1, typename _IIter2, typename _Compare>

  309.     _GLIBCXX20_CONSTEXPR

  310.     bool

  311.     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  312. 

  313.   template<typename _BIter>

  314.     void

  315.     inplace_merge(_BIter, _BIter, _BIter);

  316. 

  317.   template<typename _BIter, typename _Compare>

  318.     void

  319.     inplace_merge(_BIter, _BIter, _BIter, _Compare);

  320. 

  321. #if __cplusplus >= 201103L

  322.   template<typename _RAIter>

  323.     _GLIBCXX20_CONSTEXPR

  324.     bool

  325.     is_heap(_RAIter, _RAIter);

  326. 

  327.   template<typename _RAIter, typename _Compare>

  328.     _GLIBCXX20_CONSTEXPR

  329.     bool

  330.     is_heap(_RAIter, _RAIter, _Compare);

  331. 

  332.   template<typename _RAIter>

  333.     _GLIBCXX20_CONSTEXPR

  334.     _RAIter

  335.     is_heap_until(_RAIter, _RAIter);

  336. 

  337.   template<typename _RAIter, typename _Compare>

  338.     _GLIBCXX20_CONSTEXPR

  339.     _RAIter

  340.     is_heap_until(_RAIter, _RAIter, _Compare);

  341. 

  342.   template<typename _IIter, typename _Predicate>

  343.     _GLIBCXX20_CONSTEXPR

  344.     bool

  345.     is_partitioned(_IIter, _IIter, _Predicate);

  346. 

  347.   template<typename _FIter1, typename _FIter2>

  348.     _GLIBCXX20_CONSTEXPR

  349.     bool

  350.     is_permutation(_FIter1, _FIter1, _FIter2);

  351. 

  352.   template<typename _FIter1, typename _FIter2,

  353. 	   typename _BinaryPredicate>

  354.     _GLIBCXX20_CONSTEXPR

  355.     bool

  356.     is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);

  357. 

  358.   template<typename _FIter>

  359.     _GLIBCXX20_CONSTEXPR

  360.     bool

  361.     is_sorted(_FIter, _FIter);

  362. 

  363.   template<typename _FIter, typename _Compare>

  364.     _GLIBCXX20_CONSTEXPR

  365.     bool

  366.     is_sorted(_FIter, _FIter, _Compare);

  367. 

  368.   template<typename _FIter>

  369.     _GLIBCXX20_CONSTEXPR

  370.     _FIter

  371.     is_sorted_until(_FIter, _FIter);

  372. 

  373.   template<typename _FIter, typename _Compare>

  374.     _GLIBCXX20_CONSTEXPR

  375.     _FIter

  376.     is_sorted_until(_FIter, _FIter, _Compare);

  377. #endif

  378. 

  379.   template<typename _FIter1, typename _FIter2>

  380.     _GLIBCXX20_CONSTEXPR

  381.     void

  382.     iter_swap(_FIter1, _FIter2);

  383. 

  384.   template<typename _FIter, typename _Tp>

  385.     _GLIBCXX20_CONSTEXPR

  386.     _FIter

  387.     lower_bound(_FIter, _FIter, const _Tp&);

  388. 

  389.   template<typename _FIter, typename _Tp, typename _Compare>

  390.     _GLIBCXX20_CONSTEXPR

  391.     _FIter

  392.     lower_bound(_FIter, _FIter, const _Tp&, _Compare);

  393. 

  394.   template<typename _RAIter>

  395.     _GLIBCXX20_CONSTEXPR

  396.     void

  397.     make_heap(_RAIter, _RAIter);

  398. 

  399.   template<typename _RAIter, typename _Compare>

  400.     _GLIBCXX20_CONSTEXPR

  401.     void

  402.     make_heap(_RAIter, _RAIter, _Compare);

  403. 

  404.   template<typename _Tp>

  405.     _GLIBCXX14_CONSTEXPR

  406.     const _Tp&

  407.     max(const _Tp&, const _Tp&);

  408. 

  409.   template<typename _Tp, typename _Compare>

  410.     _GLIBCXX14_CONSTEXPR

  411.     const _Tp&

  412.     max(const _Tp&, const _Tp&, _Compare);

  413. 

  414.   // max_element

  415.   // merge

  416. 

  417.   template<typename _Tp>

  418.     _GLIBCXX14_CONSTEXPR

  419.     const _Tp&

  420.     min(const _Tp&, const _Tp&);

  421. 

  422.   template<typename _Tp, typename _Compare>

  423.     _GLIBCXX14_CONSTEXPR

  424.     const _Tp&

  425.     min(const _Tp&, const _Tp&, _Compare);

  426. 

  427.   // min_element

  428. 

  429. #if __cplusplus >= 201103L

  430.   template<typename _Tp>

  431.     _GLIBCXX14_CONSTEXPR

  432.     pair<const _Tp&, const _Tp&>

  433.     minmax(const _Tp&, const _Tp&);

  434. 

  435.   template<typename _Tp, typename _Compare>

  436.     _GLIBCXX14_CONSTEXPR

  437.     pair<const _Tp&, const _Tp&>

  438.     minmax(const _Tp&, const _Tp&, _Compare);

  439. 

  440.   template<typename _FIter>

  441.     _GLIBCXX14_CONSTEXPR

  442.     pair<_FIter, _FIter>

  443.     minmax_element(_FIter, _FIter);

  444. 

  445.   template<typename _FIter, typename _Compare>

  446.     _GLIBCXX14_CONSTEXPR

  447.     pair<_FIter, _FIter>

  448.     minmax_element(_FIter, _FIter, _Compare);

  449. 

  450.   template<typename _Tp>

  451.     _GLIBCXX14_CONSTEXPR

  452.     _Tp

  453.     min(initializer_list<_Tp>);

  454. 

  455.   template<typename _Tp, typename _Compare>

  456.     _GLIBCXX14_CONSTEXPR

  457.     _Tp

  458.     min(initializer_list<_Tp>, _Compare);

  459. 

  460.   template<typename _Tp>

  461.     _GLIBCXX14_CONSTEXPR

  462.     _Tp

  463.     max(initializer_list<_Tp>);

  464. 

  465.   template<typename _Tp, typename _Compare>

  466.     _GLIBCXX14_CONSTEXPR

  467.     _Tp

  468.     max(initializer_list<_Tp>, _Compare);

  469. 

  470.   template<typename _Tp>

  471.     _GLIBCXX14_CONSTEXPR

  472.     pair<_Tp, _Tp>

  473.     minmax(initializer_list<_Tp>);

  474. 

  475.   template<typename _Tp, typename _Compare>

  476.     _GLIBCXX14_CONSTEXPR

  477.     pair<_Tp, _Tp>

  478.     minmax(initializer_list<_Tp>, _Compare);

  479. #endif

  480. 

  481.   // mismatch

  482. 

  483.   template<typename _BIter>

  484.     _GLIBCXX20_CONSTEXPR

  485.     bool

  486.     next_permutation(_BIter, _BIter);

  487. 

  488.   template<typename _BIter, typename _Compare>

  489.     _GLIBCXX20_CONSTEXPR

  490.     bool

  491.     next_permutation(_BIter, _BIter, _Compare);

  492. 

  493. #if __cplusplus >= 201103L

  494.   template<typename _IIter, typename _Predicate>

  495.     _GLIBCXX20_CONSTEXPR

  496.     bool

  497.     none_of(_IIter, _IIter, _Predicate);

  498. #endif

  499. 

  500.   // nth_element

  501.   // partial_sort

  502. 

  503.   template<typename _IIter, typename _RAIter>

  504.     _GLIBCXX20_CONSTEXPR

  505.     _RAIter

  506.     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

  507. 

  508.   template<typename _IIter, typename _RAIter, typename _Compare>

  509.     _GLIBCXX20_CONSTEXPR

  510.     _RAIter

  511.     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);

  512. 

  513.   // partition

  514. 

  515. #if __cplusplus >= 201103L

  516.   template<typename _IIter, typename _OIter1,

  517. 	   typename _OIter2, typename _Predicate>

  518.     _GLIBCXX20_CONSTEXPR

  519.     pair<_OIter1, _OIter2>

  520.     partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);

  521. 

  522.   template<typename _FIter, typename _Predicate>

  523.     _GLIBCXX20_CONSTEXPR

  524.     _FIter

  525.     partition_point(_FIter, _FIter, _Predicate);

  526. #endif

  527. 

  528.   template<typename _RAIter>

  529.     _GLIBCXX20_CONSTEXPR

  530.     void

  531.     pop_heap(_RAIter, _RAIter);

  532. 

  533.   template<typename _RAIter, typename _Compare>

  534.     _GLIBCXX20_CONSTEXPR

  535.     void

  536.     pop_heap(_RAIter, _RAIter, _Compare);

  537. 

  538.   template<typename _BIter>

  539.     _GLIBCXX20_CONSTEXPR

  540.     bool

  541.     prev_permutation(_BIter, _BIter);

  542. 

  543.   template<typename _BIter, typename _Compare>

  544.     _GLIBCXX20_CONSTEXPR

  545.     bool

  546.     prev_permutation(_BIter, _BIter, _Compare);

  547. 

  548.   template<typename _RAIter>

  549.     _GLIBCXX20_CONSTEXPR

  550.     void

  551.     push_heap(_RAIter, _RAIter);

  552. 

  553.   template<typename _RAIter, typename _Compare>

  554.     _GLIBCXX20_CONSTEXPR

  555.     void

  556.     push_heap(_RAIter, _RAIter, _Compare);

  557. 

  558.   // random_shuffle

  559. 

  560.   template<typename _FIter, typename _Tp>

  561.     _GLIBCXX20_CONSTEXPR

  562.     _FIter

  563.     remove(_FIter, _FIter, const _Tp&);

  564. 

  565.   template<typename _FIter, typename _Predicate>

  566.     _GLIBCXX20_CONSTEXPR

  567.     _FIter

  568.     remove_if(_FIter, _FIter, _Predicate);

  569. 

  570.   template<typename _IIter, typename _OIter, typename _Tp>

  571.     _GLIBCXX20_CONSTEXPR

  572.     _OIter

  573.     remove_copy(_IIter, _IIter, _OIter, const _Tp&);

  574. 

  575.   template<typename _IIter, typename _OIter, typename _Predicate>

  576.     _GLIBCXX20_CONSTEXPR

  577.     _OIter

  578.     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);

  579. 

  580.   // replace

  581. 

  582.   template<typename _IIter, typename _OIter, typename _Tp>

  583.     _GLIBCXX20_CONSTEXPR

  584.     _OIter

  585.     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

  586. 

  587.   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>

  588.     _GLIBCXX20_CONSTEXPR

  589.     _OIter

  590.     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);

  591. 

  592.   // replace_if

  593. 

  594.   template<typename _BIter>

  595.     _GLIBCXX20_CONSTEXPR

  596.     void

  597.     reverse(_BIter, _BIter);

  598. 

  599.   template<typename _BIter, typename _OIter>

  600.     _GLIBCXX20_CONSTEXPR

  601.     _OIter

  602.     reverse_copy(_BIter, _BIter, _OIter);

  603. 

  604.   inline namespace _V2

  605.   {

  606.     template<typename _FIter>

  607.       _GLIBCXX20_CONSTEXPR

  608.       _FIter

  609.       rotate(_FIter, _FIter, _FIter);

  610.   }

  611. 

  612.   template<typename _FIter, typename _OIter>

  613.     _GLIBCXX20_CONSTEXPR

  614.     _OIter

  615.     rotate_copy(_FIter, _FIter, _FIter, _OIter);

  616. 

  617.   // search

  618.   // search_n

  619.   // set_difference

  620.   // set_intersection

  621.   // set_symmetric_difference

  622.   // set_union

  623. 

  624. #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)

  625.   template<typename _RAIter, typename _UGenerator>

  626.     void

  627.     shuffle(_RAIter, _RAIter, _UGenerator&&);

  628. #endif

  629. 

  630.   template<typename _RAIter>

  631.     _GLIBCXX20_CONSTEXPR

  632.     void

  633.     sort_heap(_RAIter, _RAIter);

  634. 

  635.   template<typename _RAIter, typename _Compare>

  636.     _GLIBCXX20_CONSTEXPR

  637.     void

  638.     sort_heap(_RAIter, _RAIter, _Compare);

  639. 

  640.   template<typename _BIter, typename _Predicate>

  641.     _BIter

  642.     stable_partition(_BIter, _BIter, _Predicate);

  643. 

  644. #if __cplusplus < 201103L

  645.   // For C++11 swap() is declared in <type_traits>.

  646. 

  647.   template<typename _Tp, size_t _Nm>

  648.     _GLIBCXX20_CONSTEXPR

  649.     inline void

  650.     swap(_Tp& __a, _Tp& __b);

  651. 

  652.   template<typename _Tp, size_t _Nm>

  653.     _GLIBCXX20_CONSTEXPR

  654.     inline void

  655.     swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);

  656. #endif

  657. 

  658.   template<typename _FIter1, typename _FIter2>

  659.     _GLIBCXX20_CONSTEXPR

  660.     _FIter2

  661.     swap_ranges(_FIter1, _FIter1, _FIter2);

  662. 

  663.   // transform

  664. 

  665.   template<typename _FIter>

  666.     _GLIBCXX20_CONSTEXPR

  667.     _FIter

  668.     unique(_FIter, _FIter);

  669. 

  670.   template<typename _FIter, typename _BinaryPredicate>

  671.     _GLIBCXX20_CONSTEXPR

  672.     _FIter

  673.     unique(_FIter, _FIter, _BinaryPredicate);

  674. 

  675.   // unique_copy

  676. 

  677.   template<typename _FIter, typename _Tp>

  678.     _GLIBCXX20_CONSTEXPR

  679.     _FIter

  680.     upper_bound(_FIter, _FIter, const _Tp&);

  681. 

  682.   template<typename _FIter, typename _Tp, typename _Compare>

  683.     _GLIBCXX20_CONSTEXPR

  684.     _FIter

  685.     upper_bound(_FIter, _FIter, const _Tp&, _Compare);

  686. 

  687. _GLIBCXX_BEGIN_NAMESPACE_ALGO

  688. 

  689.   template<typename _FIter>

  690.     _GLIBCXX20_CONSTEXPR

  691.     _FIter

  692.     adjacent_find(_FIter, _FIter);

  693. 

  694.   template<typename _FIter, typename _BinaryPredicate>

  695.     _GLIBCXX20_CONSTEXPR

  696.     _FIter

  697.     adjacent_find(_FIter, _FIter, _BinaryPredicate);

  698. 

  699.   template<typename _IIter, typename _Tp>

  700.     _GLIBCXX20_CONSTEXPR

  701.     typename iterator_traits<_IIter>::difference_type

  702.     count(_IIter, _IIter, const _Tp&);

  703. 

  704.   template<typename _IIter, typename _Predicate>

  705.     _GLIBCXX20_CONSTEXPR

  706.     typename iterator_traits<_IIter>::difference_type

  707.     count_if(_IIter, _IIter, _Predicate);

  708. 

  709.   template<typename _IIter1, typename _IIter2>

  710.     _GLIBCXX20_CONSTEXPR

  711.     bool

  712.     equal(_IIter1, _IIter1, _IIter2);

  713. 

  714.   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>

  715.     _GLIBCXX20_CONSTEXPR

  716.     bool

  717.     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  718. 

  719.   template<typename _IIter, typename _Tp>

  720.     _GLIBCXX20_CONSTEXPR

  721.     _IIter

  722.     find(_IIter, _IIter, const _Tp&);

  723. 

  724.   template<typename _FIter1, typename _FIter2>

  725.     _GLIBCXX20_CONSTEXPR

  726.     _FIter1

  727.     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

  728. 

  729.   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>

  730.     _GLIBCXX20_CONSTEXPR

  731.     _FIter1

  732.     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  733. 

  734.   template<typename _IIter, typename _Predicate>

  735.     _GLIBCXX20_CONSTEXPR

  736.     _IIter

  737.     find_if(_IIter, _IIter, _Predicate);

  738. 

  739.   template<typename _IIter, typename _Funct>

  740.     _GLIBCXX20_CONSTEXPR

  741.     _Funct

  742.     for_each(_IIter, _IIter, _Funct);

  743. 

  744.   template<typename _FIter, typename _Generator>

  745.     _GLIBCXX20_CONSTEXPR

  746.     void

  747.     generate(_FIter, _FIter, _Generator);

  748. 

  749.   template<typename _OIter, typename _Size, typename _Generator>

  750.     _GLIBCXX20_CONSTEXPR

  751.     _OIter

  752.     generate_n(_OIter, _Size, _Generator);

  753. 

  754.   template<typename _IIter1, typename _IIter2>

  755.     _GLIBCXX20_CONSTEXPR

  756.     bool

  757.     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

  758. 

  759.   template<typename _IIter1, typename _IIter2, typename _Compare>

  760.     _GLIBCXX20_CONSTEXPR

  761.     bool

  762.     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  763. 

  764.   template<typename _FIter>

  765.     _GLIBCXX14_CONSTEXPR

  766.     _FIter

  767.     max_element(_FIter, _FIter);

  768. 

  769.   template<typename _FIter, typename _Compare>

  770.     _GLIBCXX14_CONSTEXPR

  771.     _FIter

  772.     max_element(_FIter, _FIter, _Compare);

  773. 

  774.   template<typename _IIter1, typename _IIter2, typename _OIter>

  775.     _GLIBCXX20_CONSTEXPR

  776.     _OIter

  777.     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  778. 

  779.   template<typename _IIter1, typename _IIter2, typename _OIter,

  780. 	   typename _Compare>

  781.     _GLIBCXX20_CONSTEXPR

  782.     _OIter

  783.     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  784. 

  785.   template<typename _FIter>

  786.     _GLIBCXX14_CONSTEXPR

  787.     _FIter

  788.     min_element(_FIter, _FIter);

  789. 

  790.   template<typename _FIter, typename _Compare>

  791.     _GLIBCXX14_CONSTEXPR

  792.     _FIter

  793.     min_element(_FIter, _FIter, _Compare);

  794. 

  795.   template<typename _IIter1, typename _IIter2>

  796.     _GLIBCXX20_CONSTEXPR

  797.     pair<_IIter1, _IIter2>

  798.     mismatch(_IIter1, _IIter1, _IIter2);

  799. 

  800.   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>

  801.     _GLIBCXX20_CONSTEXPR

  802.     pair<_IIter1, _IIter2>

  803.     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  804. 

  805.   template<typename _RAIter>

  806.     _GLIBCXX20_CONSTEXPR

  807.     void

  808.     nth_element(_RAIter, _RAIter, _RAIter);

  809. 

  810.   template<typename _RAIter, typename _Compare>

  811.     _GLIBCXX20_CONSTEXPR

  812.     void

  813.     nth_element(_RAIter, _RAIter, _RAIter, _Compare);

  814. 

  815.   template<typename _RAIter>

  816.     _GLIBCXX20_CONSTEXPR

  817.     void

  818.     partial_sort(_RAIter, _RAIter, _RAIter);

  819. 

  820.   template<typename _RAIter, typename _Compare>

  821.     _GLIBCXX20_CONSTEXPR

  822.     void

  823.     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

  824. 

  825.   template<typename _BIter, typename _Predicate>

  826.     _GLIBCXX20_CONSTEXPR

  827.     _BIter

  828.     partition(_BIter, _BIter, _Predicate);

  829. 

  830.   template<typename _RAIter>

  831.     void

  832.     random_shuffle(_RAIter, _RAIter);

  833. 

  834.   template<typename _RAIter, typename _Generator>

  835.     void

  836.     random_shuffle(_RAIter, _RAIter,

  837. #if __cplusplus >= 201103L

  838. 		   _Generator&&);

  839. #else

  840. 		   _Generator&);

  841. #endif

  842. 

  843.   template<typename _FIter, typename _Tp>

  844.     _GLIBCXX20_CONSTEXPR

  845.     void

  846.     replace(_FIter, _FIter, const _Tp&, const _Tp&);

  847. 

  848.   template<typename _FIter, typename _Predicate, typename _Tp>

  849.     _GLIBCXX20_CONSTEXPR

  850.     void

  851.     replace_if(_FIter, _FIter, _Predicate, const _Tp&);

  852. 

  853.   template<typename _FIter1, typename _FIter2>

  854.     _GLIBCXX20_CONSTEXPR

  855.     _FIter1

  856.     search(_FIter1, _FIter1, _FIter2, _FIter2);

  857. 

  858.   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>

  859.     _GLIBCXX20_CONSTEXPR

  860.     _FIter1

  861.     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  862. 

  863.   template<typename _FIter, typename _Size, typename _Tp>

  864.     _GLIBCXX20_CONSTEXPR

  865.     _FIter

  866.     search_n(_FIter, _FIter, _Size, const _Tp&);

  867. 

  868.   template<typename _FIter, typename _Size, typename _Tp,

  869. 	   typename _BinaryPredicate>

  870.     _GLIBCXX20_CONSTEXPR

  871.     _FIter

  872.     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

  873. 

  874.   template<typename _IIter1, typename _IIter2, typename _OIter>

  875.     _GLIBCXX20_CONSTEXPR

  876.     _OIter

  877.     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  878. 

  879.   template<typename _IIter1, typename _IIter2, typename _OIter,

  880. 	   typename _Compare>

  881.     _GLIBCXX20_CONSTEXPR

  882.     _OIter

  883.     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  884. 

  885.   template<typename _IIter1, typename _IIter2, typename _OIter>

  886.     _GLIBCXX20_CONSTEXPR

  887.     _OIter

  888.     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  889. 

  890.   template<typename _IIter1, typename _IIter2, typename _OIter,

  891. 	   typename _Compare>

  892.     _GLIBCXX20_CONSTEXPR

  893.     _OIter

  894.     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  895. 

  896.   template<typename _IIter1, typename _IIter2, typename _OIter>

  897.     _GLIBCXX20_CONSTEXPR

  898.     _OIter

  899.     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  900. 

  901.   template<typename _IIter1, typename _IIter2, typename _OIter,

  902. 	   typename _Compare>

  903.     _GLIBCXX20_CONSTEXPR

  904.     _OIter

  905.     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,

  906. 			     _OIter, _Compare);

  907. 

  908.   template<typename _IIter1, typename _IIter2, typename _OIter>

  909.     _GLIBCXX20_CONSTEXPR

  910.     _OIter

  911.     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  912. 

  913.   template<typename _IIter1, typename _IIter2, typename _OIter,

  914. 	   typename _Compare>

  915.     _GLIBCXX20_CONSTEXPR

  916.     _OIter

  917.     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  918. 

  919.   template<typename _RAIter>

  920.     _GLIBCXX20_CONSTEXPR

  921.     void

  922.     sort(_RAIter, _RAIter);

  923. 

  924.   template<typename _RAIter, typename _Compare>

  925.     _GLIBCXX20_CONSTEXPR

  926.     void

  927.     sort(_RAIter, _RAIter, _Compare);

  928. 

  929.   template<typename _RAIter>

  930.     void

  931.     stable_sort(_RAIter, _RAIter);

  932. 

  933.   template<typename _RAIter, typename _Compare>

  934.     void

  935.     stable_sort(_RAIter, _RAIter, _Compare);

  936. 

  937.   template<typename _IIter, typename _OIter, typename _UnaryOperation>

  938.     _GLIBCXX20_CONSTEXPR

  939.     _OIter

  940.     transform(_IIter, _IIter, _OIter, _UnaryOperation);

  941. 

  942.   template<typename _IIter1, typename _IIter2, typename _OIter,

  943. 	   typename _BinaryOperation>

  944.     _GLIBCXX20_CONSTEXPR

  945.     _OIter

  946.     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

  947. 

  948.   template<typename _IIter, typename _OIter>

  949.     _GLIBCXX20_CONSTEXPR

  950.     _OIter

  951.     unique_copy(_IIter, _IIter, _OIter);

  952. 

  953.   template<typename _IIter, typename _OIter, typename _BinaryPredicate>

  954.     _GLIBCXX20_CONSTEXPR

  955.     _OIter

  956.     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);

  957. 

  958. _GLIBCXX_END_NAMESPACE_ALGO

  959. _GLIBCXX_END_NAMESPACE_VERSION

  960. } // namespace std

  961. 

  962. #ifdef _GLIBCXX_PARALLEL

  963. # include <parallel/algorithmfwd.h>

  964. #endif

  965. 

  966. #endif