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
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057 #ifndef _STL_ALGO_H
00058 #define _STL_ALGO_H 1
00059
00060 #include <cstdlib>
00061 #include <bits/algorithmfwd.h>
00062 #include <bits/stl_heap.h>
00063 #include <bits/stl_tempbuf.h>
00064
00065
00066
00067 _GLIBCXX_BEGIN_NAMESPACE(std)
00068
00069
00070 template<typename _Iterator>
00071 void
00072 __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
00073 {
00074
00075 __glibcxx_function_requires(_LessThanComparableConcept<
00076 typename iterator_traits<_Iterator>::value_type>)
00077
00078 if (*__a < *__b)
00079 {
00080 if (*__b < *__c)
00081 std::iter_swap(__a, __b);
00082 else if (*__a < *__c)
00083 std::iter_swap(__a, __c);
00084 }
00085 else if (*__a < *__c)
00086 return;
00087 else if (*__b < *__c)
00088 std::iter_swap(__a, __c);
00089 else
00090 std::iter_swap(__a, __b);
00091 }
00092
00093
00094 template<typename _Iterator, typename _Compare>
00095 void
00096 __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
00097 _Compare __comp)
00098 {
00099
00100 __glibcxx_function_requires(_BinaryFunctionConcept<_Compare, bool,
00101 typename iterator_traits<_Iterator>::value_type,
00102 typename iterator_traits<_Iterator>::value_type>)
00103
00104 if (__comp(*__a, *__b))
00105 {
00106 if (__comp(*__b, *__c))
00107 std::iter_swap(__a, __b);
00108 else if (__comp(*__a, *__c))
00109 std::iter_swap(__a, __c);
00110 }
00111 else if (__comp(*__a, *__c))
00112 return;
00113 else if (__comp(*__b, *__c))
00114 std::iter_swap(__a, __c);
00115 else
00116 std::iter_swap(__a, __b);
00117 }
00118
00119
00120
00121
00122 template<typename _InputIterator, typename _Tp>
00123 inline _InputIterator
00124 __find(_InputIterator __first, _InputIterator __last,
00125 const _Tp& __val, input_iterator_tag)
00126 {
00127 while (__first != __last && !(*__first == __val))
00128 ++__first;
00129 return __first;
00130 }
00131
00132
00133 template<typename _InputIterator, typename _Predicate>
00134 inline _InputIterator
00135 __find_if(_InputIterator __first, _InputIterator __last,
00136 _Predicate __pred, input_iterator_tag)
00137 {
00138 while (__first != __last && !bool(__pred(*__first)))
00139 ++__first;
00140 return __first;
00141 }
00142
00143
00144 template<typename _RandomAccessIterator, typename _Tp>
00145 _RandomAccessIterator
00146 __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
00147 const _Tp& __val, random_access_iterator_tag)
00148 {
00149 typename iterator_traits<_RandomAccessIterator>::difference_type
00150 __trip_count = (__last - __first) >> 2;
00151
00152 for (; __trip_count > 0; --__trip_count)
00153 {
00154 if (*__first == __val)
00155 return __first;
00156 ++__first;
00157
00158 if (*__first == __val)
00159 return __first;
00160 ++__first;
00161
00162 if (*__first == __val)
00163 return __first;
00164 ++__first;
00165
00166 if (*__first == __val)
00167 return __first;
00168 ++__first;
00169 }
00170
00171 switch (__last - __first)
00172 {
00173 case 3:
00174 if (*__first == __val)
00175 return __first;
00176 ++__first;
00177 case 2:
00178 if (*__first == __val)
00179 return __first;
00180 ++__first;
00181 case 1:
00182 if (*__first == __val)
00183 return __first;
00184 ++__first;
00185 case 0:
00186 default:
00187 return __last;
00188 }
00189 }
00190
00191
00192 template<typename _RandomAccessIterator, typename _Predicate>
00193 _RandomAccessIterator
00194 __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
00195 _Predicate __pred, random_access_iterator_tag)
00196 {
00197 typename iterator_traits<_RandomAccessIterator>::difference_type
00198 __trip_count = (__last - __first) >> 2;
00199
00200 for (; __trip_count > 0; --__trip_count)
00201 {
00202 if (__pred(*__first))
00203 return __first;
00204 ++__first;
00205
00206 if (__pred(*__first))
00207 return __first;
00208 ++__first;
00209
00210 if (__pred(*__first))
00211 return __first;
00212 ++__first;
00213
00214 if (__pred(*__first))
00215 return __first;
00216 ++__first;
00217 }
00218
00219 switch (__last - __first)
00220 {
00221 case 3:
00222 if (__pred(*__first))
00223 return __first;
00224 ++__first;
00225 case 2:
00226 if (__pred(*__first))
00227 return __first;
00228 ++__first;
00229 case 1:
00230 if (__pred(*__first))
00231 return __first;
00232 ++__first;
00233 case 0:
00234 default:
00235 return __last;
00236 }
00237 }
00238
00239 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00240
00241 template<typename _InputIterator, typename _Predicate>
00242 inline _InputIterator
00243 __find_if_not(_InputIterator __first, _InputIterator __last,
00244 _Predicate __pred, input_iterator_tag)
00245 {
00246 while (__first != __last && bool(__pred(*__first)))
00247 ++__first;
00248 return __first;
00249 }
00250
00251
00252 template<typename _RandomAccessIterator, typename _Predicate>
00253 _RandomAccessIterator
00254 __find_if_not(_RandomAccessIterator __first, _RandomAccessIterator __last,
00255 _Predicate __pred, random_access_iterator_tag)
00256 {
00257 typename iterator_traits<_RandomAccessIterator>::difference_type
00258 __trip_count = (__last - __first) >> 2;
00259
00260 for (; __trip_count > 0; --__trip_count)
00261 {
00262 if (!bool(__pred(*__first)))
00263 return __first;
00264 ++__first;
00265
00266 if (!bool(__pred(*__first)))
00267 return __first;
00268 ++__first;
00269
00270 if (!bool(__pred(*__first)))
00271 return __first;
00272 ++__first;
00273
00274 if (!bool(__pred(*__first)))
00275 return __first;
00276 ++__first;
00277 }
00278
00279 switch (__last - __first)
00280 {
00281 case 3:
00282 if (!bool(__pred(*__first)))
00283 return __first;
00284 ++__first;
00285 case 2:
00286 if (!bool(__pred(*__first)))
00287 return __first;
00288 ++__first;
00289 case 1:
00290 if (!bool(__pred(*__first)))
00291 return __first;
00292 ++__first;
00293 case 0:
00294 default:
00295 return __last;
00296 }
00297 }
00298 #endif
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318 template<typename _ForwardIterator, typename _Integer, typename _Tp>
00319 _ForwardIterator
00320 __search_n(_ForwardIterator __first, _ForwardIterator __last,
00321 _Integer __count, const _Tp& __val,
00322 std::forward_iterator_tag)
00323 {
00324 __first = _GLIBCXX_STD_P::find(__first, __last, __val);
00325 while (__first != __last)
00326 {
00327 typename iterator_traits<_ForwardIterator>::difference_type
00328 __n = __count;
00329 _ForwardIterator __i = __first;
00330 ++__i;
00331 while (__i != __last && __n != 1 && *__i == __val)
00332 {
00333 ++__i;
00334 --__n;
00335 }
00336 if (__n == 1)
00337 return __first;
00338 if (__i == __last)
00339 return __last;
00340 __first = _GLIBCXX_STD_P::find(++__i, __last, __val);
00341 }
00342 return __last;
00343 }
00344
00345
00346
00347
00348
00349
00350 template<typename _RandomAccessIter, typename _Integer, typename _Tp>
00351 _RandomAccessIter
00352 __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
00353 _Integer __count, const _Tp& __val,
00354 std::random_access_iterator_tag)
00355 {
00356
00357 typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
00358 _DistanceType;
00359
00360 _DistanceType __tailSize = __last - __first;
00361 const _DistanceType __pattSize = __count;
00362
00363 if (__tailSize < __pattSize)
00364 return __last;
00365
00366 const _DistanceType __skipOffset = __pattSize - 1;
00367 _RandomAccessIter __lookAhead = __first + __skipOffset;
00368 __tailSize -= __pattSize;
00369
00370 while (1)
00371 {
00372
00373
00374 while (!(*__lookAhead == __val))
00375 {
00376 if (__tailSize < __pattSize)
00377 return __last;
00378 __lookAhead += __pattSize;
00379 __tailSize -= __pattSize;
00380 }
00381 _DistanceType __remainder = __skipOffset;
00382 for (_RandomAccessIter __backTrack = __lookAhead - 1;
00383 *__backTrack == __val; --__backTrack)
00384 {
00385 if (--__remainder == 0)
00386 return (__lookAhead - __skipOffset);
00387 }
00388 if (__remainder > __tailSize)
00389 return __last;
00390 __lookAhead += __remainder;
00391 __tailSize -= __remainder;
00392 }
00393 }
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403 template<typename _ForwardIterator, typename _Integer, typename _Tp,
00404 typename _BinaryPredicate>
00405 _ForwardIterator
00406 __search_n(_ForwardIterator __first, _ForwardIterator __last,
00407 _Integer __count, const _Tp& __val,
00408 _BinaryPredicate __binary_pred, std::forward_iterator_tag)
00409 {
00410 while (__first != __last && !bool(__binary_pred(*__first, __val)))
00411 ++__first;
00412
00413 while (__first != __last)
00414 {
00415 typename iterator_traits<_ForwardIterator>::difference_type
00416 __n = __count;
00417 _ForwardIterator __i = __first;
00418 ++__i;
00419 while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
00420 {
00421 ++__i;
00422 --__n;
00423 }
00424 if (__n == 1)
00425 return __first;
00426 if (__i == __last)
00427 return __last;
00428 __first = ++__i;
00429 while (__first != __last
00430 && !bool(__binary_pred(*__first, __val)))
00431 ++__first;
00432 }
00433 return __last;
00434 }
00435
00436
00437
00438
00439
00440
00441
00442 template<typename _RandomAccessIter, typename _Integer, typename _Tp,
00443 typename _BinaryPredicate>
00444 _RandomAccessIter
00445 __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
00446 _Integer __count, const _Tp& __val,
00447 _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
00448 {
00449
00450 typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
00451 _DistanceType;
00452
00453 _DistanceType __tailSize = __last - __first;
00454 const _DistanceType __pattSize = __count;
00455
00456 if (__tailSize < __pattSize)
00457 return __last;
00458
00459 const _DistanceType __skipOffset = __pattSize - 1;
00460 _RandomAccessIter __lookAhead = __first + __skipOffset;
00461 __tailSize -= __pattSize;
00462
00463 while (1)
00464 {
00465
00466
00467 while (!bool(__binary_pred(*__lookAhead, __val)))
00468 {
00469 if (__tailSize < __pattSize)
00470 return __last;
00471 __lookAhead += __pattSize;
00472 __tailSize -= __pattSize;
00473 }
00474 _DistanceType __remainder = __skipOffset;
00475 for (_RandomAccessIter __backTrack = __lookAhead - 1;
00476 __binary_pred(*__backTrack, __val); --__backTrack)
00477 {
00478 if (--__remainder == 0)
00479 return (__lookAhead - __skipOffset);
00480 }
00481 if (__remainder > __tailSize)
00482 return __last;
00483 __lookAhead += __remainder;
00484 __tailSize -= __remainder;
00485 }
00486 }
00487
00488
00489 template<typename _ForwardIterator1, typename _ForwardIterator2>
00490 _ForwardIterator1
00491 __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
00492 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
00493 forward_iterator_tag, forward_iterator_tag)
00494 {
00495 if (__first2 == __last2)
00496 return __last1;
00497 else
00498 {
00499 _ForwardIterator1 __result = __last1;
00500 while (1)
00501 {
00502 _ForwardIterator1 __new_result
00503 = _GLIBCXX_STD_P::search(__first1, __last1, __first2, __last2);
00504 if (__new_result == __last1)
00505 return __result;
00506 else
00507 {
00508 __result = __new_result;
00509 __first1 = __new_result;
00510 ++__first1;
00511 }
00512 }
00513 }
00514 }
00515
00516 template<typename _ForwardIterator1, typename _ForwardIterator2,
00517 typename _BinaryPredicate>
00518 _ForwardIterator1
00519 __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
00520 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
00521 forward_iterator_tag, forward_iterator_tag,
00522 _BinaryPredicate __comp)
00523 {
00524 if (__first2 == __last2)
00525 return __last1;
00526 else
00527 {
00528 _ForwardIterator1 __result = __last1;
00529 while (1)
00530 {
00531 _ForwardIterator1 __new_result
00532 = _GLIBCXX_STD_P::search(__first1, __last1, __first2,
00533 __last2, __comp);
00534 if (__new_result == __last1)
00535 return __result;
00536 else
00537 {
00538 __result = __new_result;
00539 __first1 = __new_result;
00540 ++__first1;
00541 }
00542 }
00543 }
00544 }
00545
00546
00547 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
00548 _BidirectionalIterator1
00549 __find_end(_BidirectionalIterator1 __first1,
00550 _BidirectionalIterator1 __last1,
00551 _BidirectionalIterator2 __first2,
00552 _BidirectionalIterator2 __last2,
00553 bidirectional_iterator_tag, bidirectional_iterator_tag)
00554 {
00555
00556 __glibcxx_function_requires(_BidirectionalIteratorConcept<
00557 _BidirectionalIterator1>)
00558 __glibcxx_function_requires(_BidirectionalIteratorConcept<
00559 _BidirectionalIterator2>)
00560
00561 typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
00562 typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
00563
00564 _RevIterator1 __rlast1(__first1);
00565 _RevIterator2 __rlast2(__first2);
00566 _RevIterator1 __rresult = _GLIBCXX_STD_P::search(_RevIterator1(__last1),
00567 __rlast1,
00568 _RevIterator2(__last2),
00569 __rlast2);
00570
00571 if (__rresult == __rlast1)
00572 return __last1;
00573 else
00574 {
00575 _BidirectionalIterator1 __result = __rresult.base();
00576 std::advance(__result, -std::distance(__first2, __last2));
00577 return __result;
00578 }
00579 }
00580
00581 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
00582 typename _BinaryPredicate>
00583 _BidirectionalIterator1
00584 __find_end(_BidirectionalIterator1 __first1,
00585 _BidirectionalIterator1 __last1,
00586 _BidirectionalIterator2 __first2,
00587 _BidirectionalIterator2 __last2,
00588 bidirectional_iterator_tag, bidirectional_iterator_tag,
00589 _BinaryPredicate __comp)
00590 {
00591
00592 __glibcxx_function_requires(_BidirectionalIteratorConcept<
00593 _BidirectionalIterator1>)
00594 __glibcxx_function_requires(_BidirectionalIteratorConcept<
00595 _BidirectionalIterator2>)
00596
00597 typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
00598 typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
00599
00600 _RevIterator1 __rlast1(__first1);
00601 _RevIterator2 __rlast2(__first2);
00602 _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
00603 _RevIterator2(__last2), __rlast2,
00604 __comp);
00605
00606 if (__rresult == __rlast1)
00607 return __last1;
00608 else
00609 {
00610 _BidirectionalIterator1 __result = __rresult.base();
00611 std::advance(__result, -std::distance(__first2, __last2));
00612 return __result;
00613 }
00614 }
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641 template<typename _ForwardIterator1, typename _ForwardIterator2>
00642 inline _ForwardIterator1
00643 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
00644 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
00645 {
00646
00647 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
00648 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
00649 __glibcxx_function_requires(_EqualOpConcept<
00650 typename iterator_traits<_ForwardIterator1>::value_type,
00651 typename iterator_traits<_ForwardIterator2>::value_type>)
00652 __glibcxx_requires_valid_range(__first1, __last1);
00653 __glibcxx_requires_valid_range(__first2, __last2);
00654
00655 return std::__find_end(__first1, __last1, __first2, __last2,
00656 std::__iterator_category(__first1),
00657 std::__iterator_category(__first2));
00658 }
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687 template<typename _ForwardIterator1, typename _ForwardIterator2,
00688 typename _BinaryPredicate>
00689 inline _ForwardIterator1
00690 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
00691 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
00692 _BinaryPredicate __comp)
00693 {
00694
00695 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
00696 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
00697 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
00698 typename iterator_traits<_ForwardIterator1>::value_type,
00699 typename iterator_traits<_ForwardIterator2>::value_type>)
00700 __glibcxx_requires_valid_range(__first1, __last1);
00701 __glibcxx_requires_valid_range(__first2, __last2);
00702
00703 return std::__find_end(__first1, __last1, __first2, __last2,
00704 std::__iterator_category(__first1),
00705 std::__iterator_category(__first2),
00706 __comp);
00707 }
00708
00709 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722 template<typename _InputIterator, typename _Predicate>
00723 inline bool
00724 all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
00725 { return __last == std::find_if_not(__first, __last, __pred); }
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739 template<typename _InputIterator, typename _Predicate>
00740 inline bool
00741 none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
00742 { return __last == _GLIBCXX_STD_P::find_if(__first, __last, __pred); }
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756 template<typename _InputIterator, typename _Predicate>
00757 inline bool
00758 any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
00759 { return !std::none_of(__first, __last, __pred); }
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771 template<typename _InputIterator, typename _Predicate>
00772 inline _InputIterator
00773 find_if_not(_InputIterator __first, _InputIterator __last,
00774 _Predicate __pred)
00775 {
00776
00777 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
00778 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
00779 typename iterator_traits<_InputIterator>::value_type>)
00780 __glibcxx_requires_valid_range(__first, __last);
00781 return std::__find_if_not(__first, __last, __pred,
00782 std::__iterator_category(__first));
00783 }
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795 template<typename _InputIterator, typename _Predicate>
00796 inline bool
00797 is_partitioned(_InputIterator __first, _InputIterator __last,
00798 _Predicate __pred)
00799 {
00800 __first = std::find_if_not(__first, __last, __pred);
00801 return std::none_of(__first, __last, __pred);
00802 }
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813 template<typename _ForwardIterator, typename _Predicate>
00814 _ForwardIterator
00815 partition_point(_ForwardIterator __first, _ForwardIterator __last,
00816 _Predicate __pred)
00817 {
00818
00819 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
00820 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
00821 typename iterator_traits<_ForwardIterator>::value_type>)
00822
00823
00824 __glibcxx_requires_valid_range(__first, __last);
00825
00826 typedef typename iterator_traits<_ForwardIterator>::difference_type
00827 _DistanceType;
00828
00829 _DistanceType __len = std::distance(__first, __last);
00830 _DistanceType __half;
00831 _ForwardIterator __middle;
00832
00833 while (__len > 0)
00834 {
00835 __half = __len >> 1;
00836 __middle = __first;
00837 std::advance(__middle, __half);
00838 if (__pred(*__middle))
00839 {
00840 __first = __middle;
00841 ++__first;
00842 __len = __len - __half - 1;
00843 }
00844 else
00845 __len = __half;
00846 }
00847 return __first;
00848 }
00849 #endif
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866 template<typename _InputIterator, typename _OutputIterator, typename _Tp>
00867 _OutputIterator
00868 remove_copy(_InputIterator __first, _InputIterator __last,
00869 _OutputIterator __result, const _Tp& __value)
00870 {
00871
00872 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
00873 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
00874 typename iterator_traits<_InputIterator>::value_type>)
00875 __glibcxx_function_requires(_EqualOpConcept<
00876 typename iterator_traits<_InputIterator>::value_type, _Tp>)
00877 __glibcxx_requires_valid_range(__first, __last);
00878
00879 for (; __first != __last; ++__first)
00880 if (!(*__first == __value))
00881 {
00882 *__result = *__first;
00883 ++__result;
00884 }
00885 return __result;
00886 }
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903 template<typename _InputIterator, typename _OutputIterator,
00904 typename _Predicate>
00905 _OutputIterator
00906 remove_copy_if(_InputIterator __first, _InputIterator __last,
00907 _OutputIterator __result, _Predicate __pred)
00908 {
00909
00910 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
00911 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
00912 typename iterator_traits<_InputIterator>::value_type>)
00913 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
00914 typename iterator_traits<_InputIterator>::value_type>)
00915 __glibcxx_requires_valid_range(__first, __last);
00916
00917 for (; __first != __last; ++__first)
00918 if (!bool(__pred(*__first)))
00919 {
00920 *__result = *__first;
00921 ++__result;
00922 }
00923 return __result;
00924 }
00925
00926 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942 template<typename _InputIterator, typename _OutputIterator,
00943 typename _Predicate>
00944 _OutputIterator
00945 copy_if(_InputIterator __first, _InputIterator __last,
00946 _OutputIterator __result, _Predicate __pred)
00947 {
00948
00949 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
00950 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
00951 typename iterator_traits<_InputIterator>::value_type>)
00952 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
00953 typename iterator_traits<_InputIterator>::value_type>)
00954 __glibcxx_requires_valid_range(__first, __last);
00955
00956 for (; __first != __last; ++__first)
00957 if (__pred(*__first))
00958 {
00959 *__result = *__first;
00960 ++__result;
00961 }
00962 return __result;
00963 }
00964
00965
00966 template<typename _InputIterator, typename _Size, typename _OutputIterator>
00967 _OutputIterator
00968 __copy_n(_InputIterator __first, _Size __n,
00969 _OutputIterator __result, input_iterator_tag)
00970 {
00971 for (; __n > 0; --__n)
00972 {
00973 *__result = *__first;
00974 ++__first;
00975 ++__result;
00976 }
00977 return __result;
00978 }
00979
00980 template<typename _RandomAccessIterator, typename _Size,
00981 typename _OutputIterator>
00982 inline _OutputIterator
00983 __copy_n(_RandomAccessIterator __first, _Size __n,
00984 _OutputIterator __result, random_access_iterator_tag)
00985 { return std::copy(__first, __first + __n, __result); }
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000 template<typename _InputIterator, typename _Size, typename _OutputIterator>
01001 inline _OutputIterator
01002 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
01003 {
01004
01005 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
01006 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
01007 typename iterator_traits<_InputIterator>::value_type>)
01008
01009 return std::__copy_n(__first, __n, __result,
01010 std::__iterator_category(__first));
01011 }
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028 template<typename _InputIterator, typename _OutputIterator1,
01029 typename _OutputIterator2, typename _Predicate>
01030 pair<_OutputIterator1, _OutputIterator2>
01031 partition_copy(_InputIterator __first, _InputIterator __last,
01032 _OutputIterator1 __out_true, _OutputIterator2 __out_false,
01033 _Predicate __pred)
01034 {
01035
01036 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
01037 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
01038 typename iterator_traits<_InputIterator>::value_type>)
01039 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
01040 typename iterator_traits<_InputIterator>::value_type>)
01041 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
01042 typename iterator_traits<_InputIterator>::value_type>)
01043 __glibcxx_requires_valid_range(__first, __last);
01044
01045 for (; __first != __last; ++__first)
01046 if (__pred(*__first))
01047 {
01048 *__out_true = *__first;
01049 ++__out_true;
01050 }
01051 else
01052 {
01053 *__out_false = *__first;
01054 ++__out_false;
01055 }
01056
01057 return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
01058 }
01059 #endif
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078 template<typename _ForwardIterator, typename _Tp>
01079 _ForwardIterator
01080 remove(_ForwardIterator __first, _ForwardIterator __last,
01081 const _Tp& __value)
01082 {
01083
01084 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
01085 _ForwardIterator>)
01086 __glibcxx_function_requires(_EqualOpConcept<
01087 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
01088 __glibcxx_requires_valid_range(__first, __last);
01089
01090 __first = _GLIBCXX_STD_P::find(__first, __last, __value);
01091 if(__first == __last)
01092 return __first;
01093 _ForwardIterator __result = __first;
01094 ++__first;
01095 for(; __first != __last; ++__first)
01096 if(!(*__first == __value))
01097 {
01098 *__result = _GLIBCXX_MOVE(*__first);
01099 ++__result;
01100 }
01101 return __result;
01102 }
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121 template<typename _ForwardIterator, typename _Predicate>
01122 _ForwardIterator
01123 remove_if(_ForwardIterator __first, _ForwardIterator __last,
01124 _Predicate __pred)
01125 {
01126
01127 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
01128 _ForwardIterator>)
01129 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
01130 typename iterator_traits<_ForwardIterator>::value_type>)
01131 __glibcxx_requires_valid_range(__first, __last);
01132
01133 __first = _GLIBCXX_STD_P::find_if(__first, __last, __pred);
01134 if(__first == __last)
01135 return __first;
01136 _ForwardIterator __result = __first;
01137 ++__first;
01138 for(; __first != __last; ++__first)
01139 if(!bool(__pred(*__first)))
01140 {
01141 *__result = _GLIBCXX_MOVE(*__first);
01142 ++__result;
01143 }
01144 return __result;
01145 }
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161 template<typename _ForwardIterator>
01162 _ForwardIterator
01163 unique(_ForwardIterator __first, _ForwardIterator __last)
01164 {
01165
01166 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
01167 _ForwardIterator>)
01168 __glibcxx_function_requires(_EqualityComparableConcept<
01169 typename iterator_traits<_ForwardIterator>::value_type>)
01170 __glibcxx_requires_valid_range(__first, __last);
01171
01172
01173 __first = _GLIBCXX_STD_P::adjacent_find(__first, __last);
01174 if (__first == __last)
01175 return __last;
01176
01177
01178 _ForwardIterator __dest = __first;
01179 ++__first;
01180 while (++__first != __last)
01181 if (!(*__dest == *__first))
01182 *++__dest = _GLIBCXX_MOVE(*__first);
01183 return ++__dest;
01184 }
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201 template<typename _ForwardIterator, typename _BinaryPredicate>
01202 _ForwardIterator
01203 unique(_ForwardIterator __first, _ForwardIterator __last,
01204 _BinaryPredicate __binary_pred)
01205 {
01206
01207 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
01208 _ForwardIterator>)
01209 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
01210 typename iterator_traits<_ForwardIterator>::value_type,
01211 typename iterator_traits<_ForwardIterator>::value_type>)
01212 __glibcxx_requires_valid_range(__first, __last);
01213
01214
01215 __first = _GLIBCXX_STD_P::adjacent_find(__first, __last, __binary_pred);
01216 if (__first == __last)
01217 return __last;
01218
01219
01220 _ForwardIterator __dest = __first;
01221 ++__first;
01222 while (++__first != __last)
01223 if (!bool(__binary_pred(*__dest, *__first)))
01224 *++__dest = _GLIBCXX_MOVE(*__first);
01225 return ++__dest;
01226 }
01227
01228
01229
01230
01231
01232
01233 template<typename _ForwardIterator, typename _OutputIterator>
01234 _OutputIterator
01235 __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
01236 _OutputIterator __result,
01237 forward_iterator_tag, output_iterator_tag)
01238 {
01239
01240 _ForwardIterator __next = __first;
01241 *__result = *__first;
01242 while (++__next != __last)
01243 if (!(*__first == *__next))
01244 {
01245 __first = __next;
01246 *++__result = *__first;
01247 }
01248 return ++__result;
01249 }
01250
01251
01252
01253
01254
01255
01256 template<typename _InputIterator, typename _OutputIterator>
01257 _OutputIterator
01258 __unique_copy(_InputIterator __first, _InputIterator __last,
01259 _OutputIterator __result,
01260 input_iterator_tag, output_iterator_tag)
01261 {
01262
01263 typename iterator_traits<_InputIterator>::value_type __value = *__first;
01264 *__result = __value;
01265 while (++__first != __last)
01266 if (!(__value == *__first))
01267 {
01268 __value = *__first;
01269 *++__result = __value;
01270 }
01271 return ++__result;
01272 }
01273
01274
01275
01276
01277
01278
01279 template<typename _InputIterator, typename _ForwardIterator>
01280 _ForwardIterator
01281 __unique_copy(_InputIterator __first, _InputIterator __last,
01282 _ForwardIterator __result,
01283 input_iterator_tag, forward_iterator_tag)
01284 {
01285
01286 *__result = *__first;
01287 while (++__first != __last)
01288 if (!(*__result == *__first))
01289 *++__result = *__first;
01290 return ++__result;
01291 }
01292
01293
01294
01295
01296
01297
01298
01299 template<typename _ForwardIterator, typename _OutputIterator,
01300 typename _BinaryPredicate>
01301 _OutputIterator
01302 __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
01303 _OutputIterator __result, _BinaryPredicate __binary_pred,
01304 forward_iterator_tag, output_iterator_tag)
01305 {
01306
01307 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
01308 typename iterator_traits<_ForwardIterator>::value_type,
01309 typename iterator_traits<_ForwardIterator>::value_type>)
01310
01311 _ForwardIterator __next = __first;
01312 *__result = *__first;
01313 while (++__next != __last)
01314 if (!bool(__binary_pred(*__first, *__next)))
01315 {
01316 __first = __next;
01317 *++__result = *__first;
01318 }
01319 return ++__result;
01320 }
01321
01322
01323
01324
01325
01326
01327
01328 template<typename _InputIterator, typename _OutputIterator,
01329 typename _BinaryPredicate>
01330 _OutputIterator
01331 __unique_copy(_InputIterator __first, _InputIterator __last,
01332 _OutputIterator __result, _BinaryPredicate __binary_pred,
01333 input_iterator_tag, output_iterator_tag)
01334 {
01335
01336 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
01337 typename iterator_traits<_InputIterator>::value_type,
01338 typename iterator_traits<_InputIterator>::value_type>)
01339
01340 typename iterator_traits<_InputIterator>::value_type __value = *__first;
01341 *__result = __value;
01342 while (++__first != __last)
01343 if (!bool(__binary_pred(__value, *__first)))
01344 {
01345 __value = *__first;
01346 *++__result = __value;
01347 }
01348 return ++__result;
01349 }
01350
01351
01352
01353
01354
01355
01356
01357 template<typename _InputIterator, typename _ForwardIterator,
01358 typename _BinaryPredicate>
01359 _ForwardIterator
01360 __unique_copy(_InputIterator __first, _InputIterator __last,
01361 _ForwardIterator __result, _BinaryPredicate __binary_pred,
01362 input_iterator_tag, forward_iterator_tag)
01363 {
01364
01365 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
01366 typename iterator_traits<_ForwardIterator>::value_type,
01367 typename iterator_traits<_InputIterator>::value_type>)
01368
01369 *__result = *__first;
01370 while (++__first != __last)
01371 if (!bool(__binary_pred(*__result, *__first)))
01372 *++__result = *__first;
01373 return ++__result;
01374 }
01375
01376
01377
01378
01379
01380
01381 template<typename _BidirectionalIterator>
01382 void
01383 __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
01384 bidirectional_iterator_tag)
01385 {
01386 while (true)
01387 if (__first == __last || __first == --__last)
01388 return;
01389 else
01390 {
01391 std::iter_swap(__first, __last);
01392 ++__first;
01393 }
01394 }
01395
01396
01397
01398
01399
01400
01401 template<typename _RandomAccessIterator>
01402 void
01403 __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
01404 random_access_iterator_tag)
01405 {
01406 if (__first == __last)
01407 return;
01408 --__last;
01409 while (__first < __last)
01410 {
01411 std::iter_swap(__first, __last);
01412 ++__first;
01413 --__last;
01414 }
01415 }
01416
01417
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429 template<typename _BidirectionalIterator>
01430 inline void
01431 reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
01432 {
01433
01434 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
01435 _BidirectionalIterator>)
01436 __glibcxx_requires_valid_range(__first, __last);
01437 std::__reverse(__first, __last, std::__iterator_category(__first));
01438 }
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456 template<typename _BidirectionalIterator, typename _OutputIterator>
01457 _OutputIterator
01458 reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
01459 _OutputIterator __result)
01460 {
01461
01462 __glibcxx_function_requires(_BidirectionalIteratorConcept<
01463 _BidirectionalIterator>)
01464 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
01465 typename iterator_traits<_BidirectionalIterator>::value_type>)
01466 __glibcxx_requires_valid_range(__first, __last);
01467
01468 while (__first != __last)
01469 {
01470 --__last;
01471 *__result = *__last;
01472 ++__result;
01473 }
01474 return __result;
01475 }
01476
01477
01478
01479
01480
01481 template<typename _EuclideanRingElement>
01482 _EuclideanRingElement
01483 __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
01484 {
01485 while (__n != 0)
01486 {
01487 _EuclideanRingElement __t = __m % __n;
01488 __m = __n;
01489 __n = __t;
01490 }
01491 return __m;
01492 }
01493
01494
01495 template<typename _ForwardIterator>
01496 void
01497 __rotate(_ForwardIterator __first,
01498 _ForwardIterator __middle,
01499 _ForwardIterator __last,
01500 forward_iterator_tag)
01501 {
01502 if (__first == __middle || __last == __middle)
01503 return;
01504
01505 _ForwardIterator __first2 = __middle;
01506 do
01507 {
01508 std::iter_swap(__first, __first2);
01509 ++__first;
01510 ++__first2;
01511 if (__first == __middle)
01512 __middle = __first2;
01513 }
01514 while (__first2 != __last);
01515
01516 __first2 = __middle;
01517
01518 while (__first2 != __last)
01519 {
01520 std::iter_swap(__first, __first2);
01521 ++__first;
01522 ++__first2;
01523 if (__first == __middle)
01524 __middle = __first2;
01525 else if (__first2 == __last)
01526 __first2 = __middle;
01527 }
01528 }
01529
01530
01531 template<typename _BidirectionalIterator>
01532 void
01533 __rotate(_BidirectionalIterator __first,
01534 _BidirectionalIterator __middle,
01535 _BidirectionalIterator __last,
01536 bidirectional_iterator_tag)
01537 {
01538
01539 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
01540 _BidirectionalIterator>)
01541
01542 if (__first == __middle || __last == __middle)
01543 return;
01544
01545 std::__reverse(__first, __middle, bidirectional_iterator_tag());
01546 std::__reverse(__middle, __last, bidirectional_iterator_tag());
01547
01548 while (__first != __middle && __middle != __last)
01549 {
01550 std::iter_swap(__first, --__last);
01551 ++__first;
01552 }
01553
01554 if (__first == __middle)
01555 std::__reverse(__middle, __last, bidirectional_iterator_tag());
01556 else
01557 std::__reverse(__first, __middle, bidirectional_iterator_tag());
01558 }
01559
01560
01561 template<typename _RandomAccessIterator>
01562 void
01563 __rotate(_RandomAccessIterator __first,
01564 _RandomAccessIterator __middle,
01565 _RandomAccessIterator __last,
01566 random_access_iterator_tag)
01567 {
01568
01569 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
01570 _RandomAccessIterator>)
01571
01572 if (__first == __middle || __last == __middle)
01573 return;
01574
01575 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
01576 _Distance;
01577 typedef typename iterator_traits<_RandomAccessIterator>::value_type
01578 _ValueType;
01579
01580 _Distance __n = __last - __first;
01581 _Distance __k = __middle - __first;
01582
01583 if (__k == __n - __k)
01584 {
01585 std::swap_ranges(__first, __middle, __middle);
01586 return;
01587 }
01588
01589 _RandomAccessIterator __p = __first;
01590
01591 for (;;)
01592 {
01593 if (__k < __n - __k)
01594 {
01595 if (__is_pod(_ValueType) && __k == 1)
01596 {
01597 _ValueType __t = _GLIBCXX_MOVE(*__p);
01598 _GLIBCXX_MOVE3(__p + 1, __p + __n, __p);
01599 *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
01600 return;
01601 }
01602 _RandomAccessIterator __q = __p + __k;
01603 for (_Distance __i = 0; __i < __n - __k; ++ __i)
01604 {
01605 std::iter_swap(__p, __q);
01606 ++__p;
01607 ++__q;
01608 }
01609 __n %= __k;
01610 if (__n == 0)
01611 return;
01612 std::swap(__n, __k);
01613 __k = __n - __k;
01614 }
01615 else
01616 {
01617 __k = __n - __k;
01618 if (__is_pod(_ValueType) && __k == 1)
01619 {
01620 _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1));
01621 _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n);
01622 *__p = _GLIBCXX_MOVE(__t);
01623 return;
01624 }
01625 _RandomAccessIterator __q = __p + __n;
01626 __p = __q - __k;
01627 for (_Distance __i = 0; __i < __n - __k; ++ __i)
01628 {
01629 --__p;
01630 --__q;
01631 std::iter_swap(__p, __q);
01632 }
01633 __n %= __k;
01634 if (__n == 0)
01635 return;
01636 std::swap(__n, __k);
01637 }
01638 }
01639 }
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660 template<typename _ForwardIterator>
01661 inline void
01662 rotate(_ForwardIterator __first, _ForwardIterator __middle,
01663 _ForwardIterator __last)
01664 {
01665
01666 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
01667 _ForwardIterator>)
01668 __glibcxx_requires_valid_range(__first, __middle);
01669 __glibcxx_requires_valid_range(__middle, __last);
01670
01671 typedef typename iterator_traits<_ForwardIterator>::iterator_category
01672 _IterType;
01673 std::__rotate(__first, __middle, __last, _IterType());
01674 }
01675
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694 template<typename _ForwardIterator, typename _OutputIterator>
01695 _OutputIterator
01696 rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
01697 _ForwardIterator __last, _OutputIterator __result)
01698 {
01699
01700 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
01701 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
01702 typename iterator_traits<_ForwardIterator>::value_type>)
01703 __glibcxx_requires_valid_range(__first, __middle);
01704 __glibcxx_requires_valid_range(__middle, __last);
01705
01706 return std::copy(__first, __middle,
01707 std::copy(__middle, __last, __result));
01708 }
01709
01710
01711 template<typename _ForwardIterator, typename _Predicate>
01712 _ForwardIterator
01713 __partition(_ForwardIterator __first, _ForwardIterator __last,
01714 _Predicate __pred, forward_iterator_tag)
01715 {
01716 if (__first == __last)
01717 return __first;
01718
01719 while (__pred(*__first))
01720 if (++__first == __last)
01721 return __first;
01722
01723 _ForwardIterator __next = __first;
01724
01725 while (++__next != __last)
01726 if (__pred(*__next))
01727 {
01728 std::iter_swap(__first, __next);
01729 ++__first;
01730 }
01731
01732 return __first;
01733 }
01734
01735
01736 template<typename _BidirectionalIterator, typename _Predicate>
01737 _BidirectionalIterator
01738 __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
01739 _Predicate __pred, bidirectional_iterator_tag)
01740 {
01741 while (true)
01742 {
01743 while (true)
01744 if (__first == __last)
01745 return __first;
01746 else if (__pred(*__first))
01747 ++__first;
01748 else
01749 break;
01750 --__last;
01751 while (true)
01752 if (__first == __last)
01753 return __first;
01754 else if (!bool(__pred(*__last)))
01755 --__last;
01756 else
01757 break;
01758 std::iter_swap(__first, __last);
01759 ++__first;
01760 }
01761 }
01762
01763
01764
01765
01766 template<typename _ForwardIterator, typename _Predicate, typename _Distance>
01767 _ForwardIterator
01768 __inplace_stable_partition(_ForwardIterator __first,
01769 _ForwardIterator __last,
01770 _Predicate __pred, _Distance __len)
01771 {
01772 if (__len == 1)
01773 return __pred(*__first) ? __last : __first;
01774 _ForwardIterator __middle = __first;
01775 std::advance(__middle, __len / 2);
01776 _ForwardIterator __begin = std::__inplace_stable_partition(__first,
01777 __middle,
01778 __pred,
01779 __len / 2);
01780 _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
01781 __pred,
01782 __len
01783 - __len / 2);
01784 std::rotate(__begin, __middle, __end);
01785 std::advance(__begin, std::distance(__middle, __end));
01786 return __begin;
01787 }
01788
01789
01790 template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
01791 typename _Distance>
01792 _ForwardIterator
01793 __stable_partition_adaptive(_ForwardIterator __first,
01794 _ForwardIterator __last,
01795 _Predicate __pred, _Distance __len,
01796 _Pointer __buffer,
01797 _Distance __buffer_size)
01798 {
01799 if (__len <= __buffer_size)
01800 {
01801 _ForwardIterator __result1 = __first;
01802 _Pointer __result2 = __buffer;
01803 for (; __first != __last; ++__first)
01804 if (__pred(*__first))
01805 {
01806 *__result1 = _GLIBCXX_MOVE(*__first);
01807 ++__result1;
01808 }
01809 else
01810 {
01811 *__result2 = _GLIBCXX_MOVE(*__first);
01812 ++__result2;
01813 }
01814 _GLIBCXX_MOVE3(__buffer, __result2, __result1);
01815 return __result1;
01816 }
01817 else
01818 {
01819 _ForwardIterator __middle = __first;
01820 std::advance(__middle, __len / 2);
01821 _ForwardIterator __begin =
01822 std::__stable_partition_adaptive(__first, __middle, __pred,
01823 __len / 2, __buffer,
01824 __buffer_size);
01825 _ForwardIterator __end =
01826 std::__stable_partition_adaptive(__middle, __last, __pred,
01827 __len - __len / 2,
01828 __buffer, __buffer_size);
01829 std::rotate(__begin, __middle, __end);
01830 std::advance(__begin, std::distance(__middle, __end));
01831 return __begin;
01832 }
01833 }
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846
01847
01848
01849
01850
01851
01852 template<typename _ForwardIterator, typename _Predicate>
01853 _ForwardIterator
01854 stable_partition(_ForwardIterator __first, _ForwardIterator __last,
01855 _Predicate __pred)
01856 {
01857
01858 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
01859 _ForwardIterator>)
01860 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
01861 typename iterator_traits<_ForwardIterator>::value_type>)
01862 __glibcxx_requires_valid_range(__first, __last);
01863
01864 if (__first == __last)
01865 return __first;
01866 else
01867 {
01868 typedef typename iterator_traits<_ForwardIterator>::value_type
01869 _ValueType;
01870 typedef typename iterator_traits<_ForwardIterator>::difference_type
01871 _DistanceType;
01872
01873 _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
01874 __last);
01875 if (__buf.size() > 0)
01876 return
01877 std::__stable_partition_adaptive(__first, __last, __pred,
01878 _DistanceType(__buf.requested_size()),
01879 __buf.begin(),
01880 _DistanceType(__buf.size()));
01881 else
01882 return
01883 std::__inplace_stable_partition(__first, __last, __pred,
01884 _DistanceType(__buf.requested_size()));
01885 }
01886 }
01887
01888
01889 template<typename _RandomAccessIterator>
01890 void
01891 __heap_select(_RandomAccessIterator __first,
01892 _RandomAccessIterator __middle,
01893 _RandomAccessIterator __last)
01894 {
01895 std::make_heap(__first, __middle);
01896 for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
01897 if (*__i < *__first)
01898 std::__pop_heap(__first, __middle, __i);
01899 }
01900
01901
01902 template<typename _RandomAccessIterator, typename _Compare>
01903 void
01904 __heap_select(_RandomAccessIterator __first,
01905 _RandomAccessIterator __middle,
01906 _RandomAccessIterator __last, _Compare __comp)
01907 {
01908 std::make_heap(__first, __middle, __comp);
01909 for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
01910 if (__comp(*__i, *__first))
01911 std::__pop_heap(__first, __middle, __i, __comp);
01912 }
01913
01914
01915
01916
01917
01918
01919
01920
01921
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931
01932
01933
01934 template<typename _InputIterator, typename _RandomAccessIterator>
01935 _RandomAccessIterator
01936 partial_sort_copy(_InputIterator __first, _InputIterator __last,
01937 _RandomAccessIterator __result_first,
01938 _RandomAccessIterator __result_last)
01939 {
01940 typedef typename iterator_traits<_InputIterator>::value_type
01941 _InputValueType;
01942 typedef typename iterator_traits<_RandomAccessIterator>::value_type
01943 _OutputValueType;
01944 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
01945 _DistanceType;
01946
01947
01948 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
01949 __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
01950 _OutputValueType>)
01951 __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
01952 _OutputValueType>)
01953 __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
01954 __glibcxx_requires_valid_range(__first, __last);
01955 __glibcxx_requires_valid_range(__result_first, __result_last);
01956
01957 if (__result_first == __result_last)
01958 return __result_last;
01959 _RandomAccessIterator __result_real_last = __result_first;
01960 while(__first != __last && __result_real_last != __result_last)
01961 {
01962 *__result_real_last = *__first;
01963 ++__result_real_last;
01964 ++__first;
01965 }
01966 std::make_heap(__result_first, __result_real_last);
01967 while (__first != __last)
01968 {
01969 if (*__first < *__result_first)
01970 std::__adjust_heap(__result_first, _DistanceType(0),
01971 _DistanceType(__result_real_last
01972 - __result_first),
01973 _InputValueType(*__first));
01974 ++__first;
01975 }
01976 std::sort_heap(__result_first, __result_real_last);
01977 return __result_real_last;
01978 }
01979
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997
01998
01999
02000 template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
02001 _RandomAccessIterator
02002 partial_sort_copy(_InputIterator __first, _InputIterator __last,
02003 _RandomAccessIterator __result_first,
02004 _RandomAccessIterator __result_last,
02005 _Compare __comp)
02006 {
02007 typedef typename iterator_traits<_InputIterator>::value_type
02008 _InputValueType;
02009 typedef typename iterator_traits<_RandomAccessIterator>::value_type
02010 _OutputValueType;
02011 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
02012 _DistanceType;
02013
02014
02015 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
02016 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
02017 _RandomAccessIterator>)
02018 __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
02019 _OutputValueType>)
02020 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02021 _InputValueType, _OutputValueType>)
02022 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02023 _OutputValueType, _OutputValueType>)
02024 __glibcxx_requires_valid_range(__first, __last);
02025 __glibcxx_requires_valid_range(__result_first, __result_last);
02026
02027 if (__result_first == __result_last)
02028 return __result_last;
02029 _RandomAccessIterator __result_real_last = __result_first;
02030 while(__first != __last && __result_real_last != __result_last)
02031 {
02032 *__result_real_last = *__first;
02033 ++__result_real_last;
02034 ++__first;
02035 }
02036 std::make_heap(__result_first, __result_real_last, __comp);
02037 while (__first != __last)
02038 {
02039 if (__comp(*__first, *__result_first))
02040 std::__adjust_heap(__result_first, _DistanceType(0),
02041 _DistanceType(__result_real_last
02042 - __result_first),
02043 _InputValueType(*__first),
02044 __comp);
02045 ++__first;
02046 }
02047 std::sort_heap(__result_first, __result_real_last, __comp);
02048 return __result_real_last;
02049 }
02050
02051
02052 template<typename _RandomAccessIterator>
02053 void
02054 __unguarded_linear_insert(_RandomAccessIterator __last)
02055 {
02056 typename iterator_traits<_RandomAccessIterator>::value_type
02057 __val = _GLIBCXX_MOVE(*__last);
02058 _RandomAccessIterator __next = __last;
02059 --__next;
02060 while (__val < *__next)
02061 {
02062 *__last = _GLIBCXX_MOVE(*__next);
02063 __last = __next;
02064 --__next;
02065 }
02066 *__last = _GLIBCXX_MOVE(__val);
02067 }
02068
02069
02070 template<typename _RandomAccessIterator, typename _Compare>
02071 void
02072 __unguarded_linear_insert(_RandomAccessIterator __last,
02073 _Compare __comp)
02074 {
02075 typename iterator_traits<_RandomAccessIterator>::value_type
02076 __val = _GLIBCXX_MOVE(*__last);
02077 _RandomAccessIterator __next = __last;
02078 --__next;
02079 while (__comp(__val, *__next))
02080 {
02081 *__last = _GLIBCXX_MOVE(*__next);
02082 __last = __next;
02083 --__next;
02084 }
02085 *__last = _GLIBCXX_MOVE(__val);
02086 }
02087
02088
02089 template<typename _RandomAccessIterator>
02090 void
02091 __insertion_sort(_RandomAccessIterator __first,
02092 _RandomAccessIterator __last)
02093 {
02094 if (__first == __last)
02095 return;
02096
02097 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
02098 {
02099 if (*__i < *__first)
02100 {
02101 typename iterator_traits<_RandomAccessIterator>::value_type
02102 __val = _GLIBCXX_MOVE(*__i);
02103 _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
02104 *__first = _GLIBCXX_MOVE(__val);
02105 }
02106 else
02107 std::__unguarded_linear_insert(__i);
02108 }
02109 }
02110
02111
02112 template<typename _RandomAccessIterator, typename _Compare>
02113 void
02114 __insertion_sort(_RandomAccessIterator __first,
02115 _RandomAccessIterator __last, _Compare __comp)
02116 {
02117 if (__first == __last) return;
02118
02119 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
02120 {
02121 if (__comp(*__i, *__first))
02122 {
02123 typename iterator_traits<_RandomAccessIterator>::value_type
02124 __val = _GLIBCXX_MOVE(*__i);
02125 _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
02126 *__first = _GLIBCXX_MOVE(__val);
02127 }
02128 else
02129 std::__unguarded_linear_insert(__i, __comp);
02130 }
02131 }
02132
02133
02134 template<typename _RandomAccessIterator>
02135 inline void
02136 __unguarded_insertion_sort(_RandomAccessIterator __first,
02137 _RandomAccessIterator __last)
02138 {
02139 typedef typename iterator_traits<_RandomAccessIterator>::value_type
02140 _ValueType;
02141
02142 for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
02143 std::__unguarded_linear_insert(__i);
02144 }
02145
02146
02147 template<typename _RandomAccessIterator, typename _Compare>
02148 inline void
02149 __unguarded_insertion_sort(_RandomAccessIterator __first,
02150 _RandomAccessIterator __last, _Compare __comp)
02151 {
02152 typedef typename iterator_traits<_RandomAccessIterator>::value_type
02153 _ValueType;
02154
02155 for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
02156 std::__unguarded_linear_insert(__i, __comp);
02157 }
02158
02159
02160
02161
02162
02163 enum { _S_threshold = 16 };
02164
02165
02166 template<typename _RandomAccessIterator>
02167 void
02168 __final_insertion_sort(_RandomAccessIterator __first,
02169 _RandomAccessIterator __last)
02170 {
02171 if (__last - __first > int(_S_threshold))
02172 {
02173 std::__insertion_sort(__first, __first + int(_S_threshold));
02174 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
02175 }
02176 else
02177 std::__insertion_sort(__first, __last);
02178 }
02179
02180
02181 template<typename _RandomAccessIterator, typename _Compare>
02182 void
02183 __final_insertion_sort(_RandomAccessIterator __first,
02184 _RandomAccessIterator __last, _Compare __comp)
02185 {
02186 if (__last - __first > int(_S_threshold))
02187 {
02188 std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
02189 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
02190 __comp);
02191 }
02192 else
02193 std::__insertion_sort(__first, __last, __comp);
02194 }
02195
02196
02197 template<typename _RandomAccessIterator, typename _Tp>
02198 _RandomAccessIterator
02199 __unguarded_partition(_RandomAccessIterator __first,
02200 _RandomAccessIterator __last, const _Tp& __pivot)
02201 {
02202 while (true)
02203 {
02204 while (*__first < __pivot)
02205 ++__first;
02206 --__last;
02207 while (__pivot < *__last)
02208 --__last;
02209 if (!(__first < __last))
02210 return __first;
02211 std::iter_swap(__first, __last);
02212 ++__first;
02213 }
02214 }
02215
02216
02217 template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
02218 _RandomAccessIterator
02219 __unguarded_partition(_RandomAccessIterator __first,
02220 _RandomAccessIterator __last,
02221 const _Tp& __pivot, _Compare __comp)
02222 {
02223 while (true)
02224 {
02225 while (__comp(*__first, __pivot))
02226 ++__first;
02227 --__last;
02228 while (__comp(__pivot, *__last))
02229 --__last;
02230 if (!(__first < __last))
02231 return __first;
02232 std::iter_swap(__first, __last);
02233 ++__first;
02234 }
02235 }
02236
02237
02238 template<typename _RandomAccessIterator>
02239 inline _RandomAccessIterator
02240 __unguarded_partition_pivot(_RandomAccessIterator __first,
02241 _RandomAccessIterator __last)
02242 {
02243 _RandomAccessIterator __mid = __first + (__last - __first) / 2;
02244 std::__move_median_first(__first, __mid, (__last - 1));
02245 return std::__unguarded_partition(__first + 1, __last, *__first);
02246 }
02247
02248
02249
02250 template<typename _RandomAccessIterator, typename _Compare>
02251 inline _RandomAccessIterator
02252 __unguarded_partition_pivot(_RandomAccessIterator __first,
02253 _RandomAccessIterator __last, _Compare __comp)
02254 {
02255 _RandomAccessIterator __mid = __first + (__last - __first) / 2;
02256 std::__move_median_first(__first, __mid, (__last - 1), __comp);
02257 return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
02258 }
02259
02260
02261 template<typename _RandomAccessIterator, typename _Size>
02262 void
02263 __introsort_loop(_RandomAccessIterator __first,
02264 _RandomAccessIterator __last,
02265 _Size __depth_limit)
02266 {
02267 while (__last - __first > int(_S_threshold))
02268 {
02269 if (__depth_limit == 0)
02270 {
02271 _GLIBCXX_STD_P::partial_sort(__first, __last, __last);
02272 return;
02273 }
02274 --__depth_limit;
02275 _RandomAccessIterator __cut =
02276 std::__unguarded_partition_pivot(__first, __last);
02277 std::__introsort_loop(__cut, __last, __depth_limit);
02278 __last = __cut;
02279 }
02280 }
02281
02282
02283 template<typename _RandomAccessIterator, typename _Size, typename _Compare>
02284 void
02285 __introsort_loop(_RandomAccessIterator __first,
02286 _RandomAccessIterator __last,
02287 _Size __depth_limit, _Compare __comp)
02288 {
02289 while (__last - __first > int(_S_threshold))
02290 {
02291 if (__depth_limit == 0)
02292 {
02293 _GLIBCXX_STD_P::partial_sort(__first, __last, __last, __comp);
02294 return;
02295 }
02296 --__depth_limit;
02297 _RandomAccessIterator __cut =
02298 std::__unguarded_partition_pivot(__first, __last, __comp);
02299 std::__introsort_loop(__cut, __last, __depth_limit, __comp);
02300 __last = __cut;
02301 }
02302 }
02303
02304
02305 template<typename _Size>
02306 inline _Size
02307 __lg(_Size __n)
02308 {
02309 _Size __k;
02310 for (__k = 0; __n != 0; __n >>= 1)
02311 ++__k;
02312 return __k - 1;
02313 }
02314
02315 inline int
02316 __lg(int __n)
02317 { return sizeof(int) * __CHAR_BIT__ - 1 - __builtin_clz(__n); }
02318
02319 inline long
02320 __lg(long __n)
02321 { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }
02322
02323 inline long long
02324 __lg(long long __n)
02325 { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }
02326
02327
02328
02329 template<typename _RandomAccessIterator, typename _Size>
02330 void
02331 __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
02332 _RandomAccessIterator __last, _Size __depth_limit)
02333 {
02334 typedef typename iterator_traits<_RandomAccessIterator>::value_type
02335 _ValueType;
02336
02337 while (__last - __first > 3)
02338 {
02339 if (__depth_limit == 0)
02340 {
02341 std::__heap_select(__first, __nth + 1, __last);
02342
02343
02344 std::iter_swap(__first, __nth);
02345 return;
02346 }
02347 --__depth_limit;
02348 _RandomAccessIterator __cut =
02349 std::__unguarded_partition_pivot(__first, __last);
02350 if (__cut <= __nth)
02351 __first = __cut;
02352 else
02353 __last = __cut;
02354 }
02355 std::__insertion_sort(__first, __last);
02356 }
02357
02358 template<typename _RandomAccessIterator, typename _Size, typename _Compare>
02359 void
02360 __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
02361 _RandomAccessIterator __last, _Size __depth_limit,
02362 _Compare __comp)
02363 {
02364 typedef typename iterator_traits<_RandomAccessIterator>::value_type
02365 _ValueType;
02366
02367 while (__last - __first > 3)
02368 {
02369 if (__depth_limit == 0)
02370 {
02371 std::__heap_select(__first, __nth + 1, __last, __comp);
02372
02373 std::iter_swap(__first, __nth);
02374 return;
02375 }
02376 --__depth_limit;
02377 _RandomAccessIterator __cut =
02378 std::__unguarded_partition_pivot(__first, __last, __comp);
02379 if (__cut <= __nth)
02380 __first = __cut;
02381 else
02382 __last = __cut;
02383 }
02384 std::__insertion_sort(__first, __last, __comp);
02385 }
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400 template<typename _ForwardIterator, typename _Tp>
02401 _ForwardIterator
02402 lower_bound(_ForwardIterator __first, _ForwardIterator __last,
02403 const _Tp& __val)
02404 {
02405 typedef typename iterator_traits<_ForwardIterator>::value_type
02406 _ValueType;
02407 typedef typename iterator_traits<_ForwardIterator>::difference_type
02408 _DistanceType;
02409
02410
02411 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02412 __glibcxx_function_requires(_LessThanOpConcept<_ValueType, _Tp>)
02413 __glibcxx_requires_partitioned_lower(__first, __last, __val);
02414
02415 _DistanceType __len = std::distance(__first, __last);
02416 _DistanceType __half;
02417 _ForwardIterator __middle;
02418
02419 while (__len > 0)
02420 {
02421 __half = __len >> 1;
02422 __middle = __first;
02423 std::advance(__middle, __half);
02424 if (*__middle < __val)
02425 {
02426 __first = __middle;
02427 ++__first;
02428 __len = __len - __half - 1;
02429 }
02430 else
02431 __len = __half;
02432 }
02433 return __first;
02434 }
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452 template<typename _ForwardIterator, typename _Tp, typename _Compare>
02453 _ForwardIterator
02454 lower_bound(_ForwardIterator __first, _ForwardIterator __last,
02455 const _Tp& __val, _Compare __comp)
02456 {
02457 typedef typename iterator_traits<_ForwardIterator>::value_type
02458 _ValueType;
02459 typedef typename iterator_traits<_ForwardIterator>::difference_type
02460 _DistanceType;
02461
02462
02463 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02464 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02465 _ValueType, _Tp>)
02466 __glibcxx_requires_partitioned_lower_pred(__first, __last,
02467 __val, __comp);
02468
02469 _DistanceType __len = std::distance(__first, __last);
02470 _DistanceType __half;
02471 _ForwardIterator __middle;
02472
02473 while (__len > 0)
02474 {
02475 __half = __len >> 1;
02476 __middle = __first;
02477 std::advance(__middle, __half);
02478 if (__comp(*__middle, __val))
02479 {
02480 __first = __middle;
02481 ++__first;
02482 __len = __len - __half - 1;
02483 }
02484 else
02485 __len = __half;
02486 }
02487 return __first;
02488 }
02489
02490
02491
02492
02493
02494
02495
02496
02497
02498
02499
02500
02501 template<typename _ForwardIterator, typename _Tp>
02502 _ForwardIterator
02503 upper_bound(_ForwardIterator __first, _ForwardIterator __last,
02504 const _Tp& __val)
02505 {
02506 typedef typename iterator_traits<_ForwardIterator>::value_type
02507 _ValueType;
02508 typedef typename iterator_traits<_ForwardIterator>::difference_type
02509 _DistanceType;
02510
02511
02512 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02513 __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
02514 __glibcxx_requires_partitioned_upper(__first, __last, __val);
02515
02516 _DistanceType __len = std::distance(__first, __last);
02517 _DistanceType __half;
02518 _ForwardIterator __middle;
02519
02520 while (__len > 0)
02521 {
02522 __half = __len >> 1;
02523 __middle = __first;
02524 std::advance(__middle, __half);
02525 if (__val < *__middle)
02526 __len = __half;
02527 else
02528 {
02529 __first = __middle;
02530 ++__first;
02531 __len = __len - __half - 1;
02532 }
02533 }
02534 return __first;
02535 }
02536
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551
02552 template<typename _ForwardIterator, typename _Tp, typename _Compare>
02553 _ForwardIterator
02554 upper_bound(_ForwardIterator __first, _ForwardIterator __last,
02555 const _Tp& __val, _Compare __comp)
02556 {
02557 typedef typename iterator_traits<_ForwardIterator>::value_type
02558 _ValueType;
02559 typedef typename iterator_traits<_ForwardIterator>::difference_type
02560 _DistanceType;
02561
02562
02563 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02564 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02565 _Tp, _ValueType>)
02566 __glibcxx_requires_partitioned_upper_pred(__first, __last,
02567 __val, __comp);
02568
02569 _DistanceType __len = std::distance(__first, __last);
02570 _DistanceType __half;
02571 _ForwardIterator __middle;
02572
02573 while (__len > 0)
02574 {
02575 __half = __len >> 1;
02576 __middle = __first;
02577 std::advance(__middle, __half);
02578 if (__comp(__val, *__middle))
02579 __len = __half;
02580 else
02581 {
02582 __first = __middle;
02583 ++__first;
02584 __len = __len - __half - 1;
02585 }
02586 }
02587 return __first;
02588 }
02589
02590
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607 template<typename _ForwardIterator, typename _Tp>
02608 pair<_ForwardIterator, _ForwardIterator>
02609 equal_range(_ForwardIterator __first, _ForwardIterator __last,
02610 const _Tp& __val)
02611 {
02612 typedef typename iterator_traits<_ForwardIterator>::value_type
02613 _ValueType;
02614 typedef typename iterator_traits<_ForwardIterator>::difference_type
02615 _DistanceType;
02616
02617
02618 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02619 __glibcxx_function_requires(_LessThanOpConcept<_ValueType, _Tp>)
02620 __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
02621 __glibcxx_requires_partitioned_lower(__first, __last, __val);
02622 __glibcxx_requires_partitioned_upper(__first, __last, __val);
02623
02624 _DistanceType __len = std::distance(__first, __last);
02625 _DistanceType __half;
02626 _ForwardIterator __middle, __left, __right;
02627
02628 while (__len > 0)
02629 {
02630 __half = __len >> 1;
02631 __middle = __first;
02632 std::advance(__middle, __half);
02633 if (*__middle < __val)
02634 {
02635 __first = __middle;
02636 ++__first;
02637 __len = __len - __half - 1;
02638 }
02639 else if (__val < *__middle)
02640 __len = __half;
02641 else
02642 {
02643 __left = std::lower_bound(__first, __middle, __val);
02644 std::advance(__first, __len);
02645 __right = std::upper_bound(++__middle, __first, __val);
02646 return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
02647 }
02648 }
02649 return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
02650 }
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669 template<typename _ForwardIterator, typename _Tp, typename _Compare>
02670 pair<_ForwardIterator, _ForwardIterator>
02671 equal_range(_ForwardIterator __first, _ForwardIterator __last,
02672 const _Tp& __val,
02673 _Compare __comp)
02674 {
02675 typedef typename iterator_traits<_ForwardIterator>::value_type
02676 _ValueType;
02677 typedef typename iterator_traits<_ForwardIterator>::difference_type
02678 _DistanceType;
02679
02680
02681 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02682 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02683 _ValueType, _Tp>)
02684 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02685 _Tp, _ValueType>)
02686 __glibcxx_requires_partitioned_lower_pred(__first, __last,
02687 __val, __comp);
02688 __glibcxx_requires_partitioned_upper_pred(__first, __last,
02689 __val, __comp);
02690
02691 _DistanceType __len = std::distance(__first, __last);
02692 _DistanceType __half;
02693 _ForwardIterator __middle, __left, __right;
02694
02695 while (__len > 0)
02696 {
02697 __half = __len >> 1;
02698 __middle = __first;
02699 std::advance(__middle, __half);
02700 if (__comp(*__middle, __val))
02701 {
02702 __first = __middle;
02703 ++__first;
02704 __len = __len - __half - 1;
02705 }
02706 else if (__comp(__val, *__middle))
02707 __len = __half;
02708 else
02709 {
02710 __left = std::lower_bound(__first, __middle, __val, __comp);
02711 std::advance(__first, __len);
02712 __right = std::upper_bound(++__middle, __first, __val, __comp);
02713 return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
02714 }
02715 }
02716 return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
02717 }
02718
02719
02720
02721
02722
02723
02724
02725
02726
02727
02728
02729
02730 template<typename _ForwardIterator, typename _Tp>
02731 bool
02732 binary_search(_ForwardIterator __first, _ForwardIterator __last,
02733 const _Tp& __val)
02734 {
02735 typedef typename iterator_traits<_ForwardIterator>::value_type
02736 _ValueType;
02737
02738
02739 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02740 __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
02741 __glibcxx_requires_partitioned_lower(__first, __last, __val);
02742 __glibcxx_requires_partitioned_upper(__first, __last, __val);
02743
02744 _ForwardIterator __i = std::lower_bound(__first, __last, __val);
02745 return __i != __last && !(__val < *__i);
02746 }
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758
02759
02760
02761
02762
02763 template<typename _ForwardIterator, typename _Tp, typename _Compare>
02764 bool
02765 binary_search(_ForwardIterator __first, _ForwardIterator __last,
02766 const _Tp& __val, _Compare __comp)
02767 {
02768 typedef typename iterator_traits<_ForwardIterator>::value_type
02769 _ValueType;
02770
02771
02772 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
02773 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
02774 _Tp, _ValueType>)
02775 __glibcxx_requires_partitioned_lower_pred(__first, __last,
02776 __val, __comp);
02777 __glibcxx_requires_partitioned_upper_pred(__first, __last,
02778 __val, __comp);
02779
02780 _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
02781 return __i != __last && !bool(__comp(__val, *__i));
02782 }
02783
02784
02785
02786
02787 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
02788 typename _BidirectionalIterator3>
02789 _BidirectionalIterator3
02790 __merge_backward(_BidirectionalIterator1 __first1,
02791 _BidirectionalIterator1 __last1,
02792 _BidirectionalIterator2 __first2,
02793 _BidirectionalIterator2 __last2,
02794 _BidirectionalIterator3 __result)
02795 {
02796 if (__first1 == __last1)
02797 return std::copy_backward(__first2, __last2, __result);
02798 if (__first2 == __last2)
02799 return std::copy_backward(__first1, __last1, __result);
02800 --__last1;
02801 --__last2;
02802 while (true)
02803 {
02804 if (*__last2 < *__last1)
02805 {
02806 *--__result = *__last1;
02807 if (__first1 == __last1)
02808 return std::copy_backward(__first2, ++__last2, __result);
02809 --__last1;
02810 }
02811 else
02812 {
02813 *--__result = *__last2;
02814 if (__first2 == __last2)
02815 return std::copy_backward(__first1, ++__last1, __result);
02816 --__last2;
02817 }
02818 }
02819 }
02820
02821
02822 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
02823 typename _BidirectionalIterator3, typename _Compare>
02824 _BidirectionalIterator3
02825 __merge_backward(_BidirectionalIterator1 __first1,
02826 _BidirectionalIterator1 __last1,
02827 _BidirectionalIterator2 __first2,
02828 _BidirectionalIterator2 __last2,
02829 _BidirectionalIterator3 __result,
02830 _Compare __comp)
02831 {
02832 if (__first1 == __last1)
02833 return std::copy_backward(__first2, __last2, __result);
02834 if (__first2 == __last2)
02835 return std::copy_backward(__first1, __last1, __result);
02836 --__last1;
02837 --__last2;
02838 while (true)
02839 {
02840 if (__comp(*__last2, *__last1))
02841 {
02842 *--__result = *__last1;
02843 if (__first1 == __last1)
02844 return std::copy_backward(__first2, ++__last2, __result);
02845 --__last1;
02846 }
02847 else
02848 {
02849 *--__result = *__last2;
02850 if (__first2 == __last2)
02851 return std::copy_backward(__first1, ++__last1, __result);
02852 --__last2;
02853 }
02854 }
02855 }
02856
02857
02858 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
02859 typename _Distance>
02860 _BidirectionalIterator1
02861 __rotate_adaptive(_BidirectionalIterator1 __first,
02862 _BidirectionalIterator1 __middle,
02863 _BidirectionalIterator1 __last,
02864 _Distance __len1, _Distance __len2,
02865 _BidirectionalIterator2 __buffer,
02866 _Distance __buffer_size)
02867 {
02868 _BidirectionalIterator2 __buffer_end;
02869 if (__len1 > __len2 && __len2 <= __buffer_size)
02870 {
02871 __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
02872 _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last);
02873 return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first);
02874 }
02875 else if (__len1 <= __buffer_size)
02876 {
02877 __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
02878 _GLIBCXX_MOVE3(__middle, __last, __first);
02879 return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last);
02880 }
02881 else
02882 {
02883 std::rotate(__first, __middle, __last);
02884 std::advance(__first, std::distance(__middle, __last));
02885 return __first;
02886 }
02887 }
02888
02889
02890 template<typename _BidirectionalIterator, typename _Distance,
02891 typename _Pointer>
02892 void
02893 __merge_adaptive(_BidirectionalIterator __first,
02894 _BidirectionalIterator __middle,
02895 _BidirectionalIterator __last,
02896 _Distance __len1, _Distance __len2,
02897 _Pointer __buffer, _Distance __buffer_size)
02898 {
02899 if (__len1 <= __len2 && __len1 <= __buffer_size)
02900 {
02901 _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
02902 _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
02903 _GLIBCXX_MAKE_MOVE_ITERATOR(__buffer_end),
02904 _GLIBCXX_MAKE_MOVE_ITERATOR(__middle),
02905 _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
02906 __first);
02907 }
02908 else if (__len2 <= __buffer_size)
02909 {
02910 _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
02911 std::__merge_backward(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
02912 _GLIBCXX_MAKE_MOVE_ITERATOR(__middle),
02913 _GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
02914 _GLIBCXX_MAKE_MOVE_ITERATOR(__buffer_end),
02915 __last);
02916 }
02917 else
02918 {
02919 _BidirectionalIterator __first_cut = __first;
02920 _BidirectionalIterator __second_cut = __middle;
02921 _Distance __len11 = 0;
02922 _Distance __len22 = 0;
02923 if (__len1 > __len2)
02924 {
02925 __len11 = __len1 / 2;
02926 std::advance(__first_cut, __len11);
02927 __second_cut = std::lower_bound(__middle, __last,
02928 *__first_cut);
02929 __len22 = std::distance(__middle, __second_cut);
02930 }
02931 else
02932 {
02933 __len22 = __len2 / 2;
02934 std::advance(__second_cut, __len22);
02935 __first_cut = std::upper_bound(__first, __middle,
02936 *__second_cut);
02937 __len11 = std::distance(__first, __first_cut);
02938 }
02939 _BidirectionalIterator __new_middle =
02940 std::__rotate_adaptive(__first_cut, __middle, __second_cut,
02941 __len1 - __len11, __len22, __buffer,
02942 __buffer_size);
02943 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
02944 __len22, __buffer, __buffer_size);
02945 std::__merge_adaptive(__new_middle, __second_cut, __last,
02946 __len1 - __len11,
02947 __len2 - __len22, __buffer, __buffer_size);
02948 }
02949 }
02950
02951
02952 template<typename _BidirectionalIterator, typename _Distance,
02953 typename _Pointer, typename _Compare>
02954 void
02955 __merge_adaptive(_BidirectionalIterator __first,
02956 _BidirectionalIterator __middle,
02957 _BidirectionalIterator __last,
02958 _Distance __len1, _Distance __len2,
02959 _Pointer __buffer, _Distance __buffer_size,
02960 _Compare __comp)
02961 {
02962 if (__len1 <= __len2 && __len1 <= __buffer_size)
02963 {
02964 _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
02965 _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
02966 _GLIBCXX_MAKE_MOVE_ITERATOR(__buffer_end),
02967 _GLIBCXX_MAKE_MOVE_ITERATOR(__middle),
02968 _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
02969 __first, __comp);
02970 }
02971 else if (__len2 <= __buffer_size)
02972 {
02973 _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
02974 std::__merge_backward(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
02975 _GLIBCXX_MAKE_MOVE_ITERATOR(__middle),
02976 _GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
02977 _GLIBCXX_MAKE_MOVE_ITERATOR(__buffer_end),
02978 __last,__comp);
02979 }
02980 else
02981 {
02982 _BidirectionalIterator __first_cut = __first;
02983 _BidirectionalIterator __second_cut = __middle;
02984 _Distance __len11 = 0;
02985 _Distance __len22 = 0;
02986 if (__len1 > __len2)
02987 {
02988 __len11 = __len1 / 2;
02989 std::advance(__first_cut, __len11);
02990 __second_cut = std::lower_bound(__middle, __last, *__first_cut,
02991 __comp);
02992 __len22 = std::distance(__middle, __second_cut);
02993 }
02994 else
02995 {
02996 __len22 = __len2 / 2;
02997 std::advance(__second_cut, __len22);
02998 __first_cut = std::upper_bound(__first, __middle, *__second_cut,
02999 __comp);
03000 __len11 = std::distance(__first, __first_cut);
03001 }
03002 _BidirectionalIterator __new_middle =
03003 std::__rotate_adaptive(__first_cut, __middle, __second_cut,
03004 __len1 - __len11, __len22, __buffer,
03005 __buffer_size);
03006 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
03007 __len22, __buffer, __buffer_size, __comp);
03008 std::__merge_adaptive(__new_middle, __second_cut, __last,
03009 __len1 - __len11,
03010 __len2 - __len22, __buffer,
03011 __buffer_size, __comp);
03012 }
03013 }
03014
03015
03016 template<typename _BidirectionalIterator, typename _Distance>
03017 void
03018 __merge_without_buffer(_BidirectionalIterator __first,
03019 _BidirectionalIterator __middle,
03020 _BidirectionalIterator __last,
03021 _Distance __len1, _Distance __len2)
03022 {
03023 if (__len1 == 0 || __len2 == 0)
03024 return;
03025 if (__len1 + __len2 == 2)
03026 {
03027 if (*__middle < *__first)
03028 std::iter_swap(__first, __middle);
03029 return;
03030 }
03031 _BidirectionalIterator __first_cut = __first;
03032 _BidirectionalIterator __second_cut = __middle;
03033 _Distance __len11 = 0;
03034 _Distance __len22 = 0;
03035 if (__len1 > __len2)
03036 {
03037 __len11 = __len1 / 2;
03038 std::advance(__first_cut, __len11);
03039 __second_cut = std::lower_bound(__middle, __last, *__first_cut);
03040 __len22 = std::distance(__middle, __second_cut);
03041 }
03042 else
03043 {
03044 __len22 = __len2 / 2;
03045 std::advance(__second_cut, __len22);
03046 __first_cut = std::upper_bound(__first, __middle, *__second_cut);
03047 __len11 = std::distance(__first, __first_cut);
03048 }
03049 std::rotate(__first_cut, __middle, __second_cut);
03050 _BidirectionalIterator __new_middle = __first_cut;
03051 std::advance(__new_middle, std::distance(__middle, __second_cut));
03052 std::__merge_without_buffer(__first, __first_cut, __new_middle,
03053 __len11, __len22);
03054 std::__merge_without_buffer(__new_middle, __second_cut, __last,
03055 __len1 - __len11, __len2 - __len22);
03056 }
03057
03058
03059 template<typename _BidirectionalIterator, typename _Distance,
03060 typename _Compare>
03061 void
03062 __merge_without_buffer(_BidirectionalIterator __first,
03063 _BidirectionalIterator __middle,
03064 _BidirectionalIterator __last,
03065 _Distance __len1, _Distance __len2,
03066 _Compare __comp)
03067 {
03068 if (__len1 == 0 || __len2 == 0)
03069 return;
03070 if (__len1 + __len2 == 2)
03071 {
03072 if (__comp(*__middle, *__first))
03073 std::iter_swap(__first, __middle);
03074 return;
03075 }
03076 _BidirectionalIterator __first_cut = __first;
03077 _BidirectionalIterator __second_cut = __middle;
03078 _Distance __len11 = 0;
03079 _Distance __len22 = 0;
03080 if (__len1 > __len2)
03081 {
03082 __len11 = __len1 / 2;
03083 std::advance(__first_cut, __len11);
03084 __second_cut = std::lower_bound(__middle, __last, *__first_cut,
03085 __comp);
03086 __len22 = std::distance(__middle, __second_cut);
03087 }
03088 else
03089 {
03090 __len22 = __len2 / 2;
03091 std::advance(__second_cut, __len22);
03092 __first_cut = std::upper_bound(__first, __middle, *__second_cut,
03093 __comp);
03094 __len11 = std::distance(__first, __first_cut);
03095 }
03096 std::rotate(__first_cut, __middle, __second_cut);
03097 _BidirectionalIterator __new_middle = __first_cut;
03098 std::advance(__new_middle, std::distance(__middle, __second_cut));
03099 std::__merge_without_buffer(__first, __first_cut, __new_middle,
03100 __len11, __len22, __comp);
03101 std::__merge_without_buffer(__new_middle, __second_cut, __last,
03102 __len1 - __len11, __len2 - __len22, __comp);
03103 }
03104
03105
03106
03107
03108
03109
03110
03111
03112
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123 template<typename _BidirectionalIterator>
03124 void
03125 inplace_merge(_BidirectionalIterator __first,
03126 _BidirectionalIterator __middle,
03127 _BidirectionalIterator __last)
03128 {
03129 typedef typename iterator_traits<_BidirectionalIterator>::value_type
03130 _ValueType;
03131 typedef typename iterator_traits<_BidirectionalIterator>::difference_type
03132 _DistanceType;
03133
03134
03135 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
03136 _BidirectionalIterator>)
03137 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
03138 __glibcxx_requires_sorted(__first, __middle);
03139 __glibcxx_requires_sorted(__middle, __last);
03140
03141 if (__first == __middle || __middle == __last)
03142 return;
03143
03144 _DistanceType __len1 = std::distance(__first, __middle);
03145 _DistanceType __len2 = std::distance(__middle, __last);
03146
03147 _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
03148 __last);
03149 if (__buf.begin() == 0)
03150 std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
03151 else
03152 std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
03153 __buf.begin(), _DistanceType(__buf.size()));
03154 }
03155
03156
03157
03158
03159
03160
03161
03162
03163
03164
03165
03166
03167
03168
03169
03170
03171
03172
03173
03174
03175
03176
03177
03178 template<typename _BidirectionalIterator, typename _Compare>
03179 void
03180 inplace_merge(_BidirectionalIterator __first,
03181 _BidirectionalIterator __middle,
03182 _BidirectionalIterator __last,
03183 _Compare __comp)
03184 {
03185 typedef typename iterator_traits<_BidirectionalIterator>::value_type
03186 _ValueType;
03187 typedef typename iterator_traits<_BidirectionalIterator>::difference_type
03188 _DistanceType;
03189
03190
03191 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
03192 _BidirectionalIterator>)
03193 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
03194 _ValueType, _ValueType>)
03195 __glibcxx_requires_sorted_pred(__first, __middle, __comp);
03196 __glibcxx_requires_sorted_pred(__middle, __last, __comp);
03197
03198 if (__first == __middle || __middle == __last)
03199 return;
03200
03201 const _DistanceType __len1 = std::distance(__first, __middle);
03202 const _DistanceType __len2 = std::distance(__middle, __last);
03203
03204 _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
03205 __last);
03206 if (__buf.begin() == 0)
03207 std::__merge_without_buffer(__first, __middle, __last, __len1,
03208 __len2, __comp);
03209 else
03210 std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
03211 __buf.begin(), _DistanceType(__buf.size()),
03212 __comp);
03213 }
03214
03215 template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
03216 typename _Distance>
03217 void
03218 __merge_sort_loop(_RandomAccessIterator1 __first,
03219 _RandomAccessIterator1 __last,
03220 _RandomAccessIterator2 __result,
03221 _Distance __step_size)
03222 {
03223 const _Distance __two_step = 2 * __step_size;
03224
03225 while (__last - __first >= __two_step)
03226 {
03227 __result = _GLIBCXX_STD_P::merge(
03228 _GLIBCXX_MAKE_MOVE_ITERATOR(__first),
03229 _GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
03230 _GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
03231 _GLIBCXX_MAKE_MOVE_ITERATOR(__first + __two_step),
03232 __result);
03233 __first += __two_step;
03234 }
03235
03236 __step_size = std::min(_Distance(__last - __first), __step_size);
03237 _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
03238 _GLIBCXX_MAKE_MOVE_ITERATOR(__first +
03239 __step_size),
03240 _GLIBCXX_MAKE_MOVE_ITERATOR(__first +
03241 __step_size),
03242 _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
03243 __result);
03244 }
03245
03246 template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
03247 typename _Distance, typename _Compare>
03248 void
03249 __merge_sort_loop(_RandomAccessIterator1 __first,
03250 _RandomAccessIterator1 __last,
03251 _RandomAccessIterator2 __result, _Distance __step_size,
03252 _Compare __comp)
03253 {
03254 const _Distance __two_step = 2 * __step_size;
03255
03256 while (__last - __first >= __two_step)
03257 {
03258 __result = _GLIBCXX_STD_P::merge(
03259 _GLIBCXX_MAKE_MOVE_ITERATOR(__first),
03260 _GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
03261 _GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
03262 _GLIBCXX_MAKE_MOVE_ITERATOR(__first + __two_step),
03263 __result, __comp);
03264 __first += __two_step;
03265 }
03266 __step_size = std::min(_Distance(__last - __first), __step_size);
03267
03268 _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
03269 _GLIBCXX_MAKE_MOVE_ITERATOR(__first +
03270 __step_size),
03271 _GLIBCXX_MAKE_MOVE_ITERATOR(__first +
03272 __step_size),
03273 _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
03274 __result, __comp);
03275 }
03276
03277 template<typename _RandomAccessIterator, typename _Distance>
03278 void
03279 __chunk_insertion_sort(_RandomAccessIterator __first,
03280 _RandomAccessIterator __last,
03281 _Distance __chunk_size)
03282 {
03283 while (__last - __first >= __chunk_size)
03284 {
03285 std::__insertion_sort(__first, __first + __chunk_size);
03286 __first += __chunk_size;
03287 }
03288 std::__insertion_sort(__first, __last);
03289 }
03290
03291 template<typename _RandomAccessIterator, typename _Distance,
03292 typename _Compare>
03293 void
03294 __chunk_insertion_sort(_RandomAccessIterator __first,
03295 _RandomAccessIterator __last,
03296 _Distance __chunk_size, _Compare __comp)
03297 {
03298 while (__last - __first >= __chunk_size)
03299 {
03300 std::__insertion_sort(__first, __first + __chunk_size, __comp);
03301 __first += __chunk_size;
03302 }
03303 std::__insertion_sort(__first, __last, __comp);
03304 }
03305
03306 enum { _S_chunk_size = 7 };
03307
03308 template<typename _RandomAccessIterator, typename _Pointer>
03309 void
03310 __merge_sort_with_buffer(_RandomAccessIterator __first,
03311 _RandomAccessIterator __last,
03312 _Pointer __buffer)
03313 {
03314 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
03315 _Distance;
03316
03317 const _Distance __len = __last - __first;
03318 const _Pointer __buffer_last = __buffer + __len;
03319
03320 _Distance __step_size = _S_chunk_size;
03321 std::__chunk_insertion_sort(__first, __last, __step_size);
03322
03323 while (__step_size < __len)
03324 {
03325 std::__merge_sort_loop(__first, __last, __buffer, __step_size);
03326 __step_size *= 2;
03327 std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
03328 __step_size *= 2;
03329 }
03330 }
03331
03332 template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
03333 void
03334 __merge_sort_with_buffer(_RandomAccessIterator __first,
03335 _RandomAccessIterator __last,
03336 _Pointer __buffer, _Compare __comp)
03337 {
03338 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
03339 _Distance;
03340
03341 const _Distance __len = __last - __first;
03342 const _Pointer __buffer_last = __buffer + __len;
03343
03344 _Distance __step_size = _S_chunk_size;
03345 std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
03346
03347 while (__step_size < __len)
03348 {
03349 std::__merge_sort_loop(__first, __last, __buffer,
03350 __step_size, __comp);
03351 __step_size *= 2;
03352 std::__merge_sort_loop(__buffer, __buffer_last, __first,
03353 __step_size, __comp);
03354 __step_size *= 2;
03355 }
03356 }
03357
03358 template<typename _RandomAccessIterator, typename _Pointer,
03359 typename _Distance>
03360 void
03361 __stable_sort_adaptive(_RandomAccessIterator __first,
03362 _RandomAccessIterator __last,
03363 _Pointer __buffer, _Distance __buffer_size)
03364 {
03365 const _Distance __len = (__last - __first + 1) / 2;
03366 const _RandomAccessIterator __middle = __first + __len;
03367 if (__len > __buffer_size)
03368 {
03369 std::__stable_sort_adaptive(__first, __middle,
03370 __buffer, __buffer_size);
03371 std::__stable_sort_adaptive(__middle, __last,
03372 __buffer, __buffer_size);
03373 }
03374 else
03375 {
03376 std::__merge_sort_with_buffer(__first, __middle, __buffer);
03377 std::__merge_sort_with_buffer(__middle, __last, __buffer);
03378 }
03379 std::__merge_adaptive(__first, __middle, __last,
03380 _Distance(__middle - __first),
03381 _Distance(__last - __middle),
03382 __buffer, __buffer_size);
03383 }
03384
03385 template<typename _RandomAccessIterator, typename _Pointer,
03386 typename _Distance, typename _Compare>
03387 void
03388 __stable_sort_adaptive(_RandomAccessIterator __first,
03389 _RandomAccessIterator __last,
03390 _Pointer __buffer, _Distance __buffer_size,
03391 _Compare __comp)
03392 {
03393 const _Distance __len = (__last - __first + 1) / 2;
03394 const _RandomAccessIterator __middle = __first + __len;
03395 if (__len > __buffer_size)
03396 {
03397 std::__stable_sort_adaptive(__first, __middle, __buffer,
03398 __buffer_size, __comp);
03399 std::__stable_sort_adaptive(__middle, __last, __buffer,
03400 __buffer_size, __comp);
03401 }
03402 else
03403 {
03404 std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
03405 std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
03406 }
03407 std::__merge_adaptive(__first, __middle, __last,
03408 _Distance(__middle - __first),
03409 _Distance(__last - __middle),
03410 __buffer, __buffer_size,
03411 __comp);
03412 }
03413
03414
03415 template<typename _RandomAccessIterator>
03416 void
03417 __inplace_stable_sort(_RandomAccessIterator __first,
03418 _RandomAccessIterator __last)
03419 {
03420 if (__last - __first < 15)
03421 {
03422 std::__insertion_sort(__first, __last);
03423 return;
03424 }
03425 _RandomAccessIterator __middle = __first + (__last - __first) / 2;
03426 std::__inplace_stable_sort(__first, __middle);
03427 std::__inplace_stable_sort(__middle, __last);
03428 std::__merge_without_buffer(__first, __middle, __last,
03429 __middle - __first,
03430 __last - __middle);
03431 }
03432
03433
03434 template<typename _RandomAccessIterator, typename _Compare>
03435 void
03436 __inplace_stable_sort(_RandomAccessIterator __first,
03437 _RandomAccessIterator __last, _Compare __comp)
03438 {
03439 if (__last - __first < 15)
03440 {
03441 std::__insertion_sort(__first, __last, __comp);
03442 return;
03443 }
03444 _RandomAccessIterator __middle = __first + (__last - __first) / 2;
03445 std::__inplace_stable_sort(__first, __middle, __comp);
03446 std::__inplace_stable_sort(__middle, __last, __comp);
03447 std::__merge_without_buffer(__first, __middle, __last,
03448 __middle - __first,
03449 __last - __middle,
03450 __comp);
03451 }
03452
03453
03454
03455
03456
03457
03458
03459
03460
03461
03462
03463
03464
03465
03466
03467
03468
03469
03470
03471
03472
03473
03474
03475
03476 template<typename _InputIterator1, typename _InputIterator2>
03477 bool
03478 includes(_InputIterator1 __first1, _InputIterator1 __last1,
03479 _InputIterator2 __first2, _InputIterator2 __last2)
03480 {
03481 typedef typename iterator_traits<_InputIterator1>::value_type
03482 _ValueType1;
03483 typedef typename iterator_traits<_InputIterator2>::value_type
03484 _ValueType2;
03485
03486
03487 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
03488 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
03489 __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
03490 __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
03491 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
03492 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
03493
03494 while (__first1 != __last1 && __first2 != __last2)
03495 if (*__first2 < *__first1)
03496 return false;
03497 else if(*__first1 < *__first2)
03498 ++__first1;
03499 else
03500 ++__first1, ++__first2;
03501
03502 return __first2 == __last2;
03503 }
03504
03505
03506
03507
03508
03509
03510
03511
03512
03513
03514
03515
03516
03517
03518
03519
03520
03521
03522
03523
03524
03525 template<typename _InputIterator1, typename _InputIterator2,
03526 typename _Compare>
03527 bool
03528 includes(_InputIterator1 __first1, _InputIterator1 __last1,
03529 _InputIterator2 __first2, _InputIterator2 __last2,
03530 _Compare __comp)
03531 {
03532 typedef typename iterator_traits<_InputIterator1>::value_type
03533 _ValueType1;
03534 typedef typename iterator_traits<_InputIterator2>::value_type
03535 _ValueType2;
03536
03537
03538 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
03539 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
03540 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
03541 _ValueType1, _ValueType2>)
03542 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
03543 _ValueType2, _ValueType1>)
03544 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
03545 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
03546
03547 while (__first1 != __last1 && __first2 != __last2)
03548 if (__comp(*__first2, *__first1))
03549 return false;
03550 else if(__comp(*__first1, *__first2))
03551 ++__first1;
03552 else
03553 ++__first1, ++__first2;
03554
03555 return __first2 == __last2;
03556 }
03557
03558
03559
03560
03561
03562
03563
03564
03565
03566
03567
03568
03569
03570
03571
03572
03573
03574
03575
03576
03577
03578
03579
03580 template<typename _BidirectionalIterator>
03581 bool
03582 next_permutation(_BidirectionalIterator __first,
03583 _BidirectionalIterator __last)
03584 {
03585
03586 __glibcxx_function_requires(_BidirectionalIteratorConcept<
03587 _BidirectionalIterator>)
03588 __glibcxx_function_requires(_LessThanComparableConcept<
03589 typename iterator_traits<_BidirectionalIterator>::value_type>)
03590 __glibcxx_requires_valid_range(__first, __last);
03591
03592 if (__first == __last)
03593 return false;
03594 _BidirectionalIterator __i = __first;
03595 ++__i;
03596 if (__i == __last)
03597 return false;
03598 __i = __last;
03599 --__i;
03600
03601 for(;;)
03602 {
03603 _BidirectionalIterator __ii = __i;
03604 --__i;
03605 if (*__i < *__ii)
03606 {
03607 _BidirectionalIterator __j = __last;
03608 while (!(*__i < *--__j))
03609 {}
03610 std::iter_swap(__i, __j);
03611 std::reverse(__ii, __last);
03612 return true;
03613 }
03614 if (__i == __first)
03615 {
03616 std::reverse(__first, __last);
03617 return false;
03618 }
03619 }
03620 }
03621
03622
03623
03624
03625
03626
03627
03628
03629
03630
03631
03632
03633
03634
03635
03636
03637 template<typename _BidirectionalIterator, typename _Compare>
03638 bool
03639 next_permutation(_BidirectionalIterator __first,
03640 _BidirectionalIterator __last, _Compare __comp)
03641 {
03642
03643 __glibcxx_function_requires(_BidirectionalIteratorConcept<
03644 _BidirectionalIterator>)
03645 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
03646 typename iterator_traits<_BidirectionalIterator>::value_type,
03647 typename iterator_traits<_BidirectionalIterator>::value_type>)
03648 __glibcxx_requires_valid_range(__first, __last);
03649
03650 if (__first == __last)
03651 return false;
03652 _BidirectionalIterator __i = __first;
03653 ++__i;
03654 if (__i == __last)
03655 return false;
03656 __i = __last;
03657 --__i;
03658
03659 for(;;)
03660 {
03661 _BidirectionalIterator __ii = __i;
03662 --__i;
03663 if (__comp(*__i, *__ii))
03664 {
03665 _BidirectionalIterator __j = __last;
03666 while (!bool(__comp(*__i, *--__j)))
03667 {}
03668 std::iter_swap(__i, __j);
03669 std::reverse(__ii, __last);
03670 return true;
03671 }
03672 if (__i == __first)
03673 {
03674 std::reverse(__first, __last);
03675 return false;
03676 }
03677 }
03678 }
03679
03680
03681
03682
03683
03684
03685
03686
03687
03688
03689
03690
03691
03692
03693 template<typename _BidirectionalIterator>
03694 bool
03695 prev_permutation(_BidirectionalIterator __first,
03696 _BidirectionalIterator __last)
03697 {
03698
03699 __glibcxx_function_requires(_BidirectionalIteratorConcept<
03700 _BidirectionalIterator>)
03701 __glibcxx_function_requires(_LessThanComparableConcept<
03702 typename iterator_traits<_BidirectionalIterator>::value_type>)
03703 __glibcxx_requires_valid_range(__first, __last);
03704
03705 if (__first == __last)
03706 return false;
03707 _BidirectionalIterator __i = __first;
03708 ++__i;
03709 if (__i == __last)
03710 return false;
03711 __i = __last;
03712 --__i;
03713
03714 for(;;)
03715 {
03716 _BidirectionalIterator __ii = __i;
03717 --__i;
03718 if (*__ii < *__i)
03719 {
03720 _BidirectionalIterator __j = __last;
03721 while (!(*--__j < *__i))
03722 {}
03723 std::iter_swap(__i, __j);
03724 std::reverse(__ii, __last);
03725 return true;
03726 }
03727 if (__i == __first)
03728 {
03729 std::reverse(__first, __last);
03730 return false;
03731 }
03732 }
03733 }
03734
03735
03736
03737
03738
03739
03740
03741
03742
03743
03744
03745
03746
03747
03748
03749
03750 template<typename _BidirectionalIterator, typename _Compare>
03751 bool
03752 prev_permutation(_BidirectionalIterator __first,
03753 _BidirectionalIterator __last, _Compare __comp)
03754 {
03755
03756 __glibcxx_function_requires(_BidirectionalIteratorConcept<
03757 _BidirectionalIterator>)
03758 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
03759 typename iterator_traits<_BidirectionalIterator>::value_type,
03760 typename iterator_traits<_BidirectionalIterator>::value_type>)
03761 __glibcxx_requires_valid_range(__first, __last);
03762
03763 if (__first == __last)
03764 return false;
03765 _BidirectionalIterator __i = __first;
03766 ++__i;
03767 if (__i == __last)
03768 return false;
03769 __i = __last;
03770 --__i;
03771
03772 for(;;)
03773 {
03774 _BidirectionalIterator __ii = __i;
03775 --__i;
03776 if (__comp(*__ii, *__i))
03777 {
03778 _BidirectionalIterator __j = __last;
03779 while (!bool(__comp(*--__j, *__i)))
03780 {}
03781 std::iter_swap(__i, __j);
03782 std::reverse(__ii, __last);
03783 return true;
03784 }
03785 if (__i == __first)
03786 {
03787 std::reverse(__first, __last);
03788 return false;
03789 }
03790 }
03791 }
03792
03793
03794
03795
03796
03797
03798
03799
03800
03801
03802
03803
03804
03805
03806
03807
03808
03809
03810 template<typename _InputIterator, typename _OutputIterator, typename _Tp>
03811 _OutputIterator
03812 replace_copy(_InputIterator __first, _InputIterator __last,
03813 _OutputIterator __result,
03814 const _Tp& __old_value, const _Tp& __new_value)
03815 {
03816
03817 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
03818 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
03819 typename iterator_traits<_InputIterator>::value_type>)
03820 __glibcxx_function_requires(_EqualOpConcept<
03821 typename iterator_traits<_InputIterator>::value_type, _Tp>)
03822 __glibcxx_requires_valid_range(__first, __last);
03823
03824 for (; __first != __last; ++__first, ++__result)
03825 if (*__first == __old_value)
03826 *__result = __new_value;
03827 else
03828 *__result = *__first;
03829 return __result;
03830 }
03831
03832
03833
03834
03835
03836
03837
03838
03839
03840
03841
03842
03843
03844
03845
03846
03847 template<typename _InputIterator, typename _OutputIterator,
03848 typename _Predicate, typename _Tp>
03849 _OutputIterator
03850 replace_copy_if(_InputIterator __first, _InputIterator __last,
03851 _OutputIterator __result,
03852 _Predicate __pred, const _Tp& __new_value)
03853 {
03854
03855 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
03856 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
03857 typename iterator_traits<_InputIterator>::value_type>)
03858 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
03859 typename iterator_traits<_InputIterator>::value_type>)
03860 __glibcxx_requires_valid_range(__first, __last);
03861
03862 for (; __first != __last; ++__first, ++__result)
03863 if (__pred(*__first))
03864 *__result = __new_value;
03865 else
03866 *__result = *__first;
03867 return __result;
03868 }
03869
03870 #ifdef __GXX_EXPERIMENTAL_CXX0X__
03871
03872
03873
03874
03875
03876
03877
03878 template<typename _ForwardIterator>
03879 inline bool
03880 is_sorted(_ForwardIterator __first, _ForwardIterator __last)
03881 { return std::is_sorted_until(__first, __last) == __last; }
03882
03883
03884
03885
03886
03887
03888
03889
03890
03891
03892 template<typename _ForwardIterator, typename _Compare>
03893 inline bool
03894 is_sorted(_ForwardIterator __first, _ForwardIterator __last,
03895 _Compare __comp)
03896 { return std::is_sorted_until(__first, __last, __comp) == __last; }
03897
03898
03899
03900
03901
03902
03903
03904
03905
03906 template<typename _ForwardIterator>
03907 _ForwardIterator
03908 is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
03909 {
03910
03911 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
03912 __glibcxx_function_requires(_LessThanComparableConcept<
03913 typename iterator_traits<_ForwardIterator>::value_type>)
03914 __glibcxx_requires_valid_range(__first, __last);
03915
03916 if (__first == __last)
03917 return __last;
03918
03919 _ForwardIterator __next = __first;
03920 for (++__next; __next != __last; __first = __next, ++__next)
03921 if (*__next < *__first)
03922 return __next;
03923 return __next;
03924 }
03925
03926
03927
03928
03929
03930
03931
03932
03933
03934
03935 template<typename _ForwardIterator, typename _Compare>
03936 _ForwardIterator
03937 is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
03938 _Compare __comp)
03939 {
03940
03941 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
03942 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
03943 typename iterator_traits<_ForwardIterator>::value_type,
03944 typename iterator_traits<_ForwardIterator>::value_type>)
03945 __glibcxx_requires_valid_range(__first, __last);
03946
03947 if (__first == __last)
03948 return __last;
03949
03950 _ForwardIterator __next = __first;
03951 for (++__next; __next != __last; __first = __next, ++__next)
03952 if (__comp(*__next, *__first))
03953 return __next;
03954 return __next;
03955 }
03956
03957
03958
03959
03960
03961
03962
03963
03964 template<typename _Tp>
03965 inline pair<const _Tp&, const _Tp&>
03966 minmax(const _Tp& __a, const _Tp& __b)
03967 {
03968
03969 __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
03970
03971 return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
03972 : pair<const _Tp&, const _Tp&>(__a, __b);
03973 }
03974
03975
03976
03977
03978
03979
03980
03981
03982
03983 template<typename _Tp, typename _Compare>
03984 inline pair<const _Tp&, const _Tp&>
03985 minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
03986 {
03987 return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
03988 : pair<const _Tp&, const _Tp&>(__a, __b);
03989 }
03990
03991
03992
03993
03994
03995
03996
03997
03998
03999
04000
04001
04002 template<typename _ForwardIterator>
04003 pair<_ForwardIterator, _ForwardIterator>
04004 minmax_element(_ForwardIterator __first, _ForwardIterator __last)
04005 {
04006
04007 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04008 __glibcxx_function_requires(_LessThanComparableConcept<
04009 typename iterator_traits<_ForwardIterator>::value_type>)
04010 __glibcxx_requires_valid_range(__first, __last);
04011
04012 _ForwardIterator __next = __first;
04013 if (__first == __last
04014 || ++__next == __last)
04015 return std::make_pair(__first, __first);
04016
04017 _ForwardIterator __min, __max;
04018 if (*__next < *__first)
04019 {
04020 __min = __next;
04021 __max = __first;
04022 }
04023 else
04024 {
04025 __min = __first;
04026 __max = __next;
04027 }
04028
04029 __first = __next;
04030 ++__first;
04031
04032 while (__first != __last)
04033 {
04034 __next = __first;
04035 if (++__next == __last)
04036 {
04037 if (*__first < *__min)
04038 __min = __first;
04039 else if (!(*__first < *__max))
04040 __max = __first;
04041 break;
04042 }
04043
04044 if (*__next < *__first)
04045 {
04046 if (*__next < *__min)
04047 __min = __next;
04048 if (!(*__first < *__max))
04049 __max = __first;
04050 }
04051 else
04052 {
04053 if (*__first < *__min)
04054 __min = __first;
04055 if (!(*__next < *__max))
04056 __max = __next;
04057 }
04058
04059 __first = __next;
04060 ++__first;
04061 }
04062
04063 return std::make_pair(__min, __max);
04064 }
04065
04066
04067
04068
04069
04070
04071
04072
04073
04074
04075
04076
04077
04078 template<typename _ForwardIterator, typename _Compare>
04079 pair<_ForwardIterator, _ForwardIterator>
04080 minmax_element(_ForwardIterator __first, _ForwardIterator __last,
04081 _Compare __comp)
04082 {
04083
04084 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04085 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
04086 typename iterator_traits<_ForwardIterator>::value_type,
04087 typename iterator_traits<_ForwardIterator>::value_type>)
04088 __glibcxx_requires_valid_range(__first, __last);
04089
04090 _ForwardIterator __next = __first;
04091 if (__first == __last
04092 || ++__next == __last)
04093 return std::make_pair(__first, __first);
04094
04095 _ForwardIterator __min, __max;
04096 if (__comp(*__next, *__first))
04097 {
04098 __min = __next;
04099 __max = __first;
04100 }
04101 else
04102 {
04103 __min = __first;
04104 __max = __next;
04105 }
04106
04107 __first = __next;
04108 ++__first;
04109
04110 while (__first != __last)
04111 {
04112 __next = __first;
04113 if (++__next == __last)
04114 {
04115 if (__comp(*__first, *__min))
04116 __min = __first;
04117 else if (!__comp(*__first, *__max))
04118 __max = __first;
04119 break;
04120 }
04121
04122 if (__comp(*__next, *__first))
04123 {
04124 if (__comp(*__next, *__min))
04125 __min = __next;
04126 if (!__comp(*__first, *__max))
04127 __max = __first;
04128 }
04129 else
04130 {
04131 if (__comp(*__first, *__min))
04132 __min = __first;
04133 if (!__comp(*__next, *__max))
04134 __max = __next;
04135 }
04136
04137 __first = __next;
04138 ++__first;
04139 }
04140
04141 return std::make_pair(__min, __max);
04142 }
04143
04144
04145 template<typename _Tp>
04146 inline _Tp
04147 min(initializer_list<_Tp> __l)
04148 { return *std::min_element(__l.begin(), __l.end()); }
04149
04150 template<typename _Tp, typename _Compare>
04151 inline _Tp
04152 min(initializer_list<_Tp> __l, _Compare __comp)
04153 { return *std::min_element(__l.begin(), __l.end(), __comp); }
04154
04155 template<typename _Tp>
04156 inline _Tp
04157 max(initializer_list<_Tp> __l)
04158 { return *std::max_element(__l.begin(), __l.end()); }
04159
04160 template<typename _Tp, typename _Compare>
04161 inline _Tp
04162 max(initializer_list<_Tp> __l, _Compare __comp)
04163 { return *std::max_element(__l.begin(), __l.end(), __comp); }
04164
04165 template<typename _Tp>
04166 inline pair<_Tp, _Tp>
04167 minmax(initializer_list<_Tp> __l)
04168 {
04169 pair<const _Tp*, const _Tp*> __p =
04170 std::minmax_element(__l.begin(), __l.end());
04171 return std::make_pair(*__p.first, *__p.second);
04172 }
04173
04174 template<typename _Tp, typename _Compare>
04175 inline pair<_Tp, _Tp>
04176 minmax(initializer_list<_Tp> __l, _Compare __comp)
04177 {
04178 pair<const _Tp*, const _Tp*> __p =
04179 std::minmax_element(__l.begin(), __l.end(), __comp);
04180 return std::make_pair(*__p.first, *__p.second);
04181 }
04182 #endif // __GXX_EXPERIMENTAL_CXX0X__
04183
04184 _GLIBCXX_END_NAMESPACE
04185
04186 _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
04187
04188
04189
04190
04191
04192
04193
04194
04195
04196
04197
04198
04199
04200 template<typename _InputIterator, typename _Function>
04201 _Function
04202 for_each(_InputIterator __first, _InputIterator __last, _Function __f)
04203 {
04204
04205 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04206 __glibcxx_requires_valid_range(__first, __last);
04207 for (; __first != __last; ++__first)
04208 __f(*__first);
04209 return _GLIBCXX_MOVE(__f);
04210 }
04211
04212
04213
04214
04215
04216
04217
04218
04219
04220
04221 template<typename _InputIterator, typename _Tp>
04222 inline _InputIterator
04223 find(_InputIterator __first, _InputIterator __last,
04224 const _Tp& __val)
04225 {
04226
04227 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04228 __glibcxx_function_requires(_EqualOpConcept<
04229 typename iterator_traits<_InputIterator>::value_type, _Tp>)
04230 __glibcxx_requires_valid_range(__first, __last);
04231 return std::__find(__first, __last, __val,
04232 std::__iterator_category(__first));
04233 }
04234
04235
04236
04237
04238
04239
04240
04241
04242
04243
04244
04245 template<typename _InputIterator, typename _Predicate>
04246 inline _InputIterator
04247 find_if(_InputIterator __first, _InputIterator __last,
04248 _Predicate __pred)
04249 {
04250
04251 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04252 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
04253 typename iterator_traits<_InputIterator>::value_type>)
04254 __glibcxx_requires_valid_range(__first, __last);
04255 return std::__find_if(__first, __last, __pred,
04256 std::__iterator_category(__first));
04257 }
04258
04259
04260
04261
04262
04263
04264
04265
04266
04267
04268
04269
04270
04271
04272
04273
04274 template<typename _InputIterator, typename _ForwardIterator>
04275 _InputIterator
04276 find_first_of(_InputIterator __first1, _InputIterator __last1,
04277 _ForwardIterator __first2, _ForwardIterator __last2)
04278 {
04279
04280 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04281 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04282 __glibcxx_function_requires(_EqualOpConcept<
04283 typename iterator_traits<_InputIterator>::value_type,
04284 typename iterator_traits<_ForwardIterator>::value_type>)
04285 __glibcxx_requires_valid_range(__first1, __last1);
04286 __glibcxx_requires_valid_range(__first2, __last2);
04287
04288 for (; __first1 != __last1; ++__first1)
04289 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
04290 if (*__first1 == *__iter)
04291 return __first1;
04292 return __last1;
04293 }
04294
04295
04296
04297
04298
04299
04300
04301
04302
04303
04304
04305
04306
04307
04308
04309
04310
04311
04312
04313 template<typename _InputIterator, typename _ForwardIterator,
04314 typename _BinaryPredicate>
04315 _InputIterator
04316 find_first_of(_InputIterator __first1, _InputIterator __last1,
04317 _ForwardIterator __first2, _ForwardIterator __last2,
04318 _BinaryPredicate __comp)
04319 {
04320
04321 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04322 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04323 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
04324 typename iterator_traits<_InputIterator>::value_type,
04325 typename iterator_traits<_ForwardIterator>::value_type>)
04326 __glibcxx_requires_valid_range(__first1, __last1);
04327 __glibcxx_requires_valid_range(__first2, __last2);
04328
04329 for (; __first1 != __last1; ++__first1)
04330 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
04331 if (__comp(*__first1, *__iter))
04332 return __first1;
04333 return __last1;
04334 }
04335
04336
04337
04338
04339
04340
04341
04342
04343
04344
04345 template<typename _ForwardIterator>
04346 _ForwardIterator
04347 adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
04348 {
04349
04350 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04351 __glibcxx_function_requires(_EqualityComparableConcept<
04352 typename iterator_traits<_ForwardIterator>::value_type>)
04353 __glibcxx_requires_valid_range(__first, __last);
04354 if (__first == __last)
04355 return __last;
04356 _ForwardIterator __next = __first;
04357 while(++__next != __last)
04358 {
04359 if (*__first == *__next)
04360 return __first;
04361 __first = __next;
04362 }
04363 return __last;
04364 }
04365
04366
04367
04368
04369
04370
04371
04372
04373
04374
04375
04376
04377 template<typename _ForwardIterator, typename _BinaryPredicate>
04378 _ForwardIterator
04379 adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
04380 _BinaryPredicate __binary_pred)
04381 {
04382
04383 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04384 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
04385 typename iterator_traits<_ForwardIterator>::value_type,
04386 typename iterator_traits<_ForwardIterator>::value_type>)
04387 __glibcxx_requires_valid_range(__first, __last);
04388 if (__first == __last)
04389 return __last;
04390 _ForwardIterator __next = __first;
04391 while(++__next != __last)
04392 {
04393 if (__binary_pred(*__first, *__next))
04394 return __first;
04395 __first = __next;
04396 }
04397 return __last;
04398 }
04399
04400
04401
04402
04403
04404
04405
04406
04407
04408
04409 template<typename _InputIterator, typename _Tp>
04410 typename iterator_traits<_InputIterator>::difference_type
04411 count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
04412 {
04413
04414 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04415 __glibcxx_function_requires(_EqualOpConcept<
04416 typename iterator_traits<_InputIterator>::value_type, _Tp>)
04417 __glibcxx_requires_valid_range(__first, __last);
04418 typename iterator_traits<_InputIterator>::difference_type __n = 0;
04419 for (; __first != __last; ++__first)
04420 if (*__first == __value)
04421 ++__n;
04422 return __n;
04423 }
04424
04425
04426
04427
04428
04429
04430
04431
04432
04433
04434 template<typename _InputIterator, typename _Predicate>
04435 typename iterator_traits<_InputIterator>::difference_type
04436 count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
04437 {
04438
04439 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04440 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
04441 typename iterator_traits<_InputIterator>::value_type>)
04442 __glibcxx_requires_valid_range(__first, __last);
04443 typename iterator_traits<_InputIterator>::difference_type __n = 0;
04444 for (; __first != __last; ++__first)
04445 if (__pred(*__first))
04446 ++__n;
04447 return __n;
04448 }
04449
04450
04451
04452
04453
04454
04455
04456
04457
04458
04459
04460
04461
04462
04463
04464
04465
04466
04467
04468
04469
04470
04471
04472
04473
04474 template<typename _ForwardIterator1, typename _ForwardIterator2>
04475 _ForwardIterator1
04476 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
04477 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
04478 {
04479
04480 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
04481 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
04482 __glibcxx_function_requires(_EqualOpConcept<
04483 typename iterator_traits<_ForwardIterator1>::value_type,
04484 typename iterator_traits<_ForwardIterator2>::value_type>)
04485 __glibcxx_requires_valid_range(__first1, __last1);
04486 __glibcxx_requires_valid_range(__first2, __last2);
04487
04488
04489 if (__first1 == __last1 || __first2 == __last2)
04490 return __first1;
04491
04492
04493 _ForwardIterator2 __p1(__first2);
04494 if (++__p1 == __last2)
04495 return _GLIBCXX_STD_P::find(__first1, __last1, *__first2);
04496
04497
04498 _ForwardIterator2 __p;
04499 _ForwardIterator1 __current = __first1;
04500
04501 for (;;)
04502 {
04503 __first1 = _GLIBCXX_STD_P::find(__first1, __last1, *__first2);
04504 if (__first1 == __last1)
04505 return __last1;
04506
04507 __p = __p1;
04508 __current = __first1;
04509 if (++__current == __last1)
04510 return __last1;
04511
04512 while (*__current == *__p)
04513 {
04514 if (++__p == __last2)
04515 return __first1;
04516 if (++__current == __last1)
04517 return __last1;
04518 }
04519 ++__first1;
04520 }
04521 return __first1;
04522 }
04523
04524
04525
04526
04527
04528
04529
04530
04531
04532
04533
04534
04535
04536
04537
04538
04539
04540
04541
04542
04543
04544
04545 template<typename _ForwardIterator1, typename _ForwardIterator2,
04546 typename _BinaryPredicate>
04547 _ForwardIterator1
04548 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
04549 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
04550 _BinaryPredicate __predicate)
04551 {
04552
04553 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
04554 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
04555 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
04556 typename iterator_traits<_ForwardIterator1>::value_type,
04557 typename iterator_traits<_ForwardIterator2>::value_type>)
04558 __glibcxx_requires_valid_range(__first1, __last1);
04559 __glibcxx_requires_valid_range(__first2, __last2);
04560
04561
04562 if (__first1 == __last1 || __first2 == __last2)
04563 return __first1;
04564
04565
04566 _ForwardIterator2 __p1(__first2);
04567 if (++__p1 == __last2)
04568 {
04569 while (__first1 != __last1
04570 && !bool(__predicate(*__first1, *__first2)))
04571 ++__first1;
04572 return __first1;
04573 }
04574
04575
04576 _ForwardIterator2 __p;
04577 _ForwardIterator1 __current = __first1;
04578
04579 for (;;)
04580 {
04581 while (__first1 != __last1
04582 && !bool(__predicate(*__first1, *__first2)))
04583 ++__first1;
04584 if (__first1 == __last1)
04585 return __last1;
04586
04587 __p = __p1;
04588 __current = __first1;
04589 if (++__current == __last1)
04590 return __last1;
04591
04592 while (__predicate(*__current, *__p))
04593 {
04594 if (++__p == __last2)
04595 return __first1;
04596 if (++__current == __last1)
04597 return __last1;
04598 }
04599 ++__first1;
04600 }
04601 return __first1;
04602 }
04603
04604
04605
04606
04607
04608
04609
04610
04611
04612
04613
04614
04615
04616
04617
04618
04619 template<typename _ForwardIterator, typename _Integer, typename _Tp>
04620 _ForwardIterator
04621 search_n(_ForwardIterator __first, _ForwardIterator __last,
04622 _Integer __count, const _Tp& __val)
04623 {
04624
04625 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04626 __glibcxx_function_requires(_EqualOpConcept<
04627 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
04628 __glibcxx_requires_valid_range(__first, __last);
04629
04630 if (__count <= 0)
04631 return __first;
04632 if (__count == 1)
04633 return _GLIBCXX_STD_P::find(__first, __last, __val);
04634 return std::__search_n(__first, __last, __count, __val,
04635 std::__iterator_category(__first));
04636 }
04637
04638
04639
04640
04641
04642
04643
04644
04645
04646
04647
04648
04649
04650
04651
04652
04653
04654
04655 template<typename _ForwardIterator, typename _Integer, typename _Tp,
04656 typename _BinaryPredicate>
04657 _ForwardIterator
04658 search_n(_ForwardIterator __first, _ForwardIterator __last,
04659 _Integer __count, const _Tp& __val,
04660 _BinaryPredicate __binary_pred)
04661 {
04662
04663 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04664 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
04665 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
04666 __glibcxx_requires_valid_range(__first, __last);
04667
04668 if (__count <= 0)
04669 return __first;
04670 if (__count == 1)
04671 {
04672 while (__first != __last && !bool(__binary_pred(*__first, __val)))
04673 ++__first;
04674 return __first;
04675 }
04676 return std::__search_n(__first, __last, __count, __val, __binary_pred,
04677 std::__iterator_category(__first));
04678 }
04679
04680
04681
04682
04683
04684
04685
04686
04687
04688
04689
04690
04691
04692
04693
04694
04695
04696
04697 template<typename _InputIterator, typename _OutputIterator,
04698 typename _UnaryOperation>
04699 _OutputIterator
04700 transform(_InputIterator __first, _InputIterator __last,
04701 _OutputIterator __result, _UnaryOperation __unary_op)
04702 {
04703
04704 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04705 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
04706
04707 __typeof__(__unary_op(*__first))>)
04708 __glibcxx_requires_valid_range(__first, __last);
04709
04710 for (; __first != __last; ++__first, ++__result)
04711 *__result = __unary_op(*__first);
04712 return __result;
04713 }
04714
04715
04716
04717
04718
04719
04720
04721
04722
04723
04724
04725
04726
04727
04728
04729
04730
04731
04732
04733 template<typename _InputIterator1, typename _InputIterator2,
04734 typename _OutputIterator, typename _BinaryOperation>
04735 _OutputIterator
04736 transform(_InputIterator1 __first1, _InputIterator1 __last1,
04737 _InputIterator2 __first2, _OutputIterator __result,
04738 _BinaryOperation __binary_op)
04739 {
04740
04741 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
04742 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
04743 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
04744
04745 __typeof__(__binary_op(*__first1,*__first2))>)
04746 __glibcxx_requires_valid_range(__first1, __last1);
04747
04748 for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
04749 *__result = __binary_op(*__first1, *__first2);
04750 return __result;
04751 }
04752
04753
04754
04755
04756
04757
04758
04759
04760
04761
04762
04763
04764
04765
04766 template<typename _ForwardIterator, typename _Tp>
04767 void
04768 replace(_ForwardIterator __first, _ForwardIterator __last,
04769 const _Tp& __old_value, const _Tp& __new_value)
04770 {
04771
04772 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
04773 _ForwardIterator>)
04774 __glibcxx_function_requires(_EqualOpConcept<
04775 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
04776 __glibcxx_function_requires(_ConvertibleConcept<_Tp,
04777 typename iterator_traits<_ForwardIterator>::value_type>)
04778 __glibcxx_requires_valid_range(__first, __last);
04779
04780 for (; __first != __last; ++__first)
04781 if (*__first == __old_value)
04782 *__first = __new_value;
04783 }
04784
04785
04786
04787
04788
04789
04790
04791
04792
04793
04794
04795
04796
04797
04798 template<typename _ForwardIterator, typename _Predicate, typename _Tp>
04799 void
04800 replace_if(_ForwardIterator __first, _ForwardIterator __last,
04801 _Predicate __pred, const _Tp& __new_value)
04802 {
04803
04804 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
04805 _ForwardIterator>)
04806 __glibcxx_function_requires(_ConvertibleConcept<_Tp,
04807 typename iterator_traits<_ForwardIterator>::value_type>)
04808 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
04809 typename iterator_traits<_ForwardIterator>::value_type>)
04810 __glibcxx_requires_valid_range(__first, __last);
04811
04812 for (; __first != __last; ++__first)
04813 if (__pred(*__first))
04814 *__first = __new_value;
04815 }
04816
04817
04818
04819
04820
04821
04822
04823
04824
04825
04826
04827
04828
04829
04830 template<typename _ForwardIterator, typename _Generator>
04831 void
04832 generate(_ForwardIterator __first, _ForwardIterator __last,
04833 _Generator __gen)
04834 {
04835
04836 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
04837 __glibcxx_function_requires(_GeneratorConcept<_Generator,
04838 typename iterator_traits<_ForwardIterator>::value_type>)
04839 __glibcxx_requires_valid_range(__first, __last);
04840
04841 for (; __first != __last; ++__first)
04842 *__first = __gen();
04843 }
04844
04845
04846
04847
04848
04849
04850
04851
04852
04853
04854
04855
04856
04857
04858
04859
04860
04861 template<typename _OutputIterator, typename _Size, typename _Generator>
04862 _OutputIterator
04863 generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
04864 {
04865
04866 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
04867
04868 __typeof__(__gen())>)
04869
04870 for (; __n > 0; --__n, ++__first)
04871 *__first = __gen();
04872 return __first;
04873 }
04874
04875
04876
04877
04878
04879
04880
04881
04882
04883
04884
04885
04886
04887
04888
04889
04890
04891
04892
04893
04894
04895
04896
04897 template<typename _InputIterator, typename _OutputIterator>
04898 inline _OutputIterator
04899 unique_copy(_InputIterator __first, _InputIterator __last,
04900 _OutputIterator __result)
04901 {
04902
04903 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04904 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
04905 typename iterator_traits<_InputIterator>::value_type>)
04906 __glibcxx_function_requires(_EqualityComparableConcept<
04907 typename iterator_traits<_InputIterator>::value_type>)
04908 __glibcxx_requires_valid_range(__first, __last);
04909
04910 if (__first == __last)
04911 return __result;
04912 return std::__unique_copy(__first, __last, __result,
04913 std::__iterator_category(__first),
04914 std::__iterator_category(__result));
04915 }
04916
04917
04918
04919
04920
04921
04922
04923
04924
04925
04926
04927
04928
04929
04930
04931
04932
04933
04934
04935
04936 template<typename _InputIterator, typename _OutputIterator,
04937 typename _BinaryPredicate>
04938 inline _OutputIterator
04939 unique_copy(_InputIterator __first, _InputIterator __last,
04940 _OutputIterator __result,
04941 _BinaryPredicate __binary_pred)
04942 {
04943
04944 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
04945 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
04946 typename iterator_traits<_InputIterator>::value_type>)
04947 __glibcxx_requires_valid_range(__first, __last);
04948
04949 if (__first == __last)
04950 return __result;
04951 return std::__unique_copy(__first, __last, __result, __binary_pred,
04952 std::__iterator_category(__first),
04953 std::__iterator_category(__result));
04954 }
04955
04956
04957
04958
04959
04960
04961
04962
04963
04964
04965
04966
04967
04968 template<typename _RandomAccessIterator>
04969 inline void
04970 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
04971 {
04972
04973 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
04974 _RandomAccessIterator>)
04975 __glibcxx_requires_valid_range(__first, __last);
04976
04977 if (__first != __last)
04978 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
04979 std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
04980 }
04981
04982
04983
04984
04985
04986
04987
04988
04989
04990
04991
04992
04993
04994
04995
04996 template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
04997 void
04998 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
04999 _RandomNumberGenerator& __rand)
05000 {
05001
05002 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05003 _RandomAccessIterator>)
05004 __glibcxx_requires_valid_range(__first, __last);
05005
05006 if (__first == __last)
05007 return;
05008 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
05009 std::iter_swap(__i, __first + __rand((__i - __first) + 1));
05010 }
05011
05012
05013
05014
05015
05016
05017
05018
05019
05020
05021
05022
05023
05024
05025
05026
05027
05028 template<typename _ForwardIterator, typename _Predicate>
05029 inline _ForwardIterator
05030 partition(_ForwardIterator __first, _ForwardIterator __last,
05031 _Predicate __pred)
05032 {
05033
05034 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
05035 _ForwardIterator>)
05036 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
05037 typename iterator_traits<_ForwardIterator>::value_type>)
05038 __glibcxx_requires_valid_range(__first, __last);
05039
05040 return std::__partition(__first, __last, __pred,
05041 std::__iterator_category(__first));
05042 }
05043
05044
05045
05046
05047
05048
05049
05050
05051
05052
05053
05054
05055
05056
05057
05058
05059
05060
05061
05062 template<typename _RandomAccessIterator>
05063 inline void
05064 partial_sort(_RandomAccessIterator __first,
05065 _RandomAccessIterator __middle,
05066 _RandomAccessIterator __last)
05067 {
05068 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05069 _ValueType;
05070
05071
05072 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05073 _RandomAccessIterator>)
05074 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
05075 __glibcxx_requires_valid_range(__first, __middle);
05076 __glibcxx_requires_valid_range(__middle, __last);
05077
05078 std::__heap_select(__first, __middle, __last);
05079 std::sort_heap(__first, __middle);
05080 }
05081
05082
05083
05084
05085
05086
05087
05088
05089
05090
05091
05092
05093
05094
05095
05096
05097
05098
05099
05100
05101 template<typename _RandomAccessIterator, typename _Compare>
05102 inline void
05103 partial_sort(_RandomAccessIterator __first,
05104 _RandomAccessIterator __middle,
05105 _RandomAccessIterator __last,
05106 _Compare __comp)
05107 {
05108 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05109 _ValueType;
05110
05111
05112 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05113 _RandomAccessIterator>)
05114 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05115 _ValueType, _ValueType>)
05116 __glibcxx_requires_valid_range(__first, __middle);
05117 __glibcxx_requires_valid_range(__middle, __last);
05118
05119 std::__heap_select(__first, __middle, __last, __comp);
05120 std::sort_heap(__first, __middle, __comp);
05121 }
05122
05123
05124
05125
05126
05127
05128
05129
05130
05131
05132
05133
05134
05135
05136
05137
05138
05139 template<typename _RandomAccessIterator>
05140 inline void
05141 nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
05142 _RandomAccessIterator __last)
05143 {
05144 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05145 _ValueType;
05146
05147
05148 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05149 _RandomAccessIterator>)
05150 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
05151 __glibcxx_requires_valid_range(__first, __nth);
05152 __glibcxx_requires_valid_range(__nth, __last);
05153
05154 if (__first == __last || __nth == __last)
05155 return;
05156
05157 std::__introselect(__first, __nth, __last,
05158 std::__lg(__last - __first) * 2);
05159 }
05160
05161
05162
05163
05164
05165
05166
05167
05168
05169
05170
05171
05172
05173
05174
05175
05176
05177
05178 template<typename _RandomAccessIterator, typename _Compare>
05179 inline void
05180 nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
05181 _RandomAccessIterator __last, _Compare __comp)
05182 {
05183 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05184 _ValueType;
05185
05186
05187 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05188 _RandomAccessIterator>)
05189 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05190 _ValueType, _ValueType>)
05191 __glibcxx_requires_valid_range(__first, __nth);
05192 __glibcxx_requires_valid_range(__nth, __last);
05193
05194 if (__first == __last || __nth == __last)
05195 return;
05196
05197 std::__introselect(__first, __nth, __last,
05198 std::__lg(__last - __first) * 2, __comp);
05199 }
05200
05201
05202
05203
05204
05205
05206
05207
05208
05209
05210
05211
05212
05213
05214
05215
05216 template<typename _RandomAccessIterator>
05217 inline void
05218 sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
05219 {
05220 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05221 _ValueType;
05222
05223
05224 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05225 _RandomAccessIterator>)
05226 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
05227 __glibcxx_requires_valid_range(__first, __last);
05228
05229 if (__first != __last)
05230 {
05231 std::__introsort_loop(__first, __last,
05232 std::__lg(__last - __first) * 2);
05233 std::__final_insertion_sort(__first, __last);
05234 }
05235 }
05236
05237
05238
05239
05240
05241
05242
05243
05244
05245
05246
05247
05248
05249
05250
05251
05252 template<typename _RandomAccessIterator, typename _Compare>
05253 inline void
05254 sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
05255 _Compare __comp)
05256 {
05257 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05258 _ValueType;
05259
05260
05261 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05262 _RandomAccessIterator>)
05263 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType,
05264 _ValueType>)
05265 __glibcxx_requires_valid_range(__first, __last);
05266
05267 if (__first != __last)
05268 {
05269 std::__introsort_loop(__first, __last,
05270 std::__lg(__last - __first) * 2, __comp);
05271 std::__final_insertion_sort(__first, __last, __comp);
05272 }
05273 }
05274
05275
05276
05277
05278
05279
05280
05281
05282
05283
05284
05285
05286
05287
05288
05289
05290
05291
05292
05293 template<typename _InputIterator1, typename _InputIterator2,
05294 typename _OutputIterator>
05295 _OutputIterator
05296 merge(_InputIterator1 __first1, _InputIterator1 __last1,
05297 _InputIterator2 __first2, _InputIterator2 __last2,
05298 _OutputIterator __result)
05299 {
05300 typedef typename iterator_traits<_InputIterator1>::value_type
05301 _ValueType1;
05302 typedef typename iterator_traits<_InputIterator2>::value_type
05303 _ValueType2;
05304
05305
05306 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05307 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05308 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05309 _ValueType1>)
05310 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05311 _ValueType2>)
05312 __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
05313 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
05314 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
05315
05316 while (__first1 != __last1 && __first2 != __last2)
05317 {
05318 if (*__first2 < *__first1)
05319 {
05320 *__result = *__first2;
05321 ++__first2;
05322 }
05323 else
05324 {
05325 *__result = *__first1;
05326 ++__first1;
05327 }
05328 ++__result;
05329 }
05330 return std::copy(__first2, __last2, std::copy(__first1, __last1,
05331 __result));
05332 }
05333
05334
05335
05336
05337
05338
05339
05340
05341
05342
05343
05344
05345
05346
05347
05348
05349
05350
05351
05352
05353
05354
05355
05356 template<typename _InputIterator1, typename _InputIterator2,
05357 typename _OutputIterator, typename _Compare>
05358 _OutputIterator
05359 merge(_InputIterator1 __first1, _InputIterator1 __last1,
05360 _InputIterator2 __first2, _InputIterator2 __last2,
05361 _OutputIterator __result, _Compare __comp)
05362 {
05363 typedef typename iterator_traits<_InputIterator1>::value_type
05364 _ValueType1;
05365 typedef typename iterator_traits<_InputIterator2>::value_type
05366 _ValueType2;
05367
05368
05369 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05370 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05371 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05372 _ValueType1>)
05373 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05374 _ValueType2>)
05375 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05376 _ValueType2, _ValueType1>)
05377 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
05378 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
05379
05380 while (__first1 != __last1 && __first2 != __last2)
05381 {
05382 if (__comp(*__first2, *__first1))
05383 {
05384 *__result = *__first2;
05385 ++__first2;
05386 }
05387 else
05388 {
05389 *__result = *__first1;
05390 ++__first1;
05391 }
05392 ++__result;
05393 }
05394 return std::copy(__first2, __last2, std::copy(__first1, __last1,
05395 __result));
05396 }
05397
05398
05399
05400
05401
05402
05403
05404
05405
05406
05407
05408
05409
05410
05411
05412
05413
05414
05415
05416 template<typename _RandomAccessIterator>
05417 inline void
05418 stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
05419 {
05420 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05421 _ValueType;
05422 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
05423 _DistanceType;
05424
05425
05426 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05427 _RandomAccessIterator>)
05428 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
05429 __glibcxx_requires_valid_range(__first, __last);
05430
05431 _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
05432 __last);
05433 if (__buf.begin() == 0)
05434 std::__inplace_stable_sort(__first, __last);
05435 else
05436 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
05437 _DistanceType(__buf.size()));
05438 }
05439
05440
05441
05442
05443
05444
05445
05446
05447
05448
05449
05450
05451
05452
05453
05454
05455
05456
05457
05458 template<typename _RandomAccessIterator, typename _Compare>
05459 inline void
05460 stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
05461 _Compare __comp)
05462 {
05463 typedef typename iterator_traits<_RandomAccessIterator>::value_type
05464 _ValueType;
05465 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
05466 _DistanceType;
05467
05468
05469 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05470 _RandomAccessIterator>)
05471 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05472 _ValueType,
05473 _ValueType>)
05474 __glibcxx_requires_valid_range(__first, __last);
05475
05476 _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
05477 __last);
05478 if (__buf.begin() == 0)
05479 std::__inplace_stable_sort(__first, __last, __comp);
05480 else
05481 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
05482 _DistanceType(__buf.size()), __comp);
05483 }
05484
05485
05486
05487
05488
05489
05490
05491
05492
05493
05494
05495
05496
05497
05498
05499
05500
05501
05502
05503
05504 template<typename _InputIterator1, typename _InputIterator2,
05505 typename _OutputIterator>
05506 _OutputIterator
05507 set_union(_InputIterator1 __first1, _InputIterator1 __last1,
05508 _InputIterator2 __first2, _InputIterator2 __last2,
05509 _OutputIterator __result)
05510 {
05511 typedef typename iterator_traits<_InputIterator1>::value_type
05512 _ValueType1;
05513 typedef typename iterator_traits<_InputIterator2>::value_type
05514 _ValueType2;
05515
05516
05517 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05518 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05519 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05520 _ValueType1>)
05521 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05522 _ValueType2>)
05523 __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
05524 __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
05525 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
05526 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
05527
05528 while (__first1 != __last1 && __first2 != __last2)
05529 {
05530 if (*__first1 < *__first2)
05531 {
05532 *__result = *__first1;
05533 ++__first1;
05534 }
05535 else if (*__first2 < *__first1)
05536 {
05537 *__result = *__first2;
05538 ++__first2;
05539 }
05540 else
05541 {
05542 *__result = *__first1;
05543 ++__first1;
05544 ++__first2;
05545 }
05546 ++__result;
05547 }
05548 return std::copy(__first2, __last2, std::copy(__first1, __last1,
05549 __result));
05550 }
05551
05552
05553
05554
05555
05556
05557
05558
05559
05560
05561
05562
05563
05564
05565
05566
05567
05568
05569
05570
05571 template<typename _InputIterator1, typename _InputIterator2,
05572 typename _OutputIterator, typename _Compare>
05573 _OutputIterator
05574 set_union(_InputIterator1 __first1, _InputIterator1 __last1,
05575 _InputIterator2 __first2, _InputIterator2 __last2,
05576 _OutputIterator __result, _Compare __comp)
05577 {
05578 typedef typename iterator_traits<_InputIterator1>::value_type
05579 _ValueType1;
05580 typedef typename iterator_traits<_InputIterator2>::value_type
05581 _ValueType2;
05582
05583
05584 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05585 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05586 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05587 _ValueType1>)
05588 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05589 _ValueType2>)
05590 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05591 _ValueType1, _ValueType2>)
05592 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05593 _ValueType2, _ValueType1>)
05594 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
05595 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
05596
05597 while (__first1 != __last1 && __first2 != __last2)
05598 {
05599 if (__comp(*__first1, *__first2))
05600 {
05601 *__result = *__first1;
05602 ++__first1;
05603 }
05604 else if (__comp(*__first2, *__first1))
05605 {
05606 *__result = *__first2;
05607 ++__first2;
05608 }
05609 else
05610 {
05611 *__result = *__first1;
05612 ++__first1;
05613 ++__first2;
05614 }
05615 ++__result;
05616 }
05617 return std::copy(__first2, __last2, std::copy(__first1, __last1,
05618 __result));
05619 }
05620
05621
05622
05623
05624
05625
05626
05627
05628
05629
05630
05631
05632
05633
05634
05635
05636
05637
05638 template<typename _InputIterator1, typename _InputIterator2,
05639 typename _OutputIterator>
05640 _OutputIterator
05641 set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
05642 _InputIterator2 __first2, _InputIterator2 __last2,
05643 _OutputIterator __result)
05644 {
05645 typedef typename iterator_traits<_InputIterator1>::value_type
05646 _ValueType1;
05647 typedef typename iterator_traits<_InputIterator2>::value_type
05648 _ValueType2;
05649
05650
05651 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05652 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05653 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05654 _ValueType1>)
05655 __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
05656 __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
05657 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
05658 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
05659
05660 while (__first1 != __last1 && __first2 != __last2)
05661 if (*__first1 < *__first2)
05662 ++__first1;
05663 else if (*__first2 < *__first1)
05664 ++__first2;
05665 else
05666 {
05667 *__result = *__first1;
05668 ++__first1;
05669 ++__first2;
05670 ++__result;
05671 }
05672 return __result;
05673 }
05674
05675
05676
05677
05678
05679
05680
05681
05682
05683
05684
05685
05686
05687
05688
05689
05690
05691
05692
05693
05694
05695 template<typename _InputIterator1, typename _InputIterator2,
05696 typename _OutputIterator, typename _Compare>
05697 _OutputIterator
05698 set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
05699 _InputIterator2 __first2, _InputIterator2 __last2,
05700 _OutputIterator __result, _Compare __comp)
05701 {
05702 typedef typename iterator_traits<_InputIterator1>::value_type
05703 _ValueType1;
05704 typedef typename iterator_traits<_InputIterator2>::value_type
05705 _ValueType2;
05706
05707
05708 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05709 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05710 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05711 _ValueType1>)
05712 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05713 _ValueType1, _ValueType2>)
05714 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05715 _ValueType2, _ValueType1>)
05716 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
05717 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
05718
05719 while (__first1 != __last1 && __first2 != __last2)
05720 if (__comp(*__first1, *__first2))
05721 ++__first1;
05722 else if (__comp(*__first2, *__first1))
05723 ++__first2;
05724 else
05725 {
05726 *__result = *__first1;
05727 ++__first1;
05728 ++__first2;
05729 ++__result;
05730 }
05731 return __result;
05732 }
05733
05734
05735
05736
05737
05738
05739
05740
05741
05742
05743
05744
05745
05746
05747
05748
05749
05750
05751
05752
05753 template<typename _InputIterator1, typename _InputIterator2,
05754 typename _OutputIterator>
05755 _OutputIterator
05756 set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
05757 _InputIterator2 __first2, _InputIterator2 __last2,
05758 _OutputIterator __result)
05759 {
05760 typedef typename iterator_traits<_InputIterator1>::value_type
05761 _ValueType1;
05762 typedef typename iterator_traits<_InputIterator2>::value_type
05763 _ValueType2;
05764
05765
05766 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05767 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05768 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05769 _ValueType1>)
05770 __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
05771 __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
05772 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
05773 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
05774
05775 while (__first1 != __last1 && __first2 != __last2)
05776 if (*__first1 < *__first2)
05777 {
05778 *__result = *__first1;
05779 ++__first1;
05780 ++__result;
05781 }
05782 else if (*__first2 < *__first1)
05783 ++__first2;
05784 else
05785 {
05786 ++__first1;
05787 ++__first2;
05788 }
05789 return std::copy(__first1, __last1, __result);
05790 }
05791
05792
05793
05794
05795
05796
05797
05798
05799
05800
05801
05802
05803
05804
05805
05806
05807
05808
05809
05810
05811
05812
05813
05814 template<typename _InputIterator1, typename _InputIterator2,
05815 typename _OutputIterator, typename _Compare>
05816 _OutputIterator
05817 set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
05818 _InputIterator2 __first2, _InputIterator2 __last2,
05819 _OutputIterator __result, _Compare __comp)
05820 {
05821 typedef typename iterator_traits<_InputIterator1>::value_type
05822 _ValueType1;
05823 typedef typename iterator_traits<_InputIterator2>::value_type
05824 _ValueType2;
05825
05826
05827 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05828 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05829 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05830 _ValueType1>)
05831 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05832 _ValueType1, _ValueType2>)
05833 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05834 _ValueType2, _ValueType1>)
05835 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
05836 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
05837
05838 while (__first1 != __last1 && __first2 != __last2)
05839 if (__comp(*__first1, *__first2))
05840 {
05841 *__result = *__first1;
05842 ++__first1;
05843 ++__result;
05844 }
05845 else if (__comp(*__first2, *__first1))
05846 ++__first2;
05847 else
05848 {
05849 ++__first1;
05850 ++__first2;
05851 }
05852 return std::copy(__first1, __last1, __result);
05853 }
05854
05855
05856
05857
05858
05859
05860
05861
05862
05863
05864
05865
05866
05867
05868
05869
05870
05871
05872 template<typename _InputIterator1, typename _InputIterator2,
05873 typename _OutputIterator>
05874 _OutputIterator
05875 set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
05876 _InputIterator2 __first2, _InputIterator2 __last2,
05877 _OutputIterator __result)
05878 {
05879 typedef typename iterator_traits<_InputIterator1>::value_type
05880 _ValueType1;
05881 typedef typename iterator_traits<_InputIterator2>::value_type
05882 _ValueType2;
05883
05884
05885 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05886 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05887 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05888 _ValueType1>)
05889 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05890 _ValueType2>)
05891 __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
05892 __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
05893 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
05894 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
05895
05896 while (__first1 != __last1 && __first2 != __last2)
05897 if (*__first1 < *__first2)
05898 {
05899 *__result = *__first1;
05900 ++__first1;
05901 ++__result;
05902 }
05903 else if (*__first2 < *__first1)
05904 {
05905 *__result = *__first2;
05906 ++__first2;
05907 ++__result;
05908 }
05909 else
05910 {
05911 ++__first1;
05912 ++__first2;
05913 }
05914 return std::copy(__first2, __last2, std::copy(__first1,
05915 __last1, __result));
05916 }
05917
05918
05919
05920
05921
05922
05923
05924
05925
05926
05927
05928
05929
05930
05931
05932
05933
05934
05935
05936
05937
05938 template<typename _InputIterator1, typename _InputIterator2,
05939 typename _OutputIterator, typename _Compare>
05940 _OutputIterator
05941 set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
05942 _InputIterator2 __first2, _InputIterator2 __last2,
05943 _OutputIterator __result,
05944 _Compare __comp)
05945 {
05946 typedef typename iterator_traits<_InputIterator1>::value_type
05947 _ValueType1;
05948 typedef typename iterator_traits<_InputIterator2>::value_type
05949 _ValueType2;
05950
05951
05952 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
05953 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
05954 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05955 _ValueType1>)
05956 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
05957 _ValueType2>)
05958 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05959 _ValueType1, _ValueType2>)
05960 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
05961 _ValueType2, _ValueType1>)
05962 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
05963 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
05964
05965 while (__first1 != __last1 && __first2 != __last2)
05966 if (__comp(*__first1, *__first2))
05967 {
05968 *__result = *__first1;
05969 ++__first1;
05970 ++__result;
05971 }
05972 else if (__comp(*__first2, *__first1))
05973 {
05974 *__result = *__first2;
05975 ++__first2;
05976 ++__result;
05977 }
05978 else
05979 {
05980 ++__first1;
05981 ++__first2;
05982 }
05983 return std::copy(__first2, __last2,
05984 std::copy(__first1, __last1, __result));
05985 }
05986
05987
05988
05989
05990
05991
05992
05993
05994
05995 template<typename _ForwardIterator>
05996 _ForwardIterator
05997 min_element(_ForwardIterator __first, _ForwardIterator __last)
05998 {
05999
06000 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
06001 __glibcxx_function_requires(_LessThanComparableConcept<
06002 typename iterator_traits<_ForwardIterator>::value_type>)
06003 __glibcxx_requires_valid_range(__first, __last);
06004
06005 if (__first == __last)
06006 return __first;
06007 _ForwardIterator __result = __first;
06008 while (++__first != __last)
06009 if (*__first < *__result)
06010 __result = __first;
06011 return __result;
06012 }
06013
06014
06015
06016
06017
06018
06019
06020
06021
06022
06023 template<typename _ForwardIterator, typename _Compare>
06024 _ForwardIterator
06025 min_element(_ForwardIterator __first, _ForwardIterator __last,
06026 _Compare __comp)
06027 {
06028
06029 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
06030 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
06031 typename iterator_traits<_ForwardIterator>::value_type,
06032 typename iterator_traits<_ForwardIterator>::value_type>)
06033 __glibcxx_requires_valid_range(__first, __last);
06034
06035 if (__first == __last)
06036 return __first;
06037 _ForwardIterator __result = __first;
06038 while (++__first != __last)
06039 if (__comp(*__first, *__result))
06040 __result = __first;
06041 return __result;
06042 }
06043
06044
06045
06046
06047
06048
06049
06050
06051 template<typename _ForwardIterator>
06052 _ForwardIterator
06053 max_element(_ForwardIterator __first, _ForwardIterator __last)
06054 {
06055
06056 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
06057 __glibcxx_function_requires(_LessThanComparableConcept<
06058 typename iterator_traits<_ForwardIterator>::value_type>)
06059 __glibcxx_requires_valid_range(__first, __last);
06060
06061 if (__first == __last)
06062 return __first;
06063 _ForwardIterator __result = __first;
06064 while (++__first != __last)
06065 if (*__result < *__first)
06066 __result = __first;
06067 return __result;
06068 }
06069
06070
06071
06072
06073
06074
06075
06076
06077
06078
06079 template<typename _ForwardIterator, typename _Compare>
06080 _ForwardIterator
06081 max_element(_ForwardIterator __first, _ForwardIterator __last,
06082 _Compare __comp)
06083 {
06084
06085 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
06086 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
06087 typename iterator_traits<_ForwardIterator>::value_type,
06088 typename iterator_traits<_ForwardIterator>::value_type>)
06089 __glibcxx_requires_valid_range(__first, __last);
06090
06091 if (__first == __last) return __first;
06092 _ForwardIterator __result = __first;
06093 while (++__first != __last)
06094 if (__comp(*__result, *__first))
06095 __result = __first;
06096 return __result;
06097 }
06098
06099 _GLIBCXX_END_NESTED_NAMESPACE
06100
06101 #endif