Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

stl_algo.h

Go to the documentation of this file.
00001 /*
00002  *
00003  * Copyright (c) 1994
00004  * Hewlett-Packard Company
00005  *
00006  * Permission to use, copy, modify, distribute and sell this software
00007  * and its documentation for any purpose is hereby granted without fee,
00008  * provided that the above copyright notice appear in all copies and
00009  * that both that copyright notice and this permission notice appear
00010  * in supporting documentation.  Hewlett-Packard Company makes no
00011  * representations about the suitability of this software for any
00012  * purpose.  It is provided "as is" without express or implied warranty.
00013  *
00014  *
00015  * Copyright (c) 1996
00016  * Silicon Graphics Computer Systems, Inc.
00017  *
00018  * Permission to use, copy, modify, distribute and sell this software
00019  * and its documentation for any purpose is hereby granted without fee,
00020  * provided that the above copyright notice appear in all copies and
00021  * that both that copyright notice and this permission notice appear
00022  * in supporting documentation.  Silicon Graphics makes no
00023  * representations about the suitability of this software for any
00024  * purpose.  It is provided "as is" without express or implied warranty.
00025  */
00026 
00027 /* NOTE: This is an internal header file, included by other STL headers.
00028  *   You should not attempt to use it directly.
00029  */
00030 
00031 #ifndef __SGI_STL_INTERNAL_ALGO_H
00032 #define __SGI_STL_INTERNAL_ALGO_H
00033 
00034 #include <bits/stl_heap.h>
00035 
00036 // See concept_check.h for the __glibcpp_*_requires macros.
00037 
00038 namespace std
00039 {
00040 
00041 // __median (an extension, not present in the C++ standard).
00042 
00043 template <class _Tp>
00044 inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
00045 {
00046   // concept requirements
00047   __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
00048   if (__a < __b)
00049     if (__b < __c)
00050       return __b;
00051     else if (__a < __c)
00052       return __c;
00053     else
00054       return __a;
00055   else if (__a < __c)
00056     return __a;
00057   else if (__b < __c)
00058     return __c;
00059   else
00060     return __b;
00061 }
00062 
00063 template <class _Tp, class _Compare>
00064 inline const _Tp&
00065 __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
00066 {
00067   // concept requirements
00068   __glibcpp_function_requires(_BinaryFunctionConcept<_Compare, bool, _Tp, _Tp>);
00069   if (__comp(__a, __b))
00070     if (__comp(__b, __c))
00071       return __b;
00072     else if (__comp(__a, __c))
00073       return __c;
00074     else
00075       return __a;
00076   else if (__comp(__a, __c))
00077     return __a;
00078   else if (__comp(__b, __c))
00079     return __c;
00080   else
00081     return __b;
00082 }
00083 
00084 // for_each.  Apply a function to every element of a range.
00085 template <class _InputIter, class _Function>
00086 _Function for_each(_InputIter __first, _InputIter __last, _Function __f)
00087 {
00088   // concept requirements
00089   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00090   for ( ; __first != __last; ++__first)
00091     __f(*__first);
00092   return __f;
00093 }
00094 
00095 // find and find_if.
00096 
00097 template <class _InputIter, class _Tp>
00098 inline _InputIter find(_InputIter __first, _InputIter __last,
00099                        const _Tp& __val,
00100                        input_iterator_tag)
00101 {
00102   while (__first != __last && !(*__first == __val))
00103     ++__first;
00104   return __first;
00105 }
00106 
00107 template <class _InputIter, class _Predicate>
00108 inline _InputIter find_if(_InputIter __first, _InputIter __last,
00109                           _Predicate __pred,
00110                           input_iterator_tag)
00111 {
00112   while (__first != __last && !__pred(*__first))
00113     ++__first;
00114   return __first;
00115 }
00116 
00117 template <class _RandomAccessIter, class _Tp>
00118 _RandomAccessIter find(_RandomAccessIter __first, _RandomAccessIter __last,
00119                        const _Tp& __val,
00120                        random_access_iterator_tag)
00121 {
00122   typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
00123     = (__last - __first) >> 2;
00124 
00125   for ( ; __trip_count > 0 ; --__trip_count) {
00126     if (*__first == __val) return __first;
00127     ++__first;
00128 
00129     if (*__first == __val) return __first;
00130     ++__first;
00131 
00132     if (*__first == __val) return __first;
00133     ++__first;
00134 
00135     if (*__first == __val) return __first;
00136     ++__first;
00137   }
00138 
00139   switch(__last - __first) {
00140   case 3:
00141     if (*__first == __val) return __first;
00142     ++__first;
00143   case 2:
00144     if (*__first == __val) return __first;
00145     ++__first;
00146   case 1:
00147     if (*__first == __val) return __first;
00148     ++__first;
00149   case 0:
00150   default:
00151     return __last;
00152   }
00153 }
00154 
00155 template <class _RandomAccessIter, class _Predicate>
00156 _RandomAccessIter find_if(_RandomAccessIter __first, _RandomAccessIter __last,
00157                           _Predicate __pred,
00158                           random_access_iterator_tag)
00159 {
00160   typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
00161     = (__last - __first) >> 2;
00162 
00163   for ( ; __trip_count > 0 ; --__trip_count) {
00164     if (__pred(*__first)) return __first;
00165     ++__first;
00166 
00167     if (__pred(*__first)) return __first;
00168     ++__first;
00169 
00170     if (__pred(*__first)) return __first;
00171     ++__first;
00172 
00173     if (__pred(*__first)) return __first;
00174     ++__first;
00175   }
00176 
00177   switch(__last - __first) {
00178   case 3:
00179     if (__pred(*__first)) return __first;
00180     ++__first;
00181   case 2:
00182     if (__pred(*__first)) return __first;
00183     ++__first;
00184   case 1:
00185     if (__pred(*__first)) return __first;
00186     ++__first;
00187   case 0:
00188   default:
00189     return __last;
00190   }
00191 }
00192 
00193 template <class _InputIter, class _Tp>
00194 inline _InputIter find(_InputIter __first, _InputIter __last,
00195                        const _Tp& __val)
00196 {
00197   // concept requirements
00198   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00199   __glibcpp_function_requires(_EqualOpConcept<
00200             typename iterator_traits<_InputIter>::value_type, _Tp>);
00201   return find(__first, __last, __val, __iterator_category(__first));
00202 }
00203 
00204 template <class _InputIter, class _Predicate>
00205 inline _InputIter find_if(_InputIter __first, _InputIter __last,
00206                           _Predicate __pred)
00207 {
00208   // concept requirements
00209   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00210   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00211           typename iterator_traits<_InputIter>::value_type>);
00212   return find_if(__first, __last, __pred, __iterator_category(__first));
00213 }
00214 
00215 // adjacent_find.
00216 
00217 template <class _ForwardIter>
00218 _ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last)
00219 {
00220   // concept requirements
00221   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
00222   __glibcpp_function_requires(_EqualityComparableConcept<
00223     typename iterator_traits<_ForwardIter>::value_type>);
00224   if (__first == __last)
00225     return __last;
00226   _ForwardIter __next = __first;
00227   while(++__next != __last) {
00228     if (*__first == *__next)
00229       return __first;
00230     __first = __next;
00231   }
00232   return __last;
00233 }
00234 
00235 template <class _ForwardIter, class _BinaryPredicate>
00236 _ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last,
00237                            _BinaryPredicate __binary_pred)
00238 {
00239   // concept requirements
00240   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
00241   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
00242         typename iterator_traits<_ForwardIter>::value_type,
00243         typename iterator_traits<_ForwardIter>::value_type>);
00244   if (__first == __last)
00245     return __last;
00246   _ForwardIter __next = __first;
00247   while(++__next != __last) {
00248     if (__binary_pred(*__first, *__next))
00249       return __first;
00250     __first = __next;
00251   }
00252   return __last;
00253 }
00254 
00255 // count and count_if.  There are two version of each, one whose return type
00256 // type is void and one (present only if we have partial specialization)
00257 // whose return type is iterator_traits<_InputIter>::difference_type.  The
00258 // C++ standard only has the latter version, but the former, which was present
00259 // in the HP STL, is retained for backward compatibility.
00260 
00261 template <class _InputIter, class _Tp, class _Size>
00262 void count(_InputIter __first, _InputIter __last, const _Tp& __value,
00263            _Size& __n)
00264 {
00265   // concept requirements
00266   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00267   __glibcpp_function_requires(_EqualityComparableConcept<
00268         typename iterator_traits<_InputIter>::value_type >);
00269   __glibcpp_function_requires(_EqualityComparableConcept<_Tp>);
00270   for ( ; __first != __last; ++__first)
00271     if (*__first == __value)
00272       ++__n;
00273 }
00274 
00275 template <class _InputIter, class _Predicate, class _Size>
00276 void count_if(_InputIter __first, _InputIter __last, _Predicate __pred,
00277               _Size& __n)
00278 {
00279   // concept requirements
00280   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00281   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00282         typename iterator_traits<_InputIter>::value_type>);
00283   for ( ; __first != __last; ++__first)
00284     if (__pred(*__first))
00285       ++__n;
00286 }
00287 
00288 template <class _InputIter, class _Tp>
00289 typename iterator_traits<_InputIter>::difference_type
00290 count(_InputIter __first, _InputIter __last, const _Tp& __value)
00291 {
00292   // concept requirements
00293   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00294   __glibcpp_function_requires(_EqualityComparableConcept<
00295         typename iterator_traits<_InputIter>::value_type >);
00296   __glibcpp_function_requires(_EqualityComparableConcept<_Tp>);
00297   typename iterator_traits<_InputIter>::difference_type __n = 0;
00298   for ( ; __first != __last; ++__first)
00299     if (*__first == __value)
00300       ++__n;
00301   return __n;
00302 }
00303 
00304 template <class _InputIter, class _Predicate>
00305 typename iterator_traits<_InputIter>::difference_type
00306 count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
00307 {
00308   // concept requirements
00309   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00310   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00311         typename iterator_traits<_InputIter>::value_type>);
00312   typename iterator_traits<_InputIter>::difference_type __n = 0;
00313   for ( ; __first != __last; ++__first)
00314     if (__pred(*__first))
00315       ++__n;
00316   return __n;
00317 }
00318 
00319 
00320 // search.
00321 
00322 template <class _ForwardIter1, class _ForwardIter2>
00323 _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
00324                      _ForwardIter2 __first2, _ForwardIter2 __last2) 
00325 {
00326   // concept requirements
00327   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
00328   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
00329   __glibcpp_function_requires(_EqualOpConcept<
00330         typename iterator_traits<_ForwardIter1>::value_type,
00331         typename iterator_traits<_ForwardIter2>::value_type>);
00332 
00333   // Test for empty ranges
00334   if (__first1 == __last1 || __first2 == __last2)
00335     return __first1;
00336 
00337   // Test for a pattern of length 1.
00338   _ForwardIter2 __tmp(__first2);
00339   ++__tmp;
00340   if (__tmp == __last2)
00341     return find(__first1, __last1, *__first2);
00342 
00343   // General case.
00344 
00345   _ForwardIter2 __p1, __p;
00346 
00347   __p1 = __first2; ++__p1;
00348 
00349   _ForwardIter1 __current = __first1;
00350 
00351   while (__first1 != __last1) {
00352     __first1 = find(__first1, __last1, *__first2);
00353     if (__first1 == __last1)
00354       return __last1;
00355 
00356     __p = __p1;
00357     __current = __first1; 
00358     if (++__current == __last1)
00359       return __last1;
00360 
00361     while (*__current == *__p) {
00362       if (++__p == __last2)
00363         return __first1;
00364       if (++__current == __last1)
00365         return __last1;
00366     }
00367 
00368     ++__first1;
00369   }
00370   return __first1;
00371 }
00372 
00373 template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
00374 _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
00375                      _ForwardIter2 __first2, _ForwardIter2 __last2,
00376                      _BinaryPred  __predicate) 
00377 {
00378   // concept requirements
00379   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
00380   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
00381   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
00382         typename iterator_traits<_ForwardIter1>::value_type,
00383         typename iterator_traits<_ForwardIter2>::value_type>);
00384 
00385   // Test for empty ranges
00386   if (__first1 == __last1 || __first2 == __last2)
00387     return __first1;
00388 
00389   // Test for a pattern of length 1.
00390   _ForwardIter2 __tmp(__first2);
00391   ++__tmp;
00392   if (__tmp == __last2) {
00393     while (__first1 != __last1 && !__predicate(*__first1, *__first2))
00394       ++__first1;
00395     return __first1;    
00396   }
00397 
00398   // General case.
00399 
00400   _ForwardIter2 __p1, __p;
00401 
00402   __p1 = __first2; ++__p1;
00403 
00404   _ForwardIter1 __current = __first1;
00405 
00406   while (__first1 != __last1) {
00407     while (__first1 != __last1) {
00408       if (__predicate(*__first1, *__first2))
00409         break;
00410       ++__first1;
00411     }
00412     while (__first1 != __last1 && !__predicate(*__first1, *__first2))
00413       ++__first1;
00414     if (__first1 == __last1)
00415       return __last1;
00416 
00417     __p = __p1;
00418     __current = __first1; 
00419     if (++__current == __last1) return __last1;
00420 
00421     while (__predicate(*__current, *__p)) {
00422       if (++__p == __last2)
00423         return __first1;
00424       if (++__current == __last1)
00425         return __last1;
00426     }
00427 
00428     ++__first1;
00429   }
00430   return __first1;
00431 }
00432 
00433 // search_n.  Search for __count consecutive copies of __val.
00434 
00435 template <class _ForwardIter, class _Integer, class _Tp>
00436 _ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
00437                       _Integer __count, const _Tp& __val)
00438 {
00439   // concept requirements
00440   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
00441   __glibcpp_function_requires(_EqualityComparableConcept<
00442         typename iterator_traits<_ForwardIter>::value_type>);
00443   __glibcpp_function_requires(_EqualityComparableConcept<_Tp>);
00444 
00445   if (__count <= 0)
00446     return __first;
00447   else {
00448     __first = find(__first, __last, __val);
00449     while (__first != __last) {
00450       _Integer __n = __count - 1;
00451       _ForwardIter __i = __first;
00452       ++__i;
00453       while (__i != __last && __n != 0 && *__i == __val) {
00454         ++__i;
00455         --__n;
00456       }
00457       if (__n == 0)
00458         return __first;
00459       else
00460         __first = find(__i, __last, __val);
00461     }
00462     return __last;
00463   }
00464 }
00465 
00466 template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
00467 _ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
00468                       _Integer __count, const _Tp& __val,
00469                       _BinaryPred __binary_pred)
00470 {
00471   // concept requirements
00472   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
00473   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
00474         typename iterator_traits<_ForwardIter>::value_type, _Tp>);
00475 
00476   if (__count <= 0)
00477     return __first;
00478   else {
00479     while (__first != __last) {
00480       if (__binary_pred(*__first, __val))
00481         break;
00482       ++__first;
00483     }
00484     while (__first != __last) {
00485       _Integer __n = __count - 1;
00486       _ForwardIter __i = __first;
00487       ++__i;
00488       while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
00489         ++__i;
00490         --__n;
00491       }
00492       if (__n == 0)
00493         return __first;
00494       else {
00495         while (__i != __last) {
00496           if (__binary_pred(*__i, __val))
00497             break;
00498           ++__i;
00499         }
00500         __first = __i;
00501       }
00502     }
00503     return __last;
00504   }
00505 } 
00506 
00507 // swap_ranges
00508 
00509 template <class _ForwardIter1, class _ForwardIter2>
00510 _ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
00511                           _ForwardIter2 __first2)
00512 {
00513   // concept requirements
00514   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>);
00515   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>);
00516   __glibcpp_function_requires(_ConvertibleConcept<
00517         typename iterator_traits<_ForwardIter1>::value_type,
00518         typename iterator_traits<_ForwardIter2>::value_type>);
00519   __glibcpp_function_requires(_ConvertibleConcept<
00520         typename iterator_traits<_ForwardIter2>::value_type,
00521         typename iterator_traits<_ForwardIter1>::value_type>);
00522 
00523   for ( ; __first1 != __last1; ++__first1, ++__first2)
00524     iter_swap(__first1, __first2);
00525   return __first2;
00526 }
00527 
00528 // transform
00529 
00530 template <class _InputIter, class _OutputIter, class _UnaryOperation>
00531 _OutputIter transform(_InputIter __first, _InputIter __last,
00532                       _OutputIter __result, _UnaryOperation __unary_op)
00533 {
00534   // concept requirements
00535   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00536 /* XXX
00537   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00538         // should be "the type returned by _UnaryOperation"
00539         typename iterator_traits<_InputIter>::value_type>);
00540 */
00541 
00542   for ( ; __first != __last; ++__first, ++__result)
00543     *__result = __unary_op(*__first);
00544   return __result;
00545 }
00546 
00547 template <class _InputIter1, class _InputIter2, class _OutputIter,
00548           class _BinaryOperation>
00549 _OutputIter transform(_InputIter1 __first1, _InputIter1 __last1,
00550                       _InputIter2 __first2, _OutputIter __result,
00551                       _BinaryOperation __binary_op)
00552 {
00553   // concept requirements
00554   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
00555   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
00556 /* XXX
00557   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00558         // should be "the type returned by _BinaryOperation"
00559         typename iterator_traits<_InputIter1>::value_type>);
00560 */
00561 
00562   for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
00563     *__result = __binary_op(*__first1, *__first2);
00564   return __result;
00565 }
00566 
00567 // replace, replace_if, replace_copy, replace_copy_if
00568 
00569 template <class _ForwardIter, class _Tp>
00570 void replace(_ForwardIter __first, _ForwardIter __last,
00571              const _Tp& __old_value, const _Tp& __new_value)
00572 {
00573   // concept requirements
00574   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
00575   __glibcpp_function_requires(_EqualOpConcept<
00576         typename iterator_traits<_ForwardIter>::value_type, _Tp>);
00577   __glibcpp_function_requires(_ConvertibleConcept<_Tp,
00578         typename iterator_traits<_ForwardIter>::value_type>);
00579 
00580   for ( ; __first != __last; ++__first)
00581     if (*__first == __old_value)
00582       *__first = __new_value;
00583 }
00584 
00585 template <class _ForwardIter, class _Predicate, class _Tp>
00586 void replace_if(_ForwardIter __first, _ForwardIter __last,
00587                 _Predicate __pred, const _Tp& __new_value)
00588 {
00589   // concept requirements
00590   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
00591   __glibcpp_function_requires(_ConvertibleConcept<_Tp,
00592         typename iterator_traits<_ForwardIter>::value_type>);
00593   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00594         typename iterator_traits<_ForwardIter>::value_type>);
00595 
00596   for ( ; __first != __last; ++__first)
00597     if (__pred(*__first))
00598       *__first = __new_value;
00599 }
00600 
00601 template <class _InputIter, class _OutputIter, class _Tp>
00602 _OutputIter replace_copy(_InputIter __first, _InputIter __last,
00603                          _OutputIter __result,
00604                          const _Tp& __old_value, const _Tp& __new_value)
00605 {
00606   // concept requirements
00607   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00608   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00609         typename iterator_traits<_InputIter>::value_type>);
00610   __glibcpp_function_requires(_EqualOpConcept<
00611         typename iterator_traits<_InputIter>::value_type, _Tp>);
00612 
00613   for ( ; __first != __last; ++__first, ++__result)
00614     *__result = *__first == __old_value ? __new_value : *__first;
00615   return __result;
00616 }
00617 
00618 template <class _InputIter, class _OutputIter, class _Predicate, class _Tp>
00619 _OutputIter replace_copy_if(_InputIter __first, _InputIter __last,
00620                             _OutputIter __result,
00621                             _Predicate __pred, const _Tp& __new_value)
00622 {
00623   // concept requirements
00624   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00625   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00626         typename iterator_traits<_InputIter>::value_type>);
00627   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00628         typename iterator_traits<_InputIter>::value_type>);
00629 
00630   for ( ; __first != __last; ++__first, ++__result)
00631     *__result = __pred(*__first) ? __new_value : *__first;
00632   return __result;
00633 }
00634 
00635 // generate and generate_n
00636 
00637 template <class _ForwardIter, class _Generator>
00638 void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
00639 {
00640   // concept requirements
00641   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
00642   __glibcpp_function_requires(_GeneratorConcept<_Generator,
00643         typename iterator_traits<_ForwardIter>::value_type>);
00644 
00645   for ( ; __first != __last; ++__first)
00646     *__first = __gen();
00647 }
00648 
00649 template <class _OutputIter, class _Size, class _Generator>
00650 _OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen)
00651 {
00652 /*
00653   // XXX concept requirements
00654   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00655         "the return type of _Generator" ??   >);
00656 */
00657 
00658   for ( ; __n > 0; --__n, ++__first)
00659     *__first = __gen();
00660   return __first;
00661 }
00662 
00663 // remove, remove_if, remove_copy, remove_copy_if
00664 
00665 template <class _InputIter, class _OutputIter, class _Tp>
00666 _OutputIter remove_copy(_InputIter __first, _InputIter __last,
00667                         _OutputIter __result, const _Tp& __value)
00668 {
00669   // concept requirements
00670   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00671   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00672         typename iterator_traits<_InputIter>::value_type>);
00673   __glibcpp_function_requires(_EqualOpConcept<
00674         typename iterator_traits<_InputIter>::value_type, _Tp>);
00675 
00676   for ( ; __first != __last; ++__first)
00677     if (!(*__first == __value)) {
00678       *__result = *__first;
00679       ++__result;
00680     }
00681   return __result;
00682 }
00683 
00684 template <class _InputIter, class _OutputIter, class _Predicate>
00685 _OutputIter remove_copy_if(_InputIter __first, _InputIter __last,
00686                            _OutputIter __result, _Predicate __pred)
00687 {
00688   // concept requirements
00689   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00690   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00691         typename iterator_traits<_InputIter>::value_type>);
00692   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00693         typename iterator_traits<_InputIter>::value_type>);
00694 
00695   for ( ; __first != __last; ++__first)
00696     if (!__pred(*__first)) {
00697       *__result = *__first;
00698       ++__result;
00699     }
00700   return __result;
00701 }
00702 
00703 template <class _ForwardIter, class _Tp>
00704 _ForwardIter remove(_ForwardIter __first, _ForwardIter __last,
00705                     const _Tp& __value)
00706 {
00707   // concept requirements
00708   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
00709   __glibcpp_function_requires(_ConvertibleConcept<_Tp,
00710         typename iterator_traits<_ForwardIter>::value_type>);
00711   __glibcpp_function_requires(_EqualOpConcept<
00712         typename iterator_traits<_ForwardIter>::value_type, _Tp>);
00713 
00714   __first = find(__first, __last, __value);
00715   _ForwardIter __i = __first;
00716   return __first == __last ? __first 
00717                            : remove_copy(++__i, __last, __first, __value);
00718 }
00719 
00720 template <class _ForwardIter, class _Predicate>
00721 _ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last,
00722                        _Predicate __pred)
00723 {
00724   // concept requirements
00725   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
00726   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
00727         typename iterator_traits<_ForwardIter>::value_type>);
00728 
00729   __first = find_if(__first, __last, __pred);
00730   _ForwardIter __i = __first;
00731   return __first == __last ? __first 
00732                            : remove_copy_if(++__i, __last, __first, __pred);
00733 }
00734 
00735 // unique and unique_copy
00736 
00737 template <class _InputIter, class _OutputIter, class _Tp>
00738 _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
00739                           _OutputIter __result, _Tp*)
00740 {
00741   // concept requirements -- taken care of in dispatching function
00742   _Tp __value = *__first;
00743   *__result = __value;
00744   while (++__first != __last)
00745     if (!(__value == *__first)) {
00746       __value = *__first;
00747       *++__result = __value;
00748     }
00749   return ++__result;
00750 }
00751 
00752 template <class _InputIter, class _OutputIter>
00753 inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
00754                                  _OutputIter __result, 
00755                                  output_iterator_tag)
00756 {
00757   // concept requirements -- taken care of in dispatching function
00758   return __unique_copy(__first, __last, __result, __value_type(__first));
00759 }
00760 
00761 template <class _InputIter, class _ForwardIter>
00762 _ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
00763                            _ForwardIter __result, forward_iterator_tag)
00764 {
00765   // concept requirements -- taken care of in dispatching function
00766   *__result = *__first;
00767   while (++__first != __last)
00768     if (!(*__result == *__first))
00769       *++__result = *__first;
00770   return ++__result;
00771 }
00772 
00773 template <class _InputIter, class _OutputIter>
00774 inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
00775                                _OutputIter __result)
00776 {
00777   // concept requirements
00778   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00779   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00780         typename iterator_traits<_InputIter>::value_type>);
00781   __glibcpp_function_requires(_EqualityComparableConcept<
00782         typename iterator_traits<_InputIter>::value_type>);
00783 
00784   if (__first == __last) return __result;
00785   return __unique_copy(__first, __last, __result,
00786                        __iterator_category(__result));
00787 }
00788 
00789 template <class _InputIter, class _OutputIter, class _BinaryPredicate,
00790           class _Tp>
00791 _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
00792                           _OutputIter __result,
00793                           _BinaryPredicate __binary_pred, _Tp*)
00794 {
00795   // concept requirements -- iterators already checked
00796   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, _Tp, _Tp>);
00797 
00798   _Tp __value = *__first;
00799   *__result = __value;
00800   while (++__first != __last)
00801     if (!__binary_pred(__value, *__first)) {
00802       __value = *__first;
00803       *++__result = __value;
00804     }
00805   return ++__result;
00806 }
00807 
00808 template <class _InputIter, class _OutputIter, class _BinaryPredicate>
00809 inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
00810                                  _OutputIter __result,
00811                                  _BinaryPredicate __binary_pred,
00812                                  output_iterator_tag)
00813 {
00814   // concept requirements -- taken care of in dispatching function
00815   return __unique_copy(__first, __last, __result, __binary_pred,
00816                        __value_type(__first));
00817 }
00818 
00819 template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
00820 _ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
00821                            _ForwardIter __result, 
00822                            _BinaryPredicate __binary_pred,
00823                            forward_iterator_tag)
00824 {
00825   // concept requirements -- iterators already checked
00826   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
00827         typename iterator_traits<_ForwardIter>::value_type,
00828         typename iterator_traits<_InputIter>::value_type>);
00829 
00830   *__result = *__first;
00831   while (++__first != __last)
00832     if (!__binary_pred(*__result, *__first)) *++__result = *__first;
00833   return ++__result;
00834 }
00835 
00836 template <class _InputIter, class _OutputIter, class _BinaryPredicate>
00837 inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
00838                                _OutputIter __result,
00839                                _BinaryPredicate __binary_pred)
00840 {
00841   // concept requirements -- predicates checked later
00842   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00843   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00844         typename iterator_traits<_InputIter>::value_type>);
00845 
00846   if (__first == __last) return __result;
00847   return __unique_copy(__first, __last, __result, __binary_pred,
00848                        __iterator_category(__result));
00849 }
00850 
00851 template <class _ForwardIter>
00852 _ForwardIter unique(_ForwardIter __first, _ForwardIter __last)
00853 {
00854   // concept requirements
00855   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
00856   __glibcpp_function_requires(_EqualityComparableConcept<
00857         typename iterator_traits<_ForwardIter>::value_type>);
00858 
00859   __first = adjacent_find(__first, __last);
00860   return unique_copy(__first, __last, __first);
00861 }
00862 
00863 template <class _ForwardIter, class _BinaryPredicate>
00864 _ForwardIter unique(_ForwardIter __first, _ForwardIter __last,
00865                     _BinaryPredicate __binary_pred)
00866 {
00867   // concept requirements
00868   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
00869   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
00870         typename iterator_traits<_ForwardIter>::value_type,
00871         typename iterator_traits<_ForwardIter>::value_type>);
00872 
00873   __first = adjacent_find(__first, __last, __binary_pred);
00874   return unique_copy(__first, __last, __first, __binary_pred);
00875 }
00876 
00877 // reverse and reverse_copy, and their auxiliary functions
00878 
00879 template <class _BidirectionalIter>
00880 void __reverse(_BidirectionalIter __first, _BidirectionalIter __last, 
00881                bidirectional_iterator_tag) {
00882   while (true)
00883     if (__first == __last || __first == --__last)
00884       return;
00885     else
00886       iter_swap(__first++, __last);
00887 }
00888 
00889 template <class _RandomAccessIter>
00890 void __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
00891                random_access_iterator_tag) {
00892   while (__first < __last)
00893     iter_swap(__first++, --__last);
00894 }
00895 
00896 template <class _BidirectionalIter>
00897 inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last)
00898 {
00899   // concept requirements
00900   __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
00901         _BidirectionalIter>);
00902   __reverse(__first, __last, __iterator_category(__first));
00903 }
00904 
00905 template <class _BidirectionalIter, class _OutputIter>
00906 _OutputIter reverse_copy(_BidirectionalIter __first,
00907                          _BidirectionalIter __last,
00908                          _OutputIter __result)
00909 {
00910   // concept requirements
00911   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
00912   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
00913         typename iterator_traits<_BidirectionalIter>::value_type>);
00914 
00915   while (__first != __last) {
00916     --__last;
00917     *__result = *__last;
00918     ++__result;
00919   }
00920   return __result;
00921 }
00922 
00923 // rotate and rotate_copy, and their auxiliary functions
00924 
00925 template <class _EuclideanRingElement>
00926 _EuclideanRingElement __gcd(_EuclideanRingElement __m,
00927                             _EuclideanRingElement __n)
00928 {
00929   while (__n != 0) {
00930     _EuclideanRingElement __t = __m % __n;
00931     __m = __n;
00932     __n = __t;
00933   }
00934   return __m;
00935 }
00936 
00937 template <class _ForwardIter, class _Distance>
00938 _ForwardIter __rotate(_ForwardIter __first,
00939                       _ForwardIter __middle,
00940                       _ForwardIter __last,
00941                       _Distance*,
00942                       forward_iterator_tag)
00943 {
00944   if (__first == __middle)
00945     return __last;
00946   if (__last  == __middle)
00947     return __first;
00948 
00949   _ForwardIter __first2 = __middle;
00950   do {
00951     swap(*__first++, *__first2++);
00952     if (__first == __middle)
00953       __middle = __first2;
00954   } while (__first2 != __last);
00955 
00956   _ForwardIter __new_middle = __first;
00957 
00958   __first2 = __middle;
00959 
00960   while (__first2 != __last) {
00961     swap (*__first++, *__first2++);
00962     if (__first == __middle)
00963       __middle = __first2;
00964     else if (__first2 == __last)
00965       __first2 = __middle;
00966   }
00967 
00968   return __new_middle;
00969 }
00970 
00971 
00972 template <class _BidirectionalIter, class _Distance>
00973 _BidirectionalIter __rotate(_BidirectionalIter __first,
00974                             _BidirectionalIter __middle,
00975                             _BidirectionalIter __last,
00976                             _Distance*,
00977                             bidirectional_iterator_tag)
00978 {
00979   // concept requirements
00980   __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
00981         _BidirectionalIter>);
00982 
00983   if (__first == __middle)
00984     return __last;
00985   if (__last  == __middle)
00986     return __first;
00987 
00988   __reverse(__first,  __middle, bidirectional_iterator_tag());
00989   __reverse(__middle, __last,   bidirectional_iterator_tag());
00990 
00991   while (__first != __middle && __middle != __last)
00992     swap (*__first++, *--__last);
00993 
00994   if (__first == __middle) {
00995     __reverse(__middle, __last,   bidirectional_iterator_tag());
00996     return __last;
00997   }
00998   else {
00999     __reverse(__first,  __middle, bidirectional_iterator_tag());
01000     return __first;
01001   }
01002 }
01003 
01004 template <class _RandomAccessIter, class _Distance, class _Tp>
01005 _RandomAccessIter __rotate(_RandomAccessIter __first,
01006                            _RandomAccessIter __middle,
01007                            _RandomAccessIter __last,
01008                            _Distance *, _Tp *)
01009 {
01010   // concept requirements
01011   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01012         _RandomAccessIter>);
01013 
01014   _Distance __n = __last   - __first;
01015   _Distance __k = __middle - __first;
01016   _Distance __l = __n - __k;
01017   _RandomAccessIter __result = __first + (__last - __middle);
01018 
01019   if (__k == 0)
01020     return __last;
01021 
01022   else if (__k == __l) {
01023     swap_ranges(__first, __middle, __middle);
01024     return __result;
01025   }
01026 
01027   _Distance __d = __gcd(__n, __k);
01028 
01029   for (_Distance __i = 0; __i < __d; __i++) {
01030     _Tp __tmp = *__first;
01031     _RandomAccessIter __p = __first;
01032 
01033     if (__k < __l) {
01034       for (_Distance __j = 0; __j < __l/__d; __j++) {
01035         if (__p > __first + __l) {
01036           *__p = *(__p - __l);
01037           __p -= __l;
01038         }
01039 
01040         *__p = *(__p + __k);
01041         __p += __k;
01042       }
01043     }
01044 
01045     else {
01046       for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
01047         if (__p < __last - __k) {
01048           *__p = *(__p + __k);
01049           __p += __k;
01050         }
01051 
01052         *__p = * (__p - __l);
01053         __p -= __l;
01054       }
01055     }
01056 
01057     *__p = __tmp;
01058     ++__first;
01059   }
01060 
01061   return __result;
01062 }
01063 
01064 template <class _ForwardIter>
01065 inline _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle,
01066                            _ForwardIter __last)
01067 {
01068   // concept requirements
01069   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
01070 
01071   return __rotate(__first, __middle, __last,
01072                   __distance_type(__first),
01073                   __iterator_category(__first));
01074 }
01075 
01076 template <class _ForwardIter, class _OutputIter>
01077 _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
01078                         _ForwardIter __last, _OutputIter __result)
01079 {
01080   // concept requirements
01081   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
01082   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
01083         typename iterator_traits<_ForwardIter>::value_type>);
01084 
01085   return copy(__first, __middle, copy(__middle, __last, __result));
01086 }
01087 
01088 // Return a random number in the range [0, __n).  This function encapsulates
01089 // whether we're using rand (part of the standard C library) or lrand48
01090 // (not standard, but a much better choice whenever it's available).
01091 template <class _Distance>
01092 inline _Distance __random_number(_Distance __n) {
01093 #ifdef _GLIBCPP_HAVE_DRAND48
01094   return lrand48() % __n;
01095 #else
01096   return rand() % __n;
01097 #endif
01098 }
01099 
01100 // random_shuffle
01101 
01102 template <class _RandomAccessIter>
01103 inline void random_shuffle(_RandomAccessIter __first,
01104                            _RandomAccessIter __last)
01105 {
01106   // concept requirements
01107   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01108         _RandomAccessIter>);
01109 
01110   if (__first == __last) return;
01111   for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
01112     iter_swap(__i, __first + __random_number((__i - __first) + 1));
01113 }
01114 
01115 template <class _RandomAccessIter, class _RandomNumberGenerator>
01116 void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
01117                     _RandomNumberGenerator& __rand)
01118 {
01119   // concept requirements
01120   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01121         _RandomAccessIter>);
01122 
01123   if (__first == __last) return;
01124   for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
01125     iter_swap(__i, __first + __rand((__i - __first) + 1));
01126 }
01127 
01128 // random_sample and random_sample_n (extensions, not part of the standard).
01129 
01130 template <class _ForwardIter, class _OutputIter, class _Distance>
01131 _OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
01132                             _OutputIter __out, const _Distance __n)
01133 {
01134   // concept requirements
01135   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
01136   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
01137         typename iterator_traits<_ForwardIter>::value_type>);
01138 
01139   _Distance __remaining = 0;
01140   distance(__first, __last, __remaining);
01141   _Distance __m = min(__n, __remaining);
01142 
01143   while (__m > 0) {
01144     if (__random_number(__remaining) < __m) {
01145       *__out = *__first;
01146       ++__out;
01147       --__m;
01148     }
01149 
01150     --__remaining;
01151     ++__first;
01152   }
01153   return __out;
01154 }
01155 
01156 template <class _ForwardIter, class _OutputIter, class _Distance,
01157           class _RandomNumberGenerator>
01158 _OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
01159                             _OutputIter __out, const _Distance __n,
01160                             _RandomNumberGenerator& __rand)
01161 {
01162   // concept requirements
01163   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
01164   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
01165         typename iterator_traits<_ForwardIter>::value_type>);
01166   __glibcpp_function_requires(_UnaryFunctionConcept<
01167         _RandomNumberGenerator, _Distance, _Distance>);
01168 
01169   _Distance __remaining = 0;
01170   distance(__first, __last, __remaining);
01171   _Distance __m = min(__n, __remaining);
01172 
01173   while (__m > 0) {
01174     if (__rand(__remaining) < __m) {
01175       *__out = *__first;
01176       ++__out;
01177       --__m;
01178     }
01179 
01180     --__remaining;
01181     ++__first;
01182   }
01183   return __out;
01184 }
01185 
01186 template <class _InputIter, class _RandomAccessIter, class _Distance>
01187 _RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
01188                                   _RandomAccessIter __out,
01189                                   const _Distance __n)
01190 {
01191   _Distance __m = 0;
01192   _Distance __t = __n;
01193   for ( ; __first != __last && __m < __n; ++__m, ++__first) 
01194     __out[__m] = *__first;
01195 
01196   while (__first != __last) {
01197     ++__t;
01198     _Distance __M = __random_number(__t);
01199     if (__M < __n)
01200       __out[__M] = *__first;
01201     ++__first;
01202   }
01203 
01204   return __out + __m;
01205 }
01206 
01207 template <class _InputIter, class _RandomAccessIter,
01208           class _RandomNumberGenerator, class _Distance>
01209 _RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
01210                                   _RandomAccessIter __out,
01211                                   _RandomNumberGenerator& __rand,
01212                                   const _Distance __n)
01213 {
01214   // concept requirements
01215   __glibcpp_function_requires(_UnaryFunctionConcept<
01216         _RandomNumberGenerator, _Distance, _Distance>);
01217 
01218   _Distance __m = 0;
01219   _Distance __t = __n;
01220   for ( ; __first != __last && __m < __n; ++__m, ++__first)
01221     __out[__m] = *__first;
01222 
01223   while (__first != __last) {
01224     ++__t;
01225     _Distance __M = __rand(__t);
01226     if (__M < __n)
01227       __out[__M] = *__first;
01228     ++__first;
01229   }
01230 
01231   return __out + __m;
01232 }
01233 
01234 template <class _InputIter, class _RandomAccessIter>
01235 inline _RandomAccessIter
01236 random_sample(_InputIter __first, _InputIter __last,
01237               _RandomAccessIter __out_first, _RandomAccessIter __out_last) 
01238 {
01239   // concept requirements
01240   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
01241   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01242         _RandomAccessIter>);
01243 
01244   return __random_sample(__first, __last,
01245                          __out_first, __out_last - __out_first);
01246 }
01247 
01248 
01249 template <class _InputIter, class _RandomAccessIter, 
01250           class _RandomNumberGenerator>
01251 inline _RandomAccessIter
01252 random_sample(_InputIter __first, _InputIter __last,
01253               _RandomAccessIter __out_first, _RandomAccessIter __out_last,
01254               _RandomNumberGenerator& __rand) 
01255 {
01256   // concept requirements
01257   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
01258   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01259         _RandomAccessIter>);
01260 
01261   return __random_sample(__first, __last,
01262                          __out_first, __rand,
01263                          __out_last - __out_first);
01264 }
01265 
01266 // partition, stable_partition, and their auxiliary functions
01267 
01268 template <class _ForwardIter, class _Predicate>
01269 _ForwardIter __partition(_ForwardIter __first,
01270                  _ForwardIter __last,
01271              _Predicate   __pred,
01272              forward_iterator_tag)
01273 {
01274   if (__first == __last) return __first;
01275 
01276   while (__pred(*__first))
01277     if (++__first == __last) return __first;
01278 
01279   _ForwardIter __next = __first;
01280 
01281   while (++__next != __last)
01282     if (__pred(*__next)) {
01283       swap(*__first, *__next);
01284       ++__first;
01285     }
01286 
01287   return __first;
01288 }
01289 
01290 template <class _BidirectionalIter, class _Predicate>
01291 _BidirectionalIter __partition(_BidirectionalIter __first,
01292                                _BidirectionalIter __last,
01293                    _Predicate __pred,
01294                    bidirectional_iterator_tag)
01295 {
01296   while (true) {
01297     while (true)
01298       if (__first == __last)
01299         return __first;
01300       else if (__pred(*__first))
01301         ++__first;
01302       else
01303         break;
01304     --__last;
01305     while (true)
01306       if (__first == __last)
01307         return __first;
01308       else if (!__pred(*__last))
01309         --__last;
01310       else
01311         break;
01312     iter_swap(__first, __last);
01313     ++__first;
01314   }
01315 }
01316 
01317 template <class _ForwardIter, class _Predicate>
01318 inline _ForwardIter partition(_ForwardIter __first,
01319                   _ForwardIter __last,
01320                   _Predicate   __pred)
01321 {
01322   // concept requirements
01323   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
01324   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
01325         typename iterator_traits<_ForwardIter>::value_type>);
01326 
01327   return __partition(__first, __last, __pred, __iterator_category(__first));
01328 }
01329 
01330 
01331 template <class _ForwardIter, class _Predicate, class _Distance>
01332 _ForwardIter __inplace_stable_partition(_ForwardIter __first,
01333                                         _ForwardIter __last,
01334                                         _Predicate __pred, _Distance __len)
01335 {
01336   if (__len == 1)
01337     return __pred(*__first) ? __last : __first;
01338   _ForwardIter __middle = __first;
01339   advance(__middle, __len / 2);
01340   return rotate(__inplace_stable_partition(__first, __middle, __pred, 
01341                                            __len / 2),
01342                 __middle,
01343                 __inplace_stable_partition(__middle, __last, __pred,
01344                                            __len - __len / 2));
01345 }
01346 
01347 template <class _ForwardIter, class _Pointer, class _Predicate, 
01348           class _Distance>
01349 _ForwardIter __stable_partition_adaptive(_ForwardIter __first,
01350                                          _ForwardIter __last,
01351                                          _Predicate __pred, _Distance __len,
01352                                          _Pointer __buffer,
01353                                          _Distance __buffer_size) 
01354 {
01355   if (__len <= __buffer_size) {
01356     _ForwardIter __result1 = __first;
01357     _Pointer __result2 = __buffer;
01358     for ( ; __first != __last ; ++__first)
01359       if (__pred(*__first)) {
01360         *__result1 = *__first;
01361         ++__result1;
01362       }
01363       else {
01364         *__result2 = *__first;
01365         ++__result2;
01366       }
01367     copy(__buffer, __result2, __result1);
01368     return __result1;
01369   }
01370   else {
01371     _ForwardIter __middle = __first;
01372     advance(__middle, __len / 2);
01373     return rotate(__stable_partition_adaptive(
01374                           __first, __middle, __pred,
01375                           __len / 2, __buffer, __buffer_size),
01376                     __middle,
01377                     __stable_partition_adaptive(
01378                           __middle, __last, __pred,
01379                           __len - __len / 2, __buffer, __buffer_size));
01380   }
01381 }
01382 
01383 template <class _ForwardIter, class _Predicate, class _Tp, class _Distance>
01384 inline _ForwardIter
01385 __stable_partition_aux(_ForwardIter __first, _ForwardIter __last, 
01386                        _Predicate __pred, _Tp*, _Distance*)
01387 {
01388   _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last);
01389   if (__buf.size() > 0)
01390     return __stable_partition_adaptive(__first, __last, __pred,
01391                                        _Distance(__buf.requested_size()),
01392                                        __buf.begin(), __buf.size());
01393   else
01394     return __inplace_stable_partition(__first, __last, __pred, 
01395                                       _Distance(__buf.requested_size()));
01396 }
01397 
01398 template <class _ForwardIter, class _Predicate>
01399 inline _ForwardIter stable_partition(_ForwardIter __first,
01400                                      _ForwardIter __last, 
01401                                      _Predicate __pred)
01402 {
01403   // concept requirements
01404   __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
01405   __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
01406         typename iterator_traits<_ForwardIter>::value_type>);
01407 
01408   if (__first == __last)
01409     return __first;
01410   else
01411     return __stable_partition_aux(__first, __last, __pred,
01412                                   __value_type(__first),
01413                                   __distance_type(__first));
01414 }
01415 
01416 template <class _RandomAccessIter, class _Tp>
01417 _RandomAccessIter __unguarded_partition(_RandomAccessIter __first, 
01418                                         _RandomAccessIter __last, 
01419                                         _Tp __pivot) 
01420 {
01421   while (true) {
01422     while (*__first < __pivot)
01423       ++__first;
01424     --__last;
01425     while (__pivot < *__last)
01426       --__last;
01427     if (!(__first < __last))
01428       return __first;
01429     iter_swap(__first, __last);
01430     ++__first;
01431   }
01432 }    
01433 
01434 template <class _RandomAccessIter, class _Tp, class _Compare>
01435 _RandomAccessIter __unguarded_partition(_RandomAccessIter __first, 
01436                                         _RandomAccessIter __last, 
01437                                         _Tp __pivot, _Compare __comp) 
01438 {
01439   while (true) {
01440     while (__comp(*__first, __pivot))
01441       ++__first;
01442     --__last;
01443     while (__comp(__pivot, *__last))
01444       --__last;
01445     if (!(__first < __last))
01446       return __first;
01447     iter_swap(__first, __last);
01448     ++__first;
01449   }
01450 }
01451 
01452 const int __stl_threshold = 16;
01453 
01454 // sort() and its auxiliary functions. 
01455 
01456 template <class _RandomAccessIter, class _Tp>
01457 void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val)
01458 {
01459   _RandomAccessIter __next = __last;
01460   --__next;
01461   while (__val < *__next) {
01462     *__last = *__next;
01463     __last = __next;
01464     --__next;
01465   }
01466   *__last = __val;
01467 }
01468 
01469 template <class _RandomAccessIter, class _Tp, class _Compare>
01470 void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val, 
01471                                _Compare __comp)
01472 {
01473   _RandomAccessIter __next = __last;
01474   --__next;  
01475   while (__comp(__val, *__next)) {
01476     *__last = *__next;
01477     __last = __next;
01478     --__next;
01479   }
01480   *__last = __val;
01481 }
01482 
01483 template <class _RandomAccessIter, class _Tp>
01484 inline void __linear_insert(_RandomAccessIter __first, 
01485                             _RandomAccessIter __last, _Tp*)
01486 {
01487   _Tp __val = *__last;
01488   if (__val < *__first) {
01489     copy_backward(__first, __last, __last + 1);
01490     *__first = __val;
01491   }
01492   else
01493     __unguarded_linear_insert(__last, __val);
01494 }
01495 
01496 template <class _RandomAccessIter, class _Tp, class _Compare>
01497 inline void __linear_insert(_RandomAccessIter __first, 
01498                             _RandomAccessIter __last, _Tp*, _Compare __comp)
01499 {
01500   _Tp __val = *__last;
01501   if (__comp(__val, *__first)) {
01502     copy_backward(__first, __last, __last + 1);
01503     *__first = __val;
01504   }
01505   else
01506     __unguarded_linear_insert(__last, __val, __comp);
01507 }
01508 
01509 template <class _RandomAccessIter>
01510 void __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
01511 {
01512   if (__first == __last) return; 
01513   for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
01514     __linear_insert(__first, __i, __value_type(__first));
01515 }
01516 
01517 template <class _RandomAccessIter, class _Compare>
01518 void __insertion_sort(_RandomAccessIter __first,
01519                       _RandomAccessIter __last, _Compare __comp)
01520 {
01521   if (__first == __last) return;
01522   for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
01523     __linear_insert(__first, __i, __value_type(__first), __comp);
01524 }
01525 
01526 template <class _RandomAccessIter, class _Tp>
01527 void __unguarded_insertion_sort_aux(_RandomAccessIter __first, 
01528                                     _RandomAccessIter __last, _Tp*)
01529 {
01530   for (_RandomAccessIter __i = __first; __i != __last; ++__i)
01531     __unguarded_linear_insert(__i, _Tp(*__i));
01532 }
01533 
01534 template <class _RandomAccessIter>
01535 inline void __unguarded_insertion_sort(_RandomAccessIter __first, 
01536                                 _RandomAccessIter __last) {
01537   __unguarded_insertion_sort_aux(__first, __last, __value_type(__first));
01538 }
01539 
01540 template <class _RandomAccessIter, class _Tp, class _Compare>
01541 void __unguarded_insertion_sort_aux(_RandomAccessIter __first, 
01542                                     _RandomAccessIter __last,
01543                                     _Tp*, _Compare __comp)
01544 {
01545   for (_RandomAccessIter __i = __first; __i != __last; ++__i)
01546     __unguarded_linear_insert(__i, _Tp(*__i), __comp);
01547 }
01548 
01549 template <class _RandomAccessIter, class _Compare>
01550 inline void __unguarded_insertion_sort(_RandomAccessIter __first, 
01551                                        _RandomAccessIter __last,
01552                                        _Compare __comp)
01553 {
01554   __unguarded_insertion_sort_aux(__first, __last, __value_type(__first),
01555                                  __comp);
01556 }
01557 
01558 template <class _RandomAccessIter>
01559 void __final_insertion_sort(_RandomAccessIter __first, 
01560                             _RandomAccessIter __last)
01561 {
01562   if (__last - __first > __stl_threshold) {
01563     __insertion_sort(__first, __first + __stl_threshold);
01564     __unguarded_insertion_sort(__first + __stl_threshold, __last);
01565   }
01566   else
01567     __insertion_sort(__first, __last);
01568 }
01569 
01570 template <class _RandomAccessIter, class _Compare>
01571 void __final_insertion_sort(_RandomAccessIter __first, 
01572                             _RandomAccessIter __last, _Compare __comp)
01573 {
01574   if (__last - __first > __stl_threshold) {
01575     __insertion_sort(__first, __first + __stl_threshold, __comp);
01576     __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
01577   }
01578   else
01579     __insertion_sort(__first, __last, __comp);
01580 }
01581 
01582 template <class _Size>
01583 inline _Size __lg(_Size __n)
01584 {
01585   _Size __k;
01586   for (__k = 0; __n != 1; __n >>= 1) ++__k;
01587   return __k;
01588 }
01589 
01590 template <class _RandomAccessIter, class _Tp, class _Size>
01591 void __introsort_loop(_RandomAccessIter __first,
01592                       _RandomAccessIter __last, _Tp*,
01593                       _Size __depth_limit)
01594 {
01595   while (__last - __first > __stl_threshold) {
01596     if (__depth_limit == 0) {
01597       partial_sort(__first, __last, __last);
01598       return;
01599     }
01600     --__depth_limit;
01601     _RandomAccessIter __cut =
01602       __unguarded_partition(__first, __last,
01603                             _Tp(__median(*__first,
01604                                          *(__first + (__last - __first)/2),
01605                                          *(__last - 1))));
01606     __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);
01607     __last = __cut;
01608   }
01609 }
01610 
01611 template <class _RandomAccessIter, class _Tp, class _Size, class _Compare>
01612 void __introsort_loop(_RandomAccessIter __first,
01613                       _RandomAccessIter __last, _Tp*,
01614                       _Size __depth_limit, _Compare __comp)
01615 {
01616   while (__last - __first > __stl_threshold) {
01617     if (__depth_limit == 0) {
01618       partial_sort(__first, __last, __last, __comp);
01619       return;
01620     }
01621     --__depth_limit;
01622     _RandomAccessIter __cut =
01623       __unguarded_partition(__first, __last,
01624                             _Tp(__median(*__first,
01625                                          *(__first + (__last - __first)/2),
01626                                          *(__last - 1), __comp)),
01627        __comp);
01628     __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit, __comp);
01629     __last = __cut;
01630   }
01631 }
01632 
01633 template <class _RandomAccessIter>
01634 inline void sort(_RandomAccessIter __first, _RandomAccessIter __last)
01635 {
01636   // concept requirements
01637   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01638         _RandomAccessIter>);
01639   __glibcpp_function_requires(_LessThanComparableConcept<
01640         typename iterator_traits<_RandomAccessIter>::value_type>);
01641 
01642   if (__first != __last) {
01643     __introsort_loop(__first, __last,
01644                      __value_type(__first),
01645                      __lg(__last - __first) * 2);
01646     __final_insertion_sort(__first, __last);
01647   }
01648 }
01649 
01650 template <class _RandomAccessIter, class _Compare>
01651 inline void sort(_RandomAccessIter __first, _RandomAccessIter __last,
01652                  _Compare __comp)
01653 {
01654   // concept requirements
01655   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01656         _RandomAccessIter>);
01657   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
01658         typename iterator_traits<_RandomAccessIter>::value_type,
01659         typename iterator_traits<_RandomAccessIter>::value_type>);
01660 
01661   if (__first != __last) {
01662     __introsort_loop(__first, __last,
01663                      __value_type(__first),
01664                      __lg(__last - __first) * 2,
01665                      __comp);
01666     __final_insertion_sort(__first, __last, __comp);
01667   }
01668 }
01669 
01670 // stable_sort() and its auxiliary functions.
01671 
01672 template <class _RandomAccessIter>
01673 void __inplace_stable_sort(_RandomAccessIter __first,
01674                            _RandomAccessIter __last)
01675 {
01676   if (__last - __first < 15) {
01677     __insertion_sort(__first, __last);
01678     return;
01679   }
01680   _RandomAccessIter __middle = __first + (__last - __first) / 2;
01681   __inplace_stable_sort(__first, __middle);
01682   __inplace_stable_sort(__middle, __last);
01683   __merge_without_buffer(__first, __middle, __last,
01684                          __middle - __first,
01685                          __last - __middle);
01686 }
01687 
01688 template <class _RandomAccessIter, class _Compare>
01689 void __inplace_stable_sort(_RandomAccessIter __first,
01690                            _RandomAccessIter __last, _Compare __comp)
01691 {
01692   if (__last - __first < 15) {
01693     __insertion_sort(__first, __last, __comp);
01694     return;
01695   }
01696   _RandomAccessIter __middle = __first + (__last - __first) / 2;
01697   __inplace_stable_sort(__first, __middle, __comp);
01698   __inplace_stable_sort(__middle, __last, __comp);
01699   __merge_without_buffer(__first, __middle, __last,
01700                          __middle - __first,
01701                          __last - __middle,
01702                          __comp);
01703 }
01704 
01705 template <class _RandomAccessIter1, class _RandomAccessIter2,
01706           class _Distance>
01707 void __merge_sort_loop(_RandomAccessIter1 __first,
01708                        _RandomAccessIter1 __last, 
01709                        _RandomAccessIter2 __result, _Distance __step_size)
01710 {
01711   _Distance __two_step = 2 * __step_size;
01712 
01713   while (__last - __first >= __two_step) {
01714     __result = merge(__first, __first + __step_size,
01715                      __first + __step_size, __first + __two_step,
01716                      __result);
01717     __first += __two_step;
01718   }
01719 
01720   __step_size = min(_Distance(__last - __first), __step_size);
01721   merge(__first, __first + __step_size, __first + __step_size, __last,
01722         __result);
01723 }
01724 
01725 template <class _RandomAccessIter1, class _RandomAccessIter2,
01726           class _Distance, class _Compare>
01727 void __merge_sort_loop(_RandomAccessIter1 __first,
01728                        _RandomAccessIter1 __last, 
01729                        _RandomAccessIter2 __result, _Distance __step_size,
01730                        _Compare __comp)
01731 {
01732   _Distance __two_step = 2 * __step_size;
01733 
01734   while (__last - __first >= __two_step) {
01735     __result = merge(__first, __first + __step_size,
01736                      __first + __step_size, __first + __two_step,
01737                      __result,
01738                      __comp);
01739     __first += __two_step;
01740   }
01741   __step_size = min(_Distance(__last - __first), __step_size);
01742 
01743   merge(__first, __first + __step_size,
01744         __first + __step_size, __last,
01745         __result,
01746         __comp);
01747 }
01748 
01749 const int __stl_chunk_size = 7;
01750         
01751 template <class _RandomAccessIter, class _Distance>
01752 void __chunk_insertion_sort(_RandomAccessIter __first, 
01753                             _RandomAccessIter __last, _Distance __chunk_size)
01754 {
01755   while (__last - __first >= __chunk_size) {
01756     __insertion_sort(__first, __first + __chunk_size);
01757     __first += __chunk_size;
01758   }
01759   __insertion_sort(__first, __last);
01760 }
01761 
01762 template <class _RandomAccessIter, class _Distance, class _Compare>
01763 void __chunk_insertion_sort(_RandomAccessIter __first, 
01764                             _RandomAccessIter __last,
01765                             _Distance __chunk_size, _Compare __comp)
01766 {
01767   while (__last - __first >= __chunk_size) {
01768     __insertion_sort(__first, __first + __chunk_size, __comp);
01769     __first += __chunk_size;
01770   }
01771   __insertion_sort(__first, __last, __comp);
01772 }
01773 
01774 template <class _RandomAccessIter, class _Pointer, class _Distance>
01775 void __merge_sort_with_buffer(_RandomAccessIter __first, 
01776                               _RandomAccessIter __last,
01777                               _Pointer __buffer, _Distance*)
01778 {
01779   _Distance __len = __last - __first;
01780   _Pointer __buffer_last = __buffer + __len;
01781 
01782   _Distance __step_size = __stl_chunk_size;
01783   __chunk_insertion_sort(__first, __last, __step_size);
01784 
01785   while (__step_size < __len) {
01786     __merge_sort_loop(__first, __last, __buffer, __step_size);
01787     __step_size *= 2;
01788     __merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
01789     __step_size *= 2;
01790   }
01791 }
01792 
01793 template <class _RandomAccessIter, class _Pointer, class _Distance,
01794           class _Compare>
01795 void __merge_sort_with_buffer(_RandomAccessIter __first, 
01796                               _RandomAccessIter __last, _Pointer __buffer,
01797                               _Distance*, _Compare __comp)
01798 {
01799   _Distance __len = __last - __first;
01800   _Pointer __buffer_last = __buffer + __len;
01801 
01802   _Distance __step_size = __stl_chunk_size;
01803   __chunk_insertion_sort(__first, __last, __step_size, __comp);
01804 
01805   while (__step_size < __len) {
01806     __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
01807     __step_size *= 2;
01808     __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
01809     __step_size *= 2;
01810   }
01811 }
01812 
01813 template <class _RandomAccessIter, class _Pointer, class _Distance>
01814 void __stable_sort_adaptive(_RandomAccessIter __first, 
01815                             _RandomAccessIter __last, _Pointer __buffer,
01816                             _Distance __buffer_size)
01817 {
01818   _Distance __len = (__last - __first + 1) / 2;
01819   _RandomAccessIter __middle = __first + __len;
01820   if (__len > __buffer_size) {
01821     __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
01822     __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
01823   }
01824   else {
01825     __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0);
01826     __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0);
01827   }
01828   __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), 
01829                    _Distance(__last - __middle), __buffer, __buffer_size);
01830 }
01831 
01832 template <class _RandomAccessIter, class _Pointer, class _Distance, 
01833           class _Compare>
01834 void __stable_sort_adaptive(_RandomAccessIter __first, 
01835                             _RandomAccessIter __last, _Pointer __buffer,
01836                             _Distance __buffer_size, _Compare __comp)
01837 {
01838   _Distance __len = (__last - __first + 1) / 2;
01839   _RandomAccessIter __middle = __first + __len;
01840   if (__len > __buffer_size) {
01841     __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size, 
01842                            __comp);
01843     __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size, 
01844                            __comp);
01845   }
01846   else {
01847     __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0,
01848                                __comp);
01849     __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0,
01850                                __comp);
01851   }
01852   __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), 
01853                    _Distance(__last - __middle), __buffer, __buffer_size,
01854                    __comp);
01855 }
01856 
01857 template <class _RandomAccessIter, class _Tp, class _Distance>
01858 inline void __stable_sort_aux(_RandomAccessIter __first,
01859                               _RandomAccessIter __last, _Tp*, _Distance*)
01860 {
01861   _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
01862   if (buf.begin() == 0)
01863     __inplace_stable_sort(__first, __last);
01864   else 
01865     __stable_sort_adaptive(__first, __last, buf.begin(),
01866                            _Distance(buf.size()));
01867 }
01868 
01869 template <class _RandomAccessIter, class _Tp, class _Distance, class _Compare>
01870 inline void __stable_sort_aux(_RandomAccessIter __first,
01871                               _RandomAccessIter __last, _Tp*, _Distance*,
01872                               _Compare __comp)
01873 {
01874   _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
01875   if (buf.begin() == 0)
01876     __inplace_stable_sort(__first, __last, __comp);
01877   else 
01878     __stable_sort_adaptive(__first, __last, buf.begin(),
01879                            _Distance(buf.size()),
01880                            __comp);
01881 }
01882 
01883 template <class _RandomAccessIter>
01884 inline void stable_sort(_RandomAccessIter __first,
01885                         _RandomAccessIter __last)
01886 {
01887   // concept requirements
01888   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01889         _RandomAccessIter>);
01890   __glibcpp_function_requires(_LessThanComparableConcept<
01891         typename iterator_traits<_RandomAccessIter>::value_type>);
01892 
01893   __stable_sort_aux(__first, __last,
01894                     __value_type(__first),
01895                     __distance_type(__first));
01896 }
01897 
01898 template <class _RandomAccessIter, class _Compare>
01899 inline void stable_sort(_RandomAccessIter __first,
01900                         _RandomAccessIter __last, _Compare __comp)
01901 {
01902   // concept requirements
01903   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01904         _RandomAccessIter>);
01905   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
01906         typename iterator_traits<_RandomAccessIter>::value_type,
01907         typename iterator_traits<_RandomAccessIter>::value_type>);
01908 
01909   __stable_sort_aux(__first, __last,
01910                     __value_type(__first),
01911                     __distance_type(__first), 
01912                     __comp);
01913 }
01914 
01915 // partial_sort, partial_sort_copy, and auxiliary functions.
01916 
01917 template <class _RandomAccessIter, class _Tp>
01918 void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
01919                     _RandomAccessIter __last, _Tp*)
01920 {
01921   make_heap(__first, __middle);
01922   for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
01923     if (*__i < *__first) 
01924       __pop_heap(__first, __middle, __i, _Tp(*__i),
01925                  __distance_type(__first));
01926   sort_heap(__first, __middle);
01927 }
01928 
01929 template <class _RandomAccessIter>
01930 inline void partial_sort(_RandomAccessIter __first,
01931                          _RandomAccessIter __middle,
01932                          _RandomAccessIter __last)
01933 {
01934   // concept requirements
01935   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01936         _RandomAccessIter>);
01937   __glibcpp_function_requires(_LessThanComparableConcept<
01938         typename iterator_traits<_RandomAccessIter>::value_type>);
01939 
01940   __partial_sort(__first, __middle, __last, __value_type(__first));
01941 }
01942 
01943 template <class _RandomAccessIter, class _Tp, class _Compare>
01944 void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
01945                     _RandomAccessIter __last, _Tp*, _Compare __comp)
01946 {
01947   make_heap(__first, __middle, __comp);
01948   for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
01949     if (__comp(*__i, *__first))
01950       __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
01951                  __distance_type(__first));
01952   sort_heap(__first, __middle, __comp);
01953 }
01954 
01955 template <class _RandomAccessIter, class _Compare>
01956 inline void partial_sort(_RandomAccessIter __first,
01957                          _RandomAccessIter __middle,
01958                          _RandomAccessIter __last, _Compare __comp)
01959 {
01960   // concept requirements
01961   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
01962         _RandomAccessIter>);
01963   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
01964         typename iterator_traits<_RandomAccessIter>::value_type,
01965         typename iterator_traits<_RandomAccessIter>::value_type>);
01966 
01967   __partial_sort(__first, __middle, __last, __value_type(__first), __comp);
01968 }
01969 
01970 template <class _InputIter, class _RandomAccessIter, class _Distance,
01971           class _Tp>
01972 _RandomAccessIter __partial_sort_copy(_InputIter __first,
01973                                       _InputIter __last,
01974                                       _RandomAccessIter __result_first,
01975                                       _RandomAccessIter __result_last, 
01976                                       _Distance*, _Tp*)
01977 {
01978   if (__result_first == __result_last) return __result_last;
01979   _RandomAccessIter __result_real_last = __result_first;
01980   while(__first != __last && __result_real_last != __result_last) {
01981     *__result_real_last = *__first;
01982     ++__result_real_last;
01983     ++__first;
01984   }
01985   make_heap(__result_first, __result_real_last);
01986   while (__first != __last) {
01987     if (*__first < *__result_first) 
01988       __adjust_heap(__result_first, _Distance(0),
01989                     _Distance(__result_real_last - __result_first),
01990                     _Tp(*__first));
01991     ++__first;
01992   }
01993   sort_heap(__result_first, __result_real_last);
01994   return __result_real_last;
01995 }
01996 
01997 template <class _InputIter, class _RandomAccessIter>
01998 inline _RandomAccessIter
01999 partial_sort_copy(_InputIter __first, _InputIter __last,
02000                   _RandomAccessIter __result_first,
02001                   _RandomAccessIter __result_last)
02002 {
02003   // concept requirements
02004   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
02005   __glibcpp_function_requires(_ConvertibleConcept<
02006         typename iterator_traits<_InputIter>::value_type,
02007         typename iterator_traits<_RandomAccessIter>::value_type>);
02008   __glibcpp_function_requires(_LessThanComparableConcept<
02009         typename iterator_traits<_RandomAccessIter>::value_type>);
02010   __glibcpp_function_requires(_LessThanComparableConcept<
02011         typename iterator_traits<_InputIter>::value_type>);
02012 
02013   return __partial_sort_copy(__first, __last, __result_first, __result_last, 
02014                              __distance_type(__result_first),
02015                              __value_type(__first));
02016 }
02017 
02018 template <class _InputIter, class _RandomAccessIter, class _Compare,
02019           class _Distance, class _Tp>
02020 _RandomAccessIter __partial_sort_copy(_InputIter __first,
02021                                          _InputIter __last,
02022                                          _RandomAccessIter __result_first,
02023                                          _RandomAccessIter __result_last,
02024                                          _Compare __comp, _Distance*, _Tp*)
02025 {
02026   if (__result_first == __result_last) return __result_last;
02027   _RandomAccessIter __result_real_last = __result_first;
02028   while(__first != __last && __result_real_last != __result_last) {
02029     *__result_real_last = *__first;
02030     ++__result_real_last;
02031     ++__first;
02032   }
02033   make_heap(__result_first, __result_real_last, __comp);
02034   while (__first != __last) {
02035     if (__comp(*__first, *__result_first))
02036       __adjust_heap(__result_first, _Distance(0),
02037                     _Distance(__result_real_last - __result_first),
02038                     _Tp(*__first),
02039                     __comp);
02040     ++__first;
02041   }
02042   sort_heap(__result_first, __result_real_last, __comp);
02043   return __result_real_last;
02044 }
02045 
02046 template <class _InputIter, class _RandomAccessIter, class _Compare>
02047 inline _RandomAccessIter
02048 partial_sort_copy(_InputIter __first, _InputIter __last,
02049                   _RandomAccessIter __result_first,
02050                   _RandomAccessIter __result_last, _Compare __comp)
02051 {
02052   // concept requirements
02053   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
02054   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
02055         _RandomAccessIter>);
02056   __glibcpp_function_requires(_ConvertibleConcept<
02057         typename iterator_traits<_InputIter>::value_type,
02058         typename iterator_traits<_RandomAccessIter>::value_type>);
02059   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02060         typename iterator_traits<_RandomAccessIter>::value_type,
02061         typename iterator_traits<_RandomAccessIter>::value_type>);
02062 
02063   return __partial_sort_copy(__first, __last, __result_first, __result_last,
02064                              __comp,
02065                              __distance_type(__result_first),
02066                              __value_type(__first));
02067 }
02068 
02069 // nth_element() and its auxiliary functions.  
02070 
02071 template <class _RandomAccessIter, class _Tp>
02072 void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
02073                    _RandomAccessIter __last, _Tp*)
02074 {
02075   while (__last - __first > 3) {
02076     _RandomAccessIter __cut =
02077       __unguarded_partition(__first, __last,
02078                             _Tp(__median(*__first,
02079                                          *(__first + (__last - __first)/2),
02080                                          *(__last - 1))));
02081     if (__cut <= __nth)
02082       __first = __cut;
02083     else 
02084       __last = __cut;
02085   }
02086   __insertion_sort(__first, __last);
02087 }
02088 
02089 template <class _RandomAccessIter>
02090 inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
02091                         _RandomAccessIter __last)
02092 {
02093   // concept requirements
02094   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
02095         _RandomAccessIter>);
02096   __glibcpp_function_requires(_LessThanComparableConcept<
02097         typename iterator_traits<_RandomAccessIter>::value_type>);
02098 
02099   __nth_element(__first, __nth, __last, __value_type(__first));
02100 }
02101 
02102 template <class _RandomAccessIter, class _Tp, class _Compare>
02103 void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
02104                    _RandomAccessIter __last, _Tp*, _Compare __comp)
02105 {
02106   while (__last - __first > 3) {
02107     _RandomAccessIter __cut =
02108       __unguarded_partition(__first, __last,
02109                             _Tp(__median(*__first,
02110                                          *(__first + (__last - __first)/2), 
02111                                          *(__last - 1),
02112                                          __comp)),
02113                             __comp);
02114     if (__cut <= __nth)
02115       __first = __cut;
02116     else 
02117       __last = __cut;
02118   }
02119   __insertion_sort(__first, __last, __comp);
02120 }
02121 
02122 template <class _RandomAccessIter, class _Compare>
02123 inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
02124                         _RandomAccessIter __last, _Compare __comp)
02125 {
02126   // concept requirements
02127   __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
02128         _RandomAccessIter>);
02129   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02130         typename iterator_traits<_RandomAccessIter>::value_type,
02131         typename iterator_traits<_RandomAccessIter>::value_type>);
02132 
02133   __nth_element(__first, __nth, __last, __value_type(__first), __comp);
02134 }
02135 
02136 
02137 // Binary search (lower_bound, upper_bound, equal_range, binary_search).
02138 
02139 template <class _ForwardIter, class _Tp, class _Distance>
02140 _ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
02141                            const _Tp& __val, _Distance*) 
02142 {
02143   _Distance __len = 0;
02144   distance(__first, __last, __len);
02145   _Distance __half;
02146   _ForwardIter __middle;
02147 
02148   while (__len > 0) {
02149     __half = __len >> 1;
02150     __middle = __first;
02151     advance(__middle, __half);
02152     if (*__middle < __val) {
02153       __first = __middle;
02154       ++__first;
02155       __len = __len - __half - 1;
02156     }
02157     else
02158       __len = __half;
02159   }
02160   return __first;
02161 }
02162 
02163 template <class _ForwardIter, class _Tp>
02164 inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
02165                 const _Tp& __val)
02166 {
02167   // concept requirements
02168   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02169   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02170         typename iterator_traits<_ForwardIter>::value_type>);
02171   __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
02172 
02173   return __lower_bound(__first, __last, __val,
02174                        __distance_type(__first));
02175 }
02176 
02177 template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
02178 _ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
02179                               const _Tp& __val, _Compare __comp, _Distance*)
02180 {
02181   _Distance __len = 0;
02182   distance(__first, __last, __len);
02183   _Distance __half;
02184   _ForwardIter __middle;
02185 
02186   while (__len > 0) {
02187     __half = __len >> 1;
02188     __middle = __first;
02189     advance(__middle, __half);
02190     if (__comp(*__middle, __val)) {
02191       __first = __middle;
02192       ++__first;
02193       __len = __len - __half - 1;
02194     }
02195     else
02196       __len = __half;
02197   }
02198   return __first;
02199 }
02200 
02201 template <class _ForwardIter, class _Tp, class _Compare>
02202 inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
02203                                 const _Tp& __val, _Compare __comp)
02204 {
02205   // concept requirements
02206   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02207   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02208         typename iterator_traits<_ForwardIter>::value_type>);
02209   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
02210 
02211   return __lower_bound(__first, __last, __val, __comp,
02212                        __distance_type(__first));
02213 }
02214 
02215 template <class _ForwardIter, class _Tp, class _Distance>
02216 _ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
02217                            const _Tp& __val, _Distance*)
02218 {
02219   _Distance __len = 0;
02220   distance(__first, __last, __len);
02221   _Distance __half;
02222   _ForwardIter __middle;
02223 
02224   while (__len > 0) {
02225     __half = __len >> 1;
02226     __middle = __first;
02227     advance(__middle, __half);
02228     if (__val < *__middle)
02229       __len = __half;
02230     else {
02231       __first = __middle;
02232       ++__first;
02233       __len = __len - __half - 1;
02234     }
02235   }
02236   return __first;
02237 }
02238 
02239 template <class _ForwardIter, class _Tp>
02240 inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
02241                                 const _Tp& __val)
02242 {
02243   // concept requirements
02244   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02245   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02246         typename iterator_traits<_ForwardIter>::value_type>);
02247   __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
02248 
02249   return __upper_bound(__first, __last, __val,
02250                        __distance_type(__first));
02251 }
02252 
02253 template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
02254 _ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
02255                            const _Tp& __val, _Compare __comp, _Distance*)
02256 {
02257   _Distance __len = 0;
02258   distance(__first, __last, __len);
02259   _Distance __half;
02260   _ForwardIter __middle;
02261 
02262   while (__len > 0) {
02263     __half = __len >> 1;
02264     __middle = __first;
02265     advance(__middle, __half);
02266     if (__comp(__val, *__middle))
02267       __len = __half;
02268     else {
02269       __first = __middle;
02270       ++__first;
02271       __len = __len - __half - 1;
02272     }
02273   }
02274   return __first;
02275 }
02276 
02277 template <class _ForwardIter, class _Tp, class _Compare>
02278 inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
02279                                 const _Tp& __val, _Compare __comp)
02280 {
02281   // concept requirements
02282   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02283   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02284         typename iterator_traits<_ForwardIter>::value_type>);
02285   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
02286 
02287   return __upper_bound(__first, __last, __val, __comp,
02288                        __distance_type(__first));
02289 }
02290 
02291 template <class _ForwardIter, class _Tp, class _Distance>
02292 pair<_ForwardIter, _ForwardIter>
02293 __equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
02294               _Distance*)
02295 {
02296   _Distance __len = 0;
02297   distance(__first, __last, __len);
02298   _Distance __half;
02299   _ForwardIter __middle, __left, __right;
02300 
02301   while (__len > 0) {
02302     __half = __len >> 1;
02303     __middle = __first;
02304     advance(__middle, __half);
02305     if (*__middle < __val) {
02306       __first = __middle;
02307       ++__first;
02308       __len = __len - __half - 1;
02309     }
02310     else if (__val < *__middle)
02311       __len = __half;
02312     else {
02313       __left = lower_bound(__first, __middle, __val);
02314       advance(__first, __len);
02315       __right = upper_bound(++__middle, __first, __val);
02316       return pair<_ForwardIter, _ForwardIter>(__left, __right);
02317     }
02318   }
02319   return pair<_ForwardIter, _ForwardIter>(__first, __first);
02320 }
02321 
02322 template <class _ForwardIter, class _Tp>
02323 inline pair<_ForwardIter, _ForwardIter>
02324 equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
02325 {
02326   // concept requirements
02327   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02328   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02329         typename iterator_traits<_ForwardIter>::value_type>);
02330   __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
02331 
02332   return __equal_range(__first, __last, __val,
02333                        __distance_type(__first));
02334 }
02335 
02336 template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
02337 pair<_ForwardIter, _ForwardIter>
02338 __equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
02339               _Compare __comp, _Distance*)
02340 {
02341   _Distance __len = 0;
02342   distance(__first, __last, __len);
02343   _Distance __half;
02344   _ForwardIter __middle, __left, __right;
02345 
02346   while (__len > 0) {
02347     __half = __len >> 1;
02348     __middle = __first;
02349     advance(__middle, __half);
02350     if (__comp(*__middle, __val)) {
02351       __first = __middle;
02352       ++__first;
02353       __len = __len - __half - 1;
02354     }
02355     else if (__comp(__val, *__middle))
02356       __len = __half;
02357     else {
02358       __left = lower_bound(__first, __middle, __val, __comp);
02359       advance(__first, __len);
02360       __right = upper_bound(++__middle, __first, __val, __comp);
02361       return pair<_ForwardIter, _ForwardIter>(__left, __right);
02362     }
02363   }
02364   return pair<_ForwardIter, _ForwardIter>(__first, __first);
02365 }           
02366 
02367 template <class _ForwardIter, class _Tp, class _Compare>
02368 inline pair<_ForwardIter, _ForwardIter>
02369 equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
02370             _Compare __comp)
02371 {
02372   // concept requirements
02373   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02374   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02375         typename iterator_traits<_ForwardIter>::value_type>);
02376   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
02377 
02378   return __equal_range(__first, __last, __val, __comp,
02379                        __distance_type(__first));
02380 } 
02381 
02382 template <class _ForwardIter, class _Tp>
02383 bool binary_search(_ForwardIter __first, _ForwardIter __last,
02384                    const _Tp& __val)
02385 {
02386   // concept requirements
02387   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02388   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02389         typename iterator_traits<_ForwardIter>::value_type>);
02390   __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
02391 
02392   _ForwardIter __i = lower_bound(__first, __last, __val);
02393   return __i != __last && !(__val < *__i);
02394 }
02395 
02396 template <class _ForwardIter, class _Tp, class _Compare>
02397 bool binary_search(_ForwardIter __first, _ForwardIter __last,
02398                    const _Tp& __val,
02399                    _Compare __comp)
02400 {
02401   // concept requirements
02402   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
02403   __glibcpp_function_requires(_SameTypeConcept<_Tp,
02404         typename iterator_traits<_ForwardIter>::value_type>);
02405   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
02406 
02407   _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
02408   return __i != __last && !__comp(__val, *__i);
02409 }
02410 
02411 // merge, with and without an explicitly supplied comparison function.
02412 
02413 template <class _InputIter1, class _InputIter2, class _OutputIter>
02414 _OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
02415                   _InputIter2 __first2, _InputIter2 __last2,
02416                   _OutputIter __result)
02417 {
02418   // concept requirements
02419   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02420   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02421   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02422         typename iterator_traits<_InputIter1>::value_type>);
02423   __glibcpp_function_requires(_SameTypeConcept<
02424         typename iterator_traits<_InputIter1>::value_type,
02425         typename iterator_traits<_InputIter2>::value_type>);
02426   __glibcpp_function_requires(_LessThanComparableConcept<
02427         typename iterator_traits<_InputIter1>::value_type>);
02428 
02429   while (__first1 != __last1 && __first2 != __last2) {
02430     if (*__first2 < *__first1) {
02431       *__result = *__first2;
02432       ++__first2;
02433     }
02434     else {
02435       *__result = *__first1;
02436       ++__first1;
02437     }
02438     ++__result;
02439   }
02440   return copy(__first2, __last2, copy(__first1, __last1, __result));
02441 }
02442 
02443 template <class _InputIter1, class _InputIter2, class _OutputIter,
02444           class _Compare>
02445 _OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
02446                   _InputIter2 __first2, _InputIter2 __last2,
02447                   _OutputIter __result, _Compare __comp)
02448 {
02449   // concept requirements
02450   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02451   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02452   __glibcpp_function_requires(_SameTypeConcept<
02453         typename iterator_traits<_InputIter1>::value_type,
02454         typename iterator_traits<_InputIter2>::value_type>);
02455   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02456         typename iterator_traits<_InputIter1>::value_type>);
02457   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02458         typename iterator_traits<_InputIter1>::value_type,
02459         typename iterator_traits<_InputIter2>::value_type>);
02460 
02461   while (__first1 != __last1 && __first2 != __last2) {
02462     if (__comp(*__first2, *__first1)) {
02463       *__result = *__first2;
02464       ++__first2;
02465     }
02466     else {
02467       *__result = *__first1;
02468       ++__first1;
02469     }
02470     ++__result;
02471   }
02472   return copy(__first2, __last2, copy(__first1, __last1, __result));
02473 }
02474 
02475 // inplace_merge and its auxiliary functions. 
02476 
02477 template <class _BidirectionalIter, class _Distance>
02478 void __merge_without_buffer(_BidirectionalIter __first,
02479                             _BidirectionalIter __middle,
02480                             _BidirectionalIter __last,
02481                             _Distance __len1, _Distance __len2)
02482 {
02483   if (__len1 == 0 || __len2 == 0)
02484     return;
02485   if (__len1 + __len2 == 2) {
02486     if (*__middle < *__first)
02487       iter_swap(__first, __middle);
02488     return;
02489   }
02490   _BidirectionalIter __first_cut = __first;
02491   _BidirectionalIter __second_cut = __middle;
02492   _Distance __len11 = 0;
02493   _Distance __len22 = 0;
02494   if (__len1 > __len2) {
02495     __len11 = __len1 / 2;
02496     advance(__first_cut, __len11);
02497     __second_cut = lower_bound(__middle, __last, *__first_cut);
02498     distance(__middle, __second_cut, __len22);
02499   }
02500   else {
02501     __len22 = __len2 / 2;
02502     advance(__second_cut, __len22);
02503     __first_cut = upper_bound(__first, __middle, *__second_cut);
02504     distance(__first, __first_cut, __len11);
02505   }
02506   _BidirectionalIter __new_middle
02507     = rotate(__first_cut, __middle, __second_cut);
02508   __merge_without_buffer(__first, __first_cut, __new_middle,
02509                          __len11, __len22);
02510   __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
02511                          __len2 - __len22);
02512 }
02513 
02514 template <class _BidirectionalIter, class _Distance, class _Compare>
02515 void __merge_without_buffer(_BidirectionalIter __first,
02516                             _BidirectionalIter __middle,
02517                             _BidirectionalIter __last,
02518                             _Distance __len1, _Distance __len2,
02519                             _Compare __comp)
02520 {
02521   if (__len1 == 0 || __len2 == 0)
02522     return;
02523   if (__len1 + __len2 == 2) {
02524     if (__comp(*__middle, *__first))
02525       iter_swap(__first, __middle);
02526     return;
02527   }
02528   _BidirectionalIter __first_cut = __first;
02529   _BidirectionalIter __second_cut = __middle;
02530   _Distance __len11 = 0;
02531   _Distance __len22 = 0;
02532   if (__len1 > __len2) {
02533     __len11 = __len1 / 2;
02534     advance(__first_cut, __len11);
02535     __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
02536     distance(__middle, __second_cut, __len22);
02537   }
02538   else {
02539     __len22 = __len2 / 2;
02540     advance(__second_cut, __len22);
02541     __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
02542     distance(__first, __first_cut, __len11);
02543   }
02544   _BidirectionalIter __new_middle
02545     = rotate(__first_cut, __middle, __second_cut);
02546   __merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22,
02547                          __comp);
02548   __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
02549                          __len2 - __len22, __comp);
02550 }
02551 
02552 template <class _BidirectionalIter1, class _BidirectionalIter2,
02553           class _Distance>
02554 _BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first,
02555                                       _BidirectionalIter1 __middle,
02556                                       _BidirectionalIter1 __last,
02557                                       _Distance __len1, _Distance __len2,
02558                                       _BidirectionalIter2 __buffer,
02559                                       _Distance __buffer_size)
02560 {
02561   _BidirectionalIter2 __buffer_end;
02562   if (__len1 > __len2 && __len2 <= __buffer_size) {
02563     __buffer_end = copy(__middle, __last, __buffer);
02564     copy_backward(__first, __middle, __last);
02565     return copy(__buffer, __buffer_end, __first);
02566   }
02567   else if (__len1 <= __buffer_size) {
02568     __buffer_end = copy(__first, __middle, __buffer);
02569     copy(__middle, __last, __first);
02570     return copy_backward(__buffer, __buffer_end, __last);
02571   }
02572   else
02573     return rotate(__first, __middle, __last);
02574 }
02575 
02576 template <class _BidirectionalIter1, class _BidirectionalIter2,
02577           class _BidirectionalIter3>
02578 _BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
02579                                      _BidirectionalIter1 __last1,
02580                                      _BidirectionalIter2 __first2,
02581                                      _BidirectionalIter2 __last2,
02582                                      _BidirectionalIter3 __result)
02583 {
02584   if (__first1 == __last1)
02585     return copy_backward(__first2, __last2, __result);
02586   if (__first2 == __last2)
02587     return copy_backward(__first1, __last1, __result);
02588   --__last1;
02589   --__last2;
02590   while (true) {
02591     if (*__last2 < *__last1) {
02592       *--__result = *__last1;
02593       if (__first1 == __last1)
02594         return copy_backward(__first2, ++__last2, __result);
02595       --__last1;
02596     }
02597     else {
02598       *--__result = *__last2;
02599       if (__first2 == __last2)
02600         return copy_backward(__first1, ++__last1, __result);
02601       --__last2;
02602     }
02603   }
02604 }
02605 
02606 template <class _BidirectionalIter1, class _BidirectionalIter2,
02607           class _BidirectionalIter3, class _Compare>
02608 _BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
02609                                      _BidirectionalIter1 __last1,
02610                                      _BidirectionalIter2 __first2,
02611                                      _BidirectionalIter2 __last2,
02612                                      _BidirectionalIter3 __result,
02613                                      _Compare __comp)
02614 {
02615   if (__first1 == __last1)
02616     return copy_backward(__first2, __last2, __result);
02617   if (__first2 == __last2)
02618     return copy_backward(__first1, __last1, __result);
02619   --__last1;
02620   --__last2;
02621   while (true) {
02622     if (__comp(*__last2, *__last1)) {
02623       *--__result = *__last1;
02624       if (__first1 == __last1)
02625         return copy_backward(__first2, ++__last2, __result);
02626       --__last1;
02627     }
02628     else {
02629       *--__result = *__last2;
02630       if (__first2 == __last2)
02631         return copy_backward(__first1, ++__last1, __result);
02632       --__last2;
02633     }
02634   }
02635 }
02636 
02637 template <class _BidirectionalIter, class _Distance, class _Pointer>
02638 void __merge_adaptive(_BidirectionalIter __first,
02639                       _BidirectionalIter __middle, 
02640                       _BidirectionalIter __last,
02641                       _Distance __len1, _Distance __len2,
02642                       _Pointer __buffer, _Distance __buffer_size)
02643 {
02644   if (__len1 <= __len2 && __len1 <= __buffer_size) {
02645     _Pointer __buffer_end = copy(__first, __middle, __buffer);
02646     merge(__buffer, __buffer_end, __middle, __last, __first);
02647   }
02648   else if (__len2 <= __buffer_size) {
02649     _Pointer __buffer_end = copy(__middle, __last, __buffer);
02650     __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
02651   }
02652   else {
02653     _BidirectionalIter __first_cut = __first;
02654     _BidirectionalIter __second_cut = __middle;
02655     _Distance __len11 = 0;
02656     _Distance __len22 = 0;
02657     if (__len1 > __len2) {
02658       __len11 = __len1 / 2;
02659       advance(__first_cut, __len11);
02660       __second_cut = lower_bound(__middle, __last, *__first_cut);
02661       distance(__middle, __second_cut, __len22); 
02662     }
02663     else {
02664       __len22 = __len2 / 2;
02665       advance(__second_cut, __len22);
02666       __first_cut = upper_bound(__first, __middle, *__second_cut);
02667       distance(__first, __first_cut, __len11);
02668     }
02669     _BidirectionalIter __new_middle =
02670       __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
02671                         __len22, __buffer, __buffer_size);
02672     __merge_adaptive(__first, __first_cut, __new_middle, __len11,
02673                      __len22, __buffer, __buffer_size);
02674     __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
02675                      __len2 - __len22, __buffer, __buffer_size);
02676   }
02677 }
02678 
02679 template <class _BidirectionalIter, class _Distance, class _Pointer,
02680           class _Compare>
02681 void __merge_adaptive(_BidirectionalIter __first, 
02682                       _BidirectionalIter __middle, 
02683                       _BidirectionalIter __last,
02684                       _Distance __len1, _Distance __len2,
02685                       _Pointer __buffer, _Distance __buffer_size,
02686                       _Compare __comp)
02687 {
02688   if (__len1 <= __len2 && __len1 <= __buffer_size) {
02689     _Pointer __buffer_end = copy(__first, __middle, __buffer);
02690     merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
02691   }
02692   else if (__len2 <= __buffer_size) {
02693     _Pointer __buffer_end = copy(__middle, __last, __buffer);
02694     __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
02695                      __comp);
02696   }
02697   else {
02698     _BidirectionalIter __first_cut = __first;
02699     _BidirectionalIter __second_cut = __middle;
02700     _Distance __len11 = 0;
02701     _Distance __len22 = 0;
02702     if (__len1 > __len2) {
02703       __len11 = __len1 / 2;
02704       advance(__first_cut, __len11);
02705       __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
02706       distance(__middle, __second_cut, __len22);   
02707     }
02708     else {
02709       __len22 = __len2 / 2;
02710       advance(__second_cut, __len22);
02711       __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
02712       distance(__first, __first_cut, __len11);
02713     }
02714     _BidirectionalIter __new_middle =
02715       __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
02716                         __len22, __buffer, __buffer_size);
02717     __merge_adaptive(__first, __first_cut, __new_middle, __len11,
02718                      __len22, __buffer, __buffer_size, __comp);
02719     __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
02720                      __len2 - __len22, __buffer, __buffer_size, __comp);
02721   }
02722 }
02723 
02724 template <class _BidirectionalIter, class _Tp, class _Distance>
02725 inline void __inplace_merge_aux(_BidirectionalIter __first,
02726                                 _BidirectionalIter __middle,
02727                                 _BidirectionalIter __last, _Tp*, _Distance*)
02728 {
02729   _Distance __len1 = 0;
02730   distance(__first, __middle, __len1);
02731   _Distance __len2 = 0;
02732   distance(__middle, __last, __len2);
02733 
02734   _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
02735   if (__buf.begin() == 0)
02736     __merge_without_buffer(__first, __middle, __last, __len1, __len2);
02737   else
02738     __merge_adaptive(__first, __middle, __last, __len1, __len2,
02739                      __buf.begin(), _Distance(__buf.size()));
02740 }
02741 
02742 template <class _BidirectionalIter, class _Tp, 
02743           class _Distance, class _Compare>
02744 inline void __inplace_merge_aux(_BidirectionalIter __first,
02745                                 _BidirectionalIter __middle,
02746                                 _BidirectionalIter __last, _Tp*, _Distance*,
02747                                 _Compare __comp)
02748 {
02749   _Distance __len1 = 0;
02750   distance(__first, __middle, __len1);
02751   _Distance __len2 = 0;
02752   distance(__middle, __last, __len2);
02753 
02754   _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
02755   if (__buf.begin() == 0)
02756     __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
02757   else
02758     __merge_adaptive(__first, __middle, __last, __len1, __len2,
02759                      __buf.begin(), _Distance(__buf.size()),
02760                      __comp);
02761 }
02762 
02763 template <class _BidirectionalIter>
02764 inline void inplace_merge(_BidirectionalIter __first,
02765                           _BidirectionalIter __middle,
02766                           _BidirectionalIter __last)
02767 {
02768   // concept requirements
02769   __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
02770         _BidirectionalIter>);
02771   __glibcpp_function_requires(_LessThanComparableConcept<
02772         typename iterator_traits<_BidirectionalIter>::value_type>);
02773 
02774   if (__first == __middle || __middle == __last)
02775     return;
02776   __inplace_merge_aux(__first, __middle, __last,
02777                       __value_type(__first), __distance_type(__first));
02778 }
02779 
02780 template <class _BidirectionalIter, class _Compare>
02781 inline void inplace_merge(_BidirectionalIter __first,
02782                           _BidirectionalIter __middle,
02783                           _BidirectionalIter __last, _Compare __comp)
02784 {
02785   // concept requirements
02786   __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
02787         _BidirectionalIter>);
02788   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02789         typename iterator_traits<_BidirectionalIter>::value_type,
02790         typename iterator_traits<_BidirectionalIter>::value_type>);
02791 
02792   if (__first == __middle || __middle == __last)
02793     return;
02794   __inplace_merge_aux(__first, __middle, __last,
02795                       __value_type(__first), __distance_type(__first),
02796                       __comp);
02797 }
02798 
02799 // Set algorithms: includes, set_union, set_intersection, set_difference,
02800 // set_symmetric_difference.  All of these algorithms have the precondition
02801 // that their input ranges are sorted and the postcondition that their output
02802 // ranges are sorted.
02803 
02804 template <class _InputIter1, class _InputIter2>
02805 bool includes(_InputIter1 __first1, _InputIter1 __last1,
02806               _InputIter2 __first2, _InputIter2 __last2)
02807 {
02808   // concept requirements
02809   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02810   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02811   __glibcpp_function_requires(_SameTypeConcept<
02812         typename iterator_traits<_InputIter1>::value_type,
02813         typename iterator_traits<_InputIter2>::value_type>);
02814   __glibcpp_function_requires(_LessThanComparableConcept<
02815         typename iterator_traits<_InputIter1>::value_type>);
02816 
02817   while (__first1 != __last1 && __first2 != __last2)
02818     if (*__first2 < *__first1)
02819       return false;
02820     else if(*__first1 < *__first2) 
02821       ++__first1;
02822     else
02823       ++__first1, ++__first2;
02824 
02825   return __first2 == __last2;
02826 }
02827 
02828 template <class _InputIter1, class _InputIter2, class _Compare>
02829 bool includes(_InputIter1 __first1, _InputIter1 __last1,
02830               _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
02831 {
02832   // concept requirements
02833   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02834   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02835   __glibcpp_function_requires(_SameTypeConcept<
02836         typename iterator_traits<_InputIter1>::value_type,
02837         typename iterator_traits<_InputIter2>::value_type>);
02838   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02839         typename iterator_traits<_InputIter1>::value_type,
02840         typename iterator_traits<_InputIter2>::value_type>);
02841 
02842   while (__first1 != __last1 && __first2 != __last2)
02843     if (__comp(*__first2, *__first1))
02844       return false;
02845     else if(__comp(*__first1, *__first2)) 
02846       ++__first1;
02847     else
02848       ++__first1, ++__first2;
02849 
02850   return __first2 == __last2;
02851 }
02852 
02853 template <class _InputIter1, class _InputIter2, class _OutputIter>
02854 _OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
02855                       _InputIter2 __first2, _InputIter2 __last2,
02856                       _OutputIter __result)
02857 {
02858   // concept requirements
02859   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02860   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02861   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02862         typename iterator_traits<_InputIter1>::value_type>);
02863   __glibcpp_function_requires(_SameTypeConcept<
02864         typename iterator_traits<_InputIter1>::value_type,
02865         typename iterator_traits<_InputIter2>::value_type>);
02866   __glibcpp_function_requires(_LessThanComparableConcept<
02867         typename iterator_traits<_InputIter1>::value_type>);
02868 
02869   while (__first1 != __last1 && __first2 != __last2) {
02870     if (*__first1 < *__first2) {
02871       *__result = *__first1;
02872       ++__first1;
02873     }
02874     else if (*__first2 < *__first1) {
02875       *__result = *__first2;
02876       ++__first2;
02877     }
02878     else {
02879       *__result = *__first1;
02880       ++__first1;
02881       ++__first2;
02882     }
02883     ++__result;
02884   }
02885   return copy(__first2, __last2, copy(__first1, __last1, __result));
02886 }
02887 
02888 template <class _InputIter1, class _InputIter2, class _OutputIter,
02889           class _Compare>
02890 _OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
02891                       _InputIter2 __first2, _InputIter2 __last2,
02892                       _OutputIter __result, _Compare __comp)
02893 {
02894   // concept requirements
02895   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02896   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02897   __glibcpp_function_requires(_SameTypeConcept<
02898         typename iterator_traits<_InputIter1>::value_type,
02899         typename iterator_traits<_InputIter2>::value_type>);
02900   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02901         typename iterator_traits<_InputIter1>::value_type>);
02902   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02903         typename iterator_traits<_InputIter1>::value_type,
02904         typename iterator_traits<_InputIter2>::value_type>);
02905 
02906   while (__first1 != __last1 && __first2 != __last2) {
02907     if (__comp(*__first1, *__first2)) {
02908       *__result = *__first1;
02909       ++__first1;
02910     }
02911     else if (__comp(*__first2, *__first1)) {
02912       *__result = *__first2;
02913       ++__first2;
02914     }
02915     else {
02916       *__result = *__first1;
02917       ++__first1;
02918       ++__first2;
02919     }
02920     ++__result;
02921   }
02922   return copy(__first2, __last2, copy(__first1, __last1, __result));
02923 }
02924 
02925 template <class _InputIter1, class _InputIter2, class _OutputIter>
02926 _OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
02927                              _InputIter2 __first2, _InputIter2 __last2,
02928                              _OutputIter __result)
02929 {
02930   // concept requirements
02931   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02932   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02933   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02934         typename iterator_traits<_InputIter1>::value_type>);
02935   __glibcpp_function_requires(_SameTypeConcept<
02936         typename iterator_traits<_InputIter1>::value_type,
02937         typename iterator_traits<_InputIter2>::value_type>);
02938   __glibcpp_function_requires(_LessThanComparableConcept<
02939         typename iterator_traits<_InputIter1>::value_type>);
02940 
02941   while (__first1 != __last1 && __first2 != __last2) 
02942     if (*__first1 < *__first2) 
02943       ++__first1;
02944     else if (*__first2 < *__first1) 
02945       ++__first2;
02946     else {
02947       *__result = *__first1;
02948       ++__first1;
02949       ++__first2;
02950       ++__result;
02951     }
02952   return __result;
02953 }
02954 
02955 template <class _InputIter1, class _InputIter2, class _OutputIter,
02956           class _Compare>
02957 _OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
02958                              _InputIter2 __first2, _InputIter2 __last2,
02959                              _OutputIter __result, _Compare __comp)
02960 {
02961   // concept requirements
02962   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02963   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02964   __glibcpp_function_requires(_SameTypeConcept<
02965         typename iterator_traits<_InputIter1>::value_type,
02966         typename iterator_traits<_InputIter2>::value_type>);
02967   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02968         typename iterator_traits<_InputIter1>::value_type>);
02969   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
02970         typename iterator_traits<_InputIter1>::value_type,
02971         typename iterator_traits<_InputIter2>::value_type>);
02972 
02973   while (__first1 != __last1 && __first2 != __last2)
02974     if (__comp(*__first1, *__first2))
02975       ++__first1;
02976     else if (__comp(*__first2, *__first1))
02977       ++__first2;
02978     else {
02979       *__result = *__first1;
02980       ++__first1;
02981       ++__first2;
02982       ++__result;
02983     }
02984   return __result;
02985 }
02986 
02987 template <class _InputIter1, class _InputIter2, class _OutputIter>
02988 _OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
02989                            _InputIter2 __first2, _InputIter2 __last2,
02990                            _OutputIter __result)
02991 {
02992   // concept requirements
02993   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
02994   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
02995   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
02996         typename iterator_traits<_InputIter1>::value_type>);
02997   __glibcpp_function_requires(_SameTypeConcept<
02998         typename iterator_traits<_InputIter1>::value_type,
02999         typename iterator_traits<_InputIter2>::value_type>);
03000   __glibcpp_function_requires(_LessThanComparableConcept<
03001         typename iterator_traits<_InputIter1>::value_type>);
03002 
03003   while (__first1 != __last1 && __first2 != __last2)
03004     if (*__first1 < *__first2) {
03005       *__result = *__first1;
03006       ++__first1;
03007       ++__result;
03008     }
03009     else if (*__first2 < *__first1)
03010       ++__first2;
03011     else {
03012       ++__first1;
03013       ++__first2;
03014     }
03015   return copy(__first1, __last1, __result);
03016 }
03017 
03018 template <class _InputIter1, class _InputIter2, class _OutputIter, 
03019           class _Compare>
03020 _OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
03021                            _InputIter2 __first2, _InputIter2 __last2, 
03022                            _OutputIter __result, _Compare __comp)
03023 {
03024   // concept requirements
03025   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
03026   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
03027   __glibcpp_function_requires(_SameTypeConcept<
03028         typename iterator_traits<_InputIter1>::value_type,
03029         typename iterator_traits<_InputIter2>::value_type>);
03030   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
03031         typename iterator_traits<_InputIter1>::value_type>);
03032   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
03033         typename iterator_traits<_InputIter1>::value_type,
03034         typename iterator_traits<_InputIter2>::value_type>);
03035 
03036   while (__first1 != __last1 && __first2 != __last2)
03037     if (__comp(*__first1, *__first2)) {
03038       *__result = *__first1;
03039       ++__first1;
03040       ++__result;
03041     }
03042     else if (__comp(*__first2, *__first1))
03043       ++__first2;
03044     else {
03045       ++__first1;
03046       ++__first2;
03047     }
03048   return copy(__first1, __last1, __result);
03049 }
03050 
03051 template <class _InputIter1, class _InputIter2, class _OutputIter>
03052 _OutputIter 
03053 set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
03054                          _InputIter2 __first2, _InputIter2 __last2,
03055                          _OutputIter __result)
03056 {
03057   // concept requirements
03058   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
03059   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
03060   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
03061         typename iterator_traits<_InputIter1>::value_type>);
03062   __glibcpp_function_requires(_SameTypeConcept<
03063         typename iterator_traits<_InputIter1>::value_type,
03064         typename iterator_traits<_InputIter2>::value_type>);
03065   __glibcpp_function_requires(_LessThanComparableConcept<
03066         typename iterator_traits<_InputIter1>::value_type>);
03067 
03068   while (__first1 != __last1 && __first2 != __last2)
03069     if (*__first1 < *__first2) {
03070       *__result = *__first1;
03071       ++__first1;
03072       ++__result;
03073     }
03074     else if (*__first2 < *__first1) {
03075       *__result = *__first2;
03076       ++__first2;
03077       ++__result;
03078     }
03079     else {
03080       ++__first1;
03081       ++__first2;
03082     }
03083   return copy(__first2, __last2, copy(__first1, __last1, __result));
03084 }
03085 
03086 template <class _InputIter1, class _InputIter2, class _OutputIter,
03087           class _Compare>
03088 _OutputIter 
03089 set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
03090                          _InputIter2 __first2, _InputIter2 __last2,
03091                          _OutputIter __result,
03092                          _Compare __comp)
03093 {
03094   // concept requirements
03095   __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
03096   __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
03097   __glibcpp_function_requires(_SameTypeConcept<
03098         typename iterator_traits<_InputIter1>::value_type,
03099         typename iterator_traits<_InputIter2>::value_type>);
03100   __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
03101         typename iterator_traits<_InputIter1>::value_type>);
03102   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
03103         typename iterator_traits<_InputIter1>::value_type,
03104         typename iterator_traits<_InputIter2>::value_type>);
03105 
03106   while (__first1 != __last1 && __first2 != __last2)
03107     if (__comp(*__first1, *__first2)) {
03108       *__result = *__first1;
03109       ++__first1;
03110       ++__result;
03111     }
03112     else if (__comp(*__first2, *__first1)) {
03113       *__result = *__first2;
03114       ++__first2;
03115       ++__result;
03116     }
03117     else {
03118       ++__first1;
03119       ++__first2;
03120     }
03121   return copy(__first2, __last2, copy(__first1, __last1, __result));
03122 }
03123 
03124 // min_element and max_element, with and without an explicitly supplied
03125 // comparison function.
03126 
03127 template <class _ForwardIter>
03128 _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last)
03129 {
03130   // concept requirements
03131   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03132   __glibcpp_function_requires(_LessThanComparableConcept<
03133         typename iterator_traits<_ForwardIter>::value_type>);
03134 
03135   if (__first == __last) return __first;
03136   _ForwardIter __result = __first;
03137   while (++__first != __last) 
03138     if (*__result < *__first)
03139       __result = __first;
03140   return __result;
03141 }
03142 
03143 template <class _ForwardIter, class _Compare>
03144 _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
03145              _Compare __comp)
03146 {
03147   // concept requirements
03148   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03149   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
03150         typename iterator_traits<_ForwardIter>::value_type,
03151         typename iterator_traits<_ForwardIter>::value_type>);
03152 
03153   if (__first == __last) return __first;
03154   _ForwardIter __result = __first;
03155   while (++__first != __last) 
03156     if (__comp(*__result, *__first)) __result = __first;
03157   return __result;
03158 }
03159 
03160 template <class _ForwardIter>
03161 _ForwardIter min_element(_ForwardIter __first, _ForwardIter __last)
03162 {
03163   // concept requirements
03164   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03165   __glibcpp_function_requires(_LessThanComparableConcept<
03166         typename iterator_traits<_ForwardIter>::value_type>);
03167 
03168   if (__first == __last) return __first;
03169   _ForwardIter __result = __first;
03170   while (++__first != __last) 
03171     if (*__first < *__result)
03172       __result = __first;
03173   return __result;
03174 }
03175 
03176 template <class _ForwardIter, class _Compare>
03177 _ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
03178              _Compare __comp)
03179 {
03180   // concept requirements
03181   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03182   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
03183         typename iterator_traits<_ForwardIter>::value_type,
03184         typename iterator_traits<_ForwardIter>::value_type>);
03185 
03186   if (__first == __last) return __first;
03187   _ForwardIter __result = __first;
03188   while (++__first != __last) 
03189     if (__comp(*__first, *__result))
03190       __result = __first;
03191   return __result;
03192 }
03193 
03194 // next_permutation and prev_permutation, with and without an explicitly 
03195 // supplied comparison function.
03196 
03197 template <class _BidirectionalIter>
03198 bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
03199 {
03200   // concept requirements
03201   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
03202   __glibcpp_function_requires(_LessThanComparableConcept<
03203         typename iterator_traits<_BidirectionalIter>::value_type>);
03204 
03205   if (__first == __last)
03206     return false;
03207   _BidirectionalIter __i = __first;
03208   ++__i;
03209   if (__i == __last)
03210     return false;
03211   __i = __last;
03212   --__i;
03213 
03214   for(;;) {
03215     _BidirectionalIter __ii = __i;
03216     --__i;
03217     if (*__i < *__ii) {
03218       _BidirectionalIter __j = __last;
03219       while (!(*__i < *--__j))
03220         {}
03221       iter_swap(__i, __j);
03222       reverse(__ii, __last);
03223       return true;
03224     }
03225     if (__i == __first) {
03226       reverse(__first, __last);
03227       return false;
03228     }
03229   }
03230 }
03231 
03232 template <class _BidirectionalIter, class _Compare>
03233 bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
03234                       _Compare __comp)
03235 {
03236   // concept requirements
03237   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
03238   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
03239         typename iterator_traits<_BidirectionalIter>::value_type,
03240         typename iterator_traits<_BidirectionalIter>::value_type>);
03241 
03242   if (__first == __last)
03243     return false;
03244   _BidirectionalIter __i = __first;
03245   ++__i;
03246   if (__i == __last)
03247     return false;
03248   __i = __last;
03249   --__i;
03250 
03251   for(;;) {
03252     _BidirectionalIter __ii = __i;
03253     --__i;
03254     if (__comp(*__i, *__ii)) {
03255       _BidirectionalIter __j = __last;
03256       while (!__comp(*__i, *--__j))
03257         {}
03258       iter_swap(__i, __j);
03259       reverse(__ii, __last);
03260       return true;
03261     }
03262     if (__i == __first) {
03263       reverse(__first, __last);
03264       return false;
03265     }
03266   }
03267 }
03268 
03269 template <class _BidirectionalIter>
03270 bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
03271 {
03272   // concept requirements
03273   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
03274   __glibcpp_function_requires(_LessThanComparableConcept<
03275         typename iterator_traits<_BidirectionalIter>::value_type>);
03276 
03277   if (__first == __last)
03278     return false;
03279   _BidirectionalIter __i = __first;
03280   ++__i;
03281   if (__i == __last)
03282     return false;
03283   __i = __last;
03284   --__i;
03285 
03286   for(;;) {
03287     _BidirectionalIter __ii = __i;
03288     --__i;
03289     if (*__ii < *__i) {
03290       _BidirectionalIter __j = __last;
03291       while (!(*--__j < *__i))
03292         {}
03293       iter_swap(__i, __j);
03294       reverse(__ii, __last);
03295       return true;
03296     }
03297     if (__i == __first) {
03298       reverse(__first, __last);
03299       return false;
03300     }
03301   }
03302 }
03303 
03304 template <class _BidirectionalIter, class _Compare>
03305 bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
03306                       _Compare __comp)
03307 {
03308   // concept requirements
03309   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
03310   __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
03311         typename iterator_traits<_BidirectionalIter>::value_type,
03312         typename iterator_traits<_BidirectionalIter>::value_type>);
03313 
03314   if (__first == __last)
03315     return false;
03316   _BidirectionalIter __i = __first;
03317   ++__i;
03318   if (__i == __last)
03319     return false;
03320   __i = __last;
03321   --__i;
03322 
03323   for(;;) {
03324     _BidirectionalIter __ii = __i;
03325     --__i;
03326     if (__comp(*__ii, *__i)) {
03327       _BidirectionalIter __j = __last;
03328       while (!__comp(*--__j, *__i))
03329         {}
03330       iter_swap(__i, __j);
03331       reverse(__ii, __last);
03332       return true;
03333     }
03334     if (__i == __first) {
03335       reverse(__first, __last);
03336       return false;
03337     }
03338   }
03339 }
03340 
03341 // find_first_of, with and without an explicitly supplied comparison function.
03342 
03343 template <class _InputIter, class _ForwardIter>
03344 _InputIter find_first_of(_InputIter __first1, _InputIter __last1,
03345                          _ForwardIter __first2, _ForwardIter __last2)
03346 {
03347   // concept requirements
03348   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
03349   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03350   __glibcpp_function_requires(_EqualOpConcept<
03351         typename iterator_traits<_InputIter>::value_type,
03352         typename iterator_traits<_ForwardIter>::value_type>);
03353 
03354   for ( ; __first1 != __last1; ++__first1) 
03355     for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
03356       if (*__first1 == *__iter)
03357         return __first1;
03358   return __last1;
03359 }
03360 
03361 template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
03362 _InputIter find_first_of(_InputIter __first1, _InputIter __last1,
03363                          _ForwardIter __first2, _ForwardIter __last2,
03364                          _BinaryPredicate __comp)
03365 {
03366   // concept requirements
03367   __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
03368   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03369   __glibcpp_function_requires(_EqualOpConcept<
03370         typename iterator_traits<_InputIter>::value_type,
03371         typename iterator_traits<_ForwardIter>::value_type>);
03372   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
03373         typename iterator_traits<_InputIter>::value_type,
03374         typename iterator_traits<_ForwardIter>::value_type>);
03375 
03376   for ( ; __first1 != __last1; ++__first1) 
03377     for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
03378       if (__comp(*__first1, *__iter))
03379         return __first1;
03380   return __last1;
03381 }
03382 
03383 
03384 // find_end, with and without an explicitly supplied comparison function.
03385 // Search [first2, last2) as a subsequence in [first1, last1), and return
03386 // the *last* possible match.  Note that find_end for bidirectional iterators
03387 // is much faster than for forward iterators.
03388 
03389 // find_end for forward iterators. 
03390 template <class _ForwardIter1, class _ForwardIter2>
03391 _ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
03392                          _ForwardIter2 __first2, _ForwardIter2 __last2,
03393                          forward_iterator_tag, forward_iterator_tag)
03394 {
03395   if (__first2 == __last2)
03396     return __last1;
03397   else {
03398     _ForwardIter1 __result = __last1;
03399     while (1) {
03400       _ForwardIter1 __new_result
03401         = search(__first1, __last1, __first2, __last2);
03402       if (__new_result == __last1)
03403         return __result;
03404       else {
03405         __result = __new_result;
03406         __first1 = __new_result;
03407         ++__first1;
03408       }
03409     }
03410   }
03411 }
03412 
03413 template <class _ForwardIter1, class _ForwardIter2,
03414           class _BinaryPredicate>
03415 _ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
03416                          _ForwardIter2 __first2, _ForwardIter2 __last2,
03417                          forward_iterator_tag, forward_iterator_tag,
03418                          _BinaryPredicate __comp)
03419 {
03420   if (__first2 == __last2)
03421     return __last1;
03422   else {
03423     _ForwardIter1 __result = __last1;
03424     while (1) {
03425       _ForwardIter1 __new_result
03426         = search(__first1, __last1, __first2, __last2, __comp);
03427       if (__new_result == __last1)
03428         return __result;
03429       else {
03430         __result = __new_result;
03431         __first1 = __new_result;
03432         ++__first1;
03433       }
03434     }
03435   }
03436 }
03437 
03438 // find_end for bidirectional iterators.  Requires partial specialization.
03439 template <class _BidirectionalIter1, class _BidirectionalIter2>
03440 _BidirectionalIter1
03441 __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
03442            _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
03443            bidirectional_iterator_tag, bidirectional_iterator_tag)
03444 {
03445   // concept requirements
03446   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>);
03447   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>);
03448 
03449   typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
03450   typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
03451 
03452   _RevIter1 __rlast1(__first1);
03453   _RevIter2 __rlast2(__first2);
03454   _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
03455                                _RevIter2(__last2), __rlast2);
03456 
03457   if (__rresult == __rlast1)
03458     return __last1;
03459   else {
03460     _BidirectionalIter1 __result = __rresult.base();
03461     advance(__result, -distance(__first2, __last2));
03462     return __result;
03463   }
03464 }
03465 
03466 template <class _BidirectionalIter1, class _BidirectionalIter2,
03467           class _BinaryPredicate>
03468 _BidirectionalIter1
03469 __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
03470            _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
03471            bidirectional_iterator_tag, bidirectional_iterator_tag, 
03472            _BinaryPredicate __comp)
03473 {
03474   // concept requirements
03475   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>);
03476   __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>);
03477 
03478   typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
03479   typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
03480 
03481   _RevIter1 __rlast1(__first1);
03482   _RevIter2 __rlast2(__first2);
03483   _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
03484                                _RevIter2(__last2), __rlast2,
03485                                __comp);
03486 
03487   if (__rresult == __rlast1)
03488     return __last1;
03489   else {
03490     _BidirectionalIter1 __result = __rresult.base();
03491     advance(__result, -distance(__first2, __last2));
03492     return __result;
03493   }
03494 }
03495 
03496 // Dispatching functions for find_end.
03497 
03498 template <class _ForwardIter1, class _ForwardIter2>
03499 inline _ForwardIter1 
03500 find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, 
03501          _ForwardIter2 __first2, _ForwardIter2 __last2)
03502 {
03503   // concept requirements
03504   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
03505   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
03506   __glibcpp_function_requires(_EqualOpConcept<
03507         typename iterator_traits<_ForwardIter1>::value_type,
03508         typename iterator_traits<_ForwardIter2>::value_type>);
03509 
03510   return __find_end(__first1, __last1, __first2, __last2,
03511                     __iterator_category(__first1),
03512                     __iterator_category(__first2));
03513 }
03514 
03515 template <class _ForwardIter1, class _ForwardIter2, 
03516           class _BinaryPredicate>
03517 inline _ForwardIter1 
03518 find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, 
03519          _ForwardIter2 __first2, _ForwardIter2 __last2,
03520          _BinaryPredicate __comp)
03521 {
03522   // concept requirements
03523   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
03524   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
03525   __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
03526         typename iterator_traits<_ForwardIter1>::value_type,
03527         typename iterator_traits<_ForwardIter2>::value_type>);
03528 
03529   return __find_end(__first1, __last1, __first2, __last2,
03530                     __iterator_category(__first1),
03531                     __iterator_category(__first2),
03532                     __comp);
03533 }
03534 
03535 // is_heap, a predicate testing whether or not a range is
03536 // a heap.  This function is an extension, not part of the C++
03537 // standard.
03538 
03539 template <class _RandomAccessIter, class _Distance>
03540 bool __is_heap(_RandomAccessIter __first, _Distance __n)
03541 {
03542   _Distance __parent = 0;
03543   for (_Distance __child = 1; __child < __n; ++__child) {
03544     if (__first[__parent] < __first[__child]) 
03545       return false;
03546     if ((__child & 1) == 0)
03547       ++__parent;
03548   }
03549   return true;
03550 }
03551 
03552 template <class _RandomAccessIter, class _Distance, class _StrictWeakOrdering>
03553 bool __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp,
03554                _Distance __n)
03555 {
03556   _Distance __parent = 0;
03557   for (_Distance __child = 1; __child < __n; ++__child) {
03558     if (__comp(__first[__parent], __first[__child]))
03559       return false;
03560     if ((__child & 1) == 0)
03561       ++__parent;
03562   }
03563   return true;
03564 }
03565 
03566 template <class _RandomAccessIter>
03567 inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
03568 {
03569   // concept requirements
03570   __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>);
03571   __glibcpp_function_requires(_LessThanComparableConcept<
03572         typename iterator_traits<_RandomAccessIter>::value_type>);
03573 
03574   return __is_heap(__first, __last - __first);
03575 }
03576 
03577 
03578 template <class _RandomAccessIter, class _StrictWeakOrdering>
03579 inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
03580                     _StrictWeakOrdering __comp)
03581 {
03582   // concept requirements
03583   __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>);
03584   __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
03585         typename iterator_traits<_RandomAccessIter>::value_type, 
03586         typename iterator_traits<_RandomAccessIter>::value_type>);
03587 
03588   return __is_heap(__first, __comp, __last - __first);
03589 }
03590 
03591 // is_sorted, a predicated testing whether a range is sorted in
03592 // nondescending order.  This is an extension, not part of the C++
03593 // standard.
03594 
03595 template <class _ForwardIter>
03596 bool is_sorted(_ForwardIter __first, _ForwardIter __last)
03597 {
03598   // concept requirements
03599   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03600   __glibcpp_function_requires(_LessThanComparableConcept<
03601         typename iterator_traits<_ForwardIter>::value_type>);
03602 
03603   if (__first == __last)
03604     return true;
03605 
03606   _ForwardIter __next = __first;
03607   for (++__next; __next != __last; __first = __next, ++__next) {
03608     if (*__next < *__first)
03609       return false;
03610   }
03611 
03612   return true;
03613 }
03614 
03615 template <class _ForwardIter, class _StrictWeakOrdering>
03616 bool is_sorted(_ForwardIter __first, _ForwardIter __last,
03617                _StrictWeakOrdering __comp)
03618 {
03619   // concept requirements
03620   __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
03621   __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
03622         typename iterator_traits<_ForwardIter>::value_type, 
03623         typename iterator_traits<_ForwardIter>::value_type>);
03624 
03625   if (__first == __last)
03626     return true;
03627 
03628   _ForwardIter __next = __first;
03629   for (++__next; __next != __last; __first = __next, ++__next) {
03630     if (__comp(*__next, *__first))
03631       return false;
03632   }
03633 
03634   return true;
03635 }
03636 
03637 } // namespace std
03638 
03639 #endif /* __SGI_STL_INTERNAL_ALGO_H */
03640 
03641 // Local Variables:
03642 // mode:C++
03643 // End:

Generated at Tue May 1 16:28:39 2001 for libstdc++-v3 by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001