summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2010-05-06 18:00:41 (GMT)
committerRemko Tronçon <git@el-tramo.be>2010-05-06 18:00:41 (GMT)
commit4c58e9a2d266c23a2060edd08081bf86ebd1862c (patch)
tree0030a4f3360c9da905165db1feed18997481fee5 /3rdParty/Boost/src/boost/random/detail
parentc2cf7f0e59c7880a9ce979d8a45d97442c705110 (diff)
downloadswift-contrib-4c58e9a2d266c23a2060edd08081bf86ebd1862c.zip
swift-contrib-4c58e9a2d266c23a2060edd08081bf86ebd1862c.tar.bz2
Use UUIDs as nonce when authenticating with SCRAM-SHA-1.
Diffstat (limited to '3rdParty/Boost/src/boost/random/detail')
-rw-r--r--3rdParty/Boost/src/boost/random/detail/config.hpp18
-rw-r--r--3rdParty/Boost/src/boost/random/detail/const_mod.hpp363
-rw-r--r--3rdParty/Boost/src/boost/random/detail/disable_warnings.hpp23
-rw-r--r--3rdParty/Boost/src/boost/random/detail/enable_warnings.hpp18
-rw-r--r--3rdParty/Boost/src/boost/random/detail/pass_through_engine.hpp100
-rw-r--r--3rdParty/Boost/src/boost/random/detail/ptr_helper.hpp94
-rw-r--r--3rdParty/Boost/src/boost/random/detail/seed.hpp89
-rw-r--r--3rdParty/Boost/src/boost/random/detail/signed_unsigned_tools.hpp89
-rw-r--r--3rdParty/Boost/src/boost/random/detail/uniform_int_float.hpp85
9 files changed, 879 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/random/detail/config.hpp b/3rdParty/Boost/src/boost/random/detail/config.hpp
new file mode 100644
index 0000000..d6bc0cc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/config.hpp
@@ -0,0 +1,18 @@
+/* boost random/detail/config.hpp header file
+ *
+ * Copyright Steven Watanabe 2009
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: config.hpp 52492 2009-04-19 14:55:57Z steven_watanabe $
+ */
+
+#include <boost/config.hpp>
+
+#if (defined(BOOST_NO_OPERATORS_IN_NAMESPACE) || defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)) \
+ && !defined(BOOST_MSVC)
+ #define BOOST_RANDOM_NO_STREAM_OPERATORS
+#endif
diff --git a/3rdParty/Boost/src/boost/random/detail/const_mod.hpp b/3rdParty/Boost/src/boost/random/detail/const_mod.hpp
new file mode 100644
index 0000000..e0a8839
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/const_mod.hpp
@@ -0,0 +1,363 @@
+/* boost random/detail/const_mod.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: const_mod.hpp 58649 2010-01-02 21:23:17Z steven_watanabe $
+ *
+ * Revision history
+ * 2001-02-18 moved to individual header files
+ */
+
+#ifndef BOOST_RANDOM_CONST_MOD_HPP
+#define BOOST_RANDOM_CONST_MOD_HPP
+
+#include <cassert>
+#include <boost/static_assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/random/detail/disable_warnings.hpp>
+
+namespace boost {
+namespace random {
+
+/*
+ * Some random number generators require modular arithmetic. Put
+ * everything we need here.
+ * IntType must be an integral type.
+ */
+
+namespace detail {
+
+ template<bool is_signed>
+ struct do_add
+ { };
+
+ template<>
+ struct do_add<true>
+ {
+ template<class IntType>
+ static IntType add(IntType m, IntType x, IntType c)
+ {
+ if (x < m - c)
+ return x + c;
+ else
+ return x - (m-c);
+ }
+ };
+
+ template<>
+ struct do_add<false>
+ {
+ template<class IntType>
+ static IntType add(IntType, IntType, IntType)
+ {
+ // difficult
+ assert(!"const_mod::add with c too large");
+ return 0;
+ }
+ };
+} // namespace detail
+
+#if !(defined(__BORLANDC__) && (__BORLANDC__ == 0x560))
+
+template<class IntType, IntType m>
+class const_mod
+{
+public:
+ static IntType add(IntType x, IntType c)
+ {
+ if(c == 0)
+ return x;
+ else if(c <= traits::const_max - m) // i.e. m+c < max
+ return add_small(x, c);
+ else
+ return detail::do_add<traits::is_signed>::add(m, x, c);
+ }
+
+ static IntType mult(IntType a, IntType x)
+ {
+ if(a == 1)
+ return x;
+ else if(m <= traits::const_max/a) // i.e. a*m <= max
+ return mult_small(a, x);
+ else if(traits::is_signed && (m%a < m/a))
+ return mult_schrage(a, x);
+ else {
+ // difficult
+ assert(!"const_mod::mult with a too large");
+ return 0;
+ }
+ }
+
+ static IntType mult_add(IntType a, IntType x, IntType c)
+ {
+ if(m <= (traits::const_max-c)/a) // i.e. a*m+c <= max
+ return (a*x+c) % m;
+ else
+ return add(mult(a, x), c);
+ }
+
+ static IntType invert(IntType x)
+ { return x == 0 ? 0 : invert_euclidian(x); }
+
+private:
+ typedef integer_traits<IntType> traits;
+
+ const_mod(); // don't instantiate
+
+ static IntType add_small(IntType x, IntType c)
+ {
+ x += c;
+ if(x >= m)
+ x -= m;
+ return x;
+ }
+
+ static IntType mult_small(IntType a, IntType x)
+ {
+ return a*x % m;
+ }
+
+ static IntType mult_schrage(IntType a, IntType value)
+ {
+ const IntType q = m / a;
+ const IntType r = m % a;
+
+ assert(r < q); // check that overflow cannot happen
+
+ value = a*(value%q) - r*(value/q);
+ // An optimizer bug in the SGI MIPSpro 7.3.1.x compiler requires this
+ // convoluted formulation of the loop (Synge Todo)
+ for(;;) {
+ if (value > 0)
+ break;
+ value += m;
+ }
+ return value;
+ }
+
+ // invert c in the finite field (mod m) (m must be prime)
+ static IntType invert_euclidian(IntType c)
+ {
+ // we are interested in the gcd factor for c, because this is our inverse
+ BOOST_STATIC_ASSERT(m > 0);
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ assert(boost::integer_traits<IntType>::is_signed);
+#elif !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
+ BOOST_STATIC_ASSERT(boost::integer_traits<IntType>::is_signed);
+#endif
+ assert(c > 0);
+ IntType l1 = 0;
+ IntType l2 = 1;
+ IntType n = c;
+ IntType p = m;
+ for(;;) {
+ IntType q = p / n;
+ l1 -= q * l2; // this requires a signed IntType!
+ p -= q * n;
+ if(p == 0)
+ return (l2 < 1 ? l2 + m : l2);
+ IntType q2 = n / p;
+ l2 -= q2 * l1;
+ n -= q2 * p;
+ if(n == 0)
+ return (l1 < 1 ? l1 + m : l1);
+ }
+ }
+};
+
+// The modulus is exactly the word size: rely on machine overflow handling.
+// Due to a GCC bug, we cannot partially specialize in the presence of
+// template value parameters.
+template<>
+class const_mod<unsigned int, 0>
+{
+ typedef unsigned int IntType;
+public:
+ static IntType add(IntType x, IntType c) { return x+c; }
+ static IntType mult(IntType a, IntType x) { return a*x; }
+ static IntType mult_add(IntType a, IntType x, IntType c) { return a*x+c; }
+
+ // m is not prime, thus invert is not useful
+private: // don't instantiate
+ const_mod();
+};
+
+template<>
+class const_mod<unsigned long, 0>
+{
+ typedef unsigned long IntType;
+public:
+ static IntType add(IntType x, IntType c) { return x+c; }
+ static IntType mult(IntType a, IntType x) { return a*x; }
+ static IntType mult_add(IntType a, IntType x, IntType c) { return a*x+c; }
+
+ // m is not prime, thus invert is not useful
+private: // don't instantiate
+ const_mod();
+};
+
+// the modulus is some power of 2: rely partly on machine overflow handling
+// we only specialize for rand48 at the moment
+#ifndef BOOST_NO_INT64_T
+template<>
+class const_mod<uint64_t, uint64_t(1) << 48>
+{
+ typedef uint64_t IntType;
+public:
+ static IntType add(IntType x, IntType c) { return c == 0 ? x : mod(x+c); }
+ static IntType mult(IntType a, IntType x) { return mod(a*x); }
+ static IntType mult_add(IntType a, IntType x, IntType c)
+ { return mod(a*x+c); }
+ static IntType mod(IntType x) { return x &= ((uint64_t(1) << 48)-1); }
+
+ // m is not prime, thus invert is not useful
+private: // don't instantiate
+ const_mod();
+};
+#endif /* !BOOST_NO_INT64_T */
+
+#else
+
+//
+// for some reason Borland C++ Builder 6 has problems with
+// the full specialisations of const_mod, define a generic version
+// instead, the compiler will optimise away the const-if statements:
+//
+
+template<class IntType, IntType m>
+class const_mod
+{
+public:
+ static IntType add(IntType x, IntType c)
+ {
+ if(0 == m)
+ {
+ return x+c;
+ }
+ else
+ {
+ if(c == 0)
+ return x;
+ else if(c <= traits::const_max - m) // i.e. m+c < max
+ return add_small(x, c);
+ else
+ return detail::do_add<traits::is_signed>::add(m, x, c);
+ }
+ }
+
+ static IntType mult(IntType a, IntType x)
+ {
+ if(x == 0)
+ {
+ return a*x;
+ }
+ else
+ {
+ if(a == 1)
+ return x;
+ else if(m <= traits::const_max/a) // i.e. a*m <= max
+ return mult_small(a, x);
+ else if(traits::is_signed && (m%a < m/a))
+ return mult_schrage(a, x);
+ else {
+ // difficult
+ assert(!"const_mod::mult with a too large");
+ return 0;
+ }
+ }
+ }
+
+ static IntType mult_add(IntType a, IntType x, IntType c)
+ {
+ if(m == 0)
+ {
+ return a*x+c;
+ }
+ else
+ {
+ if(m <= (traits::const_max-c)/a) // i.e. a*m+c <= max
+ return (a*x+c) % m;
+ else
+ return add(mult(a, x), c);
+ }
+ }
+
+ static IntType invert(IntType x)
+ { return x == 0 ? 0 : invert_euclidian(x); }
+
+private:
+ typedef integer_traits<IntType> traits;
+
+ const_mod(); // don't instantiate
+
+ static IntType add_small(IntType x, IntType c)
+ {
+ x += c;
+ if(x >= m)
+ x -= m;
+ return x;
+ }
+
+ static IntType mult_small(IntType a, IntType x)
+ {
+ return a*x % m;
+ }
+
+ static IntType mult_schrage(IntType a, IntType value)
+ {
+ const IntType q = m / a;
+ const IntType r = m % a;
+
+ assert(r < q); // check that overflow cannot happen
+
+ value = a*(value%q) - r*(value/q);
+ while(value <= 0)
+ value += m;
+ return value;
+ }
+
+ // invert c in the finite field (mod m) (m must be prime)
+ static IntType invert_euclidian(IntType c)
+ {
+ // we are interested in the gcd factor for c, because this is our inverse
+ BOOST_STATIC_ASSERT(m > 0);
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ BOOST_STATIC_ASSERT(boost::integer_traits<IntType>::is_signed);
+#endif
+ assert(c > 0);
+ IntType l1 = 0;
+ IntType l2 = 1;
+ IntType n = c;
+ IntType p = m;
+ for(;;) {
+ IntType q = p / n;
+ l1 -= q * l2; // this requires a signed IntType!
+ p -= q * n;
+ if(p == 0)
+ return (l2 < 1 ? l2 + m : l2);
+ IntType q2 = n / p;
+ l2 -= q2 * l1;
+ n -= q2 * p;
+ if(n == 0)
+ return (l1 < 1 ? l1 + m : l1);
+ }
+ }
+};
+
+
+#endif
+
+} // namespace random
+} // namespace boost
+
+#include <boost/random/detail/enable_warnings.hpp>
+
+#endif // BOOST_RANDOM_CONST_MOD_HPP
diff --git a/3rdParty/Boost/src/boost/random/detail/disable_warnings.hpp b/3rdParty/Boost/src/boost/random/detail/disable_warnings.hpp
new file mode 100644
index 0000000..f3ade5e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/disable_warnings.hpp
@@ -0,0 +1,23 @@
+/* boost random/detail/disable_warnings.hpp header file
+ *
+ * Copyright Steven Watanabe 2009
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: disable_warnings.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $
+ *
+ */
+
+// No #include guard. This header is intended to be included multiple times.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4512)
+#pragma warning(disable:4127)
+#pragma warning(disable:4724)
+#endif
diff --git a/3rdParty/Boost/src/boost/random/detail/enable_warnings.hpp b/3rdParty/Boost/src/boost/random/detail/enable_warnings.hpp
new file mode 100644
index 0000000..26184ea
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/enable_warnings.hpp
@@ -0,0 +1,18 @@
+/* boost random/detail/enable_warnings.hpp header file
+ *
+ * Copyright Steven Watanabe 2009
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: enable_warnings.hpp 58649 2010-01-02 21:23:17Z steven_watanabe $
+ *
+ */
+
+// No #include guard. This header is intended to be included multiple times.
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
diff --git a/3rdParty/Boost/src/boost/random/detail/pass_through_engine.hpp b/3rdParty/Boost/src/boost/random/detail/pass_through_engine.hpp
new file mode 100644
index 0000000..468427c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/pass_through_engine.hpp
@@ -0,0 +1,100 @@
+/* boost random/detail/uniform_int_float.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: pass_through_engine.hpp 58649 2010-01-02 21:23:17Z steven_watanabe $
+ *
+ */
+
+#ifndef BOOST_RANDOM_DETAIL_PASS_THROUGH_ENGINE_HPP
+#define BOOST_RANDOM_DETAIL_PASS_THROUGH_ENGINE_HPP
+
+#include <boost/config.hpp>
+#include <boost/random/detail/ptr_helper.hpp>
+#include <boost/random/detail/disable_warnings.hpp>
+
+namespace boost {
+namespace random {
+namespace detail {
+
+template<class UniformRandomNumberGenerator>
+class pass_through_engine
+{
+private:
+ typedef ptr_helper<UniformRandomNumberGenerator> helper_type;
+
+public:
+ typedef typename helper_type::value_type base_type;
+ typedef typename base_type::result_type result_type;
+
+ explicit pass_through_engine(UniformRandomNumberGenerator rng)
+ // make argument an rvalue to avoid matching Generator& constructor
+ : _rng(static_cast<typename helper_type::rvalue_type>(rng))
+ { }
+
+ result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (base().min)(); }
+ result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (base().max)(); }
+ base_type& base() { return helper_type::ref(_rng); }
+ const base_type& base() const { return helper_type::ref(_rng); }
+
+ result_type operator()() { return base()(); }
+
+private:
+ UniformRandomNumberGenerator _rng;
+};
+
+#ifndef BOOST_NO_STD_LOCALE
+
+template<class UniformRandomNumberGenerator, class CharT, class Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(
+ std::basic_ostream<CharT,Traits>& os
+ , const pass_through_engine<UniformRandomNumberGenerator>& ud
+ )
+{
+ return os << ud.base();
+}
+
+template<class UniformRandomNumberGenerator, class CharT, class Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(
+ std::basic_istream<CharT,Traits>& is
+ , const pass_through_engine<UniformRandomNumberGenerator>& ud
+ )
+{
+ return is >> ud.base();
+}
+
+#else // no new streams
+
+template<class UniformRandomNumberGenerator>
+inline std::ostream&
+operator<<(std::ostream& os,
+ const pass_through_engine<UniformRandomNumberGenerator>& ud)
+{
+ return os << ud.base();
+}
+
+template<class UniformRandomNumberGenerator>
+inline std::istream&
+operator>>(std::istream& is,
+ const pass_through_engine<UniformRandomNumberGenerator>& ud)
+{
+ return is >> ud.base();
+}
+
+#endif
+
+} // namespace detail
+} // namespace random
+} // namespace boost
+
+#include <boost/random/detail/enable_warnings.hpp>
+
+#endif // BOOST_RANDOM_DETAIL_PASS_THROUGH_ENGINE_HPP
+
diff --git a/3rdParty/Boost/src/boost/random/detail/ptr_helper.hpp b/3rdParty/Boost/src/boost/random/detail/ptr_helper.hpp
new file mode 100644
index 0000000..3f3fbdd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/ptr_helper.hpp
@@ -0,0 +1,94 @@
+/* boost random/detail/ptr_helper.hpp header file
+ *
+ * Copyright Jens Maurer 2002
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: ptr_helper.hpp 24096 2004-07-27 03:43:34Z dgregor $
+ *
+ */
+
+#ifndef BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
+#define BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
+
+#include <boost/config.hpp>
+
+
+namespace boost {
+namespace random {
+namespace detail {
+
+// type_traits could help here, but I don't want to depend on type_traits.
+template<class T>
+struct ptr_helper
+{
+ typedef T value_type;
+ typedef T& reference_type;
+ typedef const T& rvalue_type;
+ static reference_type ref(T& r) { return r; }
+ static const T& ref(const T& r) { return r; }
+};
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<class T>
+struct ptr_helper<T&>
+{
+ typedef T value_type;
+ typedef T& reference_type;
+ typedef T& rvalue_type;
+ static reference_type ref(T& r) { return r; }
+ static const T& ref(const T& r) { return r; }
+};
+
+template<class T>
+struct ptr_helper<T*>
+{
+ typedef T value_type;
+ typedef T& reference_type;
+ typedef T* rvalue_type;
+ static reference_type ref(T * p) { return *p; }
+ static const T& ref(const T * p) { return *p; }
+};
+#endif
+
+} // namespace detail
+} // namespace random
+} // namespace boost
+
+//
+// BOOST_RANDOM_PTR_HELPER_SPEC --
+//
+// Helper macro for broken compilers defines specializations of
+// ptr_helper.
+//
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# define BOOST_RANDOM_PTR_HELPER_SPEC(T) \
+namespace boost { namespace random { namespace detail { \
+template<> \
+struct ptr_helper<T&> \
+{ \
+ typedef T value_type; \
+ typedef T& reference_type; \
+ typedef T& rvalue_type; \
+ static reference_type ref(T& r) { return r; } \
+ static const T& ref(const T& r) { return r; } \
+}; \
+ \
+template<> \
+struct ptr_helper<T*> \
+{ \
+ typedef T value_type; \
+ typedef T& reference_type; \
+ typedef T* rvalue_type; \
+ static reference_type ref(T * p) { return *p; } \
+ static const T& ref(const T * p) { return *p; } \
+}; \
+}}}
+#else
+# define BOOST_RANDOM_PTR_HELPER_SPEC(T)
+#endif
+
+#endif // BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
diff --git a/3rdParty/Boost/src/boost/random/detail/seed.hpp b/3rdParty/Boost/src/boost/random/detail/seed.hpp
new file mode 100644
index 0000000..48cc17e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/seed.hpp
@@ -0,0 +1,89 @@
+/* boost random/detail/seed.hpp header file
+ *
+ * Copyright Steven Watanabe 2009
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: seed.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $
+ */
+
+#ifndef BOOST_RANDOM_DETAIL_SEED_HPP
+#define BOOST_RANDOM_DETAIL_SEED_HPP
+
+#include <boost/config.hpp>
+
+// Sun seems to have trouble with the use of SFINAE for the
+// templated constructor. So does Borland.
+#if !defined(BOOST_NO_SFINAE) && !defined(__SUNPRO_CC) && !defined(__BORLANDC__)
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+namespace boost {
+namespace random {
+namespace detail {
+
+template<class T>
+struct disable_seed : boost::disable_if<boost::is_arithmetic<T> > {};
+
+template<class Engine, class T>
+struct disable_constructor : disable_seed<T> {};
+
+template<class Engine>
+struct disable_constructor<Engine, Engine> {};
+
+#define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
+ template<class Generator> \
+ explicit Self(Generator& gen, typename ::boost::random::detail::disable_constructor<Self, Generator>::type* = 0)
+
+#define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen) \
+ template<class Generator> \
+ void seed(Generator& gen, typename ::boost::random::detail::disable_seed<Generator>::type* = 0)
+
+#define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x) \
+ explicit Self(const T& x)
+
+#define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
+ void seed(const T& x)
+
+}
+}
+}
+
+#else
+
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/mpl/bool.hpp>
+
+#define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
+ Self(Self& other) { *this = other; } \
+ Self(const Self& other) { *this = other; } \
+ template<class Generator> \
+ explicit Self(Generator& gen) { \
+ boost_random_constructor_impl(gen, ::boost::is_arithmetic<Generator>());\
+ } \
+ template<class Generator> \
+ void boost_random_constructor_impl(Generator& gen, ::boost::mpl::false_)
+
+#define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen) \
+ template<class Generator> \
+ void seed(Generator& gen) { \
+ boost_random_seed_impl(gen, ::boost::is_arithmetic<Generator>());\
+ }\
+ template<class Generator>\
+ void boost_random_seed_impl(Generator& gen, ::boost::mpl::false_)
+
+#define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x) \
+ explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::mpl::true_()); }\
+ void boost_random_constructor_impl(const T& x, ::boost::mpl::true_)
+
+#define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
+ void seed(const T& x) { boost_random_seed_impl(x, ::boost::mpl::true_()); }\
+ void boost_random_seed_impl(const T& x, ::boost::mpl::true_)
+
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/random/detail/signed_unsigned_tools.hpp b/3rdParty/Boost/src/boost/random/detail/signed_unsigned_tools.hpp
new file mode 100644
index 0000000..3c81cf4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/signed_unsigned_tools.hpp
@@ -0,0 +1,89 @@
+/* boost random/detail/signed_unsigned_tools.hpp header file
+ *
+ * Copyright Jens Maurer 2006
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ */
+
+#ifndef BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
+#define BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
+
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+
+namespace boost {
+namespace random {
+namespace detail {
+
+
+/*
+ * Compute x - y, we know that x >= y, return an unsigned value.
+ */
+
+template<class T, bool sgn = std::numeric_limits<T>::is_signed>
+struct subtract { };
+
+template<class T>
+struct subtract<T, /* signed */ false>
+{
+ typedef T result_type;
+ result_type operator()(T x, T y) { return x - y; }
+};
+
+template<class T>
+struct subtract<T, /* signed */ true>
+{
+ typedef typename make_unsigned<T>::type result_type;
+ result_type operator()(T x, T y)
+ {
+ if (y >= 0) // because x >= y, it follows that x >= 0, too
+ return result_type(x) - result_type(y);
+ if (x >= 0) // y < 0
+ // avoid the nasty two's complement case for y == min()
+ return result_type(x) + result_type(-(y+1)) + 1;
+ // both x and y are negative: no signed overflow
+ return result_type(x - y);
+ }
+};
+
+/*
+ * Compute x + y, x is unsigned, result fits in type of "y".
+ */
+
+template<class T1, class T2, bool sgn = std::numeric_limits<T2>::is_signed>
+struct add { };
+
+template<class T1, class T2>
+struct add<T1, T2, /* signed */ false>
+{
+ typedef T2 result_type;
+ result_type operator()(T1 x, T2 y) { return T2(x) + y; }
+};
+
+template<class T1, class T2>
+struct add<T1, T2, /* signed */ true>
+{
+ typedef T2 result_type;
+ result_type operator()(T1 x, T2 y)
+ {
+ if (y >= 0)
+ return T2(x) + y;
+ // y < 0
+ if (x >= T1(-(y+1))) // result >= 0 after subtraction
+ // avoid the nasty two's complement edge case for y == min()
+ return T2(x - T1(-(y+1)) - 1);
+ // abs(x) < abs(y), thus T2 able to represent x
+ return T2(x) + y;
+ }
+};
+
+} // namespace detail
+} // namespace random
+} // namespace boost
+
+#endif // BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
+
diff --git a/3rdParty/Boost/src/boost/random/detail/uniform_int_float.hpp b/3rdParty/Boost/src/boost/random/detail/uniform_int_float.hpp
new file mode 100644
index 0000000..4607021
--- /dev/null
+++ b/3rdParty/Boost/src/boost/random/detail/uniform_int_float.hpp
@@ -0,0 +1,85 @@
+/* boost random/detail/uniform_int_float.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id: uniform_int_float.hpp 52492 2009-04-19 14:55:57Z steven_watanabe $
+ *
+ */
+
+#ifndef BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP
+#define BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP
+
+#include <boost/config.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/uniform_01.hpp>
+
+
+namespace boost {
+namespace random {
+namespace detail {
+
+template<class UniformRandomNumberGenerator, class IntType = unsigned long>
+class uniform_int_float
+{
+public:
+ typedef UniformRandomNumberGenerator base_type;
+ typedef IntType result_type;
+
+ uniform_int_float(base_type rng, IntType min_arg = 0, IntType max_arg = 0xffffffff)
+ : _rng(rng), _min(min_arg), _max(max_arg)
+ {
+ init();
+ }
+
+ result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
+ result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
+ base_type& base() { return _rng.base(); }
+ const base_type& base() const { return _rng.base(); }
+
+ result_type operator()()
+ {
+ return static_cast<IntType>(_rng() * _range) + _min;
+ }
+
+#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
+ template<class CharT, class Traits>
+ friend std::basic_ostream<CharT,Traits>&
+ operator<<(std::basic_ostream<CharT,Traits>& os, const uniform_int_float& ud)
+ {
+ os << ud._min << " " << ud._max;
+ return os;
+ }
+
+ template<class CharT, class Traits>
+ friend std::basic_istream<CharT,Traits>&
+ operator>>(std::basic_istream<CharT,Traits>& is, uniform_int_float& ud)
+ {
+ is >> std::ws >> ud._min >> std::ws >> ud._max;
+ ud.init();
+ return is;
+ }
+#endif
+
+private:
+ void init()
+ {
+ _range = static_cast<base_result>(_max-_min)+1;
+ }
+
+ typedef typename base_type::result_type base_result;
+ uniform_01<base_type> _rng;
+ result_type _min, _max;
+ base_result _range;
+};
+
+
+} // namespace detail
+} // namespace random
+} // namespace boost
+
+#endif // BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP