1 // <algorithm> Forward declarations -*- C++ -*- 2 3 // Copyright (C) 2007-2017 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file bits/algorithmfwd.h 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{algorithm} 28 */ 29 30 #ifndef _GLIBCXX_ALGORITHMFWD_H 31 #define _GLIBCXX_ALGORITHMFWD_H 1 32 33 #pragma GCC system_header 34 35 #include <bits/c++config.h> 36 #include <bits/stl_pair.h> 37 #include <bits/stl_iterator_base_types.h> 38 #if __cplusplus >= 201103L 39 #include <initializer_list> 40 #endif 41 42 namespace std _GLIBCXX_VISIBILITY(default) 43 { 44 _GLIBCXX_BEGIN_NAMESPACE_VERSION 45 46 /* 47 adjacent_find 48 all_of (C++11) 49 any_of (C++11) 50 binary_search 51 clamp (C++17) 52 copy 53 copy_backward 54 copy_if (C++11) 55 copy_n (C++11) 56 count 57 count_if 58 equal 59 equal_range 60 fill 61 fill_n 62 find 63 find_end 64 find_first_of 65 find_if 66 find_if_not (C++11) 67 for_each 68 generate 69 generate_n 70 includes 71 inplace_merge 72 is_heap (C++11) 73 is_heap_until (C++11) 74 is_partitioned (C++11) 75 is_sorted (C++11) 76 is_sorted_until (C++11) 77 iter_swap 78 lexicographical_compare 79 lower_bound 80 make_heap 81 max 82 max_element 83 merge 84 min 85 min_element 86 minmax (C++11) 87 minmax_element (C++11) 88 mismatch 89 next_permutation 90 none_of (C++11) 91 nth_element 92 partial_sort 93 partial_sort_copy 94 partition 95 partition_copy (C++11) 96 partition_point (C++11) 97 pop_heap 98 prev_permutation 99 push_heap 100 random_shuffle 101 remove 102 remove_copy 103 remove_copy_if 104 remove_if 105 replace 106 replace_copy 107 replace_copy_if 108 replace_if 109 reverse 110 reverse_copy 111 rotate 112 rotate_copy 113 search 114 search_n 115 set_difference 116 set_intersection 117 set_symmetric_difference 118 set_union 119 shuffle (C++11) 120 sort 121 sort_heap 122 stable_partition 123 stable_sort 124 swap 125 swap_ranges 126 transform 127 unique 128 unique_copy 129 upper_bound 130 */ 131 132 /** 133 * @defgroup algorithms Algorithms 134 * 135 * Components for performing algorithmic operations. Includes 136 * non-modifying sequence, modifying (mutating) sequence, sorting, 137 * searching, merge, partition, heap, set, minima, maxima, and 138 * permutation operations. 139 */ 140 141 /** 142 * @defgroup mutating_algorithms Mutating 143 * @ingroup algorithms 144 */ 145 146 /** 147 * @defgroup non_mutating_algorithms Non-Mutating 148 * @ingroup algorithms 149 */ 150 151 /** 152 * @defgroup sorting_algorithms Sorting 153 * @ingroup algorithms 154 */ 155 156 /** 157 * @defgroup set_algorithms Set Operation 158 * @ingroup sorting_algorithms 159 * 160 * These algorithms are common set operations performed on sequences 161 * that are already sorted. The number of comparisons will be 162 * linear. 163 */ 164 165 /** 166 * @defgroup binary_search_algorithms Binary Search 167 * @ingroup sorting_algorithms 168 * 169 * These algorithms are variations of a classic binary search, and 170 * all assume that the sequence being searched is already sorted. 171 * 172 * The number of comparisons will be logarithmic (and as few as 173 * possible). The number of steps through the sequence will be 174 * logarithmic for random-access iterators (e.g., pointers), and 175 * linear otherwise. 176 * 177 * The LWG has passed Defect Report 270, which notes: <em>The 178 * proposed resolution reinterprets binary search. Instead of 179 * thinking about searching for a value in a sorted range, we view 180 * that as an important special case of a more general algorithm: 181 * searching for the partition point in a partitioned range. We 182 * also add a guarantee that the old wording did not: we ensure that 183 * the upper bound is no earlier than the lower bound, that the pair 184 * returned by equal_range is a valid range, and that the first part 185 * of that pair is the lower bound.</em> 186 * 187 * The actual effect of the first sentence is that a comparison 188 * functor passed by the user doesn't necessarily need to induce a 189 * strict weak ordering relation. Rather, it partitions the range. 190 */ 191 192 // adjacent_find 193 194 #if __cplusplus >= 201103L 195 template<typename _IIter, typename _Predicate> 196 bool 197 all_of(_IIter, _IIter, _Predicate); 198 199 template<typename _IIter, typename _Predicate> 200 bool 201 any_of(_IIter, _IIter, _Predicate); 202 #endif 203 204 template<typename _FIter, typename _Tp> 205 bool 206 binary_search(_FIter, _FIter, const _Tp&); 207 208 template<typename _FIter, typename _Tp, typename _Compare> 209 bool 210 binary_search(_FIter, _FIter, const _Tp&, _Compare); 211 212 #if __cplusplus > 201402L 213 template<typename _Tp> 214 _GLIBCXX14_CONSTEXPR 215 const _Tp& 216 clamp(const _Tp&, const _Tp&, const _Tp&); 217 218 template<typename _Tp, typename _Compare> 219 _GLIBCXX14_CONSTEXPR 220 const _Tp& 221 clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); 222 #endif 223 224 template<typename _IIter, typename _OIter> 225 _OIter 226 copy(_IIter, _IIter, _OIter); 227 228 template<typename _BIter1, typename _BIter2> 229 _BIter2 230 copy_backward(_BIter1, _BIter1, _BIter2); 231 232 #if __cplusplus >= 201103L 233 template<typename _IIter, typename _OIter, typename _Predicate> 234 _OIter 235 copy_if(_IIter, _IIter, _OIter, _Predicate); 236 237 template<typename _IIter, typename _Size, typename _OIter> 238 _OIter 239 copy_n(_IIter, _Size, _OIter); 240 #endif 241 242 // count 243 // count_if 244 245 template<typename _FIter, typename _Tp> 246 pair<_FIter, _FIter> 247 equal_range(_FIter, _FIter, const _Tp&); 248 249 template<typename _FIter, typename _Tp, typename _Compare> 250 pair<_FIter, _FIter> 251 equal_range(_FIter, _FIter, const _Tp&, _Compare); 252 253 template<typename _FIter, typename _Tp> 254 void 255 fill(_FIter, _FIter, const _Tp&); 256 257 template<typename _OIter, typename _Size, typename _Tp> 258 _OIter 259 fill_n(_OIter, _Size, const _Tp&); 260 261 // find 262 263 template<typename _FIter1, typename _FIter2> 264 _FIter1 265 find_end(_FIter1, _FIter1, _FIter2, _FIter2); 266 267 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 268 _FIter1 269 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 270 271 // find_first_of 272 // find_if 273 274 #if __cplusplus >= 201103L 275 template<typename _IIter, typename _Predicate> 276 _IIter 277 find_if_not(_IIter, _IIter, _Predicate); 278 #endif 279 280 // for_each 281 // generate 282 // generate_n 283 284 template<typename _IIter1, typename _IIter2> 285 bool 286 includes(_IIter1, _IIter1, _IIter2, _IIter2); 287 288 template<typename _IIter1, typename _IIter2, typename _Compare> 289 bool 290 includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 291 292 template<typename _BIter> 293 void 294 inplace_merge(_BIter, _BIter, _BIter); 295 296 template<typename _BIter, typename _Compare> 297 void 298 inplace_merge(_BIter, _BIter, _BIter, _Compare); 299 300 #if __cplusplus >= 201103L 301 template<typename _RAIter> 302 bool 303 is_heap(_RAIter, _RAIter); 304 305 template<typename _RAIter, typename _Compare> 306 bool 307 is_heap(_RAIter, _RAIter, _Compare); 308 309 template<typename _RAIter> 310 _RAIter 311 is_heap_until(_RAIter, _RAIter); 312 313 template<typename _RAIter, typename _Compare> 314 _RAIter 315 is_heap_until(_RAIter, _RAIter, _Compare); 316 317 template<typename _IIter, typename _Predicate> 318 bool 319 is_partitioned(_IIter, _IIter, _Predicate); 320 321 template<typename _FIter1, typename _FIter2> 322 bool 323 is_permutation(_FIter1, _FIter1, _FIter2); 324 325 template<typename _FIter1, typename _FIter2, 326 typename _BinaryPredicate> 327 bool 328 is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); 329 330 template<typename _FIter> 331 bool 332 is_sorted(_FIter, _FIter); 333 334 template<typename _FIter, typename _Compare> 335 bool 336 is_sorted(_FIter, _FIter, _Compare); 337 338 template<typename _FIter> 339 _FIter 340 is_sorted_until(_FIter, _FIter); 341 342 template<typename _FIter, typename _Compare> 343 _FIter 344 is_sorted_until(_FIter, _FIter, _Compare); 345 #endif 346 347 template<typename _FIter1, typename _FIter2> 348 void 349 iter_swap(_FIter1, _FIter2); 350 351 template<typename _FIter, typename _Tp> 352 _FIter 353 lower_bound(_FIter, _FIter, const _Tp&); 354 355 template<typename _FIter, typename _Tp, typename _Compare> 356 _FIter 357 lower_bound(_FIter, _FIter, const _Tp&, _Compare); 358 359 template<typename _RAIter> 360 void 361 make_heap(_RAIter, _RAIter); 362 363 template<typename _RAIter, typename _Compare> 364 void 365 make_heap(_RAIter, _RAIter, _Compare); 366 367 template<typename _Tp> 368 _GLIBCXX14_CONSTEXPR 369 const _Tp& 370 max(const _Tp&, const _Tp&); 371 372 template<typename _Tp, typename _Compare> 373 _GLIBCXX14_CONSTEXPR 374 const _Tp& 375 max(const _Tp&, const _Tp&, _Compare); 376 377 // max_element 378 // merge 379 380 template<typename _Tp> 381 _GLIBCXX14_CONSTEXPR 382 const _Tp& 383 min(const _Tp&, const _Tp&); 384 385 template<typename _Tp, typename _Compare> 386 _GLIBCXX14_CONSTEXPR 387 const _Tp& 388 min(const _Tp&, const _Tp&, _Compare); 389 390 // min_element 391 392 #if __cplusplus >= 201103L 393 template<typename _Tp> 394 _GLIBCXX14_CONSTEXPR 395 pair<const _Tp&, const _Tp&> 396 minmax(const _Tp&, const _Tp&); 397 398 template<typename _Tp, typename _Compare> 399 _GLIBCXX14_CONSTEXPR 400 pair<const _Tp&, const _Tp&> 401 minmax(const _Tp&, const _Tp&, _Compare); 402 403 template<typename _FIter> 404 _GLIBCXX14_CONSTEXPR 405 pair<_FIter, _FIter> 406 minmax_element(_FIter, _FIter); 407 408 template<typename _FIter, typename _Compare> 409 _GLIBCXX14_CONSTEXPR 410 pair<_FIter, _FIter> 411 minmax_element(_FIter, _FIter, _Compare); 412 413 template<typename _Tp> 414 _GLIBCXX14_CONSTEXPR 415 _Tp 416 min(initializer_list<_Tp>); 417 418 template<typename _Tp, typename _Compare> 419 _GLIBCXX14_CONSTEXPR 420 _Tp 421 min(initializer_list<_Tp>, _Compare); 422 423 template<typename _Tp> 424 _GLIBCXX14_CONSTEXPR 425 _Tp 426 max(initializer_list<_Tp>); 427 428 template<typename _Tp, typename _Compare> 429 _GLIBCXX14_CONSTEXPR 430 _Tp 431 max(initializer_list<_Tp>, _Compare); 432 433 template<typename _Tp> 434 _GLIBCXX14_CONSTEXPR 435 pair<_Tp, _Tp> 436 minmax(initializer_list<_Tp>); 437 438 template<typename _Tp, typename _Compare> 439 _GLIBCXX14_CONSTEXPR 440 pair<_Tp, _Tp> 441 minmax(initializer_list<_Tp>, _Compare); 442 #endif 443 444 // mismatch 445 446 template<typename _BIter> 447 bool 448 next_permutation(_BIter, _BIter); 449 450 template<typename _BIter, typename _Compare> 451 bool 452 next_permutation(_BIter, _BIter, _Compare); 453 454 #if __cplusplus >= 201103L 455 template<typename _IIter, typename _Predicate> 456 bool 457 none_of(_IIter, _IIter, _Predicate); 458 #endif 459 460 // nth_element 461 // partial_sort 462 463 template<typename _IIter, typename _RAIter> 464 _RAIter 465 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); 466 467 template<typename _IIter, typename _RAIter, typename _Compare> 468 _RAIter 469 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); 470 471 // partition 472 473 #if __cplusplus >= 201103L 474 template<typename _IIter, typename _OIter1, 475 typename _OIter2, typename _Predicate> 476 pair<_OIter1, _OIter2> 477 partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); 478 479 template<typename _FIter, typename _Predicate> 480 _FIter 481 partition_point(_FIter, _FIter, _Predicate); 482 #endif 483 484 template<typename _RAIter> 485 void 486 pop_heap(_RAIter, _RAIter); 487 488 template<typename _RAIter, typename _Compare> 489 void 490 pop_heap(_RAIter, _RAIter, _Compare); 491 492 template<typename _BIter> 493 bool 494 prev_permutation(_BIter, _BIter); 495 496 template<typename _BIter, typename _Compare> 497 bool 498 prev_permutation(_BIter, _BIter, _Compare); 499 500 template<typename _RAIter> 501 void 502 push_heap(_RAIter, _RAIter); 503 504 template<typename _RAIter, typename _Compare> 505 void 506 push_heap(_RAIter, _RAIter, _Compare); 507 508 // random_shuffle 509 510 template<typename _FIter, typename _Tp> 511 _FIter 512 remove(_FIter, _FIter, const _Tp&); 513 514 template<typename _FIter, typename _Predicate> 515 _FIter 516 remove_if(_FIter, _FIter, _Predicate); 517 518 template<typename _IIter, typename _OIter, typename _Tp> 519 _OIter 520 remove_copy(_IIter, _IIter, _OIter, const _Tp&); 521 522 template<typename _IIter, typename _OIter, typename _Predicate> 523 _OIter 524 remove_copy_if(_IIter, _IIter, _OIter, _Predicate); 525 526 // replace 527 528 template<typename _IIter, typename _OIter, typename _Tp> 529 _OIter 530 replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); 531 532 template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp> 533 _OIter 534 replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); 535 536 // replace_if 537 538 template<typename _BIter> 539 void 540 reverse(_BIter, _BIter); 541 542 template<typename _BIter, typename _OIter> 543 _OIter 544 reverse_copy(_BIter, _BIter, _OIter); 545 546 inline namespace _V2 547 { 548 template<typename _FIter> 549 _FIter 550 rotate(_FIter, _FIter, _FIter); 551 } 552 553 template<typename _FIter, typename _OIter> 554 _OIter 555 rotate_copy(_FIter, _FIter, _FIter, _OIter); 556 557 // search 558 // search_n 559 // set_difference 560 // set_intersection 561 // set_symmetric_difference 562 // set_union 563 564 #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 565 template<typename _RAIter, typename _UGenerator> 566 void 567 shuffle(_RAIter, _RAIter, _UGenerator&&); 568 #endif 569 570 template<typename _RAIter> 571 void 572 sort_heap(_RAIter, _RAIter); 573 574 template<typename _RAIter, typename _Compare> 575 void 576 sort_heap(_RAIter, _RAIter, _Compare); 577 578 template<typename _BIter, typename _Predicate> 579 _BIter 580 stable_partition(_BIter, _BIter, _Predicate); 581 582 #if __cplusplus < 201103L 583 // For C++11 swap() is declared in <type_traits>. 584 585 template<typename _Tp, size_t _Nm> 586 inline void 587 swap(_Tp& __a, _Tp& __b); 588 589 template<typename _Tp, size_t _Nm> 590 inline void 591 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]); 592 #endif 593 594 template<typename _FIter1, typename _FIter2> 595 _FIter2 596 swap_ranges(_FIter1, _FIter1, _FIter2); 597 598 // transform 599 600 template<typename _FIter> 601 _FIter 602 unique(_FIter, _FIter); 603 604 template<typename _FIter, typename _BinaryPredicate> 605 _FIter 606 unique(_FIter, _FIter, _BinaryPredicate); 607 608 // unique_copy 609 610 template<typename _FIter, typename _Tp> 611 _FIter 612 upper_bound(_FIter, _FIter, const _Tp&); 613 614 template<typename _FIter, typename _Tp, typename _Compare> 615 _FIter 616 upper_bound(_FIter, _FIter, const _Tp&, _Compare); 617 618 _GLIBCXX_END_NAMESPACE_VERSION 619 620 _GLIBCXX_BEGIN_NAMESPACE_ALGO 621 622 template<typename _FIter> 623 _FIter 624 adjacent_find(_FIter, _FIter); 625 626 template<typename _FIter, typename _BinaryPredicate> 627 _FIter 628 adjacent_find(_FIter, _FIter, _BinaryPredicate); 629 630 template<typename _IIter, typename _Tp> 631 typename iterator_traits<_IIter>::difference_type 632 count(_IIter, _IIter, const _Tp&); 633 634 template<typename _IIter, typename _Predicate> 635 typename iterator_traits<_IIter>::difference_type 636 count_if(_IIter, _IIter, _Predicate); 637 638 template<typename _IIter1, typename _IIter2> 639 bool 640 equal(_IIter1, _IIter1, _IIter2); 641 642 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 643 bool 644 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 645 646 template<typename _IIter, typename _Tp> 647 _IIter 648 find(_IIter, _IIter, const _Tp&); 649 650 template<typename _FIter1, typename _FIter2> 651 _FIter1 652 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); 653 654 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 655 _FIter1 656 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 657 658 template<typename _IIter, typename _Predicate> 659 _IIter 660 find_if(_IIter, _IIter, _Predicate); 661 662 template<typename _IIter, typename _Funct> 663 _Funct 664 for_each(_IIter, _IIter, _Funct); 665 666 template<typename _FIter, typename _Generator> 667 void 668 generate(_FIter, _FIter, _Generator); 669 670 template<typename _OIter, typename _Size, typename _Generator> 671 _OIter 672 generate_n(_OIter, _Size, _Generator); 673 674 template<typename _IIter1, typename _IIter2> 675 bool 676 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); 677 678 template<typename _IIter1, typename _IIter2, typename _Compare> 679 bool 680 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 681 682 template<typename _FIter> 683 _GLIBCXX14_CONSTEXPR 684 _FIter 685 max_element(_FIter, _FIter); 686 687 template<typename _FIter, typename _Compare> 688 _GLIBCXX14_CONSTEXPR 689 _FIter 690 max_element(_FIter, _FIter, _Compare); 691 692 template<typename _IIter1, typename _IIter2, typename _OIter> 693 _OIter 694 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 695 696 template<typename _IIter1, typename _IIter2, typename _OIter, 697 typename _Compare> 698 _OIter 699 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 700 701 template<typename _FIter> 702 _GLIBCXX14_CONSTEXPR 703 _FIter 704 min_element(_FIter, _FIter); 705 706 template<typename _FIter, typename _Compare> 707 _GLIBCXX14_CONSTEXPR 708 _FIter 709 min_element(_FIter, _FIter, _Compare); 710 711 template<typename _IIter1, typename _IIter2> 712 pair<_IIter1, _IIter2> 713 mismatch(_IIter1, _IIter1, _IIter2); 714 715 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 716 pair<_IIter1, _IIter2> 717 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 718 719 template<typename _RAIter> 720 void 721 nth_element(_RAIter, _RAIter, _RAIter); 722 723 template<typename _RAIter, typename _Compare> 724 void 725 nth_element(_RAIter, _RAIter, _RAIter, _Compare); 726 727 template<typename _RAIter> 728 void 729 partial_sort(_RAIter, _RAIter, _RAIter); 730 731 template<typename _RAIter, typename _Compare> 732 void 733 partial_sort(_RAIter, _RAIter, _RAIter, _Compare); 734 735 template<typename _BIter, typename _Predicate> 736 _BIter 737 partition(_BIter, _BIter, _Predicate); 738 739 template<typename _RAIter> 740 void 741 random_shuffle(_RAIter, _RAIter); 742 743 template<typename _RAIter, typename _Generator> 744 void 745 random_shuffle(_RAIter, _RAIter, 746 #if __cplusplus >= 201103L 747 _Generator&&); 748 #else 749 _Generator&); 750 #endif 751 752 template<typename _FIter, typename _Tp> 753 void 754 replace(_FIter, _FIter, const _Tp&, const _Tp&); 755 756 template<typename _FIter, typename _Predicate, typename _Tp> 757 void 758 replace_if(_FIter, _FIter, _Predicate, const _Tp&); 759 760 template<typename _FIter1, typename _FIter2> 761 _FIter1 762 search(_FIter1, _FIter1, _FIter2, _FIter2); 763 764 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 765 _FIter1 766 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 767 768 template<typename _FIter, typename _Size, typename _Tp> 769 _FIter 770 search_n(_FIter, _FIter, _Size, const _Tp&); 771 772 template<typename _FIter, typename _Size, typename _Tp, 773 typename _BinaryPredicate> 774 _FIter 775 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); 776 777 template<typename _IIter1, typename _IIter2, typename _OIter> 778 _OIter 779 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 780 781 template<typename _IIter1, typename _IIter2, typename _OIter, 782 typename _Compare> 783 _OIter 784 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 785 786 template<typename _IIter1, typename _IIter2, typename _OIter> 787 _OIter 788 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 789 790 template<typename _IIter1, typename _IIter2, typename _OIter, 791 typename _Compare> 792 _OIter 793 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 794 795 template<typename _IIter1, typename _IIter2, typename _OIter> 796 _OIter 797 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 798 799 template<typename _IIter1, typename _IIter2, typename _OIter, 800 typename _Compare> 801 _OIter 802 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 803 _OIter, _Compare); 804 805 template<typename _IIter1, typename _IIter2, typename _OIter> 806 _OIter 807 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 808 809 template<typename _IIter1, typename _IIter2, typename _OIter, 810 typename _Compare> 811 _OIter 812 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 813 814 template<typename _RAIter> 815 void 816 sort(_RAIter, _RAIter); 817 818 template<typename _RAIter, typename _Compare> 819 void 820 sort(_RAIter, _RAIter, _Compare); 821 822 template<typename _RAIter> 823 void 824 stable_sort(_RAIter, _RAIter); 825 826 template<typename _RAIter, typename _Compare> 827 void 828 stable_sort(_RAIter, _RAIter, _Compare); 829 830 template<typename _IIter, typename _OIter, typename _UnaryOperation> 831 _OIter 832 transform(_IIter, _IIter, _OIter, _UnaryOperation); 833 834 template<typename _IIter1, typename _IIter2, typename _OIter, 835 typename _BinaryOperation> 836 _OIter 837 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); 838 839 template<typename _IIter, typename _OIter> 840 _OIter 841 unique_copy(_IIter, _IIter, _OIter); 842 843 template<typename _IIter, typename _OIter, typename _BinaryPredicate> 844 _OIter 845 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); 846 847 _GLIBCXX_END_NAMESPACE_ALGO 848 } // namespace std 849 850 #ifdef _GLIBCXX_PARALLEL 851 # include <parallel/algorithmfwd.h> 852 #endif 853 854 #endif 855 856