King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2025-08-03 12:49:50 +00:00
Code Issues Releases Wiki Activity

move textspr/sprout/* -> libs/<libname>/test/*

Browse source 
fix binomial_distribution
This commit is contained in:
bolero-MURAKAMI 2012-05-19 18:46:38 +09:00
parent 237ec76266
commit 0ceabb5b9b
107 changed files with 1228 additions and 840 deletions
Download patch file Download diff file Expand all files Collapse all files

4
sprout/array.hpp
View file

@ -293,7 +293,7 @@ namespace std {
// tuple_size
//
template<typename T, std::size_t N>
class tuple_size<sprout::array<T, N> >
struct tuple_size<sprout::array<T, N> >
: public std::integral_constant<std::size_t, N>
{};
@ -301,7 +301,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename T, std::size_t N>
class tuple_element<I, sprout::array<T, N> > {
struct tuple_element<I, sprout::array<T, N> > {
public:
static_assert(I < N, "tuple_element<>: index out of range");
typedef T type;

4
sprout/pit.hpp
View file

@ -217,7 +217,7 @@ namespace std {
// tuple_size
//
template<typename Container>
class tuple_size<sprout::pit<Container> >
struct tuple_size<sprout::pit<Container> >
: public std::tuple_size<Container>
{};
@ -225,7 +225,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename Container>
class tuple_element<I, sprout::pit<Container> >
struct tuple_element<I, sprout::pit<Container> >
: public std::tuple_element<I, Container>
{};
} // namespace std

1
sprout/random/binomial_distribution.hpp
View file

@ -7,6 +7,7 @@
#include <stdexcept>
#include <sprout/config.hpp>
#include <sprout/array.hpp>
#include <sprout/cstdlib/abs.hpp>
#include <sprout/math/abs.hpp>
#include <sprout/math/log.hpp>
#include <sprout/math/pow.hpp>

4
sprout/string/tuple.hpp
View file

@ -11,7 +11,7 @@ namespace std {
// tuple_size
//
template<typename T, std::size_t N, typename Traits>
class tuple_size<sprout::basic_string<T, N, Traits> >
struct tuple_size<sprout::basic_string<T, N, Traits> >
: public std::integral_constant<std::size_t, N>
{};
@ -19,7 +19,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename T, std::size_t N, typename Traits>
class tuple_element<I, sprout::basic_string<T, N, Traits> > {
struct tuple_element<I, sprout::basic_string<T, N, Traits> > {
public:
static_assert(I < N, "tuple_element<>: index out of range");
typedef T type;

4
sprout/sub_array.hpp
View file

@ -854,7 +854,7 @@ namespace std {
// tuple_size
//
template<typename Container>
class tuple_size<sprout::sub_array<Container> >
struct tuple_size<sprout::sub_array<Container> >
: public std::tuple_size<typename std::remove_reference<Container>::type>
{};
@ -862,7 +862,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename Container>
class tuple_element<I, sprout::sub_array<Container> >
struct tuple_element<I, sprout::sub_array<Container> >
: public std::tuple_element<I, typename std::remove_reference<Container>::type>
{};
} // namespace std

10
sprout/tuple/sscrisk/cel/utility.hpp
View file

@ -13,7 +13,7 @@ namespace sprout {
// tuple_size
//
template<typename T1, typename T2>
class tuple_size<sscrisk::cel::pair<T1, T2> >
struct tuple_size<sscrisk::cel::pair<T1, T2> >
: public std::integral_constant<std::size_t, 2>
{};
@ -22,20 +22,20 @@ namespace sprout {
//
namespace detail {
template<std::size_t I, typename T>
class tuple_element_impl;
struct tuple_element_impl;
template<typename T1, typename T2>
class tuple_element_impl<0, sscrisk::cel::pair<T1, T2> > {
struct tuple_element_impl<0, sscrisk::cel::pair<T1, T2> > {
public:
typedef T1 type;
};
template<typename T1, typename T2>
class tuple_element_impl<1, sscrisk::cel::pair<T1, T2> > {
struct tuple_element_impl<1, sscrisk::cel::pair<T1, T2> > {
public:
typedef T2 type;
};
} // namespace detail
template<std::size_t I, typename T1, typename T2>
class tuple_element<I, sscrisk::cel::pair<T1, T2> >
struct tuple_element<I, sscrisk::cel::pair<T1, T2> >
: public sprout::tuples::detail::tuple_element_impl<I, sscrisk::cel::pair<T1, T2> >
{};

26
sprout/tuple/tuple.hpp
View file

@ -416,14 +416,14 @@ namespace sprout {
namespace detail {
template<std::size_t I, typename T>
class tuple_element_impl;
struct tuple_element_impl;
template<typename Head, typename... Tail>
class tuple_element_impl<0, sprout::tuples::tuple<Head, Tail...> > {
struct tuple_element_impl<0, sprout::tuples::tuple<Head, Tail...> > {
public:
typedef Head type;
};
template<std::size_t I, typename Head, typename... Tail>
class tuple_element_impl<I, sprout::tuples::tuple<Head, Tail...> >
struct tuple_element_impl<I, sprout::tuples::tuple<Head, Tail...> >
: public sprout::tuples::detail::tuple_element_impl<I - 1, sprout::tuples::tuple<Tail...> >
{};
} // namespace detail
@ -442,7 +442,7 @@ namespace std {
// tuple_size
//
template<typename... Types>
class tuple_size<sprout::tuples::tuple<Types...> >
struct tuple_size<sprout::tuples::tuple<Types...> >
: public std::integral_constant<std::size_t, sizeof...(Types)>
{};
@ -450,7 +450,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename... Types>
class tuple_element<I, sprout::tuples::tuple<Types...> >
struct tuple_element<I, sprout::tuples::tuple<Types...> >
: public sprout::tuples::detail::tuple_element_impl<I, sprout::tuples::tuple<Types...> >
{};
} // namespace std
@ -461,19 +461,19 @@ namespace sprout {
// tuple_size
//
template<typename T>
class tuple_size
struct tuple_size
: public std::tuple_size<T>
{};
template<typename T>
class tuple_size<T const>
struct tuple_size<T const>
: public sprout::tuples::tuple_size<T>
{};
template<typename T>
class tuple_size<T volatile>
struct tuple_size<T volatile>
: public sprout::tuples::tuple_size<T>
{};
template<typename T>
class tuple_size<T const volatile>
struct tuple_size<T const volatile>
: public sprout::tuples::tuple_size<T>
{};
@ -481,19 +481,19 @@ namespace sprout {
// tuple_element
//
template<std::size_t I, typename T>
class tuple_element
struct tuple_element
: public std::tuple_element<I, T>
{};
template<std::size_t I, typename T>
class tuple_element<I, T const>
struct tuple_element<I, T const>
: public sprout::tuples::tuple_element<I, T>
{};
template<std::size_t I, typename T>
class tuple_element<I, T volatile>
struct tuple_element<I, T volatile>
: public sprout::tuples::tuple_element<I, T>
{};
template<std::size_t I, typename T>
class tuple_element<I, T const volatile>
struct tuple_element<I, T const volatile>
: public sprout::tuples::tuple_element<I, T>
{};

4
sprout/type/boost/mpl/string.hpp
View file

@ -35,14 +35,14 @@ namespace sprout {
// tuple_size
//
template<int... Values>
class tuple_size<boost::mpl::string<Values...> >
struct tuple_size<boost::mpl::string<Values...> >
: public boost::mpl::size<boost::mpl::string<Values...> >
{};
//
// tuple_element
//
template<std::size_t I, int... Values>
class tuple_element<I, boost::mpl::string<Values...> >
struct tuple_element<I, boost::mpl::string<Values...> >
: public boost::mpl::at_c<boost::mpl::string<Values...>, I>
{};

4
sprout/type/boost/mpl/vector.hpp
View file

@ -29,14 +29,14 @@ namespace sprout {
// tuple_size
//
template<typename... Types>
class tuple_size<boost::mpl::vector<Types...> >
struct tuple_size<boost::mpl::vector<Types...> >
: public boost::mpl::size<boost::mpl::vector<Types...> >
{};
//
// tuple_element
//
template<std::size_t I, typename... Types>
class tuple_element<I, boost::mpl::vector<Types...> >
struct tuple_element<I, boost::mpl::vector<Types...> >
: public boost::mpl::at_c<boost::mpl::vector<Types...>, I>
{};
} // namespace types

4
sprout/type/boost/mpl/vector_c.hpp
View file

@ -29,14 +29,14 @@ namespace sprout {
// tuple_size
//
template<typename T, T... Values>
class tuple_size<boost::mpl::vector_c<T, Values...> >
struct tuple_size<boost::mpl::vector_c<T, Values...> >
: public boost::mpl::size<boost::mpl::vector_c<T, Values...> >
{};
//
// tuple_element
//
template<std::size_t I, typename T, T... Values>
class tuple_element<I, boost::mpl::vector_c<T, Values...> >
struct tuple_element<I, boost::mpl::vector_c<T, Values...> >
: public boost::mpl::at_c<boost::mpl::vector_c<T, Values...>, I>
{};
} // namespace types

4
sprout/type/integral_array.hpp
View file

@ -28,7 +28,7 @@ namespace std {
// tuple_size
//
template<typename T, T... Values>
class tuple_size<sprout::types::integral_array<T, Values...> >
struct tuple_size<sprout::types::integral_array<T, Values...> >
: public std::tuple_size<sprout::types::type_tuple<std::integral_constant<T, Values>...> >
{};
@ -36,7 +36,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename T, T... Values>
class tuple_element<I, sprout::types::integral_array<T, Values...> >
struct tuple_element<I, sprout::types::integral_array<T, Values...> >
: public std::tuple_element<I, sprout::types::type_tuple<std::integral_constant<T, Values>...> >
{};
} // namespace std

4
sprout/type/string.hpp
View file

@ -24,7 +24,7 @@ namespace std {
// tuple_size
//
template<typename T, T... Values>
class tuple_size<sprout::types::basic_string<T, Values...> >
struct tuple_size<sprout::types::basic_string<T, Values...> >
: public std::tuple_size<sprout::types::integral_array<T, Values...> >
{};
@ -32,7 +32,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename T, T... Values>
class tuple_element<I, sprout::types::basic_string<T, Values...> >
struct tuple_element<I, sprout::types::basic_string<T, Values...> >
: public std::tuple_element<I, sprout::types::integral_array<T, Values...> >
{};
} // namespace std

4
sprout/type/tuple.hpp
View file

@ -26,14 +26,14 @@ namespace sprout {
// tuple_size
//
template<typename T, typename Enable = void>
class tuple_size
struct tuple_size
: public std::tuple_size<T>
{};
//
// tuple_element
//
template<std::size_t I, typename T, typename Enable = void>
class tuple_element
struct tuple_element
: public std::tuple_element<I, T>
{};
} // namespace types

10
sprout/type/type_tuple.hpp
View file

@ -23,14 +23,14 @@ namespace sprout {
namespace detail {
template<std::size_t I, typename T>
class tuple_element_impl;
struct tuple_element_impl;
template<typename Head, typename... Tail>
class tuple_element_impl<0, sprout::types::type_tuple<Head, Tail...> > {
struct tuple_element_impl<0, sprout::types::type_tuple<Head, Tail...> > {
public:
typedef Head type;
};
template<std::size_t I, typename Head, typename... Tail>
class tuple_element_impl<I, sprout::types::type_tuple<Head, Tail...> >
struct tuple_element_impl<I, sprout::types::type_tuple<Head, Tail...> >
: public sprout::types::detail::tuple_element_impl<I - 1, sprout::types::type_tuple<Tail...> >
{};
} // namespace detail
@ -44,7 +44,7 @@ namespace std {
// tuple_size
//
template<typename... Types>
class tuple_size<sprout::types::type_tuple<Types...> >
struct tuple_size<sprout::types::type_tuple<Types...> >
: public std::integral_constant<std::size_t, sizeof...(Types)>
{};
@ -52,7 +52,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename... Types>
class tuple_element<I, sprout::types::type_tuple<Types...> >
struct tuple_element<I, sprout::types::type_tuple<Types...> >
: public sprout::types::detail::tuple_element_impl<I, sprout::types::type_tuple<Types...> >
{};
} // namespace std

10
sprout/utility/pair.hpp
View file

@ -169,14 +169,14 @@ namespace sprout {
namespace tuples {
namespace detail {
template<std::size_t I, typename T>
class tuple_element_impl;
struct tuple_element_impl;
template<typename T1, typename T2>
class tuple_element_impl<0, sprout::pair<T1, T2> > {
struct tuple_element_impl<0, sprout::pair<T1, T2> > {
public:
typedef T1 type;
};
template<typename T1, typename T2>
class tuple_element_impl<1, sprout::pair<T1, T2> > {
struct tuple_element_impl<1, sprout::pair<T1, T2> > {
public:
typedef T2 type;
};
@ -189,7 +189,7 @@ namespace std {
// tuple_size
//
template<typename T1, typename T2>
class tuple_size<sprout::pair<T1, T2> >
struct tuple_size<sprout::pair<T1, T2> >
: public std::integral_constant<std::size_t, 2>
{};
@ -197,7 +197,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename T1, typename T2>
class tuple_element<I, sprout::pair<T1, T2> >
struct tuple_element<I, sprout::pair<T1, T2> >
: public sprout::tuples::detail::tuple_element_impl<I, sprout::pair<T1, T2> >
{};
} // namespace std

4
sprout/uuid/uuid.hpp
View file

@ -264,7 +264,7 @@ namespace std {
// tuple_size
//
template<>
class tuple_size<sprout::uuids::uuid> {
struct tuple_size<sprout::uuids::uuid> {
public:
typedef std::integral_constant<std::size_t, 16> type;
SPROUT_STATIC_CONSTEXPR std::size_t value = type::value;
@ -274,7 +274,7 @@ namespace std {
// tuple_element
//
template<std::size_t I>
class tuple_element<I, sprout::uuids::uuid> {
struct tuple_element<I, sprout::uuids::uuid> {
public:
static_assert(I < 16, "tuple_element<>: index out of range");
typedef sprout::uuids::uuid::value_type type;

4
sprout/variant/variant.hpp
View file

@ -266,7 +266,7 @@ namespace std {
// tuple_size
//
template<typename... Types>
class tuple_size<sprout::variant<Types...> >
struct tuple_size<sprout::variant<Types...> >
: public std::tuple_size<typename sprout::variant<Types...>::tuple_type>
{};
@ -274,7 +274,7 @@ namespace std {
// tuple_element
//
template<std::size_t I, typename... Types>
class tuple_element<I, sprout::variant<Types...> >
struct tuple_element<I, sprout::variant<Types...> >
: public std::tuple_element<I, typename sprout::variant<Types...>::tuple_type>
{};
} // namespace std