diff DEPENDENCIES/generic/include/boost/random/shuffle_order.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/random/shuffle_order.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,269 @@
+/* boost random/shuffle_order.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Copyright Steven Watanabe 2010
+ * 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: shuffle_order.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $
+ *
+ */
+
+#ifndef BOOST_RANDOM_SHUFFLE_ORDER_HPP
+#define BOOST_RANDOM_SHUFFLE_ORDER_HPP
+
+#include <iostream>
+#include <algorithm>     // std::copy
+#include <cassert>
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/detail/seed.hpp>
+#include <boost/random/detail/signed_unsigned_tools.hpp>
+#include <boost/random/linear_congruential.hpp>
+
+#include <boost/random/detail/disable_warnings.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * Instatiations of class template @c shuffle_order_engine model a
+ * \pseudo_random_number_generator. It mixes the output
+ * of some (usually \linear_congruential_engine)
+ * \uniform_random_number_generator to get better statistical properties.
+ * The algorithm is described in
+ *
+ *  @blockquote
+ *  "Improving a poor random number generator", Carter Bays
+ *  and S.D. Durham, ACM Transactions on Mathematical Software,
+ *  Vol 2, No. 1, March 1976, pp. 59-64.
+ *  http://doi.acm.org/10.1145/355666.355670
+ *  @endblockquote
+ *
+ * The output of the base generator is buffered in an array of
+ * length k. Every output X(n) has a second role: It gives an
+ * index into the array where X(n+1) will be retrieved. Used
+ * array elements are replaced with fresh output from the base
+ * generator.
+ *
+ * Template parameters are the base generator and the array
+ * length k, which should be around 100.
+ */
+template<class UniformRandomNumberGenerator, std::size_t k>
+class shuffle_order_engine
+{
+public:
+    typedef UniformRandomNumberGenerator base_type;
+    typedef typename base_type::result_type result_type;
+
+    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
+    BOOST_STATIC_CONSTANT(std::size_t, buffer_size = k);
+    BOOST_STATIC_CONSTANT(std::size_t, table_size = k);
+
+    BOOST_STATIC_ASSERT(std::numeric_limits<result_type>::is_integer);
+    BOOST_STATIC_ASSERT(k > 0);
+
+    /**
+     * Constructs a @c shuffle_order_engine by invoking the
+     * default constructor of the base generator.
+     *
+     * Complexity: Exactly k+1 invocations of the base generator.
+     */
+    shuffle_order_engine() : _rng() { init(); }
+    /**
+     * Constructs a @c shuffle_output_engine by invoking the one-argument
+     * constructor of the base generator with the parameter seed.
+     *
+     * Complexity: Exactly k+1 invocations of the base generator.
+     */
+    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(shuffle_order_engine,
+                                               result_type, s)
+    { _rng.seed(s); init(); }
+    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(shuffle_order_engine, SeedSeq, seq)
+    { _rng.seed(seq); init(); }
+    /**
+     * Constructs a @c shuffle_output_engine by using a copy
+     * of the provided generator.
+     *
+     * Precondition: The template argument UniformRandomNumberGenerator
+     * shall denote a CopyConstructible type.
+     *
+     * Complexity: Exactly k+1 invocations of the base generator.
+     */
+    explicit shuffle_order_engine(const base_type & rng) : _rng(rng) { init(); }
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+    explicit shuffle_order_engine(base_type&& rng) : _rng(rng) { init(); }
+#endif
+
+    template<class It> shuffle_order_engine(It& first, It last)
+      : _rng(first, last) { init(); }
+    void seed() { _rng.seed(); init(); }
+    /**
+     * Invokes the one-argument seed method of the base generator
+     * with the parameter seed and re-initializes the internal buffer array.
+     *
+     * Complexity: Exactly k+1 invocations of the base generator.
+     */
+    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(shuffle_order_engine,
+        result_type, seed_arg)
+    { _rng.seed(seed_arg); init(); }
+    /**
+     * Invokes the one-argument seed method of the base generator
+     * with the parameter seq and re-initializes the internal buffer array.
+     *
+     * Complexity: Exactly k+1 invocations of the base generator.
+     */
+    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(shuffle_order_engine, SeedSeq, seq)
+    { _rng.seed(seq); init(); }
+    template<class It> void seed(It& first, It last)
+    { _rng.seed(first, last); init(); }
+
+    const base_type& base() const { return _rng; }
+
+    result_type operator()() {
+        // calculating the range every time may seem wasteful.  However, this
+        // makes the information locally available for the optimizer.
+        typedef typename make_unsigned<result_type>::type base_unsigned;
+        const base_unsigned brange =
+            detail::subtract<result_type>()((max)(), (min)());
+        const base_unsigned off =
+            detail::subtract<result_type>()(y, (min)());
+
+        base_unsigned j;
+        if(k == 1) {
+            j = 0;
+        } else if(brange < (std::numeric_limits<base_unsigned>::max)() / k) {
+            // try to do it in the native type if we know that it won't
+            // overflow
+            j = k * off / (brange + 1);
+        } else if(brange < (std::numeric_limits<uintmax_t>::max)() / k) {
+            // Otherwise try to use uint64_t
+            j = static_cast<base_unsigned>(
+                static_cast<uintmax_t>(off) * k /
+                (static_cast<uintmax_t>(brange) + 1));
+        } else {
+            boost::uintmax_t divisor =
+                static_cast<boost::uintmax_t>(brange) + 1;
+            j = static_cast<base_unsigned>(detail::muldiv(off, k, divisor));
+        }
+        // assert(0 <= j && j < k);
+        y = v[j];
+        v[j] = _rng();
+        return y;
+    }
+
+    /** Advances the generator by z steps. */
+    void discard(boost::uintmax_t z)
+    {
+        for(boost::uintmax_t j = 0; j < z; ++j) {
+            (*this)();
+        }
+    }
+
+    /** Fills a range with pseudo-random values. */
+    template<class Iter>
+    void generate(Iter first, Iter last)
+    { detail::generate_from_int(*this, first, last); }
+
+    /** Returns the smallest value that the generator can produce. */
+    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    { return (base_type::min)(); }
+    /** Returns the largest value that the generator can produce. */
+    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    { return (base_type::max)(); }
+
+    /** Writes a @c shuffle_order_engine to a @c std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, shuffle_order_engine, s)
+    {
+        os << s._rng;
+        for(std::size_t i = 0; i < k; ++i)
+            os << ' ' << s.v[i];
+        os << ' ' << s.y;
+        return os;
+    }
+
+    /** Reads a @c shuffle_order_engine from a @c std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, shuffle_order_engine, s)
+    {
+        is >> s._rng;
+        for(std::size_t i = 0; i < k; ++i)
+            is >> std::ws >> s.v[i];
+        is >> std::ws >> s.y;
+        return is;
+    }
+
+    /** Returns true if the two generators will produce identical sequences. */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y)
+    { return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); }
+    /** Returns true if the two generators will produce different sequences. */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine)
+
+private:
+
+    /// \cond show_private
+
+    void init()
+    {
+        // we cannot use std::generate, because it uses pass-by-value for _rng
+        for(result_type * p = v; p != v+k; ++p)
+            *p = _rng();
+        y = _rng();
+    }
+
+    /// \endcond
+
+    base_type _rng;
+    result_type v[k];
+    result_type y;
+};
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+//  A definition is required even for integral static constants
+template<class URNG, std::size_t k>
+const bool shuffle_order_engine<URNG, k>::has_fixed_range;
+template<class URNG, std::size_t k>
+const std::size_t shuffle_order_engine<URNG, k>::table_size;
+template<class URNG, std::size_t k>
+const std::size_t shuffle_order_engine<URNG, k>::buffer_size;
+#endif
+
+/**
+ * According to Harry Erwin (private e-mail), the specialization
+ * @c kreutzer1986 was suggested in:
+ *
+ * @blockquote
+ * "System Simulation: Programming Styles and Languages (International
+ * Computer Science Series)", Wolfgang Kreutzer, Addison-Wesley, December 1986.
+ * @endblockquote
+ */
+typedef shuffle_order_engine<
+    linear_congruential_engine<uint32_t, 1366, 150889, 714025>,
+    97> kreutzer1986;
+
+/**
+ * The specialization @c knuth_b is specified by the C++ standard.
+ * It is described in
+ *
+ * @blockquote
+ * "The Art of Computer Programming, Second Edition, Volume 2,
+ * Seminumerical Algorithms", Donald Knuth, Addison-Wesley, 1981.
+ * @endblockquote
+ */
+typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
+
+} // namespace random
+
+using random::kreutzer1986;
+
+} // namespace boost
+
+#include <boost/random/detail/enable_warnings.hpp>
+
+#endif // BOOST_RANDOM_SHUFFLE_OUTPUT_HPP