libstdc++-v3/include/bits/algorithmfwd.h

   1 // <algorithm> Forward declarations  -*- C++ -*-
   2
   3 // Copyright (C) 2007-2018 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_BEGIN_NAMESPACE_ALGO
 619
 620   template<typename _FIter>
 621     _FIter
 622     adjacent_find(_FIter, _FIter);
 623
 624   template<typename _FIter, typename _BinaryPredicate>
 625     _FIter
 626     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 627
 628   template<typename _IIter, typename _Tp>
 629     typename iterator_traits<_IIter>::difference_type
 630     count(_IIter, _IIter, const _Tp&);
 631
 632   template<typename _IIter, typename _Predicate>
 633     typename iterator_traits<_IIter>::difference_type
 634     count_if(_IIter, _IIter, _Predicate);
 635
 636   template<typename _IIter1, typename _IIter2>
 637     bool
 638     equal(_IIter1, _IIter1, _IIter2);
 639
 640   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 641     bool
 642     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 643
 644   template<typename _IIter, typename _Tp>
 645     _IIter
 646     find(_IIter, _IIter, const _Tp&);
 647
 648   template<typename _FIter1, typename _FIter2>
 649     _FIter1
 650     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
 651
 652   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 653     _FIter1
 654     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 655
 656   template<typename _IIter, typename _Predicate>
 657     _IIter
 658     find_if(_IIter, _IIter, _Predicate);
 659
 660   template<typename _IIter, typename _Funct>
 661     _Funct
 662     for_each(_IIter, _IIter, _Funct);
 663
 664   template<typename _FIter, typename _Generator>
 665     void
 666     generate(_FIter, _FIter, _Generator);
 667
 668   template<typename _OIter, typename _Size, typename _Generator>
 669     _OIter
 670     generate_n(_OIter, _Size, _Generator);
 671
 672   template<typename _IIter1, typename _IIter2>
 673     bool
 674     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 675
 676   template<typename _IIter1, typename _IIter2, typename _Compare>
 677     bool
 678     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 679
 680   template<typename _FIter>
 681     _GLIBCXX14_CONSTEXPR
 682     _FIter
 683     max_element(_FIter, _FIter);
 684
 685   template<typename _FIter, typename _Compare>
 686     _GLIBCXX14_CONSTEXPR
 687     _FIter
 688     max_element(_FIter, _FIter, _Compare);
 689
 690   template<typename _IIter1, typename _IIter2, typename _OIter>
 691     _OIter
 692     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 693
 694   template<typename _IIter1, typename _IIter2, typename _OIter,
 695            typename _Compare>
 696     _OIter
 697     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 698
 699   template<typename _FIter>
 700     _GLIBCXX14_CONSTEXPR
 701     _FIter
 702     min_element(_FIter, _FIter);
 703
 704   template<typename _FIter, typename _Compare>
 705     _GLIBCXX14_CONSTEXPR
 706     _FIter
 707     min_element(_FIter, _FIter, _Compare);
 708
 709   template<typename _IIter1, typename _IIter2>
 710     pair<_IIter1, _IIter2>
 711     mismatch(_IIter1, _IIter1, _IIter2);
 712
 713   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 714     pair<_IIter1, _IIter2>
 715     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 716
 717   template<typename _RAIter>
 718     void
 719     nth_element(_RAIter, _RAIter, _RAIter);
 720
 721   template<typename _RAIter, typename _Compare>
 722     void
 723     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 724
 725   template<typename _RAIter>
 726     void
 727     partial_sort(_RAIter, _RAIter, _RAIter);
 728
 729   template<typename _RAIter, typename _Compare>
 730     void
 731     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 732
 733   template<typename _BIter, typename _Predicate>
 734     _BIter
 735     partition(_BIter, _BIter, _Predicate);
 736
 737   template<typename _RAIter>
 738     void
 739     random_shuffle(_RAIter, _RAIter);
 740
 741   template<typename _RAIter, typename _Generator>
 742     void
 743     random_shuffle(_RAIter, _RAIter,
 744 #if __cplusplus >= 201103L
 745                    _Generator&&);
 746 #else
 747                    _Generator&);
 748 #endif
 749
 750   template<typename _FIter, typename _Tp>
 751     void
 752     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 753
 754   template<typename _FIter, typename _Predicate, typename _Tp>
 755     void
 756     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 757
 758   template<typename _FIter1, typename _FIter2>
 759     _FIter1
 760     search(_FIter1, _FIter1, _FIter2, _FIter2);
 761
 762   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 763     _FIter1
 764     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 765
 766   template<typename _FIter, typename _Size, typename _Tp>
 767     _FIter
 768     search_n(_FIter, _FIter, _Size, const _Tp&);
 769
 770   template<typename _FIter, typename _Size, typename _Tp,
 771            typename _BinaryPredicate>
 772     _FIter
 773     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 774
 775   template<typename _IIter1, typename _IIter2, typename _OIter>
 776     _OIter
 777     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 778
 779   template<typename _IIter1, typename _IIter2, typename _OIter,
 780            typename _Compare>
 781     _OIter
 782     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 783
 784   template<typename _IIter1, typename _IIter2, typename _OIter>
 785     _OIter
 786     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 787
 788   template<typename _IIter1, typename _IIter2, typename _OIter,
 789            typename _Compare>
 790     _OIter
 791     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 792
 793   template<typename _IIter1, typename _IIter2, typename _OIter>
 794     _OIter
 795     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 796
 797   template<typename _IIter1, typename _IIter2, typename _OIter,
 798            typename _Compare>
 799     _OIter
 800     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
 801                              _OIter, _Compare);
 802
 803   template<typename _IIter1, typename _IIter2, typename _OIter>
 804     _OIter
 805     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 806
 807   template<typename _IIter1, typename _IIter2, typename _OIter,
 808            typename _Compare>
 809     _OIter
 810     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 811
 812   template<typename _RAIter>
 813     void
 814     sort(_RAIter, _RAIter);
 815
 816   template<typename _RAIter, typename _Compare>
 817     void
 818     sort(_RAIter, _RAIter, _Compare);
 819
 820   template<typename _RAIter>
 821     void
 822     stable_sort(_RAIter, _RAIter);
 823
 824   template<typename _RAIter, typename _Compare>
 825     void
 826     stable_sort(_RAIter, _RAIter, _Compare);
 827
 828   template<typename _IIter, typename _OIter, typename _UnaryOperation>
 829     _OIter
 830     transform(_IIter, _IIter, _OIter, _UnaryOperation);
 831
 832   template<typename _IIter1, typename _IIter2, typename _OIter,
 833            typename _BinaryOperation>
 834     _OIter
 835     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 836
 837   template<typename _IIter, typename _OIter>
 838     _OIter
 839     unique_copy(_IIter, _IIter, _OIter);
 840
 841   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
 842     _OIter
 843     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 844
 845 _GLIBCXX_END_NAMESPACE_ALGO
 846 _GLIBCXX_END_NAMESPACE_VERSION
 847 } // namespace std
 848
 849 #ifdef _GLIBCXX_PARALLEL
 850 # include <parallel/algorithmfwd.h>
 851 #endif
 852
 853 #endif
 854