mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-02-01 09:04:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix algorithm: bogo_sort, bozo_sort

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-02-04 01:10:26 +09:00
parent aace49ac65
commit f3b405ad0f
75 changed files with 634 additions and 776 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
sprout/algorithm/fixed/bogo_sort.hpp
View file

@ -2,75 +2,28 @@
#define SPROUT_ALGORITHM_FIXED_BOGO_SORT_HPP
#include <sprout/config.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/algorithm/is_sorted.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/shuffle_result.hpp>
#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
#include <sprout/algorithm/fixed/bogo_sort_result.hpp>
namespace sprout {
namespace fixed {
namespace detail {
template<typename Container, typename Shuffled, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bogo_sort_impl_1(Shuffled const& shuffled, Compare comp) {
return sprout::is_sorted(
sprout::begin(sprout::tuples::get<0>(shuffled)),
sprout::end(sprout::tuples::get<0>(shuffled)),
comp
)
? sprout::tuples::get<0>(shuffled)
: sprout::fixed::detail::bogo_sort_impl_1<Container>(
sprout::fixed::shuffle_result(
sprout::tuples::get<0>(shuffled),
sprout::tuples::get<1>(shuffled)
),
comp
)
;
}
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bogo_sort_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::is_sorted(
sprout::begin(cont),
sprout::end(cont),
comp
)
? sprout::deep_copy(cont)
: sprout::fixed::detail::bogo_sort_impl_1<Container>(
sprout::fixed::shuffle_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g)
),
comp
)
;
}
} // namespace detail
//
// bogo_sort
//
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::fixed::detail::bogo_sort_impl(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
comp
return sprout::first(
sprout::fixed::bogo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g), comp)
);
}
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::bogo_sort_impl(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
return sprout::first(
sprout::fixed::bogo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g))
);
}
} // namespace fixed

101
sprout/algorithm/fixed/bogo_sort_result.hpp
View file

@ -3,11 +3,11 @@
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/is_sorted.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/shuffle_result.hpp>
@ -16,53 +16,56 @@
namespace sprout {
namespace fixed {
namespace detail {
template<typename Container, typename UniformRandomNumberGenerator, typename Shuffled, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
bogo_sort_result_impl_1(Shuffled const& shuffled, Compare comp) {
return sprout::is_sorted(
sprout::begin(sprout::tuples::get<0>(shuffled)),
sprout::end(sprout::tuples::get<0>(shuffled)),
comp
template<typename ResultType, typename Compare, typename Difference>
inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
bogo_sort_result_impl_1(
sprout::pair<ResultType, bool> const& current,
Compare comp, Difference n
)
{
typedef sprout::pair<ResultType, bool> type;
return current.second ? current
: n == 1 ? sprout::is_sorted(sprout::begin(sprout::first(current.first)), sprout::end(sprout::first(current.first)), comp)
? type(current.first, true)
: type(sprout::fixed::shuffle_result(sprout::first(current.first), sprout::second(current.first)), false)
: sprout::fixed::detail::bogo_sort_result_impl_1<ResultType>(
sprout::fixed::detail::bogo_sort_result_impl_1<ResultType>(
current,
comp, n / 2
),
comp, n - n / 2
)
? shuffled
: sprout::fixed::detail::bogo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
sprout::fixed::shuffle_result(
sprout::tuples::get<0>(shuffled),
sprout::tuples::get<1>(shuffled)
;
}
template<typename ResultType, typename Compare, typename Difference>
inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
bogo_sort_result_impl(
sprout::pair<ResultType, bool> const& current,
Compare comp, Difference n
)
{
typedef sprout::pair<ResultType, bool> type;
return current.second ? current
: sprout::fixed::detail::bogo_sort_result_impl<ResultType>(
sprout::fixed::detail::bogo_sort_result_impl_1<ResultType>(
current,
comp, n
),
comp
comp, n * 2
)
;
}
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
bogo_sort_result_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
typedef sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return sprout::is_sorted(
sprout::begin(cont),
sprout::end(cont),
comp
)
? result_type(
sprout::deep_copy(cont),
sprout::forward<UniformRandomNumberGenerator>(g)
)
: sprout::fixed::detail::bogo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
sprout::fixed::shuffle_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g)
),
comp
)
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
bogo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
typedef sprout::pair<result_type, bool> type;
return sprout::is_sorted(sprout::begin(cont), sprout::end(cont), comp)
? result_type(sprout::deep_copy(cont), sprout::forward<UniformRandomNumberGenerator>(g))
: sprout::fixed::detail::bogo_sort_result_impl<result_type>(
type(sprout::fixed::shuffle_result(cont, sprout::forward<UniformRandomNumberGenerator>(g)), false),
comp, static_cast<typename sprout::container_traits<Container>::difference_type>(1)
).first
;
}
} // namespace detail
@ -70,24 +73,18 @@ namespace sprout {
// bogo_sort_result
//
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
bogo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::fixed::detail::bogo_sort_result_impl(
return sprout::fixed::detail::bogo_sort_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
comp
);
}
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
bogo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::bogo_sort_result_impl(
return sprout::fixed::detail::bogo_sort_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()

59
sprout/algorithm/fixed/bozo_sort.hpp
View file

@ -2,75 +2,28 @@
#define SPROUT_ALGORITHM_FIXED_BOZO_SORT_HPP
#include <sprout/config.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/algorithm/is_sorted.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/random_swap_result.hpp>
#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
#include <sprout/algorithm/fixed/bozo_sort_result.hpp>
namespace sprout {
namespace fixed {
namespace detail {
template<typename Container, typename Shuffled, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bozo_sort_impl_1(Shuffled const& shuffled, Compare comp) {
return sprout::is_sorted(
sprout::begin(sprout::tuples::get<0>(shuffled)),
sprout::end(sprout::tuples::get<0>(shuffled)),
comp
)
? sprout::tuples::get<0>(shuffled)
: sprout::fixed::detail::bozo_sort_impl_1<Container>(
sprout::fixed::random_swap_result(
sprout::tuples::get<0>(shuffled),
sprout::tuples::get<1>(shuffled)
),
comp
)
;
}
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bozo_sort_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::is_sorted(
sprout::begin(cont),
sprout::end(cont),
comp
)
? sprout::deep_copy(cont)
: sprout::fixed::detail::bozo_sort_impl_1<Container>(
sprout::fixed::random_swap_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g)
),
comp
)
;
}
} // namespace detail
//
// bozo_sort
//
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bozo_sort(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::fixed::detail::bozo_sort_impl(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
comp
return sprout::first(
sprout::fixed::bozo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g), comp)
);
}
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bozo_sort(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::bozo_sort_impl(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
return sprout::first(
sprout::fixed::bozo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g))
);
}
} // namespace fixed

