mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-02-09 09:53:57 +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 #define SPROUT_ALGORITHM_FIXED_BOGO_SORT_HPP
#include <sprout/config.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/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/result_of.hpp>
#include <sprout/algorithm/fixed/shuffle_result.hpp> #include <sprout/algorithm/fixed/bogo_sort_result.hpp>
#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
namespace sprout { namespace sprout {
namespace fixed { 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 // bogo_sort
// //
template<typename Container, typename UniformRandomNumberGenerator, typename Compare> template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) { bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
return sprout::fixed::detail::bogo_sort_impl( return sprout::first(
cont, sprout::fixed::bogo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g), comp)
sprout::forward<UniformRandomNumberGenerator>(g),
comp
); );
} }
template<typename Container, typename UniformRandomNumberGenerator> template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g) { bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::bogo_sort_impl( return sprout::first(
cont, sprout::fixed::bogo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g))
sprout::forward<UniformRandomNumberGenerator>(g),
NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
); );
} }
} // namespace fixed } // namespace fixed

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

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

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

@ -3,11 +3,11 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp> #include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp> #include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp> #include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/is_sorted.hpp> #include <sprout/algorithm/is_sorted.hpp>
#include <sprout/algorithm/fixed/result_of.hpp> #include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/random_swap_result.hpp> #include <sprout/algorithm/fixed/random_swap_result.hpp>
@ -16,53 +16,56 @@
namespace sprout { namespace sprout {
namespace fixed { namespace fixed {
namespace detail { namespace detail {
template<typename Container, typename UniformRandomNumberGenerator, typename Shuffled, typename Compare> template<typename ResultType, typename Compare, typename Difference>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
typename sprout::fixed::result_of::algorithm<Container>::type, bozo_sort_result_impl_1(
typename std::decay<UniformRandomNumberGenerator>::type sprout::pair<ResultType, bool> const& current,
> Compare comp, Difference n
bozo_sort_result_impl_1(Shuffled const& shuffled, Compare comp) { )
return sprout::is_sorted( {
sprout::begin(sprout::tuples::get<0>(shuffled)), typedef sprout::pair<ResultType, bool> type;
sprout::end(sprout::tuples::get<0>(shuffled)), return current.second ? current
comp : 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( template<typename ResultType, typename Compare, typename Difference>
sprout::tuples::get<0>(shuffled), inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
sprout::tuples::get<1>(shuffled) 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> template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type, bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
typename std::decay<UniformRandomNumberGenerator>::type typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
> typedef sprout::pair<result_type, bool> type;
bozo_sort_result_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) { return sprout::is_sorted(sprout::begin(cont), sprout::end(cont), comp)
typedef sprout::tuples::tuple< ? result_type(sprout::deep_copy(cont), sprout::forward<UniformRandomNumberGenerator>(g))
typename sprout::fixed::result_of::algorithm<Container>::type, : sprout::fixed::detail::bozo_sort_result_impl<result_type>(
typename std::decay<UniformRandomNumberGenerator>::type type(sprout::fixed::random_swap_result(cont, sprout::forward<UniformRandomNumberGenerator>(g)), false),
> result_type; comp, static_cast<typename sprout::container_traits<Container>::difference_type>(1)
return sprout::is_sorted( ).first
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
)
; ;
} }
} // namespace detail } // namespace detail
@ -70,24 +73,18 @@ namespace sprout {
// bozo_sort_result // bozo_sort_result
// //
template<typename Container, typename UniformRandomNumberGenerator, typename Compare> template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) { 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, cont,
sprout::forward<UniformRandomNumberGenerator>(g), sprout::forward<UniformRandomNumberGenerator>(g),
comp comp
); );
} }
template<typename Container, typename UniformRandomNumberGenerator> template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g) { bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::bozo_sort_result_impl( return sprout::fixed::detail::bozo_sort_result(
cont, cont,
sprout::forward<UniformRandomNumberGenerator>(g), sprout::forward<UniformRandomNumberGenerator>(g),
NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>() 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/container/functions.hpp>
#include <sprout/iterator/operation.hpp> #include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp> #include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp> #include <sprout/algorithm/fixed/swap_element.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE #include <sprout/workaround/detail/uniform_int_distribution.hpp>
# 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
namespace sprout { namespace sprout {
namespace fixed { namespace fixed {
@ -39,7 +34,9 @@ namespace sprout {
make_random_swap_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) { make_random_swap_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
return n > 1 return n > 1
? sprout::fixed::detail::make_random_swap_indexes_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>{{}} : sprout::array<std::ptrdiff_t, 2>{{}}
; ;
@ -88,6 +85,4 @@ namespace sprout {
using sprout::fixed::random_swap; using sprout::fixed::random_swap;
} // namespace sprout } // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_RANDOM_SWAP_HPP #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/container/functions.hpp>
#include <sprout/iterator/operation.hpp> #include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp> #include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp> #include <sprout/algorithm/fixed/swap_element.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE #include <sprout/workaround/detail/uniform_int_distribution.hpp>
# 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
namespace sprout { namespace sprout {
namespace fixed { namespace fixed {
namespace detail { namespace detail {
template<typename UniformRandomNumberGenerator, typename Random> template<typename UniformRandomNumberGenerator, typename Random>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
>
make_random_swap_result_indexes_2(Random const& rnd, std::ptrdiff_t i0) { make_random_swap_result_indexes_2(Random const& rnd, std::ptrdiff_t i0) {
typedef sprout::tuples::tuple< typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return result_type( return result_type(
sprout::array<std::ptrdiff_t, 2>{{i0, rnd.result()}}, sprout::array<std::ptrdiff_t, 2>{{i0, rnd.result()}},
rnd.engine() rnd.engine()
); );
} }
template<typename UniformRandomNumberGenerator, typename Random> template<typename UniformRandomNumberGenerator, typename Random>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
>
make_random_swap_result_indexes_1(Random const& rnd) { make_random_swap_result_indexes_1(Random const& rnd) {
return sprout::fixed::detail::make_random_swap_result_indexes_2<UniformRandomNumberGenerator>( return sprout::fixed::detail::make_random_swap_result_indexes_2<UniformRandomNumberGenerator>(
rnd(), rnd(),
@ -50,18 +36,14 @@ namespace sprout {
); );
} }
template<typename UniformRandomNumberGenerator> template<typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
>
make_random_swap_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) { make_random_swap_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
typedef sprout::tuples::tuple< typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
sprout::array<std::ptrdiff_t, 2>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return n > 1 return n > 1
? sprout::fixed::detail::make_random_swap_result_indexes_1<UniformRandomNumberGenerator>( ? 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( : result_type(
sprout::array<std::ptrdiff_t, 2>{{}}, sprout::array<std::ptrdiff_t, 2>{{}},
@ -70,35 +52,23 @@ namespace sprout {
; ;
} }
template<typename UniformRandomNumberGenerator, typename Container, typename RandomSwapped> template<typename UniformRandomNumberGenerator, typename Container, typename RandomSwapped>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
random_swap_result_impl_1(Container const& cont, RandomSwapped const& random_swapped) { random_swap_result_impl_1(Container const& cont, RandomSwapped const& random_swapped) {
typedef sprout::tuples::tuple< typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
typename sprout::fixed::result_of::algorithm<Container>::type, return sprout::first(random_swapped)[0] == sprout::first(random_swapped)[1]
typename std::decay<UniformRandomNumberGenerator>::type ? result_type(sprout::deep_copy(cont), sprout::second(random_swapped))
> 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)
)
: result_type( : result_type(
sprout::fixed::swap_element( sprout::fixed::swap_element(
cont, cont,
sprout::next(sprout::begin(cont), sprout::tuples::get<0>(random_swapped)[0]), sprout::next(sprout::begin(cont), sprout::first(random_swapped)[0]),
sprout::next(sprout::begin(cont), sprout::tuples::get<0>(random_swapped)[1]) 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> template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
random_swap_result_impl( random_swap_result_impl(
Container const& cont, UniformRandomNumberGenerator&& g, Container const& cont, UniformRandomNumberGenerator&& g,
typename sprout::container_traits<Container>::size_type size typename sprout::container_traits<Container>::size_type size
@ -117,10 +87,7 @@ namespace sprout {
// random_swap_result // random_swap_result
// //
template<typename Container, typename UniformRandomNumberGenerator> template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
random_swap_result(Container const& cont, UniformRandomNumberGenerator&& g) { random_swap_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::random_swap_result_impl( return sprout::fixed::detail::random_swap_result_impl(
cont, sprout::forward<UniformRandomNumberGenerator>(g), cont, sprout::forward<UniformRandomNumberGenerator>(g),
@ -132,6 +99,4 @@ namespace sprout {
using sprout::fixed::random_swap_result; using sprout::fixed::random_swap_result;
} // namespace sprout } // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_RANDOM_SWAP_RESULT_HPP #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 #ifndef SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP
#define SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP #define SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP
#include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/container/traits.hpp> #include <sprout/container/traits.hpp>
#include <sprout/utility/pair.hpp>
namespace sprout { namespace sprout {
namespace fixed { namespace fixed {
@ -15,11 +17,24 @@ namespace sprout {
public: public:
typedef typename sprout::container_construct_traits<Result>::copied_type type; 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 result_of
} // namespace fixed } // namespace fixed
namespace result_of { namespace result_of {
using sprout::fixed::result_of::algorithm; using sprout::fixed::result_of::algorithm;
using sprout::fixed::result_of::shuffle;
} // namespace result_of } // namespace result_of
} // namespace sprout } // 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/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp> #include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/numeric/fixed/iota.hpp> #include <sprout/numeric/fixed/iota.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE #include <sprout/workaround/detail/uniform_int_distribution.hpp>
# 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
namespace sprout { namespace sprout {
namespace fixed { namespace fixed {
@ -43,7 +37,9 @@ namespace sprout {
return n > 1 return n > 1
? sprout::fixed::detail::make_shuffle_indexes_1( ? sprout::fixed::detail::make_shuffle_indexes_1(
n, 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), sprout::fixed::iota(sprout::pit<sprout::array<std::ptrdiff_t, N> >(), 0),
0 0
) )
@ -110,6 +106,4 @@ namespace sprout {
using sprout::fixed::shuffle; using sprout::fixed::shuffle;
} // namespace sprout } // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_SHUFFLE_HPP #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/index_tuple.hpp>
#include <sprout/array.hpp> #include <sprout/array.hpp>
#include <sprout/pit.hpp> #include <sprout/pit.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/container/traits.hpp> #include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp> #include <sprout/container/functions.hpp>
#include <sprout/iterator/operation.hpp> #include <sprout/iterator/operation.hpp>
#include <sprout/utility/forward.hpp> #include <sprout/utility/forward.hpp>
#include <sprout/utility/pair.hpp>
#include <sprout/algorithm/fixed/result_of.hpp> #include <sprout/algorithm/fixed/result_of.hpp>
#include <sprout/algorithm/fixed/swap_element.hpp> #include <sprout/algorithm/fixed/swap_element.hpp>
#include <sprout/numeric/fixed/iota.hpp> #include <sprout/numeric/fixed/iota.hpp>
#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE #include <sprout/workaround/detail/uniform_int_distribution.hpp>
# 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
namespace sprout { namespace sprout {
namespace fixed { namespace fixed {
namespace detail { namespace detail {
template<typename UniformRandomNumberGenerator, std::size_t N, typename Random> template<typename UniformRandomNumberGenerator, std::size_t N, typename Random>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type>
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) { 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< typedef sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return i < n - 1 return i < n - 1
? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>( ? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
n, n,
@ -50,19 +38,15 @@ namespace sprout {
; ;
} }
template<std::size_t N, typename UniformRandomNumberGenerator> template<std::size_t N, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type>
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
>
make_shuffle_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) { make_shuffle_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
typedef sprout::tuples::tuple< typedef sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
sprout::array<std::ptrdiff_t, N>,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return n > 1 return n > 1
? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>( ? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
n, 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), sprout::fixed::iota(sprout::pit<sprout::array<std::ptrdiff_t, N> >(), 0),
0 0
) )
@ -73,10 +57,7 @@ namespace sprout {
; ;
} }
template<typename UniformRandomNumberGenerator, typename Container, typename Shuffled, sprout::index_t... Indexes> template<typename UniformRandomNumberGenerator, typename Container, typename Shuffled, sprout::index_t... Indexes>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
shuffle_result_impl_1( shuffle_result_impl_1(
Container const& cont, Container const& cont,
sprout::index_tuple<Indexes...>, sprout::index_tuple<Indexes...>,
@ -85,27 +66,21 @@ namespace sprout {
typename sprout::container_traits<Container>::size_type size typename sprout::container_traits<Container>::size_type size
) )
{ {
typedef sprout::tuples::tuple< typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
> result_type;
return result_type( return result_type(
sprout::remake<Container>( sprout::remake<Container>(
cont, cont,
sprout::size(cont), sprout::size(cont),
(Indexes >= offset && Indexes < offset + size (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::next(sprout::internal_begin(cont), Indexes)
)... )...
), ),
sprout::tuples::get<1>(shuffled) sprout::second(shuffled)
); );
} }
template<typename Container, typename UniformRandomNumberGenerator, sprout::index_t... Indexes> template<typename Container, typename UniformRandomNumberGenerator, sprout::index_t... Indexes>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
shuffle_result_impl( shuffle_result_impl(
Container const& cont, Container const& cont,
sprout::index_tuple<Indexes...> indexes, sprout::index_tuple<Indexes...> indexes,
@ -130,10 +105,7 @@ namespace sprout {
// shuffle_result // shuffle_result
// //
template<typename Container, typename UniformRandomNumberGenerator> template<typename Container, typename UniformRandomNumberGenerator>
inline SPROUT_CONSTEXPR sprout::tuples::tuple< inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
typename sprout::fixed::result_of::algorithm<Container>::type,
typename std::decay<UniformRandomNumberGenerator>::type
>
shuffle_result(Container const& cont, UniformRandomNumberGenerator&& g) { shuffle_result(Container const& cont, UniformRandomNumberGenerator&& g) {
return sprout::fixed::detail::shuffle_result_impl( return sprout::fixed::detail::shuffle_result_impl(
cont, cont,
@ -148,6 +120,4 @@ namespace sprout {
using sprout::fixed::shuffle_result; using sprout::fixed::shuffle_result;
} // namespace sprout } // namespace sprout
#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
#endif // #ifndef SPROUT_ALGORITHM_FIXED_SHUFFLE_RESULT_HPP #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: // 20.5.4 bitset operators:
template<std::size_t N> 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 { operator&(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
return sprout::bitset<N>(lhs.do_and(rhs)); return sprout::bitset<N>(lhs.do_and(rhs));
} }
template<std::size_t N> 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 { operator|(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
return sprout::bitset<N>(lhs.do_or(rhs)); return sprout::bitset<N>(lhs.do_or(rhs));
} }
template<std::size_t N> 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 { operator^(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
return sprout::bitset<N>(lhs.do_xor(rhs)); return sprout::bitset<N>(lhs.do_xor(rhs));
} }

44
sprout/brainfuck/brainfuck.hpp
View file

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

20
sprout/brainfuck/misa.hpp
View file

@ -57,30 +57,30 @@ namespace sprout {
// //
// exec_range // 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 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) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type; typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>( return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first, sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output, input 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 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) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type; typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>( return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first, sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output 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< 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 >::type
exec_range(Source const& source) { exec_range(BidirectionalRangeSource const& source) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type; typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>( return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first 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 // 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 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) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type; typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>( return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first, sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output, input 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 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) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type; typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>( return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first, sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
output 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< 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 >::type
exec_range(Source const& source) { exec_range(BidirectionalRangeSource const& source) {
typedef typename sprout::container_construct_traits<Source>::copied_type copied_type; typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
return sprout::brainfuck::exec_range<BufferSize>( return sprout::brainfuck::exec_range<BufferSize>(
sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first 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 >::type
> { > {
public: public:
typedef typename sprout::containers::weak_rebind_size< typedef typename sprout::container_construct_traits<
typename sprout::container_construct_traits<LRange>::copied_type, typename sprout::containers::weak_rebind_size<
sprout::adaptors::detail::jointed_range_size<LRange, RRange>::static_size typename sprout::container_construct_traits<LRange>::copied_type,
sprout::adaptors::detail::jointed_range_size<LRange, RRange>::static_size
>::type
>::type copied_type; >::type copied_type;
}; };

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

@ -13,26 +13,26 @@ namespace sprout {
// //
// clamp_range_copy // 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 inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
clamp_range_copy( clamp_range_copy(
Input const& input, Result const& result, InputRange const& rng, Result const& result,
typename sprout::container_traits<Input>::value_type const& low, typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high, typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp 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 inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
clamp_range_copy( clamp_range_copy(
Input const& input, Result const& result, InputRange const& rng, Result const& result,
typename sprout::container_traits<Input>::value_type const& low, typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high 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 fit
} // namespace range } // namespace range

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -13,10 +13,10 @@ namespace sprout {
// //
// replace_copy // 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 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) { replace_copy(InputRange const& rng, 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); return sprout::fit::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
} }
} // namespace fit } // namespace fit
} // namespace range } // namespace range

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

@ -13,10 +13,10 @@ namespace sprout {
// //
// replace_copy_if // 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 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) { replace_copy_if(InputRange const& rng, 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); return sprout::fit::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
} }
} // namespace fit } // namespace fit
} // namespace range } // namespace range

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

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

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

@ -13,14 +13,14 @@ namespace sprout {
// //
// rotate_copy // rotate_copy
// //
template<typename Input, typename Result> template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
rotate_copy( 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 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 fit
} // namespace range } // namespace range

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

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

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

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

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

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

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

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

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

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

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

@ -13,15 +13,15 @@ namespace sprout {
// //
// swap_element_copy // swap_element_copy
// //
template<typename Input, typename Result> template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
swap_element_copy( swap_element_copy(
Input const& input, Result const& result, ForwardRange const& rng, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1, typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2 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 fit
} // namespace range } // namespace range

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

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

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

@ -13,48 +13,48 @@ namespace sprout {
// //
// clamp_range_copy // 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 inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy( clamp_range_copy(
Input const& input, Result const& result, InputRange const& rng, Result const& result,
typename sprout::container_traits<Input>::value_type const& low, typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high, typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp 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 inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy( clamp_range_copy(
Input const& input, Result const& result, InputRange const& rng, Result const& result,
typename sprout::container_traits<Input>::value_type const& low, typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high 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 inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy( clamp_range_copy(
Input const& input, InputRange const& rng,
typename sprout::container_traits<Input>::value_type const& low, typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high, typename sprout::container_traits<InputRange>::value_type const& high,
Compare comp 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 inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
clamp_range_copy( clamp_range_copy(
Input const& input, InputRange const& rng,
typename sprout::container_traits<Input>::value_type const& low, typename sprout::container_traits<InputRange>::value_type const& low,
typename sprout::container_traits<Input>::value_type const& high 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 } // namespace fixed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -13,23 +13,23 @@ namespace sprout {
// //
// rotate_copy // rotate_copy
// //
template<typename Input, typename Result> template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy( 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 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 inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
rotate_copy( 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 } // namespace fixed

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

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

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

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

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

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

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

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

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

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

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

@ -13,26 +13,26 @@ namespace sprout {
// //
// swap_element_copy // swap_element_copy
// //
template<typename Input, typename Result> template<typename ForwardRange, typename Result>
inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy( swap_element_copy(
Input const& input, Result const& result, ForwardRange const& rng, Result const& result,
typename sprout::container_traits<Input>::const_iterator pos1, typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2 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 inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
swap_element_copy( swap_element_copy(
Input const& input, ForwardRange const& rng,
typename sprout::container_traits<Input>::const_iterator pos1, typename sprout::container_traits<ForwardRange>::const_iterator pos1,
typename sprout::container_traits<Input>::const_iterator pos2 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 } // namespace fixed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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