passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/vendor-modified/boost/random/taus88.hpp

@@ -0,0 +1,45 @@
+/* boost random/taus88.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Copyright Steven Watanabe 2011
+ * 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/libs/random for documentation.
+ *
+ * $Id$
+ *
+ */
+
+#ifndef BOOST_RANDOM_TAUS88_HPP
+#define BOOST_RANDOM_TAUS88_HPP
+
+#include <boost/random/linear_feedback_shift.hpp>
+#include <boost/random/xor_combine.hpp>
+
+namespace boost {
+namespace random {
+
+/** 
+ * The specialization taus88 was suggested in
+ *
+ *  @blockquote
+ *  "Maximally Equidistributed Combined Tausworthe Generators",
+ *  Pierre L'Ecuyer, Mathematics of Computation, Volume 65,
+ *  Number 213, January 1996, Pages 203-213
+ *  @endblockquote
+ */
+typedef xor_combine_engine<
+    xor_combine_engine<
+        linear_feedback_shift_engine<uint32_t, 32, 31, 13, 12>, 0,
+        linear_feedback_shift_engine<uint32_t, 32, 29, 2, 4>, 0>, 0,
+    linear_feedback_shift_engine<uint32_t, 32, 28, 3, 17>, 0> taus88;
+
+} // namespace random
+
+using random::taus88;
+
+} // namespace boost
+
+#endif // BOOST_RANDOM_TAUS88_HPP

data/src/cxx_supportlib/vendor-modified/boost/random/traits.hpp

@@ -0,0 +1,107 @@
+/* boost random/traits.hpp header file
+ *
+ * Copyright John Maddock 2015
+ * 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.
+ *
+ * These traits classes serve two purposes: they are designed to mostly
+ * work out of the box for multiprecision types (ie number types that are
+ * C++ class types and not integers or floats from type-traits point of view),
+ * they are also a potential point of specialization for user-defined
+ * number types.
+ *
+ * $Id$
+ */
+
+#ifndef BOOST_RANDOM_TRAITS_HPP
+#define BOOST_RANDOM_TRAITS_HPP
+
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/mpl/bool.hpp>
+#include <limits>
+
+namespace boost {
+namespace random {
+namespace traits {
+   // \cond show_private
+   template <class T, bool intrinsic>
+   struct make_unsigned_imp
+   {
+      typedef typename boost::make_unsigned<T>::type type;
+   };
+   template <class T>
+   struct make_unsigned_imp<T, false>
+   {
+      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_signed == false);
+      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_integer == true);
+      typedef T type;
+   };
+   // \endcond
+   /** \brief Converts the argument type T to an unsigned type.
+   *
+   * This trait has a single member `type` which is the unsigned type corresponding to T.
+   * Note that
+   * if T is signed, then member `type` *should define a type with one more bit precision than T*.  For built-in
+   * types this trait defaults to `boost::make_unsigned<T>::type`.  For user defined types it simply asserts that
+   * the argument type T is an unsigned integer (using std::numeric_limits).
+   * User defined specializations may be provided for other cases.
+   */
+   template <class T>
+   struct make_unsigned
+   // \cond show_private
+      : public make_unsigned_imp < T, boost::is_integral<T>::value > 
+      // \endcond
+   {};
+   // \cond show_private
+   template <class T, bool intrinsic>
+   struct make_unsigned_or_unbounded_imp
+   {
+      typedef typename boost::make_unsigned<T>::type type;
+   };
+   template <class T>
+   struct make_unsigned_or_unbounded_imp<T, false>
+   {
+      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+      BOOST_STATIC_ASSERT((std::numeric_limits<T>::is_signed == false) || (std::numeric_limits<T>::is_bounded == false));
+      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_integer == true);
+      typedef T type;
+   };
+   // \endcond
+   /** \brief Converts the argument type T to either an unsigned type or an unbounded integer type.
+   *
+   * This trait has a single member `type` which is either the unsigned type corresponding to T or an unbounded
+   * integer type.  This trait is used to generate types suitable for the calculation of a range: as a result
+   * if T is signed, then member `type` *should define a type with one more bit precision than T*.  For built-in
+   * types this trait defaults to `boost::make_unsigned<T>::type`.  For user defined types it simply asserts that
+   * the argument type T is either an unbounded integer, or an unsigned one (using std::numeric_limits).
+   * User defined specializations may be provided for other cases.
+   */
+   template <class T>
+   struct make_unsigned_or_unbounded
+      // \cond show_private
+      : public make_unsigned_or_unbounded_imp < T, boost::is_integral<T>::value > 
+      // \endcond
+   {};
+   /** \brief Traits class that indicates whether type T is an integer
+   */
+   template <class T>
+   struct is_integral
+      : public mpl::bool_<boost::is_integral<T>::value || (std::numeric_limits<T>::is_integer)>
+   {};
+   /** \brief Traits class that indicates whether type T is a signed integer
+   */
+   template <class T> struct is_signed
+      : public mpl::bool_ < boost::is_signed<T>::value || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed)>
+   {};
+
+}
+}
+}
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/random/triangle_distribution.hpp

