00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
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
00037
00038 namespace std
00039 {
00040
00041
00042
00043 template <class _Tp>
00044 inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
00045 {
00046
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
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
00085 template <class _InputIter, class _Function>
00086 _Function for_each(_InputIter __first, _InputIter __last, _Function __f)
00087 {
00088
00089 __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00090 for ( ; __first != __last; ++__first)
00091 __f(*__first);
00092 return __f;
00093 }
00094
00095
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
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
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
00216
00217 template <class _ForwardIter>
00218 _ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last)
00219 {
00220
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
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
00256
00257
00258
00259
00260
00261 template <class _InputIter, class _Tp, class _Size>
00262 void count(_InputIter __first, _InputIter __last, const _Tp& __value,
00263 _Size& __n)
00264 {
00265
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
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
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
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
00321
00322 template <class _ForwardIter1, class _ForwardIter2>
00323 _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
00324 _ForwardIter2 __first2, _ForwardIter2 __last2)
00325 {
00326
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
00334 if (__first1 == __last1 || __first2 == __last2)
00335 return __first1;
00336
00337
00338 _ForwardIter2 __tmp(__first2);
00339 ++__tmp;
00340 if (__tmp == __last2)
00341 return find(__first1, __last1, *__first2);
00342
00343
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
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
00386 if (__first1 == __last1 || __first2 == __last2)
00387 return __first1;
00388
00389
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
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
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
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
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
00508
00509 template <class _ForwardIter1, class _ForwardIter2>
00510 _ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
00511 _ForwardIter2 __first2)
00512 {
00513
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
00529
00530 template <class _InputIter, class _OutputIter, class _UnaryOperation>
00531 _OutputIter transform(_InputIter __first, _InputIter __last,
00532 _OutputIter __result, _UnaryOperation __unary_op)
00533 {
00534
00535 __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
00536
00537
00538
00539
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
00554 __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
00555 __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
00556
00557
00558
00559
00560
00561
00562 for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
00563 *__result = __binary_op(*__first1, *__first2);
00564 return __result;
00565 }
00566
00567
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
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
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
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
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
00636
00637 template <class _ForwardIter, class _Generator>
00638 void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
00639 {
00640
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
00654
00655
00656
00657
00658 for ( ; __n > 0; --__n, ++__first)
00659 *__first = __gen();
00660 return __first;
00661 }
00662
00663
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
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
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
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
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
00736
00737 template <class _InputIter, class _OutputIter, class _Tp>
00738 _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
00739 _OutputIter __result, _Tp*)
00740 {
00741
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
01089
01090
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
01101
01102 template <class _RandomAccessIter>
01103 inline void random_shuffle(_RandomAccessIter __first,
01104 _RandomAccessIter __last)
01105 {
01106
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
02800
02801
02802
02803
02804 template <class _InputIter1, class _InputIter2>
02805 bool includes(_InputIter1 __first1, _InputIter1 __last1,
02806 _InputIter2 __first2, _InputIter2 __last2)
02807 {
02808
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
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
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
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
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
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
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
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
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
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
03125
03126
03127 template <class _ForwardIter>
03128 _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last)
03129 {
03130
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
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
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
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
03195
03196
03197 template <class _BidirectionalIter>
03198 bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
03199 {
03200
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
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
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
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
03342
03343 template <class _InputIter, class _ForwardIter>
03344 _InputIter find_first_of(_InputIter __first1, _InputIter __last1,
03345 _ForwardIter __first2, _ForwardIter __last2)
03346 {
03347
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
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
03385
03386
03387
03388
03389
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
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
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
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
03497
03498 template <class _ForwardIter1, class _ForwardIter2>
03499 inline _ForwardIter1
03500 find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
03501 _ForwardIter2 __first2, _ForwardIter2 __last2)
03502 {
03503
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
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
03536
03537
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
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
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
03592
03593
03594
03595 template <class _ForwardIter>
03596 bool is_sorted(_ForwardIter __first, _ForwardIter __last)
03597 {
03598
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
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 }
03638
03639 #endif
03640
03641
03642
03643