diff options
Diffstat (limited to 'libstdc++-v3/testsuite/25_algorithms/headers')
6 files changed, 834 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/algorithm_parallel_mode.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/algorithm_parallel_mode.cc new file mode 100644 index 000000000..7edbd8855 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/algorithm_parallel_mode.cc @@ -0,0 +1,22 @@ +// { dg-do compile } +// { dg-require-parallel-mode "" } +// { dg-options "-D_GLIBCXX_PARALLEL -fopenmp" { target *-*-* } } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <algorithm> diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm.cc new file mode 100644 index 000000000..1286f8719 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm.cc @@ -0,0 +1,22 @@ +// { dg-do compile } +// { dg-require-parallel-mode "" } +// { dg-options "-fopenmp" { target *-*-* } } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <parallel/algorithm> diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm_mixed1.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm_mixed1.cc new file mode 100644 index 000000000..ab0d0ac36 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm_mixed1.cc @@ -0,0 +1,88 @@ +// { dg-do compile } +// { dg-require-parallel-mode "" } +// { dg-options "-fopenmp" { target *-*-* } } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <parallel/algorithm> +#include <vector> +#include <algorithm> + +void test() +{ + typedef unsigned short value_type; + typedef std::vector<value_type> vector_type; + + const value_type c(0); + + vector_type v(10), result(20); + + std::equal(v.begin(), v.end(), v.begin()); + std::equal(v.begin(), v.end(), v.begin(), std::equal_to<value_type>()); + __gnu_parallel::equal(v.begin(), v.end(), v.begin()); + __gnu_parallel::equal(v.begin(), v.end(), v.begin(), + std::equal_to<value_type>()); + + std::find(v.begin(), v.end(), c); + __gnu_parallel::find(v.begin(), v.end(), c); + + std::find_first_of(v.begin(), v.end(), v.begin(), v.end()); + std::find_first_of(v.begin(), v.end(), v.begin(), v.end(), + std::equal_to<value_type>()); + __gnu_parallel::find_first_of(v.begin(), v.end(), v.begin(), v.end()); + __gnu_parallel::find_first_of(v.begin(), v.end(), v.begin(), v.end(), + std::equal_to<value_type>()); + + std::search_n(v.begin(), v.end(), 5, value_type(1)); + std::search_n(v.begin(), v.end(), 5, value_type(1), + std::equal_to<value_type>()); + __gnu_parallel::search_n(v.begin(), v.end(), 5, value_type(1)); + __gnu_parallel::search_n(v.begin(), v.end(), 5, value_type(1), + std::equal_to<value_type>()); + + std::merge(v.begin(), v.end(), v.begin(), v.end(), result.begin()); + std::merge(v.begin(), v.end(), v.begin(), v.end(), result.begin(), + std::less<value_type>()); + __gnu_parallel::merge(v.begin(), v.end(), v.begin(), v.end(), + result.begin()); + __gnu_parallel::merge(v.begin(), v.end(), v.begin(), v.end(), + result.begin(), std::less<value_type>()); + + std::nth_element(v.begin(), v.begin() + 5, v.end()); + std::nth_element(v.begin(), v.begin() + 5, v.end(), std::less<value_type>()); + __gnu_parallel::nth_element(v.begin(), v.begin() + 5, v.end()); + __gnu_parallel::nth_element(v.begin(), v.begin() + 5, v.end(), + std::less<value_type>()); + + std::partial_sort(v.begin(), v.begin() + 5, v.end()); + std::partial_sort(v.begin(), v.begin() + 5, v.end(), + std::less<value_type>()); + __gnu_parallel::partial_sort(v.begin(), v.begin() + 5, v.end()); + __gnu_parallel::partial_sort(v.begin(), v.begin() + 5, v.end(), + std::less<value_type>()); + + std::min_element(v.begin(), v.end()); + std::min_element(v.begin(), v.end(), std::less<value_type>()); + __gnu_parallel::min_element(v.begin(), v.end()); + __gnu_parallel::min_element(v.begin(), v.end(), std::less<value_type>()); + + std::max_element(v.begin(), v.end()); + std::max_element(v.begin(), v.end(), std::less<value_type>()); + __gnu_parallel::max_element(v.begin(), v.end()); + __gnu_parallel::max_element(v.begin(), v.end(), std::less<value_type>()); +} diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm_mixed2.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm_mixed2.cc new file mode 100644 index 000000000..56f95b6fb --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/parallel_algorithm_mixed2.cc @@ -0,0 +1,93 @@ +// { dg-do compile } +// { dg-require-parallel-mode "" } +// { dg-options "-fopenmp" { target *-*-* } } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// Make sure to test without _GLIBCXX_PARALLEL +#ifdef _GLIBCXX_PARALLEL +# undef _GLIBCXX_PARALLEL +#endif + +#include <parallel/algorithm> +#include <vector> +#include <algorithm> + +void test() +{ + typedef unsigned short value_type; + typedef std::vector<value_type> vector_type; + + const value_type c(0); + + vector_type v(10), result(20); + + std::equal(v.begin(), v.end(), v.begin()); + std::equal(v.begin(), v.end(), v.begin(), std::equal_to<value_type>()); + __gnu_parallel::equal(v.begin(), v.end(), v.begin()); + __gnu_parallel::equal(v.begin(), v.end(), v.begin(), + std::equal_to<value_type>()); + + std::find(v.begin(), v.end(), c); + __gnu_parallel::find(v.begin(), v.end(), c); + + std::find_first_of(v.begin(), v.end(), v.begin(), v.end()); + std::find_first_of(v.begin(), v.end(), v.begin(), v.end(), + std::equal_to<value_type>()); + __gnu_parallel::find_first_of(v.begin(), v.end(), v.begin(), v.end()); + __gnu_parallel::find_first_of(v.begin(), v.end(), v.begin(), v.end(), + std::equal_to<value_type>()); + + std::search_n(v.begin(), v.end(), 5, value_type(1)); + std::search_n(v.begin(), v.end(), 5, value_type(1), + std::equal_to<value_type>()); + __gnu_parallel::search_n(v.begin(), v.end(), 5, value_type(1)); + __gnu_parallel::search_n(v.begin(), v.end(), 5, value_type(1), + std::equal_to<value_type>()); + + std::merge(v.begin(), v.end(), v.begin(), v.end(), result.begin()); + std::merge(v.begin(), v.end(), v.begin(), v.end(), result.begin(), + std::less<value_type>()); + __gnu_parallel::merge(v.begin(), v.end(), v.begin(), v.end(), + result.begin()); + __gnu_parallel::merge(v.begin(), v.end(), v.begin(), v.end(), + result.begin(), std::less<value_type>()); + + std::nth_element(v.begin(), v.begin() + 5, v.end()); + std::nth_element(v.begin(), v.begin() + 5, v.end(), std::less<value_type>()); + __gnu_parallel::nth_element(v.begin(), v.begin() + 5, v.end()); + __gnu_parallel::nth_element(v.begin(), v.begin() + 5, v.end(), + std::less<value_type>()); + + std::partial_sort(v.begin(), v.begin() + 5, v.end()); + std::partial_sort(v.begin(), v.begin() + 5, v.end(), + std::less<value_type>()); + __gnu_parallel::partial_sort(v.begin(), v.begin() + 5, v.end()); + __gnu_parallel::partial_sort(v.begin(), v.begin() + 5, v.end(), + std::less<value_type>()); + + std::min_element(v.begin(), v.end()); + std::min_element(v.begin(), v.end(), std::less<value_type>()); + __gnu_parallel::min_element(v.begin(), v.end()); + __gnu_parallel::min_element(v.begin(), v.end(), std::less<value_type>()); + + std::max_element(v.begin(), v.end()); + std::max_element(v.begin(), v.end(), std::less<value_type>()); + __gnu_parallel::max_element(v.begin(), v.end()); + __gnu_parallel::max_element(v.begin(), v.end(), std::less<value_type>()); +} diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc new file mode 100644 index 000000000..a78da2ecb --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc @@ -0,0 +1,583 @@ +// { dg-do compile } + +// Copyright (C) 2007, 2008, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <algorithm> + +namespace std + { + // 25.1, non-modifying sequence operations: + template<typename _IIter, typename _Funct> + _Funct + for_each(_IIter, _IIter, _Funct); + + template<typename _IIter, typename _Tp> + _IIter + find(_IIter, _IIter, const _Tp&); + + template<typename _IIter, typename _Predicate> + _IIter + find_if(_IIter, _IIter, _Predicate); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _IIter, typename _Predicate> + bool + all_of(_IIter, _IIter, _Predicate); + + template<typename _IIter, typename _Predicate> + bool + any_of(_IIter, _IIter, _Predicate); + + template<typename _IIter, typename _Predicate> + bool + none_of(_IIter, _IIter, _Predicate); + + template<typename _IIter, typename _Predicate> + _IIter + find_if_not(_IIter, _IIter, _Predicate); + + template<typename _IIter, typename _Predicate> + bool + is_partitioned(_IIter, _IIter, _Predicate); + + template<typename _FIter, typename _Predicate> + _FIter + partition_point(_FIter, _FIter, _Predicate); +#endif + + 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); + + 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 _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> + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + 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 _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); + + // 25.2, modifying sequence operations: + // 25.2.1, copy: + template<typename _IIter, typename _OIter> + _OIter + copy(_IIter, _IIter, _OIter); + + template<typename _BIter1, typename _BIter2> + _BIter2 + copy_backward (_BIter1, _BIter1, _BIter2); + + // 25.2.2, swap: + template<typename _Tp> + void + swap(_Tp&, _Tp& b); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp, size_t _Nm> + void + swap(_Tp (&)[_Nm], _Tp (&)[_Nm]); +#endif + + template<typename _FIter1, typename _FIter2> + _FIter2 + swap_ranges(_FIter1 first1, _FIter1, _FIter2); + + template<typename _FIter1, typename _FIter2> + void + iter_swap(_FIter1, _FIter2 b); + + template<typename _IIter, typename _OIter, typename _UnaryOperation> + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation op); + + template<typename _IIter1, typename _IIter2, typename _OIter, + typename _BinaryOperation> + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + 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 _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&); + + template<typename _FIter, typename _Tp> + void + fill(_FIter, _FIter, const _Tp&); + + template<typename _OIter, typename _Size, typename _Tp> + void + fill_n(_OIter, _Size n, const _Tp&); + + template<typename _FIter, typename _Generator> + void + generate(_FIter, _FIter, _Generator); + + template<typename _OIter, typename _Size, typename _Generator> + void + generate_n(_OIter, _Size, _Generator); + + 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); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _IIter, typename _OIter, typename _Predicate> + _OIter + copy_if(_IIter, _IIter, _OIter, _Predicate); + + template<typename _IIter, typename _Size, typename _OIter> + _OIter + copy_n(_IIter, _Size, _OIter); + + template<typename _IIter, typename _OIter1, + typename _OIter2, typename _Predicate> + pair<_OIter1, _OIter2> + partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); +#endif + + template<typename _FIter> + _FIter + unique(_FIter, _FIter); + + template<typename _FIter, typename _BinaryPredicate> + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + 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); + + 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); + + template<typename _RAIter> + void + random_shuffle(_RAIter, _RAIter); + + template<typename _RAIter, typename _Generator> + void + random_shuffle(_RAIter, _RAIter, _Generator&); + + // 25.2.12, partitions: + template<typename _BIter, typename _Predicate> + _BIter + partition(_BIter, _BIter, _Predicate); + + template<typename _BIter, typename _Predicate> + _BIter + stable_partition(_BIter, _BIter, _Predicate); + + // 25.3, sorting and related operations: + // 25.3.1, sorting: + 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 _RAIter> + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template<typename _RAIter, typename _Compare> + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + 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 + nth_element(_RAIter, _RAIter, _RAIter); + + template<typename _RAIter, typename _Compare> + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + // 25.3.3, binary search: + 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 _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); + + 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> + bool + binary_search(_FIter, _FIter, const _Tp&); + + template<typename _FIter, typename _Tp, typename _Compare> + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + // 25.3.4, merge: + 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 _BIter> + void + inplace_merge(_BIter, _BIter, _BIter); + + template<typename _BIter, typename _Compare> + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + + // 25.3.5, set operations: + 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 _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 _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_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_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); + + // 25.3.6, heap operations: + template<typename _RAIter> + void + push_heap(_RAIter, _RAIter); + + template<typename _RAIter, typename _Compare> + void + push_heap(_RAIter, _RAIter, _Compare); + + template<typename _RAIter> + void + pop_heap(_RAIter, _RAIter); + + template<typename _RAIter, typename _Compare> + void + pop_heap(_RAIter, _RAIter, _Compare); + + template<typename _RAIter> + void + make_heap(_RAIter, _RAIter); + + template<typename _RAIter, typename _Compare> + void + make_heap(_RAIter, _RAIter, _Compare); + + template<typename _RAIter> + void + sort_heap(_RAIter, _RAIter); + + template<typename _RAIter, typename _Compare> + void + sort_heap(_RAIter, _RAIter, _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 + + // 25.3.7, minimum and maximum: + template<typename _Tp> + const _Tp& + min(const _Tp&, const _Tp&); + + template<typename _Tp, typename _Compare> + const _Tp& + min(const _Tp&, const _Tp&, _Compare); + + template<typename _Tp> + const _Tp& + max(const _Tp&, const _Tp&); + + template<typename _Tp, typename _Compare> + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + template<typename _FIter> + _FIter + min_element(_FIter, _FIter); + + template<typename _FIter, typename _Compare> + _FIter + min_element(_FIter, _FIter, _Compare); + + template<typename _FIter> + _FIter + max_element(_FIter, _FIter); + + template<typename _FIter, typename _Compare> + _FIter + max_element(_FIter, _FIter, _Compare); + +#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); + + template<typename _Tp> + _Tp + min(initializer_list<_Tp>); + + template<typename _Tp, typename _Compare> + _Tp + min(initializer_list<_Tp>, _Compare); + + template<typename _Tp> + _Tp + max(initializer_list<_Tp>); + + template<typename _Tp, typename _Compare> + _Tp + max(initializer_list<_Tp>, _Compare); + + template<typename _Tp> + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>); + + template<typename _Tp, typename _Compare> + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>, _Compare); +#endif + + 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); + + // 25.3.9, permutations + template<typename _BIter> + bool + next_permutation(_BIter, _BIter); + + template<typename _BIter, typename _Compare> + bool + next_permutation(_BIter, _BIter, _Compare); + + template<typename _BIter> + bool + prev_permutation(_BIter, _BIter); + + template<typename _BIter, typename _Compare> + bool + prev_permutation(_BIter, _BIter, _Compare); +} diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/cstdlib/functions_std.cc b/libstdc++-v3/testsuite/25_algorithms/headers/cstdlib/functions_std.cc new file mode 100644 index 000000000..34908e893 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/headers/cstdlib/functions_std.cc @@ -0,0 +1,26 @@ +// { dg-do compile } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <cstdlib> + +namespace gnu +{ + using std::bsearch; + using std::qsort; +} |