101
sprout/algorithm/fixed/bozo_sort_result.hpp
View file

@ -3,11 +3,11 @@
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/is_sorted.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/random_swap_result.hpp>
@ -16,53 +16,56 @@
namespace sprout {
namespace fixed {
namespace detail {
template<typename Container, typename UniformRandomNumberGenerator, typename Shuffled, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
bozo_sort_result_impl_1(Shuffled const& shuffled, Compare comp) {
return sprout::is_sorted(
sprout::begin(sprout::tuples::get<0>(shuffled)),
sprout::end(sprout::tuples::get<0>(shuffled)),
comp
template<typename ResultType, typename Compare, typename Difference>
inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
bozo_sort_result_impl_1(
sprout::pair<ResultType, bool> const& current,
Compare comp, Difference n
)
{
typedef sprout::pair<ResultType, bool> type;
return current.second ? current
: n == 1 ? sprout::is_sorted(sprout::begin(sprout::first(current.first)), sprout::end(sprout::first(current.first)), comp)
? type(current.first, true)
: type(sprout::fixed::random_swap_result(sprout::first(current.first), sprout::second(current.first)), false)
: sprout::fixed::detail::bozo_sort_result_impl_1<ResultType>(
sprout::fixed::detail::bozo_sort_result_impl_1<ResultType>(
current,
comp, n / 2
),
comp, n - n / 2
)
? shuffled
: sprout::fixed::detail::bozo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
sprout::fixed::random_swap_result(
sprout::tuples::get<0>(shuffled),
sprout::tuples::get<1>(shuffled)
;
}
template<typename ResultType, typename Compare, typename Difference>
inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
bozo_sort_result_impl(
sprout::pair<ResultType, bool> const& current,
Compare comp, Difference n
)
{
typedef sprout::pair<ResultType, bool> type;
return current.second ? current
: sprout::fixed::detail::bozo_sort_result_impl<ResultType>(
sprout::fixed::detail::bozo_sort_result_impl_1<ResultType>(
current,
comp, n
),
comp
comp, n * 2
)
;
}
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
bozo_sort_result_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
typedef sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return sprout::is_sorted(
sprout::begin(cont),
sprout::end(cont),
comp
)
? result_type(
sprout::deep_copy(cont),
sprout::forward<UniformRandomNumberGenerator>(g)
)
: sprout::fixed::detail::bozo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
sprout::fixed::random_swap_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g)
),
comp
)
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
typedef sprout::pair<result_type, bool> type;
return sprout::is_sorted(sprout::begin(cont), sprout::end(cont), comp)
? result_type(sprout::deep_copy(cont), sprout::forward<UniformRandomNumberGenerator>(g))
: sprout::fixed::detail::bozo_sort_result_impl<result_type>(
type(sprout::fixed::random_swap_result(cont, sprout::forward<UniformRandomNumberGenerator>(g)), false),
comp, static_cast<typename sprout::container_traits<Container>::difference_type>(1)
).first
;
}
} // namespace detail
@ -70,24 +73,18 @@ namespace sprout {
// bozo_sort_result
//
template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::fixed::detail::bozo_sort_result_impl(
return sprout::fixed::detail::bozo_sort_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
comp
);
}
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::bozo_sort_result_impl(
return sprout::fixed::detail::bozo_sort_result(
cont,
sprout::forward<UniformRandomNumberGenerator>(g),
NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()

15
sprout/algorithm/fixed/random_swap.hpp
View file

@ -8,15 +8,10 @@
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/random/uniform_smallint.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
#else
# include <sprout/random/uniform_int_distribution.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
#endif
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
namespace fixed {
@ -39,7 +34,9 @@ namespace sprout {
make_random_swap_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
return n > 1
? sprout::fixed::detail::make_random_swap_indexes_1(
SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g))
SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
sprout::forward<UniformRandomNumberGenerator>(g)
)
)
: sprout::array<std::ptrdiff_t, 2>{{}}
;
@ -88,6 +85,4 @@ namespace sprout {
using sprout::fixed::random_swap;
} // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_RANDOM_SWAP_HPP

73
sprout/algorithm/fixed/random_swap_result.hpp
View file

@ -10,39 +10,25 @@
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/random/uniform_smallint.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
#else
# include <sprout/random/uniform_int_distribution.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
#endif
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
namespace fixed {
namespace detail {
template<typename UniformRandomNumberGenerator, typename Random>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
make_random_swap_result_indexes_2(Random const& rnd, std::ptrdiff_t i0) {
typedef sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
return result_type(
sprout::array<std::ptrdiff_t, 2>{{i0, rnd.result()}},
rnd.engine()
);
}
template<typename UniformRandomNumberGenerator, typename Random>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
make_random_swap_result_indexes_1(Random const& rnd) {
return sprout::fixed::detail::make_random_swap_result_indexes_2<UniformRandomNumberGenerator>(
rnd(),
@ -50,18 +36,14 @@ namespace sprout {
);
}
template<typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
make_random_swap_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
typedef sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
return n > 1
? sprout::fixed::detail::make_random_swap_result_indexes_1<UniformRandomNumberGenerator>(
SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g))
SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
sprout::forward<UniformRandomNumberGenerator>(g)
)
)
: result_type(
sprout::array<std::ptrdiff_t, 2>{{}},
@ -70,35 +52,23 @@ namespace sprout {
;
}
template<typename UniformRandomNumberGenerator, typename Container, typename RandomSwapped>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
random_swap_result_impl_1(Container const& cont, RandomSwapped const& random_swapped) {
typedef sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return sprout::tuples::get<0>(random_swapped)[0] == sprout::tuples::get<0>(random_swapped)[1]
? result_type(
sprout::deep_copy(cont),
sprout::tuples::get<1>(random_swapped)
)
typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
return sprout::first(random_swapped)[0] == sprout::first(random_swapped)[1]
? result_type(sprout::deep_copy(cont), sprout::second(random_swapped))
: result_type(
sprout::fixed::swap_element(
cont,
sprout::next(sprout::begin(cont), sprout::tuples::get<0>(random_swapped)[0]),
sprout::next(sprout::begin(cont), sprout::tuples::get<0>(random_swapped)[1])
sprout::next(sprout::begin(cont), sprout::first(random_swapped)[0]),
sprout::next(sprout::begin(cont), sprout::first(random_swapped)[1])
),
sprout::tuples::get<1>(random_swapped)
sprout::second(random_swapped)
)
;
}
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
random_swap_result_impl(
Container const& cont, UniformRandomNumberGenerator&& g,
typename sprout::container_traits<Container>::size_type size
@ -117,10 +87,7 @@ namespace sprout {
// random_swap_result
//
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
random_swap_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::random_swap_result_impl(
cont, sprout::forward<UniformRandomNumberGenerator>(g),
@ -132,6 +99,4 @@ namespace sprout {
using sprout::fixed::random_swap_result;
} // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_RANDOM_SWAP_RESULT_HPP

15
sprout/algorithm/fixed/result_of.hpp
View file

@ -1,8 +1,10 @@
#ifndef SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP
#define SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/utility/pair.hpp>
namespace sprout {
namespace fixed {
@ -15,11 +17,24 @@ namespace sprout {
public:
typedef typename sprout::container_construct_traits<Result>::copied_type type;
};
//
// shuffle
//
template<typename Container, typename UniformRandomNumberGenerator>
struct shuffle {
public:
typedef sprout::pair<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
> type;
};
} // namespace result_of
} // namespace fixed
namespace result_of {
using sprout::fixed::result_of::algorithm;
using sprout::fixed::result_of::shuffle;
} // namespace result_of
} // namespace sprout

14
sprout/algorithm/fixed/shuffle.hpp
View file

@ -13,13 +13,7 @@
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/numeric/fixed/iota.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/random/uniform_smallint.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
#else
# include <sprout/random/uniform_int_distribution.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
#endif
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
namespace fixed {
@ -43,7 +37,9 @@ namespace sprout {
return n > 1
? sprout::fixed::detail::make_shuffle_indexes_1(
n,
SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g)),
SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
sprout::forward<UniformRandomNumberGenerator>(g)
),
sprout::fixed::iota(sprout::pit<sprout::array<std::ptrdiff_t, N> >(), 0),
0
)
@ -110,6 +106,4 @@ namespace sprout {
using sprout::fixed::shuffle;
} // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_SHUFFLE_HPP

60
sprout/algorithm/fixed/shuffle_result.hpp
View file

@ -7,35 +7,23 @@
#include <sprout/index_tuple.hpp>
#include <sprout/array.hpp>
#include <sprout/pit.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/numeric/fixed/iota.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/random/uniform_smallint.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
#else
# include <sprout/random/uniform_int_distribution.hpp>
# define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
#endif
#include <sprout/workaround/detail/uniform_int_distribution.hpp>
namespace sprout {
namespace fixed {
namespace detail {
template<typename UniformRandomNumberGenerator, std::size_t N, typename Random>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type>
make_shuffle_result_indexes_1(std::ptrdiff_t n, Random const& rnd, sprout::array<std::ptrdiff_t, N> const& arr, std::ptrdiff_t i) {
typedef sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
typedef sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
return i < n - 1
? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
n,
@ -50,19 +38,15 @@ namespace sprout {
;
}
template<std::size_t N, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type>
make_shuffle_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
typedef sprout::tuples::tuple<
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
typedef sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
return n > 1
? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
n,
SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g)),
SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
sprout::forward<UniformRandomNumberGenerator>(g)
),
sprout::fixed::iota(sprout::pit<sprout::array<std::ptrdiff_t, N> >(), 0),
0
)
@ -73,10 +57,7 @@ namespace sprout {
;
}
template<typename UniformRandomNumberGenerator, typename Container, typename Shuffled, sprout::index_t... Indexes>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
shuffle_result_impl_1(
Container const& cont,
sprout::index_tuple<Indexes...>,
@ -85,27 +66,21 @@ namespace sprout {
typename sprout::container_traits<Container>::size_type size
)
{
typedef sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
return result_type(
sprout::remake<Container>(
cont,
sprout::size(cont),
(Indexes >= offset && Indexes < offset + size
? *sprout::next(sprout::begin(cont), sprout::tuples::get<0>(shuffled)[Indexes - offset])
? *sprout::next(sprout::begin(cont), sprout::first(shuffled)[Indexes - offset])
: *sprout::next(sprout::internal_begin(cont), Indexes)
)...
),
sprout::tuples::get<1>(shuffled)
sprout::second(shuffled)
);
}
template<typename Container, typename UniformRandomNumberGenerator, sprout::index_t... Indexes>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
shuffle_result_impl(
Container const& cont,
sprout::index_tuple<Indexes...> indexes,
@ -130,10 +105,7 @@ namespace sprout {
// shuffle_result
//
template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple<
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
shuffle_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::shuffle_result_impl(
cont,
@ -148,6 +120,4 @@ namespace sprout {
using sprout::fixed::shuffle_result;
} // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_SHUFFLE_RESULT_HPP

6
sprout/bitset/bitwise.hpp
View file

@ -9,17 +9,17 @@ namespace sprout {
// 20.5.4 bitset operators:
template<std::size_t N>
inline SPROUT_CONSTEXPR bitset<N>
inline SPROUT_CONSTEXPR sprout::bitset<N>
operator&(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
return sprout::bitset<N>(lhs.do_and(rhs));
}
template<std::size_t N>
inline SPROUT_CONSTEXPR bitset<N>
inline SPROUT_CONSTEXPR sprout::bitset<N>
operator|(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
return sprout::bitset<N>(lhs.do_or(rhs));
}
template<std::size_t N>
inline SPROUT_CONSTEXPR bitset<N>
inline SPROUT_CONSTEXPR sprout::bitset<N>
operator^(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
return sprout::bitset<N>(lhs.do_xor(rhs));
}

44
sprout/brainfuck/brainfuck.hpp
View file

@ -57,17 +57,17 @@ namespace sprout {
}
template<
typename SourceBidirectionalIterator, typename Output, typename InputInputIterator,
typename BidirectionalIteratorSource, typename Output, typename InputIteratorInput,
typename Buffer, typename OutputBuffer
>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_impl(
SourceBidirectionalIterator first, SourceBidirectionalIterator last,
Output const& output, InputInputIterator in_first, InputInputIterator in_last,
BidirectionalIteratorSource first, BidirectionalIteratorSource last,
Output const& output, InputIteratorInput in_first, InputIteratorInput in_last,
Buffer const& buffer, OutputBuffer const& out_buffer, std::size_t pos = 0, std::size_t out_pos = 0
)
{
typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
typedef typename sprout::container_traits<OutputBuffer>::value_type out_value_type;
return first == last
? sprout::fixed::copy(
@ -136,41 +136,41 @@ namespace sprout {
//
// exec
//
template<std::size_t BufferSize = 32, typename SourceBidirectionalIterator, typename Output, typename InputInputIterator>
template<std::size_t BufferSize = 32, typename BidirectionalIteratorSource, typename Output, typename InputIteratorInput>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec(
SourceBidirectionalIterator first, SourceBidirectionalIterator last,
Output const& output, InputInputIterator in_first, InputInputIterator in_last
BidirectionalIteratorSource first, BidirectionalIteratorSource last,
Output const& output, InputIteratorInput in_first, InputIteratorInput in_last
)
{
typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
typedef sprout::container_traits<Output> out_traits;
return sprout::brainfuck::detail::exec_impl(
first, last, output, in_first, in_last,
sprout::array<value_type, BufferSize>{{}}, sprout::array<typename out_traits::value_type, out_traits::static_size>{{}}
);
}
template<std::size_t BufferSize = 32, typename SourceBidirectionalIterator, typename Output>
template<std::size_t BufferSize = 32, typename BidirectionalIteratorSource, typename Output>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec(
SourceBidirectionalIterator first, SourceBidirectionalIterator last,
BidirectionalIteratorSource first, BidirectionalIteratorSource last,
Output const& output
)
{
typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
return sprout::brainfuck::exec<BufferSize>(
first, last, output, sprout::value_iterator<value_type>(value_type()), sprout::value_iterator<value_type>()
);
}
template<std::size_t BufferSize = 32, typename SourceBidirectionalIterator>
template<std::size_t BufferSize = 32, typename BidirectionalIteratorSource>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
sprout::array<typename std::iterator_traits<SourceBidirectionalIterator>::value_type, BufferSize>
sprout::array<typename std::iterator_traits<BidirectionalIteratorSource>::value_type, BufferSize>
>::type
exec(
SourceBidirectionalIterator first, SourceBidirectionalIterator last
BidirectionalIteratorSource first, BidirectionalIteratorSource last
)
{
typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
return sprout::brainfuck::exec<BufferSize>(
first, last, sprout::pit<sprout::array<value_type, BufferSize> >()
);
@ -179,25 +179,25 @@ namespace sprout {
//
// exec_range
//
template<std::size_t BufferSize = 32, typename Source, typename Output, typename Input>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output, typename InputRangeInput>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_range(Source const& source, Output const& output, Input const& input) {
exec_range(BidirectionalRangeSource const& source, Output const& output, InputRangeInput const& input) {
return sprout::brainfuck::exec<BufferSize>(
sprout::begin(source), sprout::end(source), output, sprout::begin(input), sprout::end(input)
);
}
template<std::size_t BufferSize = 32, typename Source, typename Output>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_range(Source const& source, Output const& output) {
exec_range(BidirectionalRangeSource const& source, Output const& output) {
return sprout::brainfuck::exec<BufferSize>(
sprout::begin(source), sprout::end(source), output
);
}
template<std::size_t BufferSize = 32, typename Source>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
sprout::array<typename sprout::container_traits<Source>::value_type, BufferSize>
sprout::array<typename sprout::container_traits<BidirectionalRangeSource>::value_type, BufferSize>
>::type
exec_range(Source const& source) {
exec_range(BidirectionalRangeSource const& source) {
return sprout::brainfuck::exec<BufferSize>(
sprout::begin(source), sprout::end(source)
);

20
sprout/brainfuck/misa.hpp
View file

@ -57,30 +57,30 @@ namespace sprout {
//
// exec_range
//
template<std::size_t BufferSize = 32, typename Source, typename Output, typename Input>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output, typename InputRangeInput>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_range(Source const& source, Output const& output, Input const& input) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
exec_range(BidirectionalRangeSource const& source, Output const& output, InputRangeInput const& input) {
typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output, input
);
}
template<std::size_t BufferSize = 32, typename Source, typename Output>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_range(Source const& source, Output const& output) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
exec_range(BidirectionalRangeSource const& source, Output const& output) {
typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output
);
}
template<std::size_t BufferSize = 32, typename Source>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
sprout::array<typename sprout::container_traits<Source>::value_type, BufferSize>
sprout::array<typename sprout::container_traits<BidirectionalRangeSource>::value_type, BufferSize>
>::type
exec_range(Source const& source) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
exec_range(BidirectionalRangeSource const& source) {
typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first
);

20
sprout/brainfuck/ook.hpp
View file

@ -57,30 +57,30 @@ namespace sprout {
//
// exec_range
//
template<std::size_t BufferSize = 32, typename Source, typename Output, typename Input>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output, typename InputRangeInput>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_range(Source const& source, Output const& output, Input const& input) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
exec_range(BidirectionalRangeSource const& source, Output const& output, InputRangeInput const& input) {
typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output, input
);
}
template<std::size_t BufferSize = 32, typename Source, typename Output>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
exec_range(Source const& source, Output const& output) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
exec_range(BidirectionalRangeSource const& source, Output const& output) {
typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output
);
}
template<std::size_t BufferSize = 32, typename Source>
template<std::size_t BufferSize = 32, typename BidirectionalRangeSource>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
sprout::array<typename sprout::container_traits<Source>::value_type, BufferSize>
sprout::array<typename sprout::container_traits<BidirectionalRangeSource>::value_type, BufferSize>
>::type
exec_range(Source const& source) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
exec_range(BidirectionalRangeSource const& source) {
typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first
);

8
sprout/range/adaptor/detail/jointed_range_default.hpp
View file

@ -142,9 +142,11 @@ namespace sprout {
>::type
> {
public:
typedef typename sprout::containers::weak_rebind_size<
typename sprout::container_construct_traits<LRange>::copied_type,
sprout::adaptors::detail::jointed_range_size<LRange, RRange>::static_size
typedef typename sprout::container_construct_traits<
typename sprout::containers::weak_rebind_size<
typename sprout::container_construct_traits<LRange>::copied_type,
sprout::adaptors::detail::jointed_range_size<LRange, RRange>::static_size
>::type
>::type copied_type;
};

20
sprout/range/algorithm/fit/clamp_range_copy.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// clamp_range_copy
//
template<typename Input, typename Result, typename Compare>
template<typename InputRange, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high,
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp
)
{
return sprout::fit::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high, comp);
return sprout::fit::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high, comp);
}
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high
)
{
return sprout::fit::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high);
return sprout::fit::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy(Input const& input, Result const& result) {
return sprout::fit::copy(sprout::begin(input), sprout::end(input), result);
copy(InputRange const& rng, Result const& result) {
return sprout::fit::copy(sprout::begin(rng), sprout::end(rng), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_backward.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_backward
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_backward(Input const& input, Result const& result) {
return sprout::fit::copy_backward(sprout::begin(input), sprout::end(input), result);
copy_backward(BidirectionalRange const& rng, Result const& result) {
return sprout::fit::copy_backward(sprout::begin(rng), sprout::end(rng), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_if.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_if(sprout::begin(input), sprout::end(input), result, pred);
copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_until.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_until
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_until(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_until(sprout::begin(input), sprout::end(input), result, pred);
copy_until(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::copy_until(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/copy_while.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// copy_while
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
copy_while(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::copy_while(sprout::begin(input), sprout::end(input), result, pred);
copy_while(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::copy_while(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/merge.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/partition_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/remove_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fit::remove_copy(sprout::begin(input), sprout::end(input), result, value);
remove_copy(InputRange const& rng, Result const& result, T const& value) {
return sprout::fit::remove_copy(sprout::begin(rng), sprout::end(rng), result, value);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/remove_copy_if.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
remove_copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::remove_copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/replace_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
return sprout::fit::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
replace_copy(InputRange const& rng, Result const& result, T const& old_value, T const& new_value) {
return sprout::fit::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/replace_copy_if.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
template<typename InputRange, typename Result, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
return sprout::fit::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
replace_copy_if(InputRange const& rng, Result const& result, Predicate pred, T const& new_value) {
return sprout::fit::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/reverse_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// reverse_copy
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
reverse_copy(Input const& input, Result const& result) {
return sprout::fit::reverse_copy(sprout::begin(input), sprout::end(input), result);
reverse_copy(BidirectionalRange const& rng, Result const& result) {
return sprout::fit::reverse_copy(sprout::begin(rng), sprout::end(rng), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/rotate_copy.hpp
View file

@ -13,14 +13,14 @@ namespace sprout {
//
// rotate_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle,
Result const& result
)
{
return sprout::fit::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
return sprout::fit::rotate_copy(sprout::begin(rng), middle, sprout::end(rng), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_difference.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_intersection.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_symmetric_difference.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

12
sprout/range/algorithm/fit/set_union.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fit::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fit::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/stable_partition_copy.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fit::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
stable_partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fit::stable_partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

10
sprout/range/algorithm/fit/swap_element_copy.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// swap_element_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
ForwardRange const& rng, Result const& result,
typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<ForwardRange>::const_iterator pos2
)
{
return sprout::fit::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
return sprout::fit::swap_element_copy(sprout::begin(rng), sprout::end(rng), result, pos1, pos2);
}
} // namespace fit
} // namespace range

6
sprout/range/algorithm/fit/transform.hpp
View file

@ -13,10 +13,10 @@ namespace sprout {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
template<typename InputRange, typename Result, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, Result const& result, UnaryOperation op) {
return sprout::fit::transform(sprout::begin(input), sprout::end(input), result, op);
transform(InputRange const& rng, Result const& result, UnaryOperation op) {
return sprout::fit::transform(sprout::begin(rng), sprout::end(rng), result, op);
}
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type

12
sprout/range/algorithm/fit/unique_copy.hpp
View file

@ -13,15 +13,15 @@ namespace sprout {
//
// unique_copy
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result) {
return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result);
unique_copy(InputRange const& rng, Result const& result) {
return sprout::fit::unique_copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Input, typename Result, typename BinaryPredicate>
template<typename InputRange, typename Result, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
unique_copy(InputRange const& rng, Result const& result, BinaryPredicate pred) {
return sprout::fit::unique_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
} // namespace fit
} // namespace range

40
sprout/range/algorithm/fixed/clamp_range_copy.hpp
View file

@ -13,48 +13,48 @@ namespace sprout {
//
// clamp_range_copy
//
template<typename Input, typename Result, typename Compare>
template<typename InputRange, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high,
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp
)
{
return sprout::fixed::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high, comp);
return sprout::fixed::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high, comp);
}
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high
InputRange const& rng, Result const& result,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high
)
{
return sprout::fixed::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high);
return sprout::fixed::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high);
}
template<typename Result, typename Input, typename Compare>
template<typename Result, typename InputRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high,
InputRange const& rng,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp
)
{
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(input), sprout::end(input), low, high, comp);
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(rng), sprout::end(rng), low, high, comp);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy(
Input const& input,
typename sprout::container_traits<Input>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high
InputRange const& rng,
typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<InputRange>::value_type const& high
)
{
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(input), sprout::end(input), low, high);
return sprout::fixed::clamp_range_copy<Result>(sprout::begin(rng), sprout::end(rng), low, high);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy(Input const& input, Result const& result) {
return sprout::fixed::copy(sprout::begin(input), sprout::end(input), result);
copy(InputRange const& rng, Result const& result) {
return sprout::fixed::copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy(Input const& input) {
return sprout::fixed::copy<Result>(sprout::begin(input), sprout::end(input));
copy(InputRange const& rng) {
return sprout::fixed::copy<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_backward.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_backward
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_backward(Input const& input, Result const& result) {
return sprout::fixed::copy_backward(sprout::begin(input), sprout::end(input), result);
copy_backward(BidirectionalRange const& rng, Result const& result) {
return sprout::fixed::copy_backward(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename BidirectionalRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_backward(Input const& input) {
return sprout::fixed::copy_backward<Result>(sprout::begin(input), sprout::end(input));
copy_backward(BidirectionalRange const& rng) {
return sprout::fixed::copy_backward<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_if.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_if(sprout::begin(input), sprout::end(input), result);
copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::copy_if(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_if(Input const& input, Predicate pred) {
return sprout::fixed::copy_if<Result>(sprout::begin(input), sprout::end(input));
copy_if(InputRange const& rng, Predicate pred) {
return sprout::fixed::copy_if<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_until.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_until
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_until(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_until(sprout::begin(input), sprout::end(input), result);
copy_until(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::copy_until(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_until(Input const& input, Predicate pred) {
return sprout::fixed::copy_until<Result>(sprout::begin(input), sprout::end(input));
copy_until(InputRange const& rng, Predicate pred) {
return sprout::fixed::copy_until<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/copy_while.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// copy_while
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_while(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::copy_while(sprout::begin(input), sprout::end(input), result);
copy_while(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::copy_while(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
copy_while(Input const& input, Predicate pred) {
return sprout::fixed::copy_while<Result>(sprout::begin(input), sprout::end(input));
copy_while(InputRange const& rng, Predicate pred) {
return sprout::fixed::copy_while<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/merge.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// merge
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::merge<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
merge(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::merge<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
merge(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::merge<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
merge(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::merge<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/partition_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partition_copy(Input const& input, Predicate pred) {
return sprout::fixed::partition_copy<Result>(sprout::begin(input), sprout::end(input), pred);
partition_copy(InputRange const& rng, Predicate pred) {
return sprout::fixed::partition_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/remove_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// remove_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fixed::remove_copy(sprout::begin(input), sprout::end(input), result, value);
remove_copy(InputRange const& rng, Result const& result, T const& value) {
return sprout::fixed::remove_copy(sprout::begin(rng), sprout::end(rng), result, value);
}
template<typename Result, typename Input, typename T>
template<typename Result, typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy(Input const& input, Result const& result, T const& value) {
return sprout::fixed::remove_copy<Result>(sprout::begin(input), sprout::end(input), value);
remove_copy(InputRange const& rng, Result const& result, T const& value) {
return sprout::fixed::remove_copy<Result>(sprout::begin(rng), sprout::end(rng), value);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/remove_copy_if.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// remove_copy_if
//
template<typename Input, typename Result, typename Predicate>
template<typename InputRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
remove_copy_if(InputRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::remove_copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
remove_copy_if(Input const& input, Predicate pred) {
return sprout::fixed::remove_copy_if<Result>(sprout::begin(input), sprout::end(input), pred);
remove_copy_if(InputRange const& rng, Predicate pred) {
return sprout::fixed::remove_copy_if<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/replace_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// replace_copy
//
template<typename Input, typename Result, typename T>
template<typename InputRange, typename Result, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
replace_copy(InputRange const& rng, Result const& result, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
}
template<typename Result, typename Input, typename T>
template<typename Result, typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy(Input const& input, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy<Result>(sprout::begin(input), sprout::end(input), old_value, new_value);
replace_copy(InputRange const& rng, T const& old_value, T const& new_value) {
return sprout::fixed::replace_copy<Result>(sprout::begin(rng), sprout::end(rng), old_value, new_value);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/replace_copy_if.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// replace_copy_if
//
template<typename Input, typename Result, typename T, typename Predicate>
template<typename InputRange, typename Result, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
replace_copy_if(InputRange const& rng, Result const& result, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
}
template<typename Result, typename Input, typename T, typename Predicate>
template<typename Result, typename InputRange, typename T, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
replace_copy_if(Input const& input, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if<Result>(sprout::begin(input), sprout::end(input), pred, new_value);
replace_copy_if(InputRange const& rng, Predicate pred, T const& new_value) {
return sprout::fixed::replace_copy_if<Result>(sprout::begin(rng), sprout::end(rng), pred, new_value);
}
} // namespace fixed

12
sprout/range/algorithm/fixed/reverse_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// reverse_copy
//
template<typename Input, typename Result>
template<typename BidirectionalRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(Input const& input, Result const& result) {
return sprout::fixed::reverse_copy(sprout::begin(input), sprout::end(input), result);
reverse_copy(BidirectionalRange const& rng, Result const& result) {
return sprout::fixed::reverse_copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename BidirectionalRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
reverse_copy(Input const& input) {
return sprout::fixed::reverse_copy<Result>(sprout::begin(input), sprout::end(input));
reverse_copy(BidirectionalRange const& rng) {
return sprout::fixed::reverse_copy<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/rotate_copy.hpp
View file

@ -13,23 +13,23 @@ namespace sprout {
//
// rotate_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle,
Result const& result
)
{
return sprout::fixed::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
return sprout::fixed::rotate_copy(sprout::begin(rng), middle, sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy(
Input const& input, typename sprout::container_traits<Input>::const_iterator middle
ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle
)
{
return sprout::fixed::rotate_copy<Result>(sprout::begin(input), middle, sprout::end(input));
return sprout::fixed::rotate_copy<Result>(sprout::begin(rng), middle, sprout::end(rng));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_difference.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_difference(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_difference(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_intersection.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_intersection
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_intersection<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_intersection<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_intersection(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_intersection<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_intersection(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_intersection<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_symmetric_difference.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_symmetric_difference
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_symmetric_difference(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

24
sprout/range/algorithm/fixed/set_union.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// set_union
//
template<typename Input1, typename Input2, typename Result, typename Compare>
template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
return sprout::fixed::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
}
template<typename Input1, typename Input2, typename Result>
template<typename InputRange1, typename InputRange2, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
return sprout::fixed::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
}
template<typename Result, typename Input1, typename Input2, typename Compare>
template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2, Compare comp) {
return sprout::fixed::set_union<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
set_union(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
return sprout::fixed::set_union<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
}
template<typename Result, typename Input1, typename Input2>
template<typename Result, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
set_union(Input1 const& input1, Input2 const& input2) {
return sprout::fixed::set_union<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
set_union(InputRange1 const& rng1, InputRange2 const& rng2) {
return sprout::fixed::set_union<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
}
} // namespace fixed

12
sprout/range/algorithm/fixed/stable_partition_copy.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// stable_partition_copy
//
template<typename Input, typename Result, typename Predicate>
template<typename BidirectionalRange, typename Result, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
return sprout::fixed::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
stable_partition_copy(BidirectionalRange const& rng, Result const& result, Predicate pred) {
return sprout::fixed::stable_partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Result, typename Input, typename Predicate>
template<typename Result, typename BidirectionalRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
stable_partition_copy(Input const& input, Predicate pred) {
return sprout::fixed::stable_partition_copy<Result>(sprout::begin(input), sprout::end(input), pred);
stable_partition_copy(BidirectionalRange const& rng, Predicate pred) {
return sprout::fixed::stable_partition_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
} // namespace fixed

20
sprout/range/algorithm/fixed/swap_element_copy.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// swap_element_copy
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
ForwardRange const& rng, Result const& result,
typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<ForwardRange>::const_iterator pos2
)
{
return sprout::fixed::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
return sprout::fixed::swap_element_copy(sprout::begin(rng), sprout::end(rng), result, pos1, pos2);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy(
Input const& input,
typename sprout::container_traits<Input>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2
ForwardRange const& rng,
typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<ForwardRange>::const_iterator pos2
)
{
return sprout::fixed::swap_element_copy<Result>(sprout::begin(input), sprout::end(input), pos1, pos2);
return sprout::fixed::swap_element_copy<Result>(sprout::begin(rng), sprout::end(rng), pos1, pos2);
}
} // namespace fixed

24
sprout/range/algorithm/fixed/transform.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// transform
//
template<typename Input, typename Result, typename UnaryOperation>
template<typename InputRange, typename Result, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, Result const& result, UnaryOperation op) {
return sprout::fixed::transform(sprout::begin(input), sprout::end(input), result, op);
transform(InputRange const& rng, Result const& result, UnaryOperation op) {
return sprout::fixed::transform(sprout::begin(rng), sprout::end(rng), result, op);
}
template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
template<typename InputRange1, typename InputRange2, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input1 const& input1, Input2 const& input2, Result const& result, BinaryOperation op) {
return sprout::fixed::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
transform(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, BinaryOperation op) {
return sprout::fixed::transform(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), result, op);
}
template<typename Result, typename Input, typename UnaryOperation>
template<typename Result, typename InputRange, typename UnaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input const& input, UnaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(input), sprout::end(input), op);
transform(InputRange const& rng, UnaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(rng), sprout::end(rng), op);
}
template<typename Result, typename Input1, typename Input2, typename BinaryOperation>
template<typename Result, typename InputRange1, typename InputRange2, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
transform(Input1 const& input1, Input2 const& input2, BinaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), op);
transform(InputRange1 const& rng1, InputRange2 const& rng2, BinaryOperation op) {
return sprout::fixed::transform<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), op);
}
} // namespace fixed

24
sprout/range/algorithm/fixed/unique_copy.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// unique_copy
//
template<typename Input, typename Result, typename BinaryPredicate>
template<typename InputRange, typename Result, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
unique_copy(InputRange const& rng, Result const& result, BinaryPredicate pred) {
return sprout::fixed::unique_copy(sprout::begin(rng), sprout::end(rng), result, pred);
}
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, Result const& result) {
return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result);
unique_copy(InputRange const& rng, Result const& result) {
return sprout::fixed::unique_copy(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input, typename BinaryPredicate>
template<typename Result, typename InputRange, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input, BinaryPredicate pred) {
return sprout::fixed::unique_copy<Result>(sprout::begin(input), sprout::end(input), pred);
unique_copy(InputRange const& rng, BinaryPredicate pred) {
return sprout::fixed::unique_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
unique_copy(Input const& input) {
return sprout::fixed::unique_copy<Result>(sprout::begin(input), sprout::end(input));
unique_copy(InputRange const& rng) {
return sprout::fixed::unique_copy<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

6
sprout/range/numeric/dft/dft_element.hpp
View file

@ -11,9 +11,9 @@ namespace sprout {
//
// dft_element
//
template<typename Input>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Input>::value_type
dft_element(Input const& input, typename sprout::container_traits<Input>::difference_type i) {
template<typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::container_traits<InputRange>::value_type
dft_element(InputRange const& input, typename sprout::container_traits<InputRange>::difference_type i) {
return sprout::dft_element(sprout::begin(input), sprout::end(input), i);
}
} // namespace range

12
sprout/range/numeric/dft/fit/amplitude_spectrum.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// amplitude_spectrum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
amplitude_spectrum(Input const& input, Result const& result) {
return sprout::fit::amplitude_spectrum(sprout::begin(input), sprout::end(input), result);
amplitude_spectrum(InputRange const& rng, Result const& result) {
return sprout::fit::amplitude_spectrum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
amplitude_spectrum(Input const& input) {
return sprout::fit::amplitude_spectrum<Result>(sprout::begin(input), sprout::end(input));
amplitude_spectrum(InputRange const& rng) {
return sprout::fit::amplitude_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fit
} // namespace range

12
sprout/range/numeric/dft/fit/dft.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// dft
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
dft(Input const& input, Result const& result) {
return sprout::fit::dft(sprout::begin(input), sprout::end(input), result);
dft(ForwardRange const& rng, Result const& result) {
return sprout::fit::dft(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
dft(Input const& input) {
return sprout::fit::dft<Result>(sprout::begin(input), sprout::end(input));
dft(ForwardRange const& rng) {
return sprout::fit::dft<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fit
} // namespace range

12
sprout/range/numeric/dft/fit/idft.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// idft
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
idft(Input const& input, Result const& result) {
return sprout::fit::idft(sprout::begin(input), sprout::end(input), result);
idft(ForwardRange const& rng, Result const& result) {
return sprout::fit::idft(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
idft(Input const& input) {
return sprout::fit::idft<Result>(sprout::begin(input), sprout::end(input));
idft(ForwardRange const& rng) {
return sprout::fit::idft<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fit
} // namespace range

12
sprout/range/numeric/dft/fit/phase_spectrum.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// phase_spectrum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
phase_spectrum(Input const& input, Result const& result) {
return sprout::fit::phase_spectrum(sprout::begin(input), sprout::end(input), result);
phase_spectrum(InputRange const& rng, Result const& result) {
return sprout::fit::phase_spectrum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
phase_spectrum(Input const& input) {
return sprout::fit::phase_spectrum<Result>(sprout::begin(input), sprout::end(input));
phase_spectrum(InputRange const& rng) {
return sprout::fit::phase_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fit
} // namespace range

12
sprout/range/numeric/dft/fit/spectrum.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// spectrum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
spectrum(Input const& input, Result const& result) {
return sprout::fit::spectrum(sprout::begin(input), sprout::end(input), result);
spectrum(InputRange const& rng, Result const& result) {
return sprout::fit::spectrum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
spectrum(Input const& input) {
return sprout::fit::spectrum<Result>(sprout::begin(input), sprout::end(input));
spectrum(InputRange const& rng) {
return sprout::fit::spectrum<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fit
} // namespace range

12
sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// amplitude_spectrum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
amplitude_spectrum(Input const& input, Result const& result) {
return sprout::fixed::amplitude_spectrum(sprout::begin(input), sprout::end(input), result);
amplitude_spectrum(InputRange const& rng, Result const& result) {
return sprout::fixed::amplitude_spectrum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
amplitude_spectrum(Input const& input) {
return sprout::fixed::amplitude_spectrum<Result>(sprout::begin(input), sprout::end(input));
amplitude_spectrum(InputRange const& rng) {
return sprout::fixed::amplitude_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/numeric/dft/fixed/dft.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// dft
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
dft(Input const& input, Result const& result) {
return sprout::fixed::dft(sprout::begin(input), sprout::end(input), result);
dft(ForwardRange const& rng, Result const& result) {
return sprout::fixed::dft(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
dft(Input const& input) {
return sprout::fixed::dft<Result>(sprout::begin(input), sprout::end(input));
dft(ForwardRange const& rng) {
return sprout::fixed::dft<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/numeric/dft/fixed/idft.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// idft
//
template<typename Input, typename Result>
template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
idft(Input const& input, Result const& result) {
return sprout::fixed::idft(sprout::begin(input), sprout::end(input), result);
idft(ForwardRange const& rng, Result const& result) {
return sprout::fixed::idft(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
idft(Input const& input) {
return sprout::fixed::idft<Result>(sprout::begin(input), sprout::end(input));
idft(ForwardRange const& rng) {
return sprout::fixed::idft<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/numeric/dft/fixed/phase_spectrum.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// phase_spectrum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
phase_spectrum(Input const& input, Result const& result) {
return sprout::fixed::phase_spectrum(sprout::begin(input), sprout::end(input), result);
phase_spectrum(InputRange const& rng, Result const& result) {
return sprout::fixed::phase_spectrum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
phase_spectrum(Input const& input) {
return sprout::fixed::phase_spectrum<Result>(sprout::begin(input), sprout::end(input));
phase_spectrum(InputRange const& rng) {
return sprout::fixed::phase_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

12
sprout/range/numeric/dft/fixed/spectrum.hpp
View file

@ -13,16 +13,16 @@ namespace sprout {
//
// spectrum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
spectrum(Input const& input, Result const& result) {
return sprout::fixed::spectrum(sprout::begin(input), sprout::end(input), result);
spectrum(InputRange const& rng, Result const& result) {
return sprout::fixed::spectrum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
spectrum(Input const& input) {
return sprout::fixed::spectrum<Result>(sprout::begin(input), sprout::end(input));
spectrum(InputRange const& rng) {
return sprout::fixed::spectrum<Result>(sprout::begin(rng), sprout::end(rng));
}
} // namespace fixed

6
sprout/range/numeric/dft/idft_element.hpp
View file

@ -11,9 +11,9 @@ namespace sprout {
//
// idft_element
//
template<typename Input>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Input>::value_type
idft_element(Input const& input, typename sprout::container_traits<Input>::difference_type i) {
template<typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::container_traits<InputRange>::value_type
idft_element(InputRange const& input, typename sprout::container_traits<InputRange>::difference_type i) {
return sprout::idft_element(sprout::begin(input), sprout::end(input), i);
}
} // namespace range

24
sprout/range/numeric/fit/adjacent_difference.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// adjacent_difference
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result) {
return sprout::fit::adjacent_difference(sprout::begin(input), sprout::end(input), result);
adjacent_difference(InputRange const& rng, Result const& result) {
return sprout::fit::adjacent_difference(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Input, typename Result, typename BinaryOperation>
template<typename InputRange, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fit::adjacent_difference(sprout::begin(input), sprout::end(input), result, binary_op);
adjacent_difference(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
return sprout::fit::adjacent_difference(sprout::begin(rng), sprout::end(rng), result, binary_op);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
adjacent_difference(Input const& input) {
return sprout::fit::adjacent_difference<Result>(sprout::begin(input), sprout::end(input));
adjacent_difference(InputRange const& rng) {
return sprout::fit::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng));
}
template<typename Result, typename Input, typename BinaryOperation>
template<typename Result, typename InputRange, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, BinaryOperation binary_op) {
return sprout::fit::adjacent_difference<Result>(sprout::begin(input), sprout::end(input), binary_op);
adjacent_difference(InputRange const& rng, BinaryOperation binary_op) {
return sprout::fit::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
}
} // namespace fit
} // namespace range

24
sprout/range/numeric/fit/partial_sum.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// partial_sum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result) {
return sprout::fit::partial_sum(sprout::begin(input), sprout::end(input), result);
partial_sum(InputRange const& rng, Result const& result) {
return sprout::fit::partial_sum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Input, typename Result, typename BinaryOperation>
template<typename InputRange, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fit::partial_sum(sprout::begin(input), sprout::end(input), result, binary_op);
partial_sum(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
return sprout::fit::partial_sum(sprout::begin(rng), sprout::end(rng), result, binary_op);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partial_sum(Input const& input) {
return sprout::fit::partial_sum<Result>(sprout::begin(input), sprout::end(input));
partial_sum(InputRange const& rng) {
return sprout::fit::partial_sum<Result>(sprout::begin(rng), sprout::end(rng));
}
template<typename Result, typename Input, typename BinaryOperation>
template<typename Result, typename InputRange, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
partial_sum(Input const& input, BinaryOperation binary_op) {
return sprout::fit::partial_sum<Result>(sprout::begin(input), sprout::end(input), binary_op);
partial_sum(InputRange const& rng, BinaryOperation binary_op) {
return sprout::fit::partial_sum<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
}
} // namespace fit
} // namespace range

24
sprout/range/numeric/fixed/adjacent_difference.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// adjacent_difference
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result) {
return sprout::fixed::adjacent_difference(sprout::begin(input), sprout::end(input), result);
adjacent_difference(InputRange const& rng, Result const& result) {
return sprout::fixed::adjacent_difference(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Input, typename Result, typename BinaryOperation>
template<typename InputRange, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fixed::adjacent_difference(sprout::begin(input), sprout::end(input), result, binary_op);
adjacent_difference(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
return sprout::fixed::adjacent_difference(sprout::begin(rng), sprout::end(rng), result, binary_op);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
adjacent_difference(Input const& input) {
return sprout::fixed::adjacent_difference<Result>(sprout::begin(input), sprout::end(input));
adjacent_difference(InputRange const& rng) {
return sprout::fixed::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng));
}
template<typename Result, typename Input, typename BinaryOperation>
template<typename Result, typename InputRange, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
adjacent_difference(Input const& input, BinaryOperation binary_op) {
return sprout::fixed::adjacent_difference<Result>(sprout::begin(input), sprout::end(input), binary_op);
adjacent_difference(InputRange const& rng, BinaryOperation binary_op) {
return sprout::fixed::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
}
} // namespace fixed

24
sprout/range/numeric/fixed/partial_sum.hpp
View file

@ -13,26 +13,26 @@ namespace sprout {
//
// partial_sum
//
template<typename Input, typename Result>
template<typename InputRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result) {
return sprout::fixed::partial_sum(sprout::begin(input), sprout::end(input), result);
partial_sum(InputRange const& rng, Result const& result) {
return sprout::fixed::partial_sum(sprout::begin(rng), sprout::end(rng), result);
}
template<typename Input, typename Result, typename BinaryOperation>
template<typename InputRange, typename Result, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partial_sum(Input const& input, Result const& result, BinaryOperation binary_op) {
return sprout::fixed::partial_sum(sprout::begin(input), sprout::end(input), result, binary_op);
partial_sum(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
return sprout::fixed::partial_sum(sprout::begin(rng), sprout::end(rng), result, binary_op);
}
template<typename Result, typename Input>
template<typename Result, typename InputRange>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partial_sum(Input const& input) {
return sprout::fixed::partial_sum<Result>(sprout::begin(input), sprout::end(input));
partial_sum(InputRange const& rng) {
return sprout::fixed::partial_sum<Result>(sprout::begin(rng), sprout::end(rng));
}
template<typename Result, typename Input, typename BinaryOperation>
template<typename Result, typename InputRange, typename BinaryOperation>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
partial_sum(Input const& input, BinaryOperation binary_op) {
return sprout::fixed::partial_sum<Result>(sprout::begin(input), sprout::end(input), binary_op);
partial_sum(InputRange const& rng, BinaryOperation binary_op) {
return sprout::fixed::partial_sum<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
}
} // namespace fixed

17
sprout/workaround/detail/uniform_int_distribution.hpp Normal file
View file

@ -0,0 +1,17 @@
#ifndef SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION_HPP
#define SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION_HPP
#include <sprout/config.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# include <sprout/random/uniform_smallint.hpp>
#else
# include <sprout/random/uniform_int_distribution.hpp>
#endif
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
# define SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
#else
# define SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
#endif
#endif // #ifndef SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION_HPP