Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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