mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2024-12-23 21:25:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

append 追加

Browse source 
random/linear_congruential.hpp 追加
This commit is contained in:
bolero-MURAKAMI 2011-09-29 00:51:12 +09:00
parent f64cac529c
commit 77c3faa42e
11 changed files with 626 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
sprout/operation/append.hpp Normal file
View file

@ -0,0 +1,8 @@
#ifndef SPROUT_OPERATION_APPEND_HPP
#define SPROUT_OPERATION_APPEND_HPP
#include <sprout/config.hpp>
#include <sprout/operation/fixed/append.hpp>
#include <sprout/operation/fit/append.hpp>
#endif // #ifndef SPROUT_OPERATION_APPEND_HPP

8
sprout/operation/append_back.hpp Normal file
View file

@ -0,0 +1,8 @@
#ifndef SPROUT_OPERATION_APPEND_BACK_HPP
#define SPROUT_OPERATION_APPEND_BACK_HPP
#include <sprout/config.hpp>
#include <sprout/operation/fixed/append_back.hpp>
#include <sprout/operation/fit/append_back.hpp>
#endif // #ifndef SPROUT_OPERATION_APPEND_BACK_HPP

8
sprout/operation/append_front.hpp Normal file
View file

@ -0,0 +1,8 @@
#ifndef SPROUT_OPERATION_APPEND_FRONT_HPP
#define SPROUT_OPERATION_APPEND_FRONT_HPP
#include <sprout/config.hpp>
#include <sprout/operation/fixed/append_front.hpp>
#include <sprout/operation/fit/append_front.hpp>
#endif // #ifndef SPROUT_OPERATION_APPEND_FRONT_HPP

62
sprout/operation/fit/append.hpp Normal file
View file

@ -0,0 +1,62 @@
#ifndef SPROUT_OPERATION_FIT_APPEND_HPP
#define SPROUT_OPERATION_FIT_APPEND_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/operation/fixed/append.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace fit {
namespace result_of {
//
// append
//
template<typename Container, typename Input>
struct append {
public:
typedef sprout::sub_array<
typename sprout::fixed_container_traits<
typename sprout::fixed::result_of::append<Container, Input>::type
>::internal_type
> type;
};
} // namespace result_of
//
// append
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append<Container, Input>::type append(
Container const& cont,
typename sprout::fixed_container_traits<Container>::const_iterator pos,
Input const& input
)
{
return sprout::sub_copy(
sprout::get_fixed(sprout::fixed::append(cont, pos, input)),
sprout::fixed_begin_offset(cont),
sprout::fixed_end_offset(cont) + sprout::size(input)
);
}
//
// append
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append<Container, Input>::type append(
Container const& cont,
typename sprout::fixed_container_traits<Container>::difference_type pos,
Input const& input
)
{
return sprout::sub_copy(
sprout::get_fixed(sprout::fixed::append(cont, pos, input)),
sprout::fixed_begin_offset(cont),
sprout::fixed_end_offset(cont) + sprout::size(input)
);
}
} // namespace fit
} // namespace sprout
#endif // #ifndef SPROUT_OPERATION_FIT_APPEND_HPP

44
sprout/operation/fit/append_back.hpp Normal file
View file

@ -0,0 +1,44 @@
#ifndef SPROUT_OPERATION_FIT_APPEND_BACK_HPP
#define SPROUT_OPERATION_FIT_APPEND_BACK_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/operation/fixed/append_back.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace fit {
namespace result_of {
//
// append_back
//
template<typename Container, typename Input>
struct append_back {
typedef sprout::sub_array<
typename sprout::fixed_container_traits<
typename sprout::fixed::result_of::append_back<Container, Input>::type
>::internal_type
> type;
};
} // namespace result_of
//
// append_back
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append_back<Container, Input>::type append_back(
Container const& cont,
Input const& input
)
{
return sprout::sub_copy(
sprout::get_fixed(sprout::fixed::append_back(cont, input)),
sprout::fixed_begin_offset(cont),
sprout::fixed_end_offset(cont) + sprout::size(input)
);
}
} // namespace fit
} // namespace sprout
#endif // #ifndef SPROUT_OPERATION_FIT_APPEND_BACK_HPP

44
sprout/operation/fit/append_front.hpp Normal file
View file

