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

   1 // <algorithm> declarations  -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2008, 2009, 2010, 2011 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
  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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 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     const _Tp&
 356     max(const _Tp&, const _Tp&);
 357
 358   template<typename _Tp, typename _Compare>
 359     const _Tp&
 360     max(const _Tp&, const _Tp&, _Compare);
 361
 362   // max_element
 363   // merge
 364
 365   template<typename _Tp>
 366     const _Tp&
 367     min(const _Tp&, const _Tp&);
 368
 369   template<typename _Tp, typename _Compare>
 370     const _Tp&
 371     min(const _Tp&, const _Tp&, _Compare);
 372
 373   // min_element
 374
 375 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 376   template<typename _Tp>
 377     pair<const _Tp&, const _Tp&>
 378     minmax(const _Tp&, const _Tp&);
 379
 380   template<typename _Tp, typename _Compare>
 381     pair<const _Tp&, const _Tp&>
 382     minmax(const _Tp&, const _Tp&, _Compare);
 383
 384   template<typename _FIter>
 385     pair<_FIter, _FIter>
 386     minmax_element(_FIter, _FIter);
 387
 388   template<typename _FIter, typename _Compare>
 389     pair<_FIter, _FIter>
 390     minmax_element(_FIter, _FIter, _Compare);
 391
 392   template<typename _Tp>
 393     _Tp
 394     min(initializer_list<_Tp>);
 395
 396   template<typename _Tp, typename _Compare>
 397     _Tp
 398     min(initializer_list<_Tp>, _Compare);
 399
 400   template<typename _Tp>
 401     _Tp
 402     max(initializer_list<_Tp>);
 403
 404   template<typename _Tp, typename _Compare>
 405     _Tp
 406     max(initializer_list<_Tp>, _Compare);
 407
 408   template<typename _Tp>
 409     pair<_Tp, _Tp>
 410     minmax(initializer_list<_Tp>);
 411
 412   template<typename _Tp, typename _Compare>
 413     pair<_Tp, _Tp>
 414     minmax(initializer_list<_Tp>, _Compare);
 415 #endif
 416
 417   // mismatch
 418
 419   template<typename _BIter>
 420     bool
 421     next_permutation(_BIter, _BIter);
 422
 423   template<typename _BIter, typename _Compare>
 424     bool
 425     next_permutation(_BIter, _BIter, _Compare);
 426
 427 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 428   template<typename _IIter, typename _Predicate>
 429     bool
 430     none_of(_IIter, _IIter, _Predicate);
 431 #endif
 432
 433   // nth_element
 434   // partial_sort
 435
 436   template<typename _IIter, typename _RAIter>
 437     _RAIter
 438     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
 439
 440   template<typename _IIter, typename _RAIter, typename _Compare>
 441     _RAIter
 442     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
 443
 444   // partition
 445
 446 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 447   template<typename _IIter, typename _OIter1,
 448            typename _OIter2, typename _Predicate>
 449     pair<_OIter1, _OIter2>
 450     partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
 451
 452   template<typename _FIter, typename _Predicate>
 453     _FIter
 454     partition_point(_FIter, _FIter, _Predicate);
 455 #endif
 456
 457   template<typename _RAIter>
 458     void
 459     pop_heap(_RAIter, _RAIter);
 460
 461   template<typename _RAIter, typename _Compare>
 462     void
 463     pop_heap(_RAIter, _RAIter, _Compare);
 464
 465   template<typename _BIter>
 466     bool
 467     prev_permutation(_BIter, _BIter);
 468
 469   template<typename _BIter, typename _Compare>
 470     bool
 471     prev_permutation(_BIter, _BIter, _Compare);
 472
 473   template<typename _RAIter>
 474     void
 475     push_heap(_RAIter, _RAIter);
 476
 477   template<typename _RAIter, typename _Compare>
 478     void
 479     push_heap(_RAIter, _RAIter, _Compare);
 480
 481   // random_shuffle
 482
 483   template<typename _FIter, typename _Tp>
 484     _FIter
 485     remove(_FIter, _FIter, const _Tp&);
 486
 487   template<typename _FIter, typename _Predicate>
 488     _FIter
 489     remove_if(_FIter, _FIter, _Predicate);
 490
 491   template<typename _IIter, typename _OIter, typename _Tp>
 492     _OIter
 493     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
 494
 495   template<typename _IIter, typename _OIter, typename _Predicate>
 496     _OIter
 497     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
 498
 499   // replace
 500
 501   template<typename _IIter, typename _OIter, typename _Tp>
 502     _OIter
 503     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
 504
 505   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
 506     _OIter
 507     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
 508
 509   // replace_if
 510
 511   template<typename _BIter>
 512     void
 513     reverse(_BIter, _BIter);
 514
 515   template<typename _BIter, typename _OIter>
 516     _OIter
 517     reverse_copy(_BIter, _BIter, _OIter);
 518
 519   template<typename _FIter>
 520     void
 521     rotate(_FIter, _FIter, _FIter);
 522
 523   template<typename _FIter, typename _OIter>
 524     _OIter
 525     rotate_copy(_FIter, _FIter, _FIter, _OIter);
 526
 527   // search
 528   // search_n
 529   // set_difference
 530   // set_intersection
 531   // set_symmetric_difference
 532   // set_union
 533
 534 #if defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
 535   template<typename _RAIter, typename _UGenerator>
 536     void
 537     shuffle(_RAIter, _RAIter, _UGenerator&&);
 538 #endif
 539
 540   template<typename _RAIter>
 541     void
 542     sort_heap(_RAIter, _RAIter);
 543
 544   template<typename _RAIter, typename _Compare>
 545     void
 546     sort_heap(_RAIter, _RAIter, _Compare);
 547
 548   template<typename _BIter, typename _Predicate>
 549     _BIter
 550     stable_partition(_BIter, _BIter, _Predicate);
 551
 552   template<typename _Tp>
 553     void
 554     swap(_Tp&, _Tp&)
 555 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 556     noexcept(__and_<is_nothrow_move_constructible<_Tp>,
 557                     is_nothrow_move_assignable<_Tp>>::value)
 558 #endif
 559     ;
 560
 561   template<typename _Tp, size_t _Nm>
 562     void
 563     swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
 564 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 565     noexcept(noexcept(swap(*__a, *__b)))
 566 #endif
 567     ;
 568
 569   template<typename _FIter1, typename _FIter2>
 570     _FIter2
 571     swap_ranges(_FIter1, _FIter1, _FIter2);
 572
 573   // transform
 574
 575   template<typename _FIter>
 576     _FIter
 577     unique(_FIter, _FIter);
 578
 579   template<typename _FIter, typename _BinaryPredicate>
 580     _FIter
 581     unique(_FIter, _FIter, _BinaryPredicate);
 582
 583   // unique_copy
 584
 585   template<typename _FIter, typename _Tp>
 586     _FIter
 587     upper_bound(_FIter, _FIter, const _Tp&);
 588
 589   template<typename _FIter, typename _Tp, typename _Compare>
 590     _FIter
 591     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
 592
 593 _GLIBCXX_END_NAMESPACE_VERSION
 594
 595 _GLIBCXX_BEGIN_NAMESPACE_ALGO
 596
 597   template<typename _FIter>
 598     _FIter
 599     adjacent_find(_FIter, _FIter);
 600
 601   template<typename _FIter, typename _BinaryPredicate>
 602     _FIter
 603     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 604
 605   template<typename _IIter, typename _Tp>
 606     typename iterator_traits<_IIter>::difference_type
 607     count(_IIter, _IIter, const _Tp&);
 608
 609   template<typename _IIter, typename _Predicate>
 610     typename iterator_traits<_IIter>::difference_type
 611     count_if(_IIter, _IIter, _Predicate);
 612
 613   template<typename _IIter1, typename _IIter2>
 614     bool
 615     equal(_IIter1, _IIter1, _IIter2);
 616
 617   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 618     bool
 619     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 620
 621   template<typename _IIter, typename _Tp>
 622     _IIter
 623     find(_IIter, _IIter, const _Tp&);
 624
 625   template<typename _FIter1, typename _FIter2>
 626     _FIter1
 627     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
 628
 629   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 630     _FIter1
 631     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 632
 633   template<typename _IIter, typename _Predicate>
 634     _IIter
 635     find_if(_IIter, _IIter, _Predicate);
 636
 637   template<typename _IIter, typename _Funct>
 638     _Funct
 639     for_each(_IIter, _IIter, _Funct);
 640
 641   template<typename _FIter, typename _Generator>
 642     void
 643     generate(_FIter, _FIter, _Generator);
 644
 645   template<typename _OIter, typename _Size, typename _Generator>
 646     _OIter
 647     generate_n(_OIter, _Size, _Generator);
 648
 649   template<typename _IIter1, typename _IIter2>
 650     bool
 651     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 652
 653   template<typename _IIter1, typename _IIter2, typename _Compare>
 654     bool
 655     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 656
 657   template<typename _FIter>
 658     _FIter
 659     max_element(_FIter, _FIter);
 660
 661   template<typename _FIter, typename _Compare>
 662     _FIter
 663     max_element(_FIter, _FIter, _Compare);
 664
 665   template<typename _IIter1, typename _IIter2, typename _OIter>
 666     _OIter
 667     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 668
 669   template<typename _IIter1, typename _IIter2, typename _OIter,
 670            typename _Compare>
 671     _OIter
 672     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 673
 674   template<typename _FIter>
 675     _FIter
 676     min_element(_FIter, _FIter);
 677
 678   template<typename _FIter, typename _Compare>
 679     _FIter
 680     min_element(_FIter, _FIter, _Compare);
 681
 682   template<typename _IIter1, typename _IIter2>
 683     pair<_IIter1, _IIter2>
 684     mismatch(_IIter1, _IIter1, _IIter2);
 685
 686   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 687     pair<_IIter1, _IIter2>
 688     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 689
 690   template<typename _RAIter>
 691     void
 692     nth_element(_RAIter, _RAIter, _RAIter);
 693
 694   template<typename _RAIter, typename _Compare>
 695     void
 696     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 697
 698   template<typename _RAIter>
 699     void
 700     partial_sort(_RAIter, _RAIter, _RAIter);
 701
 702   template<typename _RAIter, typename _Compare>
 703     void
 704     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 705
 706   template<typename _BIter, typename _Predicate>
 707     _BIter
 708     partition(_BIter, _BIter, _Predicate);
 709
 710   template<typename _RAIter>
 711     void
 712     random_shuffle(_RAIter, _RAIter);
 713
 714   template<typename _RAIter, typename _Generator>
 715     void
 716     random_shuffle(_RAIter, _RAIter,
 717 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 718                    _Generator&&);
 719 #else
 720                    _Generator&);
 721 #endif
 722
 723   template<typename _FIter, typename _Tp>
 724     void
 725     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 726
 727   template<typename _FIter, typename _Predicate, typename _Tp>
 728     void
 729     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 730
 731   template<typename _FIter1, typename _FIter2>
 732     _FIter1
 733     search(_FIter1, _FIter1, _FIter2, _FIter2);
 734
 735   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 736     _FIter1
 737     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 738
 739   template<typename _FIter, typename _Size, typename _Tp>
 740     _FIter
 741     search_n(_FIter, _FIter, _Size, const _Tp&);
 742
 743   template<typename _FIter, typename _Size, typename _Tp,
 744            typename _BinaryPredicate>
 745     _FIter
 746     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 747
 748   template<typename _IIter1, typename _IIter2, typename _OIter>
 749     _OIter
 750     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 751
 752   template<typename _IIter1, typename _IIter2, typename _OIter,
 753            typename _Compare>
 754     _OIter
 755     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 756
 757   template<typename _IIter1, typename _IIter2, typename _OIter>
 758     _OIter
 759     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 760
 761   template<typename _IIter1, typename _IIter2, typename _OIter,
 762            typename _Compare>
 763     _OIter
 764     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 765
 766   template<typename _IIter1, typename _IIter2, typename _OIter>
 767     _OIter
 768     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 769
 770   template<typename _IIter1, typename _IIter2, typename _OIter,
 771            typename _Compare>
 772     _OIter
 773     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
 774                              _OIter, _Compare);
 775
 776   template<typename _IIter1, typename _IIter2, typename _OIter>
 777     _OIter
 778     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 779
 780   template<typename _IIter1, typename _IIter2, typename _OIter,
 781            typename _Compare>
 782     _OIter
 783     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 784
 785   template<typename _RAIter>
 786     void
 787     sort(_RAIter, _RAIter);
 788
 789   template<typename _RAIter, typename _Compare>
 790     void
 791     sort(_RAIter, _RAIter, _Compare);
 792
 793   template<typename _RAIter>
 794     void
 795     stable_sort(_RAIter, _RAIter);
 796
 797   template<typename _RAIter, typename _Compare>
 798     void
 799     stable_sort(_RAIter, _RAIter, _Compare);
 800
 801   template<typename _IIter, typename _OIter, typename _UnaryOperation>
 802     _OIter
 803     transform(_IIter, _IIter, _OIter, _UnaryOperation);
 804
 805   template<typename _IIter1, typename _IIter2, typename _OIter,
 806            typename _BinaryOperation>
 807     _OIter
 808     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 809
 810   template<typename _IIter, typename _OIter>
 811     _OIter
 812     unique_copy(_IIter, _IIter, _OIter);
 813
 814   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
 815     _OIter
 816     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 817
 818 _GLIBCXX_END_NAMESPACE_ALGO
 819 } // namespace std
 820
 821 #ifdef _GLIBCXX_PARALLEL
 822 # include <parallel/algorithmfwd.h>
 823 #endif
 824
 825 #endif
 826