28dac70a08
2008-01-31 Ralf Wildenhues <Ralf.Wildenhues@gmx.de>
* include/backward/auto_ptr.h: Fix comment typos.
* include/bits/algorithmfwd.h: Likewise.
* include/bits/basic_ios.h: Likewise.
* include/bits/c++config: Likewise.
* include/bits/char_traits.h: Likewise.
* include/bits/codecvt.h: Likewise.
* include/bits/gslice.h: Likewise.
* include/bits/ios_base.h: Likewise.
* include/bits/locale_facets.h: Likewise.
* include/bits/locale_facets_nonio.tcc: Likewise.
* include/bits/postypes.h: Likewise.
* include/bits/sstream.tcc: Likewise.
* include/bits/stl_algo.h: Likewise.
* include/bits/stl_deque.h: Likewise.
* include/bits/stl_iterator.h: Likewise.
* include/bits/stl_iterator_base_types.h Likewise.
* include/bits/stl_list.h: Likewise.
* include/bits/stl_map.h: Likewise.
* include/bits/stl_multimap.h: Likewise.
* include/bits/stl_multiset.h: Likewise.
* include/bits/stl_set.h: Likewise.
* include/bits/stl_vector.h: Likewise.
* include/bits/valarray_array.h: Likewise.
* include/debug/safe_base.h: Likewise.
* include/ext/bitmap_allocator.h: Likewise.
* include/ext/codecvt_specializations.h Likewise.
* include/ext/mt_allocator.h: Likewise.
* include/ext/rc_string_base.h: Likewise.
* include/ext/rope: Likewise.
* include/parallel/checkers.h: Likewise.
* include/parallel/find.h: Likewise.
* include/parallel/multiseq_selection.h: Likewise.
* include/parallel/partition.h: Likewise.
* include/parallel/settings.h: Likewise.
* include/std/bitset: Likewise.
* include/std/complex: Likewise.
* include/std/fstream: Likewise.
* include/std/istream: Likewise.
* include/std/limits: Likewise.
* include/std/ostream: Likewise.
* include/std/stdexcept: Likewise.
* include/std/streambuf: Likewise.
* include/tr1/bessel_function.tcc: Likewise.
* include/tr1/cmath: Likewise.
* include/tr1/ell_integral.tcc: Likewise.
* include/tr1/hypergeometric.tcc: Likewise.
* include/tr1/legendre_function.tcc: Likewise.
* include/tr1_impl/random: Likewise.
* include/tr1_impl/regex: Likewise.
From-SVN: r131982
654 lines
16 KiB
C++
654 lines
16 KiB
C++
// <algorithm> declarations -*- C++ -*-
|
|
|
|
// Copyright (C) 2007 Free Software Foundation, Inc.
|
|
//
|
|
// This file is part of the GNU ISO C++ Library. This library is free
|
|
// software; you can redistribute it and/or modify it under the
|
|
// terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 2, or (at your option)
|
|
// any later version.
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License along
|
|
// with this library; see the file COPYING. If not, write to the Free
|
|
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
// USA.
|
|
|
|
/** @file bits/algorithmfwd.h
|
|
* This is an internal header file, included by other library headers.
|
|
* You should not attempt to use it directly.
|
|
*/
|
|
|
|
/*
|
|
adjacent_find
|
|
binary_search
|
|
copy
|
|
copy_backward
|
|
count
|
|
count_if
|
|
equal
|
|
equal_range
|
|
fill
|
|
fill_n
|
|
find
|
|
find_end
|
|
find_first_of
|
|
find_if
|
|
for_each
|
|
generate
|
|
generate_n
|
|
includes
|
|
inplace_merge
|
|
is_heap (C++0x)
|
|
is_heap_until (C++0x)
|
|
is_sorted (C++0x)
|
|
is_sorted_until (C++0x)
|
|
iter_swap
|
|
lexicographical_compare
|
|
lower_bound
|
|
make_heap
|
|
max
|
|
max_element
|
|
merge
|
|
min
|
|
min_element
|
|
minmax (C++0x)
|
|
minmax_element (C++0x)
|
|
mismatch
|
|
next_permutation
|
|
nth_element
|
|
partial_sort
|
|
partial_sort_copy
|
|
partition
|
|
pop_heap
|
|
prev_permutation
|
|
push_heap
|
|
random_shuffle
|
|
remove
|
|
remove_copy
|
|
remove_copy_if
|
|
remove_if
|
|
replace
|
|
replace_copy
|
|
replace_copy_if
|
|
replace_if
|
|
reverse
|
|
reverse_copy
|
|
rotate
|
|
rotate_copy
|
|
search
|
|
search_n
|
|
set_difference
|
|
set_intersection
|
|
set_symmetric_difference
|
|
set_union
|
|
sort
|
|
sort_heap
|
|
stable_partition
|
|
stable_sort
|
|
swap
|
|
swap_ranges
|
|
transform
|
|
unique
|
|
unique_copy
|
|
upper_bound
|
|
*/
|
|
|
|
#ifndef _GLIBCXX_ALGORITHMFWD_H
|
|
#define _GLIBCXX_ALGORITHMFWD_H 1
|
|
|
|
#pragma GCC system_header
|
|
|
|
#include <bits/c++config.h>
|
|
#include <bits/stl_pair.h>
|
|
#include <bits/stl_iterator_base_types.h>
|
|
|
|
_GLIBCXX_BEGIN_NAMESPACE(std)
|
|
|
|
// adjacent_find
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
bool
|
|
binary_search(_FIter, _FIter, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Tp, typename _Compare>
|
|
bool
|
|
binary_search(_FIter, _FIter, const _Tp&, _Compare);
|
|
|
|
template<typename _IIter, typename _OIter>
|
|
_OIter
|
|
copy(_IIter, _IIter, _OIter);
|
|
|
|
template<typename _BIter1, typename _BIter2>
|
|
_BIter2
|
|
copy_backward(_BIter1, _BIter1, _BIter2);
|
|
|
|
// count
|
|
// count_if
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
pair<_FIter, _FIter>
|
|
equal_range(_FIter, _FIter, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Tp, typename _Compare>
|
|
pair<_FIter, _FIter>
|
|
equal_range(_FIter, _FIter, const _Tp&, _Compare);
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
void
|
|
fill(_FIter, _FIter, const _Tp&);
|
|
|
|
/*
|
|
XXX NB: return type different from ISO C++.
|
|
template<typename _OIter, typename _Size, typename _Tp>
|
|
void
|
|
fill_n(_OIter, _Size, const _Tp&);
|
|
*/
|
|
|
|
template<typename _OIter, typename _Size, typename _Tp>
|
|
_OIter
|
|
fill_n(_OIter, _Size, const _Tp&);
|
|
|
|
// find
|
|
|
|
template<typename _FIter1, typename _FIter2>
|
|
_FIter1
|
|
find_end(_FIter1, _FIter1, _FIter2, _FIter2);
|
|
|
|
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
|
|
_FIter1
|
|
find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
|
|
|
|
// find_first_of
|
|
// find_if
|
|
// for_each
|
|
// generate
|
|
// generate_n
|
|
|
|
template<typename _IIter1, typename _IIter2>
|
|
bool
|
|
includes(_IIter1, _IIter1, _IIter2, _IIter2);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _Compare>
|
|
bool
|
|
includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
|
|
|
|
template<typename _BIter>
|
|
void
|
|
inplace_merge(_BIter, _BIter, _BIter);
|
|
|
|
template<typename _BIter, typename _Compare>
|
|
void
|
|
inplace_merge(_BIter, _BIter, _BIter, _Compare);
|
|
|
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
|
template<typename _RAIter>
|
|
bool
|
|
is_heap(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
bool
|
|
is_heap(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
_RAIter
|
|
is_heap_until(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
_RAIter
|
|
is_heap_until(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _FIter>
|
|
bool
|
|
is_sorted(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _Compare>
|
|
bool
|
|
is_sorted(_FIter, _FIter, _Compare);
|
|
|
|
template<typename _FIter>
|
|
_FIter
|
|
is_sorted_until(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _Compare>
|
|
_FIter
|
|
is_sorted_until(_FIter, _FIter, _Compare);
|
|
#endif
|
|
|
|
template<typename _FIter1, typename _FIter2>
|
|
void
|
|
iter_swap(_FIter1, _FIter2);
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
_FIter
|
|
lower_bound(_FIter, _FIter, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Tp, typename _Compare>
|
|
_FIter
|
|
lower_bound(_FIter, _FIter, const _Tp&, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
make_heap(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
make_heap(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _Tp>
|
|
const _Tp&
|
|
max(const _Tp&, const _Tp&);
|
|
|
|
template<typename _Tp, typename _Compare>
|
|
const _Tp&
|
|
max(const _Tp&, const _Tp&, _Compare);
|
|
|
|
// max_element
|
|
// merge
|
|
|
|
template<typename _Tp>
|
|
const _Tp&
|
|
min(const _Tp&, const _Tp&);
|
|
|
|
template<typename _Tp, typename _Compare>
|
|
const _Tp&
|
|
min(const _Tp&, const _Tp&, _Compare);
|
|
|
|
// min_element
|
|
|
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
|
template<typename _Tp>
|
|
pair<const _Tp&, const _Tp&>
|
|
minmax(const _Tp&, const _Tp&);
|
|
|
|
template<typename _Tp, typename _Compare>
|
|
pair<const _Tp&, const _Tp&>
|
|
minmax(const _Tp&, const _Tp&, _Compare);
|
|
|
|
template<typename _FIter>
|
|
pair<_FIter, _FIter>
|
|
minmax_element(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _Compare>
|
|
pair<_FIter, _FIter>
|
|
minmax_element(_FIter, _FIter, _Compare);
|
|
#endif
|
|
|
|
// mismatch
|
|
|
|
template<typename _BIter>
|
|
bool
|
|
next_permutation(_BIter, _BIter);
|
|
|
|
template<typename _BIter, typename _Compare>
|
|
bool
|
|
next_permutation(_BIter, _BIter, _Compare);
|
|
|
|
// nth_element
|
|
// partial_sort
|
|
|
|
template<typename _IIter, typename _RAIter>
|
|
_RAIter
|
|
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
|
|
|
|
template<typename _IIter, typename _RAIter, typename _Compare>
|
|
_RAIter
|
|
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
pop_heap(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
pop_heap(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _BIter>
|
|
bool
|
|
prev_permutation(_BIter, _BIter);
|
|
|
|
template<typename _BIter, typename _Compare>
|
|
bool
|
|
prev_permutation(_BIter, _BIter, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
push_heap(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
push_heap(_RAIter, _RAIter, _Compare);
|
|
|
|
// random_shuffle
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
_FIter
|
|
remove(_FIter, _FIter, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Predicate>
|
|
_FIter
|
|
remove_if(_FIter, _FIter, _Predicate);
|
|
|
|
template<typename _IIter, typename _OIter, typename _Tp>
|
|
_OIter
|
|
remove_copy(_IIter, _IIter, _OIter, const _Tp&);
|
|
|
|
template<typename _IIter, typename _OIter, typename _Predicate>
|
|
_OIter
|
|
remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
|
|
|
|
// replace
|
|
|
|
template<typename _IIter, typename _OIter, typename _Tp>
|
|
_OIter
|
|
replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
|
|
|
|
template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
|
|
_OIter
|
|
replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
|
|
|
|
// replace_if
|
|
|
|
template<typename _BIter>
|
|
void
|
|
reverse(_BIter, _BIter);
|
|
|
|
template<typename _BIter, typename _OIter>
|
|
_OIter
|
|
reverse_copy(_BIter, _BIter, _OIter);
|
|
|
|
template<typename _FIter>
|
|
void
|
|
rotate(_FIter, _FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _OIter>
|
|
_OIter
|
|
rotate_copy(_FIter, _FIter, _FIter, _OIter);
|
|
|
|
// search
|
|
// search_n
|
|
// set_difference
|
|
// set_intersection
|
|
// set_symmetric_difference
|
|
// set_union
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
sort_heap(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
sort_heap(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _BIter, typename _Predicate>
|
|
_BIter
|
|
stable_partition(_BIter, _BIter, _Predicate);
|
|
|
|
template<typename _Tp>
|
|
void
|
|
swap(_Tp&, _Tp&);
|
|
|
|
template<typename _FIter1, typename _FIter2>
|
|
_FIter2
|
|
swap_ranges(_FIter1, _FIter1, _FIter2);
|
|
|
|
// transform
|
|
|
|
template<typename _FIter>
|
|
_FIter
|
|
unique(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _BinaryPredicate>
|
|
_FIter
|
|
unique(_FIter, _FIter, _BinaryPredicate);
|
|
|
|
// unique_copy
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
_FIter
|
|
upper_bound(_FIter, _FIter, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Tp, typename _Compare>
|
|
_FIter
|
|
upper_bound(_FIter, _FIter, const _Tp&, _Compare);
|
|
|
|
_GLIBCXX_END_NAMESPACE
|
|
|
|
_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
|
|
|
|
template<typename _FIter>
|
|
_FIter
|
|
adjacent_find(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _BinaryPredicate>
|
|
_FIter
|
|
adjacent_find(_FIter, _FIter, _BinaryPredicate);
|
|
|
|
template<typename _IIter, typename _Tp>
|
|
typename iterator_traits<_IIter>::difference_type
|
|
count(_IIter, _IIter, const _Tp&);
|
|
|
|
template<typename _IIter, typename _Predicate>
|
|
typename iterator_traits<_IIter>::difference_type
|
|
count_if(_IIter, _IIter, _Predicate);
|
|
|
|
template<typename _IIter1, typename _IIter2>
|
|
bool
|
|
equal(_IIter1, _IIter1, _IIter2);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
|
|
bool
|
|
equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
|
|
|
|
template<typename _IIter, typename _Tp>
|
|
_IIter
|
|
find(_IIter, _IIter, const _Tp&);
|
|
|
|
template<typename _FIter1, typename _FIter2>
|
|
_FIter1
|
|
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
|
|
|
|
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
|
|
_FIter1
|
|
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
|
|
|
|
template<typename _IIter, typename _Predicate>
|
|
_IIter
|
|
find_if(_IIter, _IIter, _Predicate);
|
|
|
|
template<typename _IIter, typename _Funct>
|
|
_Funct
|
|
for_each(_IIter, _IIter, _Funct);
|
|
|
|
template<typename _FIter, typename _Generator>
|
|
void
|
|
generate(_FIter, _FIter, _Generator);
|
|
|
|
/*
|
|
XXX NB: return type different from ISO C++.
|
|
template<typename _OIter, typename _Size, typename _Tp>
|
|
void
|
|
generate_n(_OIter, _Size, _Generator);
|
|
*/
|
|
|
|
template<typename _OIter, typename _Size, typename _Generator>
|
|
_OIter
|
|
generate_n(_OIter, _Size, _Generator);
|
|
|
|
template<typename _IIter1, typename _IIter2>
|
|
bool
|
|
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _Compare>
|
|
bool
|
|
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
|
|
|
|
template<typename _FIter>
|
|
_FIter
|
|
max_element(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _Compare>
|
|
_FIter
|
|
max_element(_FIter, _FIter, _Compare);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter>
|
|
_OIter
|
|
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter,
|
|
typename _Compare>
|
|
_OIter
|
|
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
|
|
|
|
template<typename _FIter>
|
|
_FIter
|
|
min_element(_FIter, _FIter);
|
|
|
|
template<typename _FIter, typename _Compare>
|
|
_FIter
|
|
min_element(_FIter, _FIter, _Compare);
|
|
|
|
template<typename _IIter1, typename _IIter2>
|
|
pair<_IIter1, _IIter2>
|
|
mismatch(_IIter1, _IIter1, _IIter2);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
|
|
pair<_IIter1, _IIter2>
|
|
mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
nth_element(_RAIter, _RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
nth_element(_RAIter, _RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
partial_sort(_RAIter, _RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _BIter, typename _Predicate>
|
|
_BIter
|
|
partition(_BIter, _BIter, _Predicate);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
random_shuffle(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Generator>
|
|
void
|
|
random_shuffle(_RAIter, _RAIter, _Generator&);
|
|
|
|
template<typename _FIter, typename _Tp>
|
|
void
|
|
replace(_FIter, _FIter, const _Tp&, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Predicate, typename _Tp>
|
|
void
|
|
replace_if(_FIter, _FIter, _Predicate, const _Tp&);
|
|
|
|
template<typename _FIter1, typename _FIter2>
|
|
_FIter1
|
|
search(_FIter1, _FIter1, _FIter2, _FIter2);
|
|
|
|
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
|
|
_FIter1
|
|
search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
|
|
|
|
template<typename _FIter, typename _Size, typename _Tp>
|
|
_FIter
|
|
search_n(_FIter, _FIter, _Size, const _Tp&);
|
|
|
|
template<typename _FIter, typename _Size, typename _Tp,
|
|
typename _BinaryPredicate>
|
|
_FIter
|
|
search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter>
|
|
_OIter
|
|
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter,
|
|
typename _Compare>
|
|
_OIter
|
|
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter>
|
|
_OIter
|
|
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter,
|
|
typename _Compare>
|
|
_OIter
|
|
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter>
|
|
_OIter
|
|
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter,
|
|
typename _Compare>
|
|
_OIter
|
|
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
|
|
_OIter, _Compare);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter>
|
|
_OIter
|
|
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter,
|
|
typename _Compare>
|
|
_OIter
|
|
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
sort(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
sort(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _RAIter>
|
|
void
|
|
stable_sort(_RAIter, _RAIter);
|
|
|
|
template<typename _RAIter, typename _Compare>
|
|
void
|
|
stable_sort(_RAIter, _RAIter, _Compare);
|
|
|
|
template<typename _IIter, typename _OIter, typename _UnaryOperation>
|
|
_OIter
|
|
transform(_IIter, _IIter, _OIter, _UnaryOperation);
|
|
|
|
template<typename _IIter1, typename _IIter2, typename _OIter,
|
|
typename _BinaryOperation>
|
|
_OIter
|
|
transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
|
|
|
|
template<typename _IIter, typename _OIter>
|
|
_OIter
|
|
unique_copy(_IIter, _IIter, _OIter);
|
|
|
|
template<typename _IIter, typename _OIter, typename _BinaryPredicate>
|
|
_OIter
|
|
unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
|
|
|
|
_GLIBCXX_END_NESTED_NAMESPACE
|
|
|
|
#ifdef _GLIBCXX_NAMESPACE_ASSOCIATION_PARALLEL
|
|
# include <parallel/algorithmfwd.h>
|
|
#endif
|
|
|
|
#endif
|
|
|