libstdc++
algorithmfwd.h
Go to the documentation of this file.
00001 // <algorithm> Forward declarations  -*- C++ -*-
00002 
00003 // Copyright (C) 2007-2015 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 3, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // Under Section 7 of GPL version 3, you are granted additional
00017 // permissions described in the GCC Runtime Library Exception, version
00018 // 3.1, as published by the Free Software Foundation.
00019 
00020 // You should have received a copy of the GNU General Public License and
00021 // a copy of the GCC Runtime Library Exception along with this program;
00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00023 // <http://www.gnu.org/licenses/>.
00024 
00025 /** @file bits/algorithmfwd.h
00026  *  This is an internal header file, included by other library headers.
00027  *  Do not attempt to use it directly. @headername{algorithm}
00028  */
00029 
00030 #ifndef _GLIBCXX_ALGORITHMFWD_H
00031 #define _GLIBCXX_ALGORITHMFWD_H 1
00032 
00033 #pragma GCC system_header
00034 
00035 #include <bits/c++config.h>
00036 #include <bits/stl_pair.h>
00037 #include <bits/stl_iterator_base_types.h>
00038 #if __cplusplus >= 201103L
00039 #include <initializer_list>
00040 #endif
00041 
00042 namespace std _GLIBCXX_VISIBILITY(default)
00043 {
00044 _GLIBCXX_BEGIN_NAMESPACE_VERSION
00045 
00046   /*
00047     adjacent_find
00048     all_of (C++0x)
00049     any_of (C++0x)
00050     binary_search
00051     copy
00052     copy_backward
00053     copy_if (C++0x)
00054     copy_n (C++0x)
00055     count
00056     count_if
00057     equal
00058     equal_range
00059     fill
00060     fill_n
00061     find
00062     find_end
00063     find_first_of
00064     find_if
00065     find_if_not (C++0x)
00066     for_each
00067     generate
00068     generate_n
00069     includes
00070     inplace_merge
00071     is_heap (C++0x)
00072     is_heap_until (C++0x)
00073     is_partitioned (C++0x)
00074     is_sorted (C++0x)
00075     is_sorted_until (C++0x)
00076     iter_swap
00077     lexicographical_compare
00078     lower_bound
00079     make_heap
00080     max
00081     max_element
00082     merge
00083     min
00084     min_element
00085     minmax (C++0x)
00086     minmax_element (C++0x)
00087     mismatch
00088     next_permutation
00089     none_of (C++0x)
00090     nth_element
00091     partial_sort
00092     partial_sort_copy
00093     partition
00094     partition_copy (C++0x)
00095     partition_point (C++0x)
00096     pop_heap
00097     prev_permutation
00098     push_heap
00099     random_shuffle
00100     remove
00101     remove_copy
00102     remove_copy_if
00103     remove_if
00104     replace
00105     replace_copy
00106     replace_copy_if
00107     replace_if
00108     reverse
00109     reverse_copy
00110     rotate
00111     rotate_copy
00112     search
00113     search_n
00114     set_difference
00115     set_intersection
00116     set_symmetric_difference
00117     set_union
00118     shuffle (C++0x)
00119     sort
00120     sort_heap
00121     stable_partition
00122     stable_sort
00123     swap
00124     swap_ranges
00125     transform
00126     unique
00127     unique_copy
00128     upper_bound
00129   */
00130 
00131   /**
00132    * @defgroup algorithms Algorithms
00133    *
00134    * Components for performing algorithmic operations. Includes
00135    * non-modifying sequence, modifying (mutating) sequence, sorting,
00136    * searching, merge, partition, heap, set, minima, maxima, and
00137    * permutation operations.
00138    */
00139 
00140   /**
00141    * @defgroup mutating_algorithms Mutating
00142    * @ingroup algorithms
00143    */
00144 
00145   /**
00146    * @defgroup non_mutating_algorithms Non-Mutating
00147    * @ingroup algorithms
00148    */
00149 
00150   /**
00151    * @defgroup sorting_algorithms Sorting
00152    * @ingroup algorithms
00153    */
00154 
00155   /**
00156    * @defgroup set_algorithms Set Operation
00157    * @ingroup sorting_algorithms
00158    *
00159    * These algorithms are common set operations performed on sequences
00160    * that are already sorted. The number of comparisons will be
00161    * linear.
00162    */
00163 
00164   /**
00165    * @defgroup binary_search_algorithms Binary Search
00166    * @ingroup sorting_algorithms
00167    *
00168    * These algorithms are variations of a classic binary search, and
00169    * all assume that the sequence being searched is already sorted.
00170    * 
00171    * The number of comparisons will be logarithmic (and as few as
00172    * possible).  The number of steps through the sequence will be
00173    * logarithmic for random-access iterators (e.g., pointers), and
00174    * linear otherwise.
00175    * 
00176    * The LWG has passed Defect Report 270, which notes: <em>The
00177    * proposed resolution reinterprets binary search. Instead of
00178    * thinking about searching for a value in a sorted range, we view
00179    * that as an important special case of a more general algorithm:
00180    * searching for the partition point in a partitioned range.  We
00181    * also add a guarantee that the old wording did not: we ensure that
00182    * the upper bound is no earlier than the lower bound, that the pair
00183    * returned by equal_range is a valid range, and that the first part
00184    * of that pair is the lower bound.</em>
00185    *
00186    * The actual effect of the first sentence is that a comparison
00187    * functor passed by the user doesn't necessarily need to induce a
00188    * strict weak ordering relation.  Rather, it partitions the range.
00189    */
00190 
00191   // adjacent_find
00192 
00193 #if __cplusplus >= 201103L
00194   template<typename _IIter, typename _Predicate>
00195     bool
00196     all_of(_IIter, _IIter, _Predicate);
00197 
00198   template<typename _IIter, typename _Predicate>
00199     bool
00200     any_of(_IIter, _IIter, _Predicate);
00201 #endif
00202 
00203   template<typename _FIter, typename _Tp>
00204     bool 
00205     binary_search(_FIter, _FIter, const _Tp&);
00206 
00207   template<typename _FIter, typename _Tp, typename _Compare>
00208     bool 
00209     binary_search(_FIter, _FIter, const _Tp&, _Compare);
00210 
00211   template<typename _IIter, typename _OIter>
00212     _OIter 
00213     copy(_IIter, _IIter, _OIter);
00214 
00215   template<typename _BIter1, typename _BIter2>
00216     _BIter2
00217     copy_backward(_BIter1, _BIter1, _BIter2);
00218 
00219 #if __cplusplus >= 201103L
00220   template<typename _IIter, typename _OIter, typename _Predicate>
00221     _OIter
00222     copy_if(_IIter, _IIter, _OIter, _Predicate);
00223 
00224   template<typename _IIter, typename _Size, typename _OIter>
00225     _OIter
00226     copy_n(_IIter, _Size, _OIter);
00227 #endif
00228 
00229   // count
00230   // count_if
00231 
00232   template<typename _FIter, typename _Tp>
00233     pair<_FIter, _FIter>
00234     equal_range(_FIter, _FIter, const _Tp&);
00235 
00236   template<typename _FIter, typename _Tp, typename _Compare>
00237     pair<_FIter, _FIter>
00238     equal_range(_FIter, _FIter, const _Tp&, _Compare);
00239 
00240   template<typename _FIter, typename _Tp>
00241     void 
00242     fill(_FIter, _FIter, const _Tp&);
00243 
00244   template<typename _OIter, typename _Size, typename _Tp>
00245     _OIter
00246     fill_n(_OIter, _Size, const _Tp&);
00247 
00248   // find
00249 
00250   template<typename _FIter1, typename _FIter2>
00251     _FIter1
00252     find_end(_FIter1, _FIter1, _FIter2, _FIter2);
00253 
00254   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
00255     _FIter1
00256     find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
00257 
00258   // find_first_of
00259   // find_if
00260 
00261 #if __cplusplus >= 201103L
00262   template<typename _IIter, typename _Predicate>
00263     _IIter
00264     find_if_not(_IIter, _IIter, _Predicate);
00265 #endif
00266 
00267   // for_each
00268   // generate
00269   // generate_n
00270 
00271   template<typename _IIter1, typename _IIter2>
00272     bool 
00273     includes(_IIter1, _IIter1, _IIter2, _IIter2);
00274 
00275   template<typename _IIter1, typename _IIter2, typename _Compare>
00276     bool 
00277     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
00278 
00279   template<typename _BIter>
00280     void 
00281     inplace_merge(_BIter, _BIter, _BIter);
00282 
00283   template<typename _BIter, typename _Compare>
00284     void 
00285     inplace_merge(_BIter, _BIter, _BIter, _Compare);
00286 
00287 #if __cplusplus >= 201103L
00288   template<typename _RAIter>
00289     bool 
00290     is_heap(_RAIter, _RAIter);
00291 
00292   template<typename _RAIter, typename _Compare>
00293     bool 
00294     is_heap(_RAIter, _RAIter, _Compare);
00295 
00296   template<typename _RAIter>
00297     _RAIter 
00298     is_heap_until(_RAIter, _RAIter);
00299 
00300   template<typename _RAIter, typename _Compare>
00301     _RAIter 
00302     is_heap_until(_RAIter, _RAIter, _Compare);
00303 
00304   template<typename _IIter, typename _Predicate>
00305     bool
00306     is_partitioned(_IIter, _IIter, _Predicate);
00307 
00308   template<typename _FIter1, typename _FIter2>
00309     bool
00310     is_permutation(_FIter1, _FIter1, _FIter2);
00311 
00312   template<typename _FIter1, typename _FIter2,
00313            typename _BinaryPredicate>
00314     bool
00315     is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
00316 
00317   template<typename _FIter>
00318     bool 
00319     is_sorted(_FIter, _FIter);
00320 
00321   template<typename _FIter, typename _Compare>
00322     bool 
00323     is_sorted(_FIter, _FIter, _Compare);
00324 
00325   template<typename _FIter>
00326     _FIter 
00327     is_sorted_until(_FIter, _FIter);
00328 
00329   template<typename _FIter, typename _Compare>
00330     _FIter 
00331     is_sorted_until(_FIter, _FIter, _Compare);
00332 #endif
00333 
00334   template<typename _FIter1, typename _FIter2>
00335     void 
00336     iter_swap(_FIter1, _FIter2);
00337 
00338   template<typename _FIter, typename _Tp>
00339     _FIter 
00340     lower_bound(_FIter, _FIter, const _Tp&);
00341 
00342   template<typename _FIter, typename _Tp, typename _Compare>
00343     _FIter 
00344     lower_bound(_FIter, _FIter, const _Tp&, _Compare);
00345 
00346   template<typename _RAIter>
00347     void 
00348     make_heap(_RAIter, _RAIter);
00349 
00350   template<typename _RAIter, typename _Compare>
00351     void 
00352     make_heap(_RAIter, _RAIter, _Compare);
00353 
00354   template<typename _Tp> 
00355     _GLIBCXX14_CONSTEXPR
00356     const _Tp& 
00357     max(const _Tp&, const _Tp&);
00358 
00359   template<typename _Tp, typename _Compare>
00360     _GLIBCXX14_CONSTEXPR
00361     const _Tp& 
00362     max(const _Tp&, const _Tp&, _Compare);
00363 
00364   // max_element
00365   // merge
00366 
00367   template<typename _Tp> 
00368     _GLIBCXX14_CONSTEXPR
00369     const _Tp& 
00370     min(const _Tp&, const _Tp&);
00371 
00372   template<typename _Tp, typename _Compare>
00373     _GLIBCXX14_CONSTEXPR
00374     const _Tp& 
00375     min(const _Tp&, const _Tp&, _Compare);
00376 
00377   // min_element
00378 
00379 #if __cplusplus >= 201103L
00380   template<typename _Tp>
00381     _GLIBCXX14_CONSTEXPR
00382     pair<const _Tp&, const _Tp&> 
00383     minmax(const _Tp&, const _Tp&);
00384 
00385   template<typename _Tp, typename _Compare>
00386     _GLIBCXX14_CONSTEXPR
00387     pair<const _Tp&, const _Tp&>
00388     minmax(const _Tp&, const _Tp&, _Compare);
00389 
00390   template<typename _FIter>
00391     _GLIBCXX14_CONSTEXPR
00392     pair<_FIter, _FIter>
00393     minmax_element(_FIter, _FIter);
00394 
00395   template<typename _FIter, typename _Compare>
00396     _GLIBCXX14_CONSTEXPR
00397     pair<_FIter, _FIter>
00398     minmax_element(_FIter, _FIter, _Compare);
00399 
00400   template<typename _Tp>
00401     _GLIBCXX14_CONSTEXPR
00402     _Tp
00403     min(initializer_list<_Tp>);
00404 
00405   template<typename _Tp, typename _Compare>
00406     _GLIBCXX14_CONSTEXPR
00407     _Tp
00408     min(initializer_list<_Tp>, _Compare);
00409 
00410   template<typename _Tp>
00411     _GLIBCXX14_CONSTEXPR
00412     _Tp
00413     max(initializer_list<_Tp>);
00414 
00415   template<typename _Tp, typename _Compare>
00416     _GLIBCXX14_CONSTEXPR
00417     _Tp
00418     max(initializer_list<_Tp>, _Compare);
00419 
00420   template<typename _Tp>
00421     _GLIBCXX14_CONSTEXPR
00422     pair<_Tp, _Tp>
00423     minmax(initializer_list<_Tp>);
00424 
00425   template<typename _Tp, typename _Compare>
00426     _GLIBCXX14_CONSTEXPR
00427     pair<_Tp, _Tp>
00428     minmax(initializer_list<_Tp>, _Compare);
00429 #endif
00430 
00431   // mismatch
00432 
00433   template<typename _BIter>
00434     bool 
00435     next_permutation(_BIter, _BIter);
00436 
00437   template<typename _BIter, typename _Compare>
00438     bool 
00439     next_permutation(_BIter, _BIter, _Compare);
00440 
00441 #if __cplusplus >= 201103L
00442   template<typename _IIter, typename _Predicate>
00443     bool
00444     none_of(_IIter, _IIter, _Predicate);
00445 #endif
00446 
00447   // nth_element
00448   // partial_sort
00449 
00450   template<typename _IIter, typename _RAIter>
00451     _RAIter
00452     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
00453 
00454   template<typename _IIter, typename _RAIter, typename _Compare>
00455     _RAIter
00456     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
00457 
00458   // partition
00459 
00460 #if __cplusplus >= 201103L
00461   template<typename _IIter, typename _OIter1,
00462            typename _OIter2, typename _Predicate>
00463     pair<_OIter1, _OIter2>
00464     partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
00465 
00466   template<typename _FIter, typename _Predicate>
00467     _FIter
00468     partition_point(_FIter, _FIter, _Predicate);
00469 #endif
00470 
00471   template<typename _RAIter>
00472     void 
00473     pop_heap(_RAIter, _RAIter);
00474 
00475   template<typename _RAIter, typename _Compare>
00476     void 
00477     pop_heap(_RAIter, _RAIter, _Compare);
00478 
00479   template<typename _BIter>
00480     bool 
00481     prev_permutation(_BIter, _BIter);
00482 
00483   template<typename _BIter, typename _Compare>
00484     bool 
00485     prev_permutation(_BIter, _BIter, _Compare);
00486 
00487   template<typename _RAIter>
00488     void 
00489     push_heap(_RAIter, _RAIter);
00490 
00491   template<typename _RAIter, typename _Compare>
00492     void 
00493     push_heap(_RAIter, _RAIter, _Compare);
00494 
00495   // random_shuffle
00496 
00497   template<typename _FIter, typename _Tp>
00498     _FIter 
00499     remove(_FIter, _FIter, const _Tp&);
00500 
00501   template<typename _FIter, typename _Predicate>
00502     _FIter 
00503     remove_if(_FIter, _FIter, _Predicate);
00504 
00505   template<typename _IIter, typename _OIter, typename _Tp>
00506     _OIter 
00507     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
00508 
00509   template<typename _IIter, typename _OIter, typename _Predicate>
00510     _OIter 
00511     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
00512 
00513   // replace
00514 
00515   template<typename _IIter, typename _OIter, typename _Tp>
00516     _OIter 
00517     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
00518 
00519   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
00520     _OIter 
00521     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
00522 
00523   // replace_if
00524 
00525   template<typename _BIter>
00526     void 
00527     reverse(_BIter, _BIter);
00528 
00529   template<typename _BIter, typename _OIter>
00530     _OIter 
00531     reverse_copy(_BIter, _BIter, _OIter);
00532 
00533   inline namespace _V2
00534   {
00535     template<typename _FIter>
00536       _FIter
00537       rotate(_FIter, _FIter, _FIter);
00538   }
00539 
00540   template<typename _FIter, typename _OIter>
00541     _OIter 
00542     rotate_copy(_FIter, _FIter, _FIter, _OIter);
00543 
00544   // search
00545   // search_n
00546   // set_difference
00547   // set_intersection
00548   // set_symmetric_difference
00549   // set_union
00550 
00551 #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
00552   template<typename _RAIter, typename _UGenerator>
00553     void
00554     shuffle(_RAIter, _RAIter, _UGenerator&&);
00555 #endif
00556 
00557   template<typename _RAIter>
00558     void 
00559     sort_heap(_RAIter, _RAIter);
00560 
00561   template<typename _RAIter, typename _Compare>
00562     void 
00563     sort_heap(_RAIter, _RAIter, _Compare);
00564 
00565   template<typename _BIter, typename _Predicate>
00566     _BIter 
00567     stable_partition(_BIter, _BIter, _Predicate);
00568 
00569   template<typename _Tp> 
00570     void 
00571     swap(_Tp&, _Tp&)
00572 #if __cplusplus >= 201103L
00573     noexcept(__and_<is_nothrow_move_constructible<_Tp>,
00574                     is_nothrow_move_assignable<_Tp>>::value)
00575 #endif
00576     ;
00577 
00578   template<typename _Tp, size_t _Nm>
00579     void
00580     swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
00581 #if __cplusplus >= 201103L
00582     noexcept(noexcept(swap(*__a, *__b)))
00583 #endif
00584     ;
00585 
00586   template<typename _FIter1, typename _FIter2>
00587     _FIter2 
00588     swap_ranges(_FIter1, _FIter1, _FIter2);
00589 
00590   // transform
00591 
00592   template<typename _FIter>
00593     _FIter 
00594     unique(_FIter, _FIter);
00595 
00596   template<typename _FIter, typename _BinaryPredicate>
00597     _FIter 
00598     unique(_FIter, _FIter, _BinaryPredicate);
00599 
00600   // unique_copy
00601 
00602   template<typename _FIter, typename _Tp>
00603     _FIter 
00604     upper_bound(_FIter, _FIter, const _Tp&);
00605 
00606   template<typename _FIter, typename _Tp, typename _Compare>
00607     _FIter 
00608     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
00609 
00610 _GLIBCXX_END_NAMESPACE_VERSION
00611 
00612 _GLIBCXX_BEGIN_NAMESPACE_ALGO
00613 
00614   template<typename _FIter>
00615     _FIter 
00616     adjacent_find(_FIter, _FIter);
00617 
00618   template<typename _FIter, typename _BinaryPredicate>
00619     _FIter 
00620     adjacent_find(_FIter, _FIter, _BinaryPredicate);
00621 
00622   template<typename _IIter, typename _Tp>
00623     typename iterator_traits<_IIter>::difference_type
00624     count(_IIter, _IIter, const _Tp&);
00625 
00626   template<typename _IIter, typename _Predicate>
00627     typename iterator_traits<_IIter>::difference_type
00628     count_if(_IIter, _IIter, _Predicate);
00629 
00630   template<typename _IIter1, typename _IIter2>
00631     bool 
00632     equal(_IIter1, _IIter1, _IIter2);
00633 
00634   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
00635     bool 
00636     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
00637 
00638   template<typename _IIter, typename _Tp>
00639     _IIter 
00640     find(_IIter, _IIter, const _Tp&);
00641 
00642   template<typename _FIter1, typename _FIter2>
00643     _FIter1
00644     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
00645 
00646   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
00647     _FIter1
00648     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
00649 
00650   template<typename _IIter, typename _Predicate>
00651     _IIter
00652     find_if(_IIter, _IIter, _Predicate);
00653 
00654   template<typename _IIter, typename _Funct>
00655     _Funct 
00656     for_each(_IIter, _IIter, _Funct);
00657 
00658   template<typename _FIter, typename _Generator>
00659     void 
00660     generate(_FIter, _FIter, _Generator);
00661 
00662   template<typename _OIter, typename _Size, typename _Generator>
00663     _OIter
00664     generate_n(_OIter, _Size, _Generator);
00665 
00666   template<typename _IIter1, typename _IIter2>
00667     bool 
00668     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
00669 
00670   template<typename _IIter1, typename _IIter2, typename _Compare>
00671     bool 
00672     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
00673 
00674   template<typename _FIter>
00675     _GLIBCXX14_CONSTEXPR
00676     _FIter 
00677     max_element(_FIter, _FIter);
00678 
00679   template<typename _FIter, typename _Compare>
00680     _GLIBCXX14_CONSTEXPR
00681     _FIter 
00682     max_element(_FIter, _FIter, _Compare);
00683 
00684   template<typename _IIter1, typename _IIter2, typename _OIter>
00685     _OIter 
00686     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
00687 
00688   template<typename _IIter1, typename _IIter2, typename _OIter, 
00689            typename _Compare>
00690     _OIter 
00691     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
00692 
00693   template<typename _FIter>
00694     _GLIBCXX14_CONSTEXPR
00695     _FIter 
00696     min_element(_FIter, _FIter);
00697 
00698   template<typename _FIter, typename _Compare>
00699     _GLIBCXX14_CONSTEXPR
00700     _FIter 
00701     min_element(_FIter, _FIter, _Compare);
00702 
00703   template<typename _IIter1, typename _IIter2>
00704     pair<_IIter1, _IIter2>
00705     mismatch(_IIter1, _IIter1, _IIter2);
00706 
00707   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
00708     pair<_IIter1, _IIter2>
00709     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
00710 
00711   template<typename _RAIter>
00712     void 
00713     nth_element(_RAIter, _RAIter, _RAIter);
00714 
00715   template<typename _RAIter, typename _Compare>
00716     void 
00717     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
00718 
00719   template<typename _RAIter>
00720     void 
00721     partial_sort(_RAIter, _RAIter, _RAIter);
00722 
00723   template<typename _RAIter, typename _Compare>
00724     void 
00725     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
00726 
00727   template<typename _BIter, typename _Predicate>
00728     _BIter 
00729     partition(_BIter, _BIter, _Predicate);
00730 
00731   template<typename _RAIter>
00732     void 
00733     random_shuffle(_RAIter, _RAIter);
00734 
00735   template<typename _RAIter, typename _Generator>
00736     void 
00737     random_shuffle(_RAIter, _RAIter,
00738 #if __cplusplus >= 201103L
00739                    _Generator&&);
00740 #else
00741                    _Generator&);
00742 #endif
00743 
00744   template<typename _FIter, typename _Tp>
00745     void 
00746     replace(_FIter, _FIter, const _Tp&, const _Tp&);
00747 
00748   template<typename _FIter, typename _Predicate, typename _Tp>
00749     void 
00750     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
00751 
00752   template<typename _FIter1, typename _FIter2>
00753     _FIter1 
00754     search(_FIter1, _FIter1, _FIter2, _FIter2);
00755 
00756   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
00757     _FIter1 
00758     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
00759 
00760   template<typename _FIter, typename _Size, typename _Tp>
00761     _FIter 
00762     search_n(_FIter, _FIter, _Size, const _Tp&);
00763 
00764   template<typename _FIter, typename _Size, typename _Tp, 
00765            typename _BinaryPredicate>
00766     _FIter 
00767     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
00768 
00769   template<typename _IIter1, typename _IIter2, typename _OIter>
00770     _OIter 
00771     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
00772 
00773   template<typename _IIter1, typename _IIter2, typename _OIter, 
00774            typename _Compare>
00775     _OIter 
00776     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
00777 
00778   template<typename _IIter1, typename _IIter2, typename _OIter>
00779     _OIter 
00780     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
00781 
00782   template<typename _IIter1, typename _IIter2, typename _OIter,
00783            typename _Compare>
00784     _OIter 
00785     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
00786 
00787   template<typename _IIter1, typename _IIter2, typename _OIter>
00788     _OIter
00789     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
00790 
00791   template<typename _IIter1, typename _IIter2, typename _OIter, 
00792            typename _Compare>
00793     _OIter
00794     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 
00795                              _OIter, _Compare);
00796 
00797   template<typename _IIter1, typename _IIter2, typename _OIter>
00798     _OIter 
00799     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
00800 
00801   template<typename _IIter1, typename _IIter2, typename _OIter,
00802            typename _Compare>
00803     _OIter 
00804     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
00805 
00806   template<typename _RAIter>
00807     void 
00808     sort(_RAIter, _RAIter);
00809 
00810   template<typename _RAIter, typename _Compare>
00811     void 
00812     sort(_RAIter, _RAIter, _Compare);
00813 
00814   template<typename _RAIter>
00815     void 
00816     stable_sort(_RAIter, _RAIter);
00817 
00818   template<typename _RAIter, typename _Compare>
00819     void 
00820     stable_sort(_RAIter, _RAIter, _Compare);
00821 
00822   template<typename _IIter, typename _OIter, typename _UnaryOperation>
00823     _OIter 
00824     transform(_IIter, _IIter, _OIter, _UnaryOperation);
00825 
00826   template<typename _IIter1, typename _IIter2, typename _OIter, 
00827            typename _BinaryOperation>
00828     _OIter 
00829     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
00830 
00831   template<typename _IIter, typename _OIter>
00832     _OIter 
00833     unique_copy(_IIter, _IIter, _OIter);
00834 
00835   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
00836     _OIter 
00837     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
00838 
00839 _GLIBCXX_END_NAMESPACE_ALGO
00840 } // namespace std
00841 
00842 #ifdef _GLIBCXX_PARALLEL
00843 # include <parallel/algorithmfwd.h>
00844 #endif
00845 
00846 #endif
00847