@@ -0,0 +1,232 @@
+/* boost random/triangle_distribution.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Copyright Steven Watanabe 2011
+ * 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$
+ *
+ * Revision history
+ *  2001-02-18  moved to individual header files
+ */
+
+#ifndef BOOST_RANDOM_TRIANGLE_DISTRIBUTION_HPP
+#define BOOST_RANDOM_TRIANGLE_DISTRIBUTION_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <boost/assert.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/uniform_01.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * Instantiations of @c triangle_distribution model a \random_distribution.
+ * A @c triangle_distribution has three parameters, @c a, @c b, and @c c,
+ * which are the smallest, the most probable and the largest values of
+ * the distribution respectively.
+ */
+template<class RealType = double>
+class triangle_distribution
+{
+public:
+    typedef RealType input_type;
+    typedef RealType result_type;
+
+    class param_type
+    {
+    public:
+
+        typedef triangle_distribution distribution_type;
+
+        /** Constructs the parameters of a @c triangle_distribution. */
+        explicit param_type(RealType a_arg = RealType(0.0),
+                            RealType b_arg = RealType(0.5),
+                            RealType c_arg = RealType(1.0))
+          : _a(a_arg), _b(b_arg), _c(c_arg)
+        {
+            BOOST_ASSERT(_a <= _b && _b <= _c);
+        }
+
+        /** Returns the minimum value of the distribution. */
+        RealType a() const { return _a; }
+        /** Returns the mode of the distribution. */
+        RealType b() const { return _b; }
+        /** Returns the maximum value of the distribution. */
+        RealType c() const { return _c; }
+
+        /** Writes the parameters to a @c std::ostream. */
+        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+        {
+            os << parm._a << " " << parm._b << " " << parm._c;
+            return os;
+        }
+
+        /** Reads the parameters from a @c std::istream. */
+        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+        {
+            double a_in, b_in, c_in;
+            if(is >> a_in >> std::ws >> b_in >> std::ws >> c_in) {
+                if(a_in <= b_in && b_in <= c_in) {
+                    parm._a = a_in;
+                    parm._b = b_in;
+                    parm._c = c_in;
+                } else {
+                    is.setstate(std::ios_base::failbit);
+                }
+            }
+            return is;
+        }
+
+        /** Returns true if the two sets of parameters are equal. */
+        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        { return lhs._a == rhs._a && lhs._b == rhs._b && lhs._c == rhs._c; }
+
+        /** Returns true if the two sets of parameters are different. */
+        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+    private:
+        RealType _a;
+        RealType _b;
+        RealType _c;
+    };
+
+    /**
+     * Constructs a @c triangle_distribution with the parameters
+     * @c a, @c b, and @c c.
+     *
+     * Preconditions: a <= b <= c.
+     */
+    explicit triangle_distribution(RealType a_arg = RealType(0.0),
+                                   RealType b_arg = RealType(0.5),
+                                   RealType c_arg = RealType(1.0))
+      : _a(a_arg), _b(b_arg), _c(c_arg)
+    {
+        BOOST_ASSERT(_a <= _b && _b <= _c);
+        init();
+    }
+
+    /** Constructs a @c triangle_distribution from its parameters. */
+    explicit triangle_distribution(const param_type& parm)
+      : _a(parm.a()), _b(parm.b()), _c(parm.c())
+    {
+        init();
+    }
+
+    // compiler-generated copy ctor and assignment operator are fine
+
+    /** Returns the @c a parameter of the distribution */
+    result_type a() const { return _a; }
+    /** Returns the @c b parameter of the distribution */
+    result_type b() const { return _b; }
+    /** Returns the @c c parameter of the distribution */
+    result_type c() const { return _c; }
+
+    /** Returns the smallest value that the distribution can produce. */
+    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _a; }
+    /** Returns the largest value that the distribution can produce. */
+    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _c; }
+
+    /** Returns the parameters of the distribution. */
+    param_type param() const { return param_type(_a, _b, _c); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm)
+    {
+        _a = parm.a();
+        _b = parm.b();
+        _c = parm.c();
+        init();
+    }
+
+    /**
+     * Effects: Subsequent uses of the distribution do not depend
+     * on values produced by any engine prior to invoking reset.
+     */
+    void reset() { }
+
+    /**
+     * Returns a random variate distributed according to the
+     * triangle distribution.
+     */
+    template<class Engine>
+    result_type operator()(Engine& eng)
+    {
+        using std::sqrt;
+        result_type u = uniform_01<result_type>()(eng);
+        if( u <= q1 )
+            return _a + p1*sqrt(u);
+        else
+        return _c - d3*sqrt(d2*u-d1);
+    }
+
+    /**
+     * Returns a random variate distributed according to the
+     * triangle distribution with parameters specified by param.
+     */
+    template<class Engine>
+    result_type operator()(Engine& eng, const param_type& parm)
+    { return triangle_distribution(parm)(eng); }
+
+    /** Writes the distribution to a @c std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, triangle_distribution, td)
+    {
+        os << td.param();
+        return os;
+    }
+
+    /** Reads the distribution from a @c std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, triangle_distribution, td)
+    {
+        param_type parm;
+        if(is >> parm) {
+            td.param(parm);
+        }
+        return is;
+    }
+
+    /**
+     * Returns true if the two distributions will produce identical
+     * sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(triangle_distribution, lhs, rhs)
+    { return lhs._a == rhs._a && lhs._b == rhs._b && lhs._c == rhs._c; }
+
+    /**
+     * Returns true if the two distributions may produce different
+     * sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(triangle_distribution)
+
+private:
+    /// \cond show_private
+    void init()
+    {
+        using std::sqrt;
+        d1 = _b - _a;
+        d2 = _c - _a;
+        d3 = sqrt(_c - _b);
+        q1 = d1 / d2;
+        p1 = sqrt(d1 * d2);
+    }
+    /// \endcond
+
+    RealType _a, _b, _c;
+    RealType d1, d2, d3, q1, p1;
+};
+
+} // namespace random
+
+using random::triangle_distribution;
+
+} // namespace boost
+
+#endif // BOOST_RANDOM_TRIANGLE_DISTRIBUTION_HPP

data/src/cxx_supportlib/vendor-modified/boost/random/uniform_01.hpp

@@ -0,0 +1,257 @@
+/* boost random/uniform_01.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$
+ *
+ * Revision history
+ *  2001-02-18  moved to individual header files
+ */
+
+#ifndef BOOST_RANDOM_UNIFORM_01_HPP
+#define BOOST_RANDOM_UNIFORM_01_HPP
+
+#include <iostream>
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/ptr_helper.hpp>
+
+#include <boost/random/detail/disable_warnings.hpp>
+
+namespace boost {
+namespace random {
+
+#ifdef BOOST_RANDOM_DOXYGEN
+
+/**
+ * The distribution function uniform_01 models a \random_distribution.
+ * On each invocation, it returns a random floating-point value
+ * uniformly distributed in the range [0..1).
+ *
+ * The template parameter RealType shall denote a float-like value type
+ * with support for binary operators +, -, and /.
+ *
+ * Note: The current implementation is buggy, because it may not fill
+ * all of the mantissa with random bits. I'm unsure how to fill a
+ * (to-be-invented) @c boost::bigfloat class with random bits efficiently.
+ * It's probably time for a traits class.
+ */
+template<class RealType = double>
+class uniform_01
+{
+public:
+  typedef RealType input_type;
+  typedef RealType result_type;
+  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const;
+  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const;
+  void reset();
+
+  template<class Engine>
+  result_type operator()(Engine& eng);
+
+#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 new_uniform_01&)
+  {
+    return os;
+  }
+
+  template<class CharT, class Traits>
+  friend std::basic_istream<CharT,Traits>&
+  operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&)
+  {
+    return is;
+  }
+#endif
+};
+
+#else
+
+namespace detail {
+
+template<class RealType>
+class new_uniform_01
+{
+public:
+  typedef RealType input_type;
+  typedef RealType result_type;
+  // compiler-generated copy ctor and copy assignment are fine
+  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); }
+  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); }
+  void reset() { }
+
+  template<class Engine>
+  result_type operator()(Engine& eng) {
+    for (;;) {
+      typedef typename Engine::result_type base_result;
+      result_type factor = result_type(1) /
+              (result_type(base_result((eng.max)()-(eng.min)())) +
+               result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0));
+      result_type result = result_type(base_result(eng() - (eng.min)())) * factor;
+      if (result < result_type(1))
+        return result;
+    }
+  }
+
+#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 new_uniform_01&)
+  {
+    return os;
+  }
+
+  template<class CharT, class Traits>
+  friend std::basic_istream<CharT,Traits>&
+  operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&)
+  {
+    return is;
+  }
+#endif
+};
+
+template<class UniformRandomNumberGenerator, class RealType>
+class backward_compatible_uniform_01
+{
+  typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits;
+public:
+  typedef UniformRandomNumberGenerator base_type;
+  typedef RealType result_type;
+
+  BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
+
+#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
+  BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
+#endif
+
+  explicit backward_compatible_uniform_01(typename traits::rvalue_type rng)
+    : _rng(rng),
+      _factor(result_type(1) /
+              (result_type((base().max)()-(base().min)()) +
+               result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0)))
+  {
+  }
+  // compiler-generated copy ctor and copy assignment are fine
+
+  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); }
+  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); }
+  typename traits::value_type& base() { return traits::ref(_rng); }
+  const typename traits::value_type& base() const { return traits::ref(_rng); }
+  void reset() { }
+
+  result_type operator()() {
+    for (;;) {
+      result_type result = result_type(base()() - (base().min)()) * _factor;
+      if (result < result_type(1))
+        return result;
+    }
+  }
+
+#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+  template<class CharT, class Traits>
+  friend std::basic_ostream<CharT,Traits>&
+  operator<<(std::basic_ostream<CharT,Traits>& os, const backward_compatible_uniform_01& u)
+  {
+    os << u._rng;
+    return os;
+  }
+
+  template<class CharT, class Traits>
+  friend std::basic_istream<CharT,Traits>&
+  operator>>(std::basic_istream<CharT,Traits>& is, backward_compatible_uniform_01& u)
+  {
+    is >> u._rng;
+    return is;
+  }
+#endif
+
+private:
+  typedef typename traits::value_type::result_type base_result;
+  UniformRandomNumberGenerator _rng;
+  result_type _factor;
+};
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+//  A definition is required even for integral static constants
+template<class UniformRandomNumberGenerator, class RealType>
+const bool backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType>::has_fixed_range;
+#endif
+
+template<class UniformRandomNumberGenerator, bool is_number = std::numeric_limits<UniformRandomNumberGenerator>::is_specialized>
+struct select_uniform_01
+{
+  template<class RealType>
+  struct apply
+  {
+    typedef backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType> type;
+  };
+};
+
+template<class Num>
+struct select_uniform_01<Num, true>
+{
+  template<class RealType>
+  struct apply
+  {
+    typedef new_uniform_01<Num> type;
+  };
+};
+
+}
+
+// Because it is so commonly used: uniform distribution on the real [0..1)
+// range.  This allows for specializations to avoid a costly int -> float
+// conversion plus float multiplication
+template<class UniformRandomNumberGenerator = double, class RealType = double>
+class uniform_01
+  : public detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type
+{
+  typedef typename detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type impl_type;
+  typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits;
+public:
+
+  uniform_01() {}
+
+  explicit uniform_01(typename traits::rvalue_type rng)
+    : impl_type(rng)
+  {
+  }
+
+#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+  template<class CharT, class Traits>
+  friend std::basic_ostream<CharT,Traits>&
+  operator<<(std::basic_ostream<CharT,Traits>& os, const uniform_01& u)
+  {
+    os << static_cast<const impl_type&>(u);
+    return os;
+  }
+
+  template<class CharT, class Traits>
+  friend std::basic_istream<CharT,Traits>&
+  operator>>(std::basic_istream<CharT,Traits>& is, uniform_01& u)
+  {
+    is >> static_cast<impl_type&>(u);
+    return is;
+  }
+#endif
+};
+
+#endif
+
+} // namespace random
+
+using random::uniform_01;
+
+} // namespace boost
+
+#include <boost/random/detail/enable_warnings.hpp>
+
+#endif // BOOST_RANDOM_UNIFORM_01_HPP