@ -0,0 +1,44 @@
#ifndef SPROUT_OPERATION_FIT_APPEND_FRONT_HPP
#define SPROUT_OPERATION_FIT_APPEND_FRONT_HPP
#include <sprout/config.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/operation/fixed/append_front.hpp>
#include <sprout/sub_array.hpp>
namespace sprout {
namespace fit {
namespace result_of {
//
// append_front
//
template<typename Container, typename Input>
struct append_front {
typedef sprout::sub_array<
typename sprout::fixed_container_traits<
typename sprout::fixed::result_of::append_front<Container, Input>::type
>::internal_type
> type;
};
} // namespace result_of
//
// append_front
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append_front<Container, Input>::type append_front(
Container const& cont,
Input const& input
)
{
return sprout::sub_copy(
sprout::get_fixed(sprout::fixed::append_front(cont, input)),
sprout::fixed_begin_offset(cont),
sprout::fixed_end_offset(cont) + sprout::size(input)
);
}
} // namespace fit
} // namespace sprout
#endif // #ifndef SPROUT_OPERATION_FIT_APPEND_FRONT_HPP

98
sprout/operation/fixed/append.hpp Normal file
View file

@ -0,0 +1,98 @@
#ifndef SPROUT_OPERATION_FIXED_APPEND_HPP
#define SPROUT_OPERATION_FIXED_APPEND_HPP
#include <cstddef>
#include <sprout/config.hpp>
#include <sprout/index_tuple.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT_DETAIL
namespace sprout {
namespace fixed {
namespace result_of {
//
// append
//
template<typename Container, typename Input>
struct append {
public:
typedef typename sprout::rebind_fixed_size<
Container
>::template apply<
sprout::fixed_container_traits<Container>::fixed_size + sprout::fixed_container_traits<Input>::fixed_size
>::type type;
};
} // namespace result_of
namespace detail {
template<typename Result, typename Container, typename Input, std::ptrdiff_t... Indexes>
SPROUT_CONSTEXPR inline Result append_impl(
Container const& cont,
sprout::index_tuple<Indexes...>,
typename sprout::fixed_container_traits<Container>::difference_type pos,
typename sprout::fixed_container_traits<Container>::difference_type size,
Input const& input
)
{
return sprout::remake_clone<Result, Container>(
cont,
sprout::size(cont) + sprout::size(input),
(Indexes < sprout::fixed_container_traits<Container>::fixed_size + size
? (Indexes < pos
? *(sprout::fixed_begin(cont) + Indexes)
: Indexes < pos + size
? *(sprout::begin(input) + Indexes - pos)
: *(sprout::fixed_begin(cont) + Indexes - size)
)
: typename sprout::fixed_container_traits<Result>::value_type()
)...
);
}
} // namespace detail
//
// append
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append<Container, Input>::type append(
Container const& cont,
typename sprout::fixed_container_traits<Container>::const_iterator pos,
Input const& input
)
{
return sprout::fixed::detail::append_impl<typename sprout::fixed::result_of::append<Container, Input>::type>(
cont,
typename sprout::index_range<0, sprout::fixed_container_traits<typename sprout::fixed::result_of::append<Container, Input>::type>::fixed_size>::type(),
NS_SSCRISK_CEL_OR_SPROUT_DETAIL::distance(sprout::fixed_begin(cont), pos),
sprout::size(input),
input
);
}
//
// append
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append<Container, Input>::type append(
Container const& cont,
typename sprout::fixed_container_traits<Container>::difference_type pos,
Input const& input
)
{
return sprout::fixed::detail::append_impl<typename sprout::fixed::result_of::append<Container, Input>::type>(
cont,
typename sprout::index_range<0, sprout::fixed_container_traits<typename sprout::fixed::result_of::append<Container, Input>::type>::fixed_size>::type(),
NS_SSCRISK_CEL_OR_SPROUT_DETAIL::distance(sprout::fixed_begin(cont), sprout::begin(cont) + pos),
sprout::size(input),
input
);
}
} // namespace fixed
namespace result_of {
using sprout::fixed::result_of::append;
} // namespace result_of
using sprout::fixed::append;
} // namespace sprout
#endif // #ifndef SPROUT_OPERATION_FIXED_APPEND_HPP

49
sprout/operation/fixed/append_back.hpp Normal file
View file

