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