1 // <algorithm> Forward declarations -*- C++ -*- 2 3 // Copyright (C) 2007-2022 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 Operations 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 > 201703L 195 # define __cpp_lib_constexpr_algorithms 201806L 196 #endif 197 198 #if __cplusplus >= 201103L 199 template<typename _IIter, typename _Predicate> 200 _GLIBCXX20_CONSTEXPR 201 bool 202 all_of(_IIter, _IIter, _Predicate); 203 204 template<typename _IIter, typename _Predicate> 205 _GLIBCXX20_CONSTEXPR 206 bool 207 any_of(_IIter, _IIter, _Predicate); 208 #endif 209 210 template<typename _FIter, typename _Tp> 211 _GLIBCXX20_CONSTEXPR 212 bool 213 binary_search(_FIter, _FIter, const _Tp&); 214 215 template<typename _FIter, typename _Tp, typename _Compare> 216 _GLIBCXX20_CONSTEXPR 217 bool 218 binary_search(_FIter, _FIter, const _Tp&, _Compare); 219 220 #if __cplusplus > 201402L 221 template<typename _Tp> 222 _GLIBCXX14_CONSTEXPR 223 const _Tp& 224 clamp(const _Tp&, const _Tp&, const _Tp&); 225 226 template<typename _Tp, typename _Compare> 227 _GLIBCXX14_CONSTEXPR 228 const _Tp& 229 clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); 230 #endif 231 232 template<typename _IIter, typename _OIter> 233 _GLIBCXX20_CONSTEXPR 234 _OIter 235 copy(_IIter, _IIter, _OIter); 236 237 template<typename _BIter1, typename _BIter2> 238 _GLIBCXX20_CONSTEXPR 239 _BIter2 240 copy_backward(_BIter1, _BIter1, _BIter2); 241 242 #if __cplusplus >= 201103L 243 template<typename _IIter, typename _OIter, typename _Predicate> 244 _GLIBCXX20_CONSTEXPR 245 _OIter 246 copy_if(_IIter, _IIter, _OIter, _Predicate); 247 248 template<typename _IIter, typename _Size, typename _OIter> 249 _GLIBCXX20_CONSTEXPR 250 _OIter 251 copy_n(_IIter, _Size, _OIter); 252 #endif 253 254 // count 255 // count_if 256 257 template<typename _FIter, typename _Tp> 258 _GLIBCXX20_CONSTEXPR 259 pair<_FIter, _FIter> 260 equal_range(_FIter, _FIter, const _Tp&); 261 262 template<typename _FIter, typename _Tp, typename _Compare> 263 _GLIBCXX20_CONSTEXPR 264 pair<_FIter, _FIter> 265 equal_range(_FIter, _FIter, const _Tp&, _Compare); 266 267 template<typename _FIter, typename _Tp> 268 _GLIBCXX20_CONSTEXPR 269 void 270 fill(_FIter, _FIter, const _Tp&); 271 272 template<typename _OIter, typename _Size, typename _Tp> 273 _GLIBCXX20_CONSTEXPR 274 _OIter 275 fill_n(_OIter, _Size, const _Tp&); 276 277 // find 278 279 template<typename _FIter1, typename _FIter2> 280 _GLIBCXX20_CONSTEXPR 281 _FIter1 282 find_end(_FIter1, _FIter1, _FIter2, _FIter2); 283 284 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 285 _GLIBCXX20_CONSTEXPR 286 _FIter1 287 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 288 289 // find_first_of 290 // find_if 291 292 #if __cplusplus >= 201103L 293 template<typename _IIter, typename _Predicate> 294 _GLIBCXX20_CONSTEXPR 295 _IIter 296 find_if_not(_IIter, _IIter, _Predicate); 297 #endif 298 299 // for_each 300 // generate 301 // generate_n 302 303 template<typename _IIter1, typename _IIter2> 304 _GLIBCXX20_CONSTEXPR 305 bool 306 includes(_IIter1, _IIter1, _IIter2, _IIter2); 307 308 template<typename _IIter1, typename _IIter2, typename _Compare> 309 _GLIBCXX20_CONSTEXPR 310 bool 311 includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 312 313 template<typename _BIter> 314 void 315 inplace_merge(_BIter, _BIter, _BIter); 316 317 template<typename _BIter, typename _Compare> 318 void 319 inplace_merge(_BIter, _BIter, _BIter, _Compare); 320 321 #if __cplusplus >= 201103L 322 template<typename _RAIter> 323 _GLIBCXX20_CONSTEXPR 324 bool 325 is_heap(_RAIter, _RAIter); 326 327 template<typename _RAIter, typename _Compare> 328 _GLIBCXX20_CONSTEXPR 329 bool 330 is_heap(_RAIter, _RAIter, _Compare); 331 332 template<typename _RAIter> 333 _GLIBCXX20_CONSTEXPR 334 _RAIter 335 is_heap_until(_RAIter, _RAIter); 336 337 template<typename _RAIter, typename _Compare> 338 _GLIBCXX20_CONSTEXPR 339 _RAIter 340 is_heap_until(_RAIter, _RAIter, _Compare); 341 342 template<typename _IIter, typename _Predicate> 343 _GLIBCXX20_CONSTEXPR 344 bool 345 is_partitioned(_IIter, _IIter, _Predicate); 346 347 template<typename _FIter1, typename _FIter2> 348 _GLIBCXX20_CONSTEXPR 349 bool 350 is_permutation(_FIter1, _FIter1, _FIter2); 351 352 template<typename _FIter1, typename _FIter2, 353 typename _BinaryPredicate> 354 _GLIBCXX20_CONSTEXPR 355 bool 356 is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); 357 358 template<typename _FIter> 359 _GLIBCXX20_CONSTEXPR 360 bool 361 is_sorted(_FIter, _FIter); 362 363 template<typename _FIter, typename _Compare> 364 _GLIBCXX20_CONSTEXPR 365 bool 366 is_sorted(_FIter, _FIter, _Compare); 367 368 template<typename _FIter> 369 _GLIBCXX20_CONSTEXPR 370 _FIter 371 is_sorted_until(_FIter, _FIter); 372 373 template<typename _FIter, typename _Compare> 374 _GLIBCXX20_CONSTEXPR 375 _FIter 376 is_sorted_until(_FIter, _FIter, _Compare); 377 #endif 378 379 template<typename _FIter1, typename _FIter2> 380 _GLIBCXX20_CONSTEXPR 381 void 382 iter_swap(_FIter1, _FIter2); 383 384 template<typename _FIter, typename _Tp> 385 _GLIBCXX20_CONSTEXPR 386 _FIter 387 lower_bound(_FIter, _FIter, const _Tp&); 388 389 template<typename _FIter, typename _Tp, typename _Compare> 390 _GLIBCXX20_CONSTEXPR 391 _FIter 392 lower_bound(_FIter, _FIter, const _Tp&, _Compare); 393 394 template<typename _RAIter> 395 _GLIBCXX20_CONSTEXPR 396 void 397 make_heap(_RAIter, _RAIter); 398 399 template<typename _RAIter, typename _Compare> 400 _GLIBCXX20_CONSTEXPR 401 void 402 make_heap(_RAIter, _RAIter, _Compare); 403 404 template<typename _Tp> 405 _GLIBCXX14_CONSTEXPR 406 const _Tp& 407 max(const _Tp&, const _Tp&); 408 409 template<typename _Tp, typename _Compare> 410 _GLIBCXX14_CONSTEXPR 411 const _Tp& 412 max(const _Tp&, const _Tp&, _Compare); 413 414 // max_element 415 // merge 416 417 template<typename _Tp> 418 _GLIBCXX14_CONSTEXPR 419 const _Tp& 420 min(const _Tp&, const _Tp&); 421 422 template<typename _Tp, typename _Compare> 423 _GLIBCXX14_CONSTEXPR 424 const _Tp& 425 min(const _Tp&, const _Tp&, _Compare); 426 427 // min_element 428 429 #if __cplusplus >= 201103L 430 template<typename _Tp> 431 _GLIBCXX14_CONSTEXPR 432 pair<const _Tp&, const _Tp&> 433 minmax(const _Tp&, const _Tp&); 434 435 template<typename _Tp, typename _Compare> 436 _GLIBCXX14_CONSTEXPR 437 pair<const _Tp&, const _Tp&> 438 minmax(const _Tp&, const _Tp&, _Compare); 439 440 template<typename _FIter> 441 _GLIBCXX14_CONSTEXPR 442 pair<_FIter, _FIter> 443 minmax_element(_FIter, _FIter); 444 445 template<typename _FIter, typename _Compare> 446 _GLIBCXX14_CONSTEXPR 447 pair<_FIter, _FIter> 448 minmax_element(_FIter, _FIter, _Compare); 449 450 template<typename _Tp> 451 _GLIBCXX14_CONSTEXPR 452 _Tp 453 min(initializer_list<_Tp>); 454 455 template<typename _Tp, typename _Compare> 456 _GLIBCXX14_CONSTEXPR 457 _Tp 458 min(initializer_list<_Tp>, _Compare); 459 460 template<typename _Tp> 461 _GLIBCXX14_CONSTEXPR 462 _Tp 463 max(initializer_list<_Tp>); 464 465 template<typename _Tp, typename _Compare> 466 _GLIBCXX14_CONSTEXPR 467 _Tp 468 max(initializer_list<_Tp>, _Compare); 469 470 template<typename _Tp> 471 _GLIBCXX14_CONSTEXPR 472 pair<_Tp, _Tp> 473 minmax(initializer_list<_Tp>); 474 475 template<typename _Tp, typename _Compare> 476 _GLIBCXX14_CONSTEXPR 477 pair<_Tp, _Tp> 478 minmax(initializer_list<_Tp>, _Compare); 479 #endif 480 481 // mismatch 482 483 template<typename _BIter> 484 _GLIBCXX20_CONSTEXPR 485 bool 486 next_permutation(_BIter, _BIter); 487 488 template<typename _BIter, typename _Compare> 489 _GLIBCXX20_CONSTEXPR 490 bool 491 next_permutation(_BIter, _BIter, _Compare); 492 493 #if __cplusplus >= 201103L 494 template<typename _IIter, typename _Predicate> 495 _GLIBCXX20_CONSTEXPR 496 bool 497 none_of(_IIter, _IIter, _Predicate); 498 #endif 499 500 // nth_element 501 // partial_sort 502 503 template<typename _IIter, typename _RAIter> 504 _GLIBCXX20_CONSTEXPR 505 _RAIter 506 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); 507 508 template<typename _IIter, typename _RAIter, typename _Compare> 509 _GLIBCXX20_CONSTEXPR 510 _RAIter 511 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); 512 513 // partition 514 515 #if __cplusplus >= 201103L 516 template<typename _IIter, typename _OIter1, 517 typename _OIter2, typename _Predicate> 518 _GLIBCXX20_CONSTEXPR 519 pair<_OIter1, _OIter2> 520 partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); 521 522 template<typename _FIter, typename _Predicate> 523 _GLIBCXX20_CONSTEXPR 524 _FIter 525 partition_point(_FIter, _FIter, _Predicate); 526 #endif 527 528 template<typename _RAIter> 529 _GLIBCXX20_CONSTEXPR 530 void 531 pop_heap(_RAIter, _RAIter); 532 533 template<typename _RAIter, typename _Compare> 534 _GLIBCXX20_CONSTEXPR 535 void 536 pop_heap(_RAIter, _RAIter, _Compare); 537 538 template<typename _BIter> 539 _GLIBCXX20_CONSTEXPR 540 bool 541 prev_permutation(_BIter, _BIter); 542 543 template<typename _BIter, typename _Compare> 544 _GLIBCXX20_CONSTEXPR 545 bool 546 prev_permutation(_BIter, _BIter, _Compare); 547 548 template<typename _RAIter> 549 _GLIBCXX20_CONSTEXPR 550 void 551 push_heap(_RAIter, _RAIter); 552 553 template<typename _RAIter, typename _Compare> 554 _GLIBCXX20_CONSTEXPR 555 void 556 push_heap(_RAIter, _RAIter, _Compare); 557 558 // random_shuffle 559 560 template<typename _FIter, typename _Tp> 561 _GLIBCXX20_CONSTEXPR 562 _FIter 563 remove(_FIter, _FIter, const _Tp&); 564 565 template<typename _FIter, typename _Predicate> 566 _GLIBCXX20_CONSTEXPR 567 _FIter 568 remove_if(_FIter, _FIter, _Predicate); 569 570 template<typename _IIter, typename _OIter, typename _Tp> 571 _GLIBCXX20_CONSTEXPR 572 _OIter 573 remove_copy(_IIter, _IIter, _OIter, const _Tp&); 574 575 template<typename _IIter, typename _OIter, typename _Predicate> 576 _GLIBCXX20_CONSTEXPR 577 _OIter 578 remove_copy_if(_IIter, _IIter, _OIter, _Predicate); 579 580 // replace 581 582 template<typename _IIter, typename _OIter, typename _Tp> 583 _GLIBCXX20_CONSTEXPR 584 _OIter 585 replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); 586 587 template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp> 588 _GLIBCXX20_CONSTEXPR 589 _OIter 590 replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); 591 592 // replace_if 593 594 template<typename _BIter> 595 _GLIBCXX20_CONSTEXPR 596 void 597 reverse(_BIter, _BIter); 598 599 template<typename _BIter, typename _OIter> 600 _GLIBCXX20_CONSTEXPR 601 _OIter 602 reverse_copy(_BIter, _BIter, _OIter); 603 604 _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) 605 606 template<typename _FIter> 607 _GLIBCXX20_CONSTEXPR 608 _FIter 609 rotate(_FIter, _FIter, _FIter); 610 611 _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) 612 613 template<typename _FIter, typename _OIter> 614 _GLIBCXX20_CONSTEXPR 615 _OIter 616 rotate_copy(_FIter, _FIter, _FIter, _OIter); 617 618 // search 619 // search_n 620 // set_difference 621 // set_intersection 622 // set_symmetric_difference 623 // set_union 624 625 #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 626 template<typename _RAIter, typename _UGenerator> 627 void 628 shuffle(_RAIter, _RAIter, _UGenerator&&); 629 #endif 630 631 template<typename _RAIter> 632 _GLIBCXX20_CONSTEXPR 633 void 634 sort_heap(_RAIter, _RAIter); 635 636 template<typename _RAIter, typename _Compare> 637 _GLIBCXX20_CONSTEXPR 638 void 639 sort_heap(_RAIter, _RAIter, _Compare); 640 641 template<typename _BIter, typename _Predicate> 642 _BIter 643 stable_partition(_BIter, _BIter, _Predicate); 644 645 #if __cplusplus < 201103L 646 // For C++11 swap() is declared in <type_traits>. 647 648 template<typename _Tp, size_t _Nm> 649 _GLIBCXX20_CONSTEXPR 650 inline void 651 swap(_Tp& __a, _Tp& __b); 652 653 template<typename _Tp, size_t _Nm> 654 _GLIBCXX20_CONSTEXPR 655 inline void 656 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]); 657 #endif 658 659 template<typename _FIter1, typename _FIter2> 660 _GLIBCXX20_CONSTEXPR 661 _FIter2 662 swap_ranges(_FIter1, _FIter1, _FIter2); 663 664 // transform 665 666 template<typename _FIter> 667 _GLIBCXX20_CONSTEXPR 668 _FIter 669 unique(_FIter, _FIter); 670 671 template<typename _FIter, typename _BinaryPredicate> 672 _GLIBCXX20_CONSTEXPR 673 _FIter 674 unique(_FIter, _FIter, _BinaryPredicate); 675 676 // unique_copy 677 678 template<typename _FIter, typename _Tp> 679 _GLIBCXX20_CONSTEXPR 680 _FIter 681 upper_bound(_FIter, _FIter, const _Tp&); 682 683 template<typename _FIter, typename _Tp, typename _Compare> 684 _GLIBCXX20_CONSTEXPR 685 _FIter 686 upper_bound(_FIter, _FIter, const _Tp&, _Compare); 687 688 _GLIBCXX_BEGIN_NAMESPACE_ALGO 689 690 template<typename _FIter> 691 _GLIBCXX20_CONSTEXPR 692 _FIter 693 adjacent_find(_FIter, _FIter); 694 695 template<typename _FIter, typename _BinaryPredicate> 696 _GLIBCXX20_CONSTEXPR 697 _FIter 698 adjacent_find(_FIter, _FIter, _BinaryPredicate); 699 700 template<typename _IIter, typename _Tp> 701 _GLIBCXX20_CONSTEXPR 702 typename iterator_traits<_IIter>::difference_type 703 count(_IIter, _IIter, const _Tp&); 704 705 template<typename _IIter, typename _Predicate> 706 _GLIBCXX20_CONSTEXPR 707 typename iterator_traits<_IIter>::difference_type 708 count_if(_IIter, _IIter, _Predicate); 709 710 template<typename _IIter1, typename _IIter2> 711 _GLIBCXX20_CONSTEXPR 712 bool 713 equal(_IIter1, _IIter1, _IIter2); 714 715 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 716 _GLIBCXX20_CONSTEXPR 717 bool 718 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 719 720 template<typename _IIter, typename _Tp> 721 _GLIBCXX20_CONSTEXPR 722 _IIter 723 find(_IIter, _IIter, const _Tp&); 724 725 template<typename _FIter1, typename _FIter2> 726 _GLIBCXX20_CONSTEXPR 727 _FIter1 728 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); 729 730 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 731 _GLIBCXX20_CONSTEXPR 732 _FIter1 733 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 734 735 template<typename _IIter, typename _Predicate> 736 _GLIBCXX20_CONSTEXPR 737 _IIter 738 find_if(_IIter, _IIter, _Predicate); 739 740 template<typename _IIter, typename _Funct> 741 _GLIBCXX20_CONSTEXPR 742 _Funct 743 for_each(_IIter, _IIter, _Funct); 744 745 template<typename _FIter, typename _Generator> 746 _GLIBCXX20_CONSTEXPR 747 void 748 generate(_FIter, _FIter, _Generator); 749 750 template<typename _OIter, typename _Size, typename _Generator> 751 _GLIBCXX20_CONSTEXPR 752 _OIter 753 generate_n(_OIter, _Size, _Generator); 754 755 template<typename _IIter1, typename _IIter2> 756 _GLIBCXX20_CONSTEXPR 757 bool 758 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); 759 760 template<typename _IIter1, typename _IIter2, typename _Compare> 761 _GLIBCXX20_CONSTEXPR 762 bool 763 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 764 765 template<typename _FIter> 766 _GLIBCXX14_CONSTEXPR 767 _FIter 768 max_element(_FIter, _FIter); 769 770 template<typename _FIter, typename _Compare> 771 _GLIBCXX14_CONSTEXPR 772 _FIter 773 max_element(_FIter, _FIter, _Compare); 774 775 template<typename _IIter1, typename _IIter2, typename _OIter> 776 _GLIBCXX20_CONSTEXPR 777 _OIter 778 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 779 780 template<typename _IIter1, typename _IIter2, typename _OIter, 781 typename _Compare> 782 _GLIBCXX20_CONSTEXPR 783 _OIter 784 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 785 786 template<typename _FIter> 787 _GLIBCXX14_CONSTEXPR 788 _FIter 789 min_element(_FIter, _FIter); 790 791 template<typename _FIter, typename _Compare> 792 _GLIBCXX14_CONSTEXPR 793 _FIter 794 min_element(_FIter, _FIter, _Compare); 795 796 template<typename _IIter1, typename _IIter2> 797 _GLIBCXX20_CONSTEXPR 798 pair<_IIter1, _IIter2> 799 mismatch(_IIter1, _IIter1, _IIter2); 800 801 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 802 _GLIBCXX20_CONSTEXPR 803 pair<_IIter1, _IIter2> 804 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 805 806 template<typename _RAIter> 807 _GLIBCXX20_CONSTEXPR 808 void 809 nth_element(_RAIter, _RAIter, _RAIter); 810 811 template<typename _RAIter, typename _Compare> 812 _GLIBCXX20_CONSTEXPR 813 void 814 nth_element(_RAIter, _RAIter, _RAIter, _Compare); 815 816 template<typename _RAIter> 817 _GLIBCXX20_CONSTEXPR 818 void 819 partial_sort(_RAIter, _RAIter, _RAIter); 820 821 template<typename _RAIter, typename _Compare> 822 _GLIBCXX20_CONSTEXPR 823 void 824 partial_sort(_RAIter, _RAIter, _RAIter, _Compare); 825 826 template<typename _BIter, typename _Predicate> 827 _GLIBCXX20_CONSTEXPR 828 _BIter 829 partition(_BIter, _BIter, _Predicate); 830 831 template<typename _RAIter> 832 _GLIBCXX14_DEPRECATED_SUGGEST("std::shuffle") 833 void 834 random_shuffle(_RAIter, _RAIter); 835 836 template<typename _RAIter, typename _Generator> 837 _GLIBCXX14_DEPRECATED_SUGGEST("std::shuffle") 838 void 839 random_shuffle(_RAIter, _RAIter, 840 #if __cplusplus >= 201103L 841 _Generator&&); 842 #else 843 _Generator&); 844 #endif 845 846 template<typename _FIter, typename _Tp> 847 _GLIBCXX20_CONSTEXPR 848 void 849 replace(_FIter, _FIter, const _Tp&, const _Tp&); 850 851 template<typename _FIter, typename _Predicate, typename _Tp> 852 _GLIBCXX20_CONSTEXPR 853 void 854 replace_if(_FIter, _FIter, _Predicate, const _Tp&); 855 856 template<typename _FIter1, typename _FIter2> 857 _GLIBCXX20_CONSTEXPR 858 _FIter1 859 search(_FIter1, _FIter1, _FIter2, _FIter2); 860 861 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 862 _GLIBCXX20_CONSTEXPR 863 _FIter1 864 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 865 866 template<typename _FIter, typename _Size, typename _Tp> 867 _GLIBCXX20_CONSTEXPR 868 _FIter 869 search_n(_FIter, _FIter, _Size, const _Tp&); 870 871 template<typename _FIter, typename _Size, typename _Tp, 872 typename _BinaryPredicate> 873 _GLIBCXX20_CONSTEXPR 874 _FIter 875 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); 876 877 template<typename _IIter1, typename _IIter2, typename _OIter> 878 _GLIBCXX20_CONSTEXPR 879 _OIter 880 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 881 882 template<typename _IIter1, typename _IIter2, typename _OIter, 883 typename _Compare> 884 _GLIBCXX20_CONSTEXPR 885 _OIter 886 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 887 888 template<typename _IIter1, typename _IIter2, typename _OIter> 889 _GLIBCXX20_CONSTEXPR 890 _OIter 891 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 892 893 template<typename _IIter1, typename _IIter2, typename _OIter, 894 typename _Compare> 895 _GLIBCXX20_CONSTEXPR 896 _OIter 897 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 898 899 template<typename _IIter1, typename _IIter2, typename _OIter> 900 _GLIBCXX20_CONSTEXPR 901 _OIter 902 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 903 904 template<typename _IIter1, typename _IIter2, typename _OIter, 905 typename _Compare> 906 _GLIBCXX20_CONSTEXPR 907 _OIter 908 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 909 _OIter, _Compare); 910 911 template<typename _IIter1, typename _IIter2, typename _OIter> 912 _GLIBCXX20_CONSTEXPR 913 _OIter 914 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 915 916 template<typename _IIter1, typename _IIter2, typename _OIter, 917 typename _Compare> 918 _GLIBCXX20_CONSTEXPR 919 _OIter 920 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 921 922 template<typename _RAIter> 923 _GLIBCXX20_CONSTEXPR 924 void 925 sort(_RAIter, _RAIter); 926 927 template<typename _RAIter, typename _Compare> 928 _GLIBCXX20_CONSTEXPR 929 void 930 sort(_RAIter, _RAIter, _Compare); 931 932 template<typename _RAIter> 933 void 934 stable_sort(_RAIter, _RAIter); 935 936 template<typename _RAIter, typename _Compare> 937 void 938 stable_sort(_RAIter, _RAIter, _Compare); 939 940 template<typename _IIter, typename _OIter, typename _UnaryOperation> 941 _GLIBCXX20_CONSTEXPR 942 _OIter 943 transform(_IIter, _IIter, _OIter, _UnaryOperation); 944 945 template<typename _IIter1, typename _IIter2, typename _OIter, 946 typename _BinaryOperation> 947 _GLIBCXX20_CONSTEXPR 948 _OIter 949 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); 950 951 template<typename _IIter, typename _OIter> 952 _GLIBCXX20_CONSTEXPR 953 _OIter 954 unique_copy(_IIter, _IIter, _OIter); 955 956 template<typename _IIter, typename _OIter, typename _BinaryPredicate> 957 _GLIBCXX20_CONSTEXPR 958 _OIter 959 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); 960 961 _GLIBCXX_END_NAMESPACE_ALGO 962 _GLIBCXX_END_NAMESPACE_VERSION 963 } // namespace std 964 965 #ifdef _GLIBCXX_PARALLEL 966 # include <parallel/algorithmfwd.h> 967 #endif 968 969 #endif 970 971