@ -0,0 +1,49 @@
#ifndef SPROUT_OPERATION_FIXED_APPEND_BACK_HPP
#define SPROUT_OPERATION_FIXED_APPEND_BACK_HPP
#include <cstddef>
#include <sprout/config.hpp>
#include <sprout/index_tuple.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/operation/fixed/append.hpp>
namespace sprout {
namespace fixed {
namespace result_of {
//
// append_back
//
template<typename Container, typename Input>
struct append_back
: public sprout::fixed::result_of::append<Container, Input>
{};
} // namespace result_of
//
// append_back
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append_back<Container, Input>::type append_back(
Container const& cont,
Input const& input
)
{
return sprout::fixed::detail::append_impl<typename sprout::fixed::result_of::append_back<Container, Input>::type>(
cont,
typename sprout::index_range<0, sprout::fixed_container_traits<typename sprout::fixed::result_of::append_back<Container, Input>::type>::fixed_size>::type(),
sprout::fixed_end_offset(cont),
sprout::size(input),
input
);
}
} // namespace fixed
namespace result_of {
using sprout::fixed::result_of::append_back;
} // namespace result_of
using sprout::fixed::append_back;
} // namespace sprout
#endif // #ifndef SPROUT_OPERATION_FIXED_APPEND_BACK_HPP

49
sprout/operation/fixed/append_front.hpp Normal file
View file

@ -0,0 +1,49 @@
#ifndef SPROUT_OPERATION_FIXED_APPEND_FRONT_HPP
#define SPROUT_OPERATION_FIXED_APPEND_FRONT_HPP
#include <cstddef>
#include <sprout/config.hpp>
#include <sprout/index_tuple.hpp>
#include <sprout/fixed_container/traits.hpp>
#include <sprout/fixed_container/functions.hpp>
#include <sprout/operation/fixed/append.hpp>
namespace sprout {
namespace fixed {
namespace result_of {
//
// append_front
//
template<typename Container, typename Input>
struct append_front
: public sprout::fixed::result_of::append<Container, Input>
{};
} // namespace result_of
//
// append_front
//
template<typename Container, typename Input>
SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append_front<Container, Input>::type append_front(
Container const& cont,
Input const& input
)
{
return sprout::fixed::detail::append_impl<typename sprout::fixed::result_of::append_front<Container, Input>::type>(
cont,
typename sprout::index_range<0, sprout::fixed_container_traits<typename sprout::fixed::result_of::append_front<Container, Input>::type>::fixed_size>::type(),
sprout::fixed_begin_offset(cont),
sprout::size(input),
input
);
}
} // namespace fixed
namespace result_of {
using sprout::fixed::result_of::append_front;
} // namespace result_of
using sprout::fixed::append_front;
} // namespace sprout
#endif // #ifndef SPROUT_OPERATION_FIXED_APPEND_FRONT_HPP

132
sprout/random/detail/const_mod.hpp Normal file
View file

@ -0,0 +1,132 @@
#ifndef SPROUT_RANDOM_CONST_MOD_HPP
#define SPROUT_RANDOM_CONST_MOD_HPP
#include <type_traits>
#include <limits>
#include <sprout/config.hpp>
namespace sprout {
namespace random {
namespace detail {
template<typename IntType, IntType m>
class const_mod {
private:
typedef typename std::make_unsigned<IntType>::type unsigned_type;
private:
SPROUT_STATIC_CONSTEXPR IntType suppress_warnings = m == 0;
SPROUT_STATIC_CONSTEXPR IntType modulus = m + suppress_warnings;
private:
static_assert(suppress_warnings == 0, "suppress_warnings == 0");
static_assert(modulus == m, "modulus == m");
private:
static SPROUT_CONSTEXPR IntType pow_1(IntType a, std::uintmax_t exponent, IntType result = 1) {
return exponent != 0
? pow_1(mult(a, a), exponent / 2, exponent % 2 == 1 ? mult(result, a) : result)
: result
;
}
static SPROUT_CONSTEXPR IntType mult_small(IntType a, IntType x) {
return a * x % (m + suppress_warnings);
}
static SPROUT_CONSTEXPR IntType mult_schrage_1(IntType a, IntType value, IntType q, IntType r) {
return r < q
? sub(a * (value % q), r * (value / q))
: throw "assert(r < q)"
;
}
static SPROUT_CONSTEXPR IntType mult_schrage(IntType a, IntType value) {
return mult_schrage_1(a, value, m / a, m % a);
}
static SPROUT_CONSTEXPR IntType mult_general(IntType a, IntType b) {
return std::uintmax_t(modulus) <= std::numeric_limits<std::uintmax_t>::max() / modulus
? static_cast<IntType>(std::uintmax_t(a) * b % modulus)
: /*static_cast<IntType>(sprout::random::detail::mulmod(a, b, modulus))*/throw "Sorry, not implemented."
;
}
static SPROUT_CONSTEXPR IntType sub(IntType a, IntType b) {
return a < b ? m - (b - a) : a - b;
}
static SPROUT_CONSTEXPR unsigned_type unsigned_m() {
return m == 0 ? unsigned_type((std::numeric_limits<IntType>::max)()) + 1 : unsigned_type(m);
}
static SPROUT_CONSTEXPR IntType invert_euclidian_3(IntType c, IntType l1, IntType l2, IntType n, IntType p) {
return n == 0 ? m - l1 : invert_euclidian_1(c, l1, l2, n, p);
}
static SPROUT_CONSTEXPR IntType invert_euclidian_2(IntType c, IntType l1, IntType l2, IntType n, IntType p) {
return p == 0 ? l2 : invert_euclidian_3(c, l1, l2 + (n / p) * l1, n - (n / p) * p, p);
}
static SPROUT_CONSTEXPR IntType invert_euclidian_1(IntType c, IntType l1, IntType l2, IntType n, IntType p) {
return invert_euclidian_2(c, l1 + (p / n) * l2, l2, n, p - (p / n) * n);
}
static SPROUT_CONSTEXPR IntType invert_euclidian(IntType c) {
return c > 0
? c == 1 ? 1 : invert_euclidian_1(c, 0, 1, c, m)
: throw "assert(c > 0)"
;
}
static SPROUT_CONSTEXPR IntType invert_euclidian0_3(IntType c, IntType l1, IntType l2, IntType n, IntType p) {
return n == 0 ? m - l1 : invert_euclidian0_2(c, l1 + (p / n) * l2, l2, n, p - (p / n) * n);
}
static SPROUT_CONSTEXPR IntType invert_euclidian0_2(IntType c, IntType l1, IntType l2, IntType n, IntType p) {
return p == 0 ? l2 : invert_euclidian0_3(c, l1, l2 + (n / p) * l1, n - (n / p) * p, p);
}
static SPROUT_CONSTEXPR IntType invert_euclidian0_1(IntType c, IntType l1, IntType l2, IntType n, IntType p) {
return std::numeric_limits<IntType>::max() % n != n - 1
? invert_euclidian0_2(c, l1 + (std::numeric_limits<IntType>::max() / n) * l2, l2, n, std::numeric_limits<IntType>::max() - (std::numeric_limits<IntType>::max() / n) * n + 1)
: throw "assert(std::numeric_limits<IntType>::max() % n != n - 1)"
;
}
static SPROUT_CONSTEXPR IntType invert_euclidian0(IntType c) {
return c > 0
? c == 1 ? 1 : invert_euclidian0_1(c, 0, 1, c, m)
: throw "assert(c > 0)"
;
}
public:
static SPROUT_CONSTEXPR IntType apply(IntType x) {
return ((unsigned_m() - 1) & unsigned_m()) == 0
? (unsigned_type(x)) & (unsigned_m() - 1)
: x % (m + suppress_warnings)
;
}
static SPROUT_CONSTEXPR IntType add(IntType x, IntType c) {
return ((unsigned_m() - 1) & unsigned_m()) == 0 ? (unsigned_type(x) + unsigned_type(c)) & (unsigned_m() - 1)
: c == 0 ? x
: x < m - c ? x + c
: x - (m - c)
;
}
static SPROUT_CONSTEXPR IntType mult(IntType a, IntType x) {
return ((unsigned_m() - 1) & unsigned_m()) == 0 ? unsigned_type(a) * unsigned_type(x) & (unsigned_m() - 1)
: a == 0 ? 0
: a == 1 ? x
: m <= std::numeric_limits<IntType>::max() / a ? mult_small(a, x)
: std::numeric_limits<IntType>::is_signed && (m % a < m / a) ? mult_schrage(a, x)
: mult_general(a, x)
;
}
static SPROUT_CONSTEXPR IntType mult_add(IntType a, IntType x, IntType c) {
return ((unsigned_m() - 1) & unsigned_m()) == 0 ? (unsigned_type(a) * unsigned_type(x) + unsigned_type(c)) & (unsigned_m() - 1)
: a == 0 ? c
: m <= (std::numeric_limits<IntType>::max() - c) / a ? (a * x + c) % (m + suppress_warnings)
: add(mult(a, x), c)
;
}
static SPROUT_CONSTEXPR IntType pow(IntType a, std::uintmax_t exponent) {
return pow_1(a, exponent);
}
static SPROUT_CONSTEXPR IntType invert(IntType x) {
return x == 0 ? 0
: m == 0 ? invert_euclidian0(x)
: invert_euclidian(x)
;
}
private:
const_mod() = delete;
};
} // namespace detail
} // namespace random
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_CONST_MOD_HPP

124
sprout/random/linear_congruential.hpp Normal file
View file

@ -0,0 +1,124 @@
#ifndef SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP
#define SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP
#include <cstdint>
#include <limits>
#include <ios>
#include <sprout/config.hpp>
#include <sprout/random/detail/const_mod.hpp>
namespace sprout {
namespace random {
//
// linear_congruential_engine
//
template<typename IntType, IntType a, IntType c, IntType m>
class linear_congruential_engine {
public:
typedef IntType result_type;
private:
struct private_constructor_tag {};
public:
SPROUT_STATIC_CONSTEXPR IntType multiplier = a;
SPROUT_STATIC_CONSTEXPR IntType increment = c;
SPROUT_STATIC_CONSTEXPR IntType modulus = m;
SPROUT_STATIC_CONSTEXPR IntType default_seed = 1;
public:
static_assert(std::numeric_limits<IntType>::is_integer, "std::numeric_limits<IntType>::is_integer");
static_assert(m == 0 || a < m, "m == 0 || a < m");
static_assert(m == 0 || c < m, "m == 0 || c < m");
private:
static SPROUT_CONSTEXPR IntType init_seed_3(IntType const& x0) {
//static_assert(x0 >= static_min(), "x0 >= static_min()");
//static_assert(x0 <= static_max(), "x0 <= static_max()");
return x0;
}
static SPROUT_CONSTEXPR IntType init_seed_2(IntType const& x0) {
return init_seed_3(increment == 0 && x0 == 0 ? 1 : x0);
}
static SPROUT_CONSTEXPR IntType init_seed_1(IntType const& x0) {
return init_seed_2(x0 <= 0 && x0 != 0 ? x0 + modulus : x0);
}
static SPROUT_CONSTEXPR IntType init_seed(IntType const& x0) {
return init_seed_1(modulus == 0 ? x0 : x0 % modulus);
}
public:
static SPROUT_CONSTEXPR result_type static_min() {
return c == 0 ? 1 : 0;
}
static SPROUT_CONSTEXPR result_type static_max() {
return modulus - 1;
}
private:
IntType x_;
private:
SPROUT_CONSTEXPR linear_congruential_engine(IntType const& x, private_constructor_tag)
: x_(x)
{}
public:
SPROUT_CONSTEXPR linear_congruential_engine()
: x_(init_seed(default_seed))
{}
SPROUT_CONSTEXPR explicit linear_congruential_engine(IntType const& x0)
: x_(init_seed(x0))
{}
SPROUT_CONSTEXPR result_type min() const {
return static_min();
}
SPROUT_CONSTEXPR result_type max() const {
return static_max();
}
SPROUT_CONSTEXPR result_type operator()() const {
return sprout::random::detail::const_mod<IntType, m>::mult_add(a, x_, c);
}
SPROUT_CONSTEXPR linear_congruential_engine next() const {
return linear_congruential_engine(operator()(), private_constructor_tag());
}
friend SPROUT_CONSTEXPR bool operator==(linear_congruential_engine const& lhs, linear_congruential_engine const& rhs) {
return lhs.x_ == rhs.x_;
}
friend SPROUT_CONSTEXPR bool operator!=(linear_congruential_engine const& lhs, linear_congruential_engine const& rhs) {
return !(lhs == rhs);
}
template<typename Elem, typename Traits>
friend std::basic_istream<Elem, Traits>& operator>>(
std::basic_istream<Elem, Traits>& lhs,
linear_congruential_engine const& rhs
)
{
IntType x;
if(lhs >> x) {
if(x >= min() && x <= max()) {
rhs.x_ = x;
} else {
lhs.setstate(std::ios_base::failbit);
}
}
return lhs;
}
template<typename Elem, typename Traits>
friend std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& lhs,
linear_congruential_engine const& rhs
)
{
return lhs << rhs.x_;
}
};
//
// minstd_rand0
//
typedef sprout::random::linear_congruential_engine<std::uint32_t, 16807, 0, 2147483647> minstd_rand0;
//
// minstd_rand
//
typedef sprout::random::linear_congruential_engine<std::uint32_t, 48271, 0, 2147483647> minstd_rand;
} // namespace random
using sprout::random::minstd_rand0;
using sprout::random::minstd_rand;
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP