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

   1 // <algorithm> Forward declarations  -*- C++ -*-
   2
   3 // Copyright (C) 2007-2016 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