contrib/gcc-5.0/libstdc++-v3/include/bits/algorithmfwd.h

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