mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-07-16 15:14:13 +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
Download patch file Download diff file Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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