diff --git a/sprout/operation/append.hpp b/sprout/operation/append.hpp new file mode 100644 index 00000000..f79b7c95 --- /dev/null +++ b/sprout/operation/append.hpp @@ -0,0 +1,8 @@ +#ifndef SPROUT_OPERATION_APPEND_HPP +#define SPROUT_OPERATION_APPEND_HPP + +#include +#include +#include + +#endif // #ifndef SPROUT_OPERATION_APPEND_HPP diff --git a/sprout/operation/append_back.hpp b/sprout/operation/append_back.hpp new file mode 100644 index 00000000..7948b14d --- /dev/null +++ b/sprout/operation/append_back.hpp @@ -0,0 +1,8 @@ +#ifndef SPROUT_OPERATION_APPEND_BACK_HPP +#define SPROUT_OPERATION_APPEND_BACK_HPP + +#include +#include +#include + +#endif // #ifndef SPROUT_OPERATION_APPEND_BACK_HPP diff --git a/sprout/operation/append_front.hpp b/sprout/operation/append_front.hpp new file mode 100644 index 00000000..65e03f1f --- /dev/null +++ b/sprout/operation/append_front.hpp @@ -0,0 +1,8 @@ +#ifndef SPROUT_OPERATION_APPEND_FRONT_HPP +#define SPROUT_OPERATION_APPEND_FRONT_HPP + +#include +#include +#include + +#endif // #ifndef SPROUT_OPERATION_APPEND_FRONT_HPP diff --git a/sprout/operation/fit/append.hpp b/sprout/operation/fit/append.hpp new file mode 100644 index 00000000..01669270 --- /dev/null +++ b/sprout/operation/fit/append.hpp @@ -0,0 +1,62 @@ +#ifndef SPROUT_OPERATION_FIT_APPEND_HPP +#define SPROUT_OPERATION_FIT_APPEND_HPP + +#include +#include +#include +#include +#include + +namespace sprout { + namespace fit { + namespace result_of { + // + // append + // + template + struct append { + public: + typedef sprout::sub_array< + typename sprout::fixed_container_traits< + typename sprout::fixed::result_of::append::type + >::internal_type + > type; + }; + } // namespace result_of + + // + // append + // + template + SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append::type append( + Container const& cont, + typename sprout::fixed_container_traits::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 + SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append::type append( + Container const& cont, + typename sprout::fixed_container_traits::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 diff --git a/sprout/operation/fit/append_back.hpp b/sprout/operation/fit/append_back.hpp new file mode 100644 index 00000000..95cda077 --- /dev/null +++ b/sprout/operation/fit/append_back.hpp @@ -0,0 +1,44 @@ +#ifndef SPROUT_OPERATION_FIT_APPEND_BACK_HPP +#define SPROUT_OPERATION_FIT_APPEND_BACK_HPP + +#include +#include +#include +#include +#include + +namespace sprout { + namespace fit { + namespace result_of { + // + // append_back + // + template + struct append_back { + typedef sprout::sub_array< + typename sprout::fixed_container_traits< + typename sprout::fixed::result_of::append_back::type + >::internal_type + > type; + }; + } // namespace result_of + + // + // append_back + // + template + SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append_back::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 diff --git a/sprout/operation/fit/append_front.hpp b/sprout/operation/fit/append_front.hpp new file mode 100644 index 00000000..74e20274 --- /dev/null +++ b/sprout/operation/fit/append_front.hpp @@ -0,0 +1,44 @@ +#ifndef SPROUT_OPERATION_FIT_APPEND_FRONT_HPP +#define SPROUT_OPERATION_FIT_APPEND_FRONT_HPP + +#include +#include +#include +#include +#include + +namespace sprout { + namespace fit { + namespace result_of { + // + // append_front + // + template + struct append_front { + typedef sprout::sub_array< + typename sprout::fixed_container_traits< + typename sprout::fixed::result_of::append_front::type + >::internal_type + > type; + }; + } // namespace result_of + + // + // append_front + // + template + SPROUT_CONSTEXPR inline typename sprout::fit::result_of::append_front::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 diff --git a/sprout/operation/fixed/append.hpp b/sprout/operation/fixed/append.hpp new file mode 100644 index 00000000..666cdfdf --- /dev/null +++ b/sprout/operation/fixed/append.hpp @@ -0,0 +1,98 @@ +#ifndef SPROUT_OPERATION_FIXED_APPEND_HPP +#define SPROUT_OPERATION_FIXED_APPEND_HPP + +#include +#include +#include +#include +#include +#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT_DETAIL + +namespace sprout { + namespace fixed { + namespace result_of { + // + // append + // + template + struct append { + public: + typedef typename sprout::rebind_fixed_size< + Container + >::template apply< + sprout::fixed_container_traits::fixed_size + sprout::fixed_container_traits::fixed_size + >::type type; + }; + } // namespace result_of + + namespace detail { + template + SPROUT_CONSTEXPR inline Result append_impl( + Container const& cont, + sprout::index_tuple, + typename sprout::fixed_container_traits::difference_type pos, + typename sprout::fixed_container_traits::difference_type size, + Input const& input + ) + { + return sprout::remake_clone( + cont, + sprout::size(cont) + sprout::size(input), + (Indexes < sprout::fixed_container_traits::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::value_type() + )... + ); + } + } // namespace detail + // + // append + // + template + SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append::type append( + Container const& cont, + typename sprout::fixed_container_traits::const_iterator pos, + Input const& input + ) + { + return sprout::fixed::detail::append_impl::type>( + cont, + typename sprout::index_range<0, sprout::fixed_container_traits::type>::fixed_size>::type(), + NS_SSCRISK_CEL_OR_SPROUT_DETAIL::distance(sprout::fixed_begin(cont), pos), + sprout::size(input), + input + ); + } + // + // append + // + template + SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append::type append( + Container const& cont, + typename sprout::fixed_container_traits::difference_type pos, + Input const& input + ) + { + return sprout::fixed::detail::append_impl::type>( + cont, + typename sprout::index_range<0, sprout::fixed_container_traits::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 diff --git a/sprout/operation/fixed/append_back.hpp b/sprout/operation/fixed/append_back.hpp new file mode 100644 index 00000000..892e35be --- /dev/null +++ b/sprout/operation/fixed/append_back.hpp @@ -0,0 +1,49 @@ +#ifndef SPROUT_OPERATION_FIXED_APPEND_BACK_HPP +#define SPROUT_OPERATION_FIXED_APPEND_BACK_HPP + +#include +#include +#include +#include +#include +#include + +namespace sprout { + namespace fixed { + namespace result_of { + // + // append_back + // + template + struct append_back + : public sprout::fixed::result_of::append + {}; + } // namespace result_of + + // + // append_back + // + template + SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append_back::type append_back( + Container const& cont, + Input const& input + ) + { + return sprout::fixed::detail::append_impl::type>( + cont, + typename sprout::index_range<0, sprout::fixed_container_traits::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 diff --git a/sprout/operation/fixed/append_front.hpp b/sprout/operation/fixed/append_front.hpp new file mode 100644 index 00000000..fad728ed --- /dev/null +++ b/sprout/operation/fixed/append_front.hpp @@ -0,0 +1,49 @@ +#ifndef SPROUT_OPERATION_FIXED_APPEND_FRONT_HPP +#define SPROUT_OPERATION_FIXED_APPEND_FRONT_HPP + +#include +#include +#include +#include +#include +#include + +namespace sprout { + namespace fixed { + namespace result_of { + // + // append_front + // + template + struct append_front + : public sprout::fixed::result_of::append + {}; + } // namespace result_of + + // + // append_front + // + template + SPROUT_CONSTEXPR inline typename sprout::fixed::result_of::append_front::type append_front( + Container const& cont, + Input const& input + ) + { + return sprout::fixed::detail::append_impl::type>( + cont, + typename sprout::index_range<0, sprout::fixed_container_traits::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 diff --git a/sprout/random/detail/const_mod.hpp b/sprout/random/detail/const_mod.hpp new file mode 100644 index 00000000..f1e5dcb9 --- /dev/null +++ b/sprout/random/detail/const_mod.hpp @@ -0,0 +1,132 @@ +#ifndef SPROUT_RANDOM_CONST_MOD_HPP +#define SPROUT_RANDOM_CONST_MOD_HPP + +#include +#include +#include + +namespace sprout { + namespace random { + namespace detail { + template + class const_mod { + private: + typedef typename std::make_unsigned::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::max() / modulus + ? static_cast(std::uintmax_t(a) * b % modulus) + : /*static_cast(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::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::max() % n != n - 1 + ? invert_euclidian0_2(c, l1 + (std::numeric_limits::max() / n) * l2, l2, n, std::numeric_limits::max() - (std::numeric_limits::max() / n) * n + 1) + : throw "assert(std::numeric_limits::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::max() / a ? mult_small(a, x) + : std::numeric_limits::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::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 + diff --git a/sprout/random/linear_congruential.hpp b/sprout/random/linear_congruential.hpp new file mode 100644 index 00000000..655f6eef --- /dev/null +++ b/sprout/random/linear_congruential.hpp @@ -0,0 +1,124 @@ +#ifndef SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP +#define SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP + +#include +#include +#include +#include +#include + +namespace sprout { + namespace random { + // + // linear_congruential_engine + // + template + 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::is_integer, "std::numeric_limits::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::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 + friend std::basic_istream& operator>>( + std::basic_istream& 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 + friend std::basic_ostream& operator<<( + std::basic_ostream& lhs, + linear_congruential_engine const& rhs + ) + { + return lhs << rhs.x_; + } + }; + + // + // minstd_rand0 + // + typedef sprout::random::linear_congruential_engine minstd_rand0; + // + // minstd_rand + // + typedef sprout::random::linear_congruential_engine minstd_rand; + } // namespace random + + using sprout::random::minstd_rand0; + using sprout::random::minstd_rand; +} // namespace sprout + +#endif // #ifndef SPROUT_RANDOM_LINEAR_CONGRUENTIAL_HPP +