// random number generation -*- C++ -*-
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009-2012 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
+// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING. If not, write to the Free
-// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-// USA.
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
/**
* @file bits/random.h
* This is an internal header file, included by other library headers.
- * You should not attempt to use it directly.
+ * Do not attempt to use it directly. @headername{random}
*/
+#ifndef _RANDOM_H
+#define _RANDOM_H 1
+
#include <vector>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [26.4] Random number generation
/**
- * @addtogroup std_random Random Number Generation
+ * @defgroup random Random Number Generation
+ * @ingroup numerics
+ *
* A facility for generating random numbers on selected distributions.
* @{
*/
_RealType
generate_canonical(_UniformRandomNumberGenerator& __g);
- class seed_seq;
+_GLIBCXX_END_NAMESPACE_VERSION
/*
* Implementation-space details.
*/
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<typename _UIntType, size_t __w,
bool = __w < static_cast<size_t>
(std::numeric_limits<_UIntType>::digits)>
struct _Shift<_UIntType, __w, true>
{ static const _UIntType __value = _UIntType(1) << __w; };
- // XXX need constexpr
- template<typename _UIntType, size_t __w,
- bool = __w <static_cast<size_t>
- (std::numeric_limits<_UIntType>::digits)>
- struct _ShiftMin1
- {
- static const _UIntType __value =
- __gnu_cxx::__numeric_traits<_UIntType>::max;
- };
-
- template<typename _UIntType, size_t __w>
- struct _ShiftMin1<_UIntType, __w, true>
- { static const _UIntType __value = _UIntType(1) << __w - _UIntType(1); };
-
- template<typename _Tp, _Tp __a, _Tp __c, _Tp __m, bool>
+ template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool>
struct _Mod;
// Dispatch based on modulus value to prevent divide-by-zero compile-time
// errors when m == 0.
- template<typename _Tp, _Tp __a, _Tp __c, _Tp __m>
+ template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
inline _Tp
__mod(_Tp __x)
- { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); }
-
- typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
- unsigned, unsigned long>::__type _UInt32Type;
+ { return _Mod<_Tp, __m, __a, __c, __m == 0>::__calc(__x); }
/*
* An adaptor class for converting the output of any Generator into
_DInputType
min() const
- {
- if (is_integral<_DInputType>::value)
- return _M_g.min();
- else
- return _DInputType(0);
- }
+ { return _DInputType(0); }
_DInputType
max() const
- {
- if (is_integral<_DInputType>::value)
- return _M_g.max();
- else
- return _DInputType(1);
- }
+ { return _DInputType(1); }
/*
* Converts a value generated by the adapted random number generator
* into a value in the input domain for the dependent random number
* distribution.
- *
- * Because the type traits are compile time constants only the
- * appropriate clause of the if statements will actually be emitted
- * by the compiler.
*/
_DInputType
operator()()
{
- if (is_integral<_DInputType>::value)
- return _M_g();
- else
- return generate_canonical<_DInputType,
- numeric_limits<_DInputType>::digits,
- _Engine>(_M_g);
+ return std::generate_canonical<_DInputType,
+ std::numeric_limits<_DInputType>::digits,
+ _Engine>(_M_g);
}
private:
_Engine& _M_g;
};
+
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
- * @addtogroup std_random_generators Random Number Generators
- * @ingroup std_random
+ * @addtogroup random_generators Random Number Generators
+ * @ingroup random
*
* These classes define objects which provide random or pseudorandom
* numbers, either from a discrete or a continuous interval. The
/**
* @brief A model of a linear congruential random number generator.
*
- * A random number generator that produces pseudorandom numbers using the
- * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$.
+ * A random number generator that produces pseudorandom numbers via
+ * linear function:
+ * @f[
+ * x_{i+1}\leftarrow(ax_{i} + c) \bmod m
+ * @f]
*
* The template parameter @p _UIntType must be an unsigned integral type
* large enough to store values up to (__m-1). If the template parameter
* std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
* parameters @p __a and @p __c must be less than @p __m.
*
- * The size of the state is @f$ 1 @f$.
+ * The size of the state is @f$1@f$.
*/
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
class linear_congruential_engine
{
- __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
- static_assert(__m == 0 || (__a < __m && __c < __m),
- "template arguments out of bounds"
- " in linear_congruential_engine");
+ static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+ "substituting _UIntType not an unsigned integral type");
+ static_assert(__m == 0u || (__a < __m && __c < __m),
+ "template argument substituting __m out of bounds");
+
+ // XXX FIXME:
+ // _Mod::__calc should handle correctly __m % __a >= __m / __a too.
+ static_assert(__m % __a < __m / __a,
+ "sorry, not implemented yet: try a smaller 'a' constant");
public:
/** The type of the generated random value. */
typedef _UIntType result_type;
/** The multiplier. */
- static const result_type multiplier = __a;
+ static constexpr result_type multiplier = __a;
/** An increment. */
- static const result_type increment = __c;
+ static constexpr result_type increment = __c;
/** The modulus. */
- static const result_type modulus = __m;
- static const result_type default_seed = 1UL;
+ static constexpr result_type modulus = __m;
+ static constexpr result_type default_seed = 1u;
/**
* @brief Constructs a %linear_congruential_engine random number
*/
explicit
linear_congruential_engine(result_type __s = default_seed)
- { this->seed(__s); }
+ { seed(__s); }
/**
* @brief Constructs a %linear_congruential_engine random number
*
* @param __q the seed sequence.
*/
- explicit
- linear_congruential_engine(seed_seq& __q)
- { this->seed(__q); }
+ template<typename _Sseq, typename = typename
+ std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
+ ::type>
+ explicit
+ linear_congruential_engine(_Sseq& __q)
+ { seed(__q); }
/**
* @brief Reseeds the %linear_congruential_engine random number generator
- * engine sequence to the seed @g __s.
+ * engine sequence to the seed @p __s.
*
* @param __s The new seed.
*/
*
* @param __q the seed sequence.
*/
- void
- seed(seed_seq& __q);
+ template<typename _Sseq>
+ typename std::enable_if<std::is_class<_Sseq>::value>::type
+ seed(_Sseq& __q);
/**
* @brief Gets the smallest possible value in the output range.
*
* The minimum depends on the @p __c parameter: if it is zero, the
* minimum generated must be > 0, otherwise 0 is allowed.
- *
- * @todo This should be constexpr.
*/
- result_type
- min() const
- { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
+ static constexpr result_type
+ min()
+ { return __c == 0u ? 1u : 0u; }
/**
* @brief Gets the largest possible value in the output range.
- *
- * @todo This should be constexpr.
*/
- result_type
- max() const
- { return __m - 1; }
+ static constexpr result_type
+ max()
+ { return __m - 1u; }
/**
* @brief Discard a sequence of random numbers.
- *
- * @todo Look for a faster way to do discard.
*/
void
discard(unsigned long long __z)
* @brief Gets the next random number in the sequence.
*/
result_type
- operator()();
+ operator()()
+ {
+ _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
+ return _M_x;
+ }
/**
* @brief Compares two linear congruential random number generator
* @param __rhs Another linear congruential random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const linear_congruential_engine& __lhs,
* @returns __os.
*/
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
- _UIntType1 __m1,
- typename _CharT, typename _Traits>
+ _UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const linear_congruential_engine<_UIntType1, __a1, __c1,
- __m1>& __lcr);
+ const std::linear_congruential_engine<_UIntType1,
+ __a1, __c1, __m1>& __lcr);
/**
* @brief Sets the state of the engine by reading its textual
* @returns __is.
*/
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
- _UIntType1 __m1,
- typename _CharT, typename _Traits>
+ _UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- linear_congruential_engine<_UIntType1,
- __a1, __c1, __m1>& __lcr);
+ std::linear_congruential_engine<_UIntType1, __a1,
+ __c1, __m1>& __lcr);
private:
- template<typename _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<typename _Gen>
- void
- seed(_Gen& __g, false_type);
-
_UIntType _M_x;
};
+ /**
+ * @brief Compares two linear congruential random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A linear congruential random number generator object.
+ * @param __rhs Another linear congruential random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ inline bool
+ operator!=(const std::linear_congruential_engine<_UIntType, __a,
+ __c, __m>& __lhs,
+ const std::linear_congruential_engine<_UIntType, __a,
+ __c, __m>& __rhs)
+ { return !(__lhs == __rhs); }
+
/**
* A generalized feedback shift register discrete random number generator.
* This algorithm was originally invented by Makoto Matsumoto and
* Takuji Nishimura.
*
- * @var word_size The number of bits in each element of the state vector.
- * @var state_size The degree of recursion.
- * @var shift_size The period parameter.
- * @var mask_bits The separation point bit index.
- * @var parameter_a The last row of the twist matrix.
- * @var output_u The first right-shift tempering matrix parameter.
- * @var output_s The first left-shift tempering matrix parameter.
- * @var output_b The first left-shift tempering matrix mask.
- * @var output_t The second left-shift tempering matrix parameter.
- * @var output_c The second left-shift tempering matrix mask.
- * @var output_l The second right-shift tempering matrix parameter.
+ * @tparam __w Word size, the number of bits in each element of
+ * the state vector.
+ * @tparam __n The degree of recursion.
+ * @tparam __m The period parameter.
+ * @tparam __r The separation point bit index.
+ * @tparam __a The last row of the twist matrix.
+ * @tparam __u The first right-shift tempering matrix parameter.
+ * @tparam __d The first right-shift tempering matrix mask.
+ * @tparam __s The first left-shift tempering matrix parameter.
+ * @tparam __b The first left-shift tempering matrix mask.
+ * @tparam __t The second left-shift tempering matrix parameter.
+ * @tparam __c The second left-shift tempering matrix mask.
+ * @tparam __l The second right-shift tempering matrix parameter.
+ * @tparam __f Initialization multiplier.
*/
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __c, size_t __l, _UIntType __f>
class mersenne_twister_engine
{
- __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
-
- static_assert(__m >= 1U,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__n >= __m,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__w >= __r,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__w >= __u,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__w >= __s,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__w >= __t,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__w >= __l,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__w <= static_cast<size_t>(numeric_limits<_UIntType>::digits),
- "mersenne_twister_engine template arguments out of bounds");
-
-#if 0
- // XXX
- static_assert(__a <= __detail::_ShiftMin1<_UIntType, __w>::__value,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__b <= __detail::_ShiftMin1<_UIntType, __w>::__value,
- "mersenne_twister_engine template arguments out of bounds");
- static_assert(__c <= __detail::_ShiftMin1<_UIntType, __w>::__value,
- "mersenne_twister_engine template arguments out of bounds");
-#endif
+ static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+ "substituting _UIntType not an unsigned integral type");
+ static_assert(1u <= __m && __m <= __n,
+ "template argument substituting __m out of bounds");
+ static_assert(__r <= __w, "template argument substituting "
+ "__r out of bound");
+ static_assert(__u <= __w, "template argument substituting "
+ "__u out of bound");
+ static_assert(__s <= __w, "template argument substituting "
+ "__s out of bound");
+ static_assert(__t <= __w, "template argument substituting "
+ "__t out of bound");
+ static_assert(__l <= __w, "template argument substituting "
+ "__l out of bound");
+ static_assert(__w <= std::numeric_limits<_UIntType>::digits,
+ "template argument substituting __w out of bound");
+ static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+ "template argument substituting __a out of bound");
+ static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+ "template argument substituting __b out of bound");
+ static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+ "template argument substituting __c out of bound");
+ static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+ "template argument substituting __d out of bound");
+ static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
+ "template argument substituting __f out of bound");
public:
/** The type of the generated random value. */
typedef _UIntType result_type;
// parameter values
- static const size_t word_size = __w;
- static const size_t state_size = __n;
- static const size_t shift_size = __m;
- static const size_t mask_bits = __r;
- static const result_type xor_mask = __a;
- static const size_t tempering_u = __u;
- static const result_type tempering_d = __d;
- static const size_t tempering_s = __s;
- static const result_type tempering_b = __b;
- static const size_t tempering_t = __t;
- static const result_type tempering_c = __c;
- static const size_t tempering_l = __l;
- static const size_t initialization_multiplier = __f;
- static const result_type default_seed = 5489UL;
+ static constexpr size_t word_size = __w;
+ static constexpr size_t state_size = __n;
+ static constexpr size_t shift_size = __m;
+ static constexpr size_t mask_bits = __r;
+ static constexpr result_type xor_mask = __a;
+ static constexpr size_t tempering_u = __u;
+ static constexpr result_type tempering_d = __d;
+ static constexpr size_t tempering_s = __s;
+ static constexpr result_type tempering_b = __b;
+ static constexpr size_t tempering_t = __t;
+ static constexpr result_type tempering_c = __c;
+ static constexpr size_t tempering_l = __l;
+ static constexpr result_type initialization_multiplier = __f;
+ static constexpr result_type default_seed = 5489u;
// constructors and member function
explicit
*
* @param __q the seed sequence.
*/
- explicit
- mersenne_twister_engine(seed_seq& __q)
- { seed(__q); }
+ template<typename _Sseq, typename = typename
+ std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
+ ::type>
+ explicit
+ mersenne_twister_engine(_Sseq& __q)
+ { seed(__q); }
void
seed(result_type __sd = default_seed);
- void
- seed(seed_seq& __q);
+ template<typename _Sseq>
+ typename std::enable_if<std::is_class<_Sseq>::value>::type
+ seed(_Sseq& __q);
/**
* @brief Gets the smallest possible value in the output range.
- *
- * @todo This should be constexpr.
*/
- result_type
- min() const
+ static constexpr result_type
+ min()
{ return 0; };
/**
* @brief Gets the largest possible value in the output range.
- *
- * @todo This should be constexpr.
*/
- result_type
- max() const
- { return __detail::_ShiftMin1<_UIntType, __w>::__value; }
+ static constexpr result_type
+ max()
+ { return __detail::_Shift<_UIntType, __w>::__value - 1; }
/**
* @brief Discard a sequence of random numbers.
- *
- * @todo Look for a faster way to do discard.
*/
void
discard(unsigned long long __z)
* @param __rhs Another % mersenne_twister_engine random number
* generator object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const mersenne_twister_engine& __lhs,
const mersenne_twister_engine& __rhs)
- { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); }
+ { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
+ && __lhs._M_p == __rhs._M_p); }
/**
* @brief Inserts the current state of a % mersenne_twister_engine
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, __r1,
- __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1>& __x);
+ const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
+ __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
+ __l1, __f1>& __x);
/**
* @brief Extracts the current state of a % mersenne_twister_engine
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, __r1,
- __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1>& __x);
+ std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
+ __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
+ __l1, __f1>& __x);
private:
- template<typename _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<typename _Gen>
- void
- seed(_Gen& __g, false_type);
-
_UIntType _M_x[state_size];
size_t _M_p;
};
/**
+ * @brief Compares two % mersenne_twister_engine random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A % mersenne_twister_engine random number generator
+ * object.
+ * @param __rhs Another % mersenne_twister_engine random number
+ * generator object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _UIntType, size_t __w,
+ size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t,
+ _UIntType __c, size_t __l, _UIntType __f>
+ inline bool
+ operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+ __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
+ const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+ __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* @brief The Marsaglia-Zaman generator.
*
* This is a model of a Generalized Fibonacci discrete random number
* generator, sometimes referred to as the SWC generator.
*
* A discrete random number generator that produces pseudorandom
- * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} -
- * carry_{i-1}) \bmod m @f$.
+ * numbers using:
+ * @f[
+ * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
+ * @f]
*
- * The size of the state is @f$ r @f$
- * and the maximum period of the generator is @f$ m^r - m^s - 1 @f$.
+ * The size of the state is @f$r@f$
+ * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
*
* @var _M_x The state of the generator. This is a ring buffer.
* @var _M_carry The carry.
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
class subtract_with_carry_engine
{
- __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept)
- static_assert(__s > 0U && __r > __s
- && __w > 0U
- && __w <= static_cast<size_t>(numeric_limits<_UIntType>::digits),
- "template arguments out of bounds"
- " in subtract_with_carry_engine");
+ static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+ "substituting _UIntType not an unsigned integral type");
+ static_assert(0u < __s && __s < __r,
+ "template argument substituting __s out of bounds");
+ static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
+ "template argument substituting __w out of bounds");
public:
/** The type of the generated random value. */
typedef _UIntType result_type;
// parameter values
- static const size_t word_size = __w;
- static const size_t short_lag = __s;
- static const size_t long_lag = __r;
- static const result_type default_seed = 19780503;
+ static constexpr size_t word_size = __w;
+ static constexpr size_t short_lag = __s;
+ static constexpr size_t long_lag = __r;
+ static constexpr result_type default_seed = 19780503u;
/**
* @brief Constructs an explicitly seeded % subtract_with_carry_engine
*/
explicit
subtract_with_carry_engine(result_type __sd = default_seed)
- { this->seed(__sd); }
+ { seed(__sd); }
/**
* @brief Constructs a %subtract_with_carry_engine random number engine
*
* @param __q the seed sequence.
*/
- explicit
- subtract_with_carry_engine(seed_seq& __q)
- { this->seed(__q); }
+ template<typename _Sseq, typename = typename
+ std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
+ ::type>
+ explicit
+ subtract_with_carry_engine(_Sseq& __q)
+ { seed(__q); }
/**
- * @brief Seeds the initial state @f$ x_0 @f$ of the random number
+ * @brief Seeds the initial state @f$x_0@f$ of the random number
* generator.
*
* N1688[4.19] modifies this as follows. If @p __value == 0,
seed(result_type __sd = default_seed);
/**
- * @brief Seeds the initial state @f$ x_0 @f$ of the
+ * @brief Seeds the initial state @f$x_0@f$ of the
* % subtract_with_carry_engine random number generator.
*/
- void
- seed(seed_seq& __q);
+ template<typename _Sseq>
+ typename std::enable_if<std::is_class<_Sseq>::value>::type
+ seed(_Sseq& __q);
/**
* @brief Gets the inclusive minimum value of the range of random
* integers returned by this generator.
- *
- * @todo This should be constexpr.
*/
- result_type
- min() const
+ static constexpr result_type
+ min()
{ return 0; }
/**
* @brief Gets the inclusive maximum value of the range of random
* integers returned by this generator.
- *
- * @todo This should be constexpr.
*/
- result_type
- max() const
- { return _S_modulus - 1U; }
+ static constexpr result_type
+ max()
+ { return __detail::_Shift<_UIntType, __w>::__value - 1; }
/**
* @brief Discard a sequence of random numbers.
- *
- * @todo Look for a faster way to do discard.
*/
void
discard(unsigned long long __z)
* @param __rhs Another % subtract_with_carry_engine random number
* generator object.
*
- * @returns true if the two objects are equal, false otherwise.
- */
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
+ */
friend bool
operator==(const subtract_with_carry_engine& __lhs,
const subtract_with_carry_engine& __rhs)
- { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); }
+ { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
+ && __lhs._M_carry == __rhs._M_carry
+ && __lhs._M_p == __rhs._M_p); }
/**
* @brief Inserts the current state of a % subtract_with_carry_engine
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const subtract_with_carry_engine<_UIntType1, __w1, __s1,
- __r1>& __x);
+ operator<<(std::basic_ostream<_CharT, _Traits>&,
+ const std::subtract_with_carry_engine<_UIntType1, __w1,
+ __s1, __r1>&);
/**
* @brief Extracts the current state of a % subtract_with_carry_engine
* @p __is.
*
* @param __is An input stream.
- * @param __x A % subtract_with_carry_engine random number generator engine.
+ * @param __x A % subtract_with_carry_engine random number generator
+ * engine.
*
* @returns The input stream with the state of @p __x extracted or in
* an error state.
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- subtract_with_carry_engine<_UIntType1, __w1, __s1, __r1>& __x);
+ operator>>(std::basic_istream<_CharT, _Traits>&,
+ std::subtract_with_carry_engine<_UIntType1, __w1,
+ __s1, __r1>&);
private:
- template<typename _Gen>
- void
- seed(_Gen& __g, true_type)
- { return seed(static_cast<unsigned long>(__g)); }
-
- template<typename _Gen>
- void
- seed(_Gen& __g, false_type);
-
- static const size_t _S_modulus
- = __detail::_Shift<_UIntType, __w>::__value;
-
_UIntType _M_x[long_lag];
_UIntType _M_carry;
size_t _M_p;
};
/**
+ * @brief Compares two % subtract_with_carry_engine random number
+ * generator objects of the same type for inequality.
+ *
+ * @param __lhs A % subtract_with_carry_engine random number generator
+ * object.
+ * @param __rhs Another % subtract_with_carry_engine random number
+ * generator object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+ inline bool
+ operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
+ __s, __r>& __lhs,
+ const std::subtract_with_carry_engine<_UIntType, __w,
+ __s, __r>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* Produces random numbers from some base engine by discarding blocks of
* data.
*
template<typename _RandomNumberEngine, size_t __p, size_t __r>
class discard_block_engine
{
- static_assert(__r >= 1U && __p >= __r,
- "template arguments out of bounds"
- " in discard_block_engine");
+ static_assert(1 <= __r && __r <= __p,
+ "template argument substituting __r out of bounds");
public:
/** The type of the generated random value. */
typedef typename _RandomNumberEngine::result_type result_type;
// parameter values
- static const size_t block_size = __p;
- static const size_t used_block = __r;
+ static constexpr size_t block_size = __p;
+ static constexpr size_t used_block = __r;
/**
* @brief Constructs a default %discard_block_engine engine.
* @brief Copy constructs a %discard_block_engine engine.
*
* Copies an existing base class random number generator.
- * @param rng An existing (base class) engine object.
+ * @param __rng An existing (base class) engine object.
*/
explicit
- discard_block_engine(const _RandomNumberEngine& __rne)
- : _M_b(__rne), _M_n(0) { }
+ discard_block_engine(const _RandomNumberEngine& __rng)
+ : _M_b(__rng), _M_n(0) { }
/**
* @brief Move constructs a %discard_block_engine engine.
*
* Copies an existing base class random number generator.
- * @param rng An existing (base class) engine object.
+ * @param __rng An existing (base class) engine object.
*/
explicit
- discard_block_engine(_RandomNumberEngine&& __rne)
- : _M_b(std::move(__rne)), _M_n(0) { }
+ discard_block_engine(_RandomNumberEngine&& __rng)
+ : _M_b(std::move(__rng)), _M_n(0) { }
/**
* @brief Seed constructs a %discard_block_engine engine.
*
* @param __q A seed sequence.
*/
- explicit
- discard_block_engine(seed_seq& __q)
- : _M_b(__q), _M_n(0)
- { }
+ template<typename _Sseq, typename = typename
+ std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
+ && !std::is_same<_Sseq, _RandomNumberEngine>::value>
+ ::type>
+ explicit
+ discard_block_engine(_Sseq& __q)
+ : _M_b(__q), _M_n(0)
+ { }
/**
* @brief Reseeds the %discard_block_engine object with the default
* sequence.
* @param __q A seed generator function.
*/
- void
- seed(seed_seq& __q)
- {
- _M_b.seed(__q);
- _M_n = 0;
- }
+ template<typename _Sseq>
+ void
+ seed(_Sseq& __q)
+ {
+ _M_b.seed(__q);
+ _M_n = 0;
+ }
/**
* @brief Gets a const reference to the underlying generator engine
* object.
*/
const _RandomNumberEngine&
- base() const
+ base() const noexcept
{ return _M_b; }
/**
* @brief Gets the minimum value in the generated random number range.
- *
- * @todo This should be constexpr.
*/
- result_type
- min() const
- { return _M_b.min(); }
+ static constexpr result_type
+ min()
+ { return _RandomNumberEngine::min(); }
/**
* @brief Gets the maximum value in the generated random number range.
- *
- * @todo This should be constexpr.
*/
- result_type
- max() const
- { return _M_b.max(); }
+ static constexpr result_type
+ max()
+ { return _RandomNumberEngine::max(); }
/**
* @brief Discard a sequence of random numbers.
- *
- * @todo Look for a faster way to do discard.
*/
void
discard(unsigned long long __z)
* @param __rhs Another %discard_block_engine random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const discard_block_engine& __lhs,
const discard_block_engine& __rhs)
- { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
+ { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
/**
* @brief Inserts the current state of a %discard_block_engine random
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const discard_block_engine<_RandomNumberEngine1,
+ const std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
/**
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- discard_block_engine<_RandomNumberEngine1,
+ std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
private:
};
/**
+ * @brief Compares two %discard_block_engine random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A %discard_block_engine random number generator object.
+ * @param __rhs Another %discard_block_engine random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _RandomNumberEngine, size_t __p, size_t __r>
+ inline bool
+ operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
+ __r>& __lhs,
+ const std::discard_block_engine<_RandomNumberEngine, __p,
+ __r>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* Produces random numbers by combining random numbers from some base
* engine to produce random numbers with a specifies number of bits @p __w.
*/
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
class independent_bits_engine
{
- static_assert(__w > 0U
- && __w <= static_cast<size_t>(numeric_limits<_UIntType>::digits),
- "template arguments out of bounds"
- " in independent_bits_engine");
+ static_assert(std::is_unsigned<_UIntType>::value, "template argument "
+ "substituting _UIntType not an unsigned integral type");
+ static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
+ "template argument substituting __w out of bounds");
public:
/** The type of the generated random value. */
* @brief Copy constructs a %independent_bits_engine engine.
*
* Copies an existing base class random number generator.
- * @param rng An existing (base class) engine object.
+ * @param __rng An existing (base class) engine object.
*/
explicit
- independent_bits_engine(const _RandomNumberEngine& __rne)
- : _M_b(__rne) { }
+ independent_bits_engine(const _RandomNumberEngine& __rng)
+ : _M_b(__rng) { }
/**
* @brief Move constructs a %independent_bits_engine engine.
*
* Copies an existing base class random number generator.
- * @param rng An existing (base class) engine object.
+ * @param __rng An existing (base class) engine object.
*/
explicit
- independent_bits_engine(_RandomNumberEngine&& __rne)
- : _M_b(std::move(__rne)) { }
+ independent_bits_engine(_RandomNumberEngine&& __rng)
+ : _M_b(std::move(__rng)) { }
/**
* @brief Seed constructs a %independent_bits_engine engine.
*
* @param __q A seed sequence.
*/
- explicit
- independent_bits_engine(seed_seq& __q)
- : _M_b(__q)
- { }
+ template<typename _Sseq, typename = typename
+ std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
+ && !std::is_same<_Sseq, _RandomNumberEngine>::value>
+ ::type>
+ explicit
+ independent_bits_engine(_Sseq& __q)
+ : _M_b(__q)
+ { }
/**
* @brief Reseeds the %independent_bits_engine object with the default
* seed sequence.
* @param __q A seed generator function.
*/
- void
- seed(seed_seq& __q)
- { _M_b.seed(__q); }
+ template<typename _Sseq>
+ void
+ seed(_Sseq& __q)
+ { _M_b.seed(__q); }
/**
* @brief Gets a const reference to the underlying generator engine
* object.
*/
const _RandomNumberEngine&
- base() const
+ base() const noexcept
{ return _M_b; }
/**
* @brief Gets the minimum value in the generated random number range.
- *
- * @todo This should be constexpr.
*/
- result_type
- min() const
+ static constexpr result_type
+ min()
{ return 0U; }
/**
* @brief Gets the maximum value in the generated random number range.
- *
- * @todo This should be constexpr.
*/
- result_type
- max() const
- { return __detail::_ShiftMin1<_UIntType, __w>::__value; }
+ static constexpr result_type
+ max()
+ { return __detail::_Shift<_UIntType, __w>::__value - 1; }
/**
* @brief Discard a sequence of random numbers.
- *
- * @todo Look for a faster way to do discard.
*/
void
discard(unsigned long long __z)
* @param __rhs Another %independent_bits_engine random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const independent_bits_engine& __lhs,
template<typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- independent_bits_engine<_RandomNumberEngine,
+ std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
{
__is >> __x._M_b;
};
/**
+ * @brief Compares two %independent_bits_engine random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A %independent_bits_engine random number generator
+ * object.
+ * @param __rhs Another %independent_bits_engine random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+ inline bool
+ operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
+ _UIntType>& __lhs,
+ const std::independent_bits_engine<_RandomNumberEngine, __w,
+ _UIntType>& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
* @brief Inserts the current state of a %independent_bits_engine random
* number generator engine @p __x into the output stream @p __os.
*
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const independent_bits_engine<_RandomNumberEngine,
+ const std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
{
__os << __x.base();
return __os;
}
+
/**
* @brief Produces random numbers by combining random numbers from some
* base engine to produce random numbers with a specifies number of bits
template<typename _RandomNumberEngine, size_t __k>
class shuffle_order_engine
{
- static_assert(__k >= 1U,
- "template arguments out of bounds"
- " in shuffle_order_engine");
+ static_assert(1u <= __k, "template argument substituting "
+ "__k out of bound");
public:
/** The type of the generated random value. */
typedef typename _RandomNumberEngine::result_type result_type;
- static const size_t table_size = __k;
+ static constexpr size_t table_size = __k;
/**
* @brief Constructs a default %shuffle_order_engine engine.
* @brief Copy constructs a %shuffle_order_engine engine.
*
* Copies an existing base class random number generator.
- * @param rng An existing (base class) engine object.
+ * @param __rng An existing (base class) engine object.
*/
explicit
- shuffle_order_engine(const _RandomNumberEngine& __rne)
- : _M_b(__rne)
+ shuffle_order_engine(const _RandomNumberEngine& __rng)
+ : _M_b(__rng)
{ _M_initialize(); }
/**
* @brief Move constructs a %shuffle_order_engine engine.
*
* Copies an existing base class random number generator.
- * @param rng An existing (base class) engine object.
+ * @param __rng An existing (base class) engine object.
*/
explicit
- shuffle_order_engine(_RandomNumberEngine&& __rne)
- : _M_b(std::move(__rne))
+ shuffle_order_engine(_RandomNumberEngine&& __rng)
+ : _M_b(std::move(__rng))
{ _M_initialize(); }
/**
*
* @param __q A seed sequence.
*/
- explicit
- shuffle_order_engine(seed_seq& __q)
- : _M_b(__q)
- { _M_initialize(); }
+ template<typename _Sseq, typename = typename
+ std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
+ && !std::is_same<_Sseq, _RandomNumberEngine>::value>
+ ::type>
+ explicit
+ shuffle_order_engine(_Sseq& __q)
+ : _M_b(__q)
+ { _M_initialize(); }
/**
- * @brief Reseeds the %shuffle_order_engine object with the default seed for
- * the underlying base class generator engine.
+ * @brief Reseeds the %shuffle_order_engine object with the default seed
+ for the underlying base class generator engine.
*/
void
seed()
* sequence.
* @param __q A seed generator function.
*/
- void
- seed(seed_seq& __q)
- {
- _M_b.seed(__q);
- _M_initialize();
- }
+ template<typename _Sseq>
+ void
+ seed(_Sseq& __q)
+ {
+ _M_b.seed(__q);
+ _M_initialize();
+ }
/**
* Gets a const reference to the underlying generator engine object.
*/
const _RandomNumberEngine&
- base() const
+ base() const noexcept
{ return _M_b; }
/**
* Gets the minimum value in the generated random number range.
- *
- * @todo This should be constexpr.
*/
- result_type
- min() const
- { return _M_b.min(); }
+ static constexpr result_type
+ min()
+ { return _RandomNumberEngine::min(); }
/**
* Gets the maximum value in the generated random number range.
- *
- * @todo This should be constexpr.
*/
- result_type
- max() const
- { return _M_b.max(); }
+ static constexpr result_type
+ max()
+ { return _RandomNumberEngine::max(); }
/**
* Discard a sequence of random numbers.
- *
- * @todo Look for a faster way to do discard.
*/
void
discard(unsigned long long __z)
* @param __rhs Another %shuffle_order_engine random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
- */
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
+ */
friend bool
operator==(const shuffle_order_engine& __lhs,
const shuffle_order_engine& __rhs)
- { return __lhs._M_b == __rhs._M_b; }
+ { return (__lhs._M_b == __rhs._M_b
+ && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
+ && __lhs._M_y == __rhs._M_y); }
/**
* @brief Inserts the current state of a %shuffle_order_engine random
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const shuffle_order_engine<_RandomNumberEngine1,
+ const std::shuffle_order_engine<_RandomNumberEngine1,
__k1>& __x);
/**
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- shuffle_order_engine<_RandomNumberEngine1,
- __k1>& __x);
+ std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
private:
void _M_initialize()
};
/**
+ * Compares two %shuffle_order_engine random number generator objects
+ * of the same type for inequality.
+ *
+ * @param __lhs A %shuffle_order_engine random number generator object.
+ * @param __rhs Another %shuffle_order_engine random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _RandomNumberEngine, size_t __k>
+ inline bool
+ operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
+ __k>& __lhs,
+ const std::shuffle_order_engine<_RandomNumberEngine,
+ __k>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
*/
typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
minstd_rand0;
/**
- * An alternative LCR (Lehmer Generator function) .
+ * An alternative LCR (Lehmer Generator function).
*/
typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
minstd_rand;
* The classic Mersenne Twister.
*
* Reference:
- * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
- * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions
+ * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
+ * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
* on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
*/
typedef mersenne_twister_engine<
0xfff7eee000000000ULL, 43,
6364136223846793005ULL> mt19937_64;
- /**
- * .
- */
typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
ranlux24_base;
- typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
-
typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
ranlux48_base;
+ typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
+
typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
- /**
- * .
- */
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
- /**
- * .
- */
typedef minstd_rand0 default_random_engine;
/**
#endif
- result_type
- min() const
+ static constexpr result_type
+ min()
{ return std::numeric_limits<result_type>::min(); }
- result_type
- max() const
+ static constexpr result_type
+ max()
{ return std::numeric_limits<result_type>::max(); }
double
- entropy() const
+ entropy() const noexcept
{ return 0.0; }
result_type
#endif
};
- /* @} */ // group std_random_generators
+ /* @} */ // group random_generators
/**
- * @addtogroup std_random_distributions Random Number Distributions
- * @ingroup std_random
+ * @addtogroup random_distributions Random Number Distributions
+ * @ingroup random
* @{
*/
/**
- * @addtogroup std_random_distributions_uniform Uniform Distributions
- * @ingroup std_random_distributions
+ * @addtogroup random_distributions_uniform Uniform Distributions
+ * @ingroup random_distributions
* @{
*/
template<typename _IntType = int>
class uniform_int_distribution
{
- __glibcxx_class_requires(_IntType, _IntegerConcept)
+ static_assert(std::is_integral<_IntType>::value,
+ "template argument not an integral type");
public:
/** The type of the range of the distribution. */
typedef uniform_int_distribution<_IntType> distribution_type;
explicit
- param_type(_IntType __a = 0, _IntType __b = 9)
+ param_type(_IntType __a = 0,
+ _IntType __b = std::numeric_limits<_IntType>::max())
: _M_a(__a), _M_b(__b)
{
_GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_a == __p2._M_a) && (__p1._M_b == __p2._M_b); }
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
private:
_IntType _M_a;
* @brief Constructs a uniform distribution object.
*/
explicit
- uniform_int_distribution(_IntType __a = 0, _IntType __b = 9)
+ uniform_int_distribution(_IntType __a = 0,
+ _IntType __b = std::numeric_limits<_IntType>::max())
: _M_param(__a, __b)
{ }
{ return _M_param.b(); }
/**
- * @brief Returns the inclusive lower bound of the distribution range.
- */
- result_type
- min() const
- { return this->a(); }
-
- /**
- * @brief Returns the inclusive upper bound of the distribution range.
- */
- result_type
- max() const
- { return this->b(); }
-
- /**
* @brief Returns the parameter set of the distribution.
*/
param_type
{ _M_param = __param; }
/**
- * Gets a uniformly distributed random number in the range
- * @f$(min, max)@f$.
+ * @brief Returns the inclusive lower bound of the distribution range.
*/
- template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- {
- typedef typename _UniformRandomNumberGenerator::result_type
- _UResult_type;
- return _M_call(__urng, this->a(), this->b(),
- typename is_integral<_UResult_type>::type());
- }
+ result_type
+ min() const
+ { return this->a(); }
/**
- * Gets a uniform random number in the range @f$[0, n)@f$.
- *
- * This function is aimed at use with std::random_shuffle.
+ * @brief Returns the inclusive upper bound of the distribution range.
*/
- template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p)
- {
- typedef typename _UniformRandomNumberGenerator::result_type
- _UResult_type;
- return _M_call(__urng, __p.a(), __p.b(),
- typename is_integral<_UResult_type>::type());
- }
+ result_type
+ max() const
+ { return this->b(); }
- private:
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
- _M_call(_UniformRandomNumberGenerator& __urng,
- result_type __min, result_type __max, true_type);
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
- _M_call(_UniformRandomNumberGenerator& __urng,
- result_type __min, result_type __max, false_type)
- {
- return result_type((__urng() - __urng.min())
- / (__urng.max() - __urng.min())
- * (__max - __min + 1)) + __min;
- }
+ operator()(_UniformRandomNumberGenerator& __urng,
+ const param_type& __p);
+
+ /**
+ * @brief Return true if two uniform integer distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const uniform_int_distribution& __d1,
+ const uniform_int_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+ private:
param_type _M_param;
};
/**
* @brief Return true if two uniform integer distributions have
- * the same parameters.
+ * different parameters.
*/
template<typename _IntType>
- bool
- operator==(const uniform_int_distribution<_IntType>& __d1,
- const uniform_int_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::uniform_int_distribution<_IntType>& __d1,
+ const std::uniform_int_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %uniform_int_distribution random number
*/
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const uniform_int_distribution<_IntType>& __x);
+ operator<<(std::basic_ostream<_CharT, _Traits>&,
+ const std::uniform_int_distribution<_IntType>&);
/**
* @brief Extracts a %uniform_int_distribution random number distribution
*/
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- uniform_int_distribution<_IntType>& __x);
+ operator>>(std::basic_istream<_CharT, _Traits>&,
+ std::uniform_int_distribution<_IntType>&);
/**
template<typename _RealType = double>
class uniform_real_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_a == __p2._M_a) && (__p1._M_b == __p2._M_b); }
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
private:
_RealType _M_a;
/**
* @brief Constructs a uniform_real_distribution object.
*
- * @param __min [IN] The lower bound of the distribution.
- * @param __max [IN] The upper bound of the distribution.
+ * @param __a [IN] The lower bound of the distribution.
+ * @param __b [IN] The upper bound of the distribution.
*/
explicit
uniform_real_distribution(_RealType __a = _RealType(0),
{ return _M_param.b(); }
/**
+ * @brief Returns the parameter set of the distribution.
+ */
+ param_type
+ param() const
+ { return _M_param; }
+
+ /**
+ * @brief Sets the parameter set of the distribution.
+ * @param __param The new parameter set of the distribution.
+ */
+ void
+ param(const param_type& __param)
+ { _M_param = __param; }
+
+ /**
* @brief Returns the inclusive lower bound of the distribution range.
*/
result_type
{ return this->b(); }
/**
- * @brief Returns the parameter set of the distribution.
- */
- param_type
- param() const
- { return _M_param; }
-
- /**
- * @brief Sets the parameter set of the distribution.
- * @param __param The new parameter set of the distribution.
+ * @brief Generating functions.
*/
- void
- param(const param_type& __param)
- { _M_param = __param; }
-
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- {
- __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
- __aurng(__urng);
- return (__aurng() * (this->b() - this->a())) + this->a();
- }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
return (__aurng() * (__p.b() - __p.a())) + __p.a();
}
- private:
- param_type _M_param;
+ /**
+ * @brief Return true if two uniform real distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const uniform_real_distribution& __d1,
+ const uniform_real_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
+ private:
+ param_type _M_param;
};
/**
* @brief Return true if two uniform real distributions have
- * the same parameters.
+ * different parameters.
*/
template<typename _IntType>
- bool
- operator==(const uniform_real_distribution<_IntType>& __d1,
- const uniform_real_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::uniform_real_distribution<_IntType>& __d1,
+ const std::uniform_real_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %uniform_real_distribution random number
*/
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const uniform_real_distribution<_RealType>& __x);
+ operator<<(std::basic_ostream<_CharT, _Traits>&,
+ const std::uniform_real_distribution<_RealType>&);
/**
* @brief Extracts a %uniform_real_distribution random number distribution
*/
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- uniform_real_distribution<_RealType>& __x);
+ operator>>(std::basic_istream<_CharT, _Traits>&,
+ std::uniform_real_distribution<_RealType>&);
- /* @} */ // group std_random_distributions_uniform
+ /* @} */ // group random_distributions_uniform
/**
- * @addtogroup std_random_distributions_normal Normal Distributions
- * @ingroup std_random_distributions
+ * @addtogroup random_distributions_normal Normal Distributions
+ * @ingroup random_distributions
* @{
*/
* @brief A normal continuous distribution for random numbers.
*
* The formula for the normal probability density function is
- * @f$ p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
- * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} } @f$.
+ * @f[
+ * p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
+ * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
+ * @f]
*/
template<typename _RealType = double>
class normal_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_mean == __p2._M_mean)
- && (__p1._M_stddev == __p2._M_stddev); }
+ { return (__p1._M_mean == __p2._M_mean
+ && __p1._M_stddev == __p2._M_stddev); }
private:
_RealType _M_mean;
public:
/**
- * Constructs a normal distribution with parameters @f$ mean @f$ and
+ * Constructs a normal distribution with parameters @f$mean@f$ and
* standard deviation.
*/
explicit
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
/**
* @brief Return true if two normal distributions have
- * the same parameters.
+ * the same parameters and the sequences that would
+ * be generated are equal.
*/
template<typename _RealType1>
friend bool
- operator==(const normal_distribution<_RealType1>& __d1,
- const normal_distribution<_RealType1>& __d2);
+ operator==(const std::normal_distribution<_RealType1>& __d1,
+ const std::normal_distribution<_RealType1>& __d2);
/**
* @brief Inserts a %normal_distribution random number distribution
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const normal_distribution<_RealType1>& __x);
+ const std::normal_distribution<_RealType1>& __x);
/**
* @brief Extracts a %normal_distribution random number distribution
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- normal_distribution<_RealType1>& __x);
+ std::normal_distribution<_RealType1>& __x);
private:
param_type _M_param;
bool _M_saved_available;
};
+ /**
+ * @brief Return true if two normal distributions are different.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::normal_distribution<_RealType>& __d1,
+ const std::normal_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A lognormal_distribution random number distribution.
*
* The formula for the normal probability mass function is
- * @f$ p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
- * \exp{-\frac{(\ln{x} - m)^2}{2s^2}} @f$
+ * @f[
+ * p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
+ * \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
+ * @f]
*/
template<typename _RealType = double>
class lognormal_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_m == __p2._M_m) && (__p1._M_s == __p2._M_s); }
+ { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
private:
_RealType _M_m;
explicit
lognormal_distribution(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
- : _M_param(__m, __s)
+ : _M_param(__m, __s), _M_nd()
{ }
explicit
lognormal_distribution(const param_type& __p)
- : _M_param(__p)
+ : _M_param(__p), _M_nd()
{ }
/**
*/
void
reset()
- { }
+ { _M_nd.reset(); }
/**
*
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p);
+ const param_type& __p)
+ { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
+
+ /**
+ * @brief Return true if two lognormal distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ friend bool
+ operator==(const lognormal_distribution& __d1,
+ const lognormal_distribution& __d2)
+ { return (__d1._M_param == __d2._M_param
+ && __d1._M_nd == __d2._M_nd); }
+
+ /**
+ * @brief Inserts a %lognormal_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %lognormal_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const std::lognormal_distribution<_RealType1>& __x);
+
+ /**
+ * @brief Extracts a %lognormal_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %lognormal_distribution random number
+ * generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ std::lognormal_distribution<_RealType1>& __x);
private:
param_type _M_param;
+
+ std::normal_distribution<result_type> _M_nd;
};
/**
- * @brief Return true if two lognormal distributions have
- * the same parameters.
+ * @brief Return true if two lognormal distributions are different.
*/
template<typename _RealType>
- bool
- operator==(const lognormal_distribution<_RealType>& __d1,
- const lognormal_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::lognormal_distribution<_RealType>& __d1,
+ const std::lognormal_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
- * @brief Inserts a %lognormal_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %lognormal_distribution random number distribution.
+ * @brief A gamma continuous distribution for random numbers.
*
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
+ * The formula for the gamma probability density function is:
+ * @f[
+ * p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
+ * (x/\beta)^{\alpha - 1} e^{-x/\beta}
+ * @f]
*/
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const lognormal_distribution<_RealType>& __x);
+ template<typename _RealType = double>
+ class gamma_distribution
+ {
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
+ public:
+ /** The type of the range of the distribution. */
+ typedef _RealType result_type;
+ /** Parameter type. */
+ struct param_type
+ {
+ typedef gamma_distribution<_RealType> distribution_type;
+ friend class gamma_distribution<_RealType>;
+
+ explicit
+ param_type(_RealType __alpha_val = _RealType(1),
+ _RealType __beta_val = _RealType(1))
+ : _M_alpha(__alpha_val), _M_beta(__beta_val)
+ {
+ _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
+ _M_initialize();
+ }
+
+ _RealType
+ alpha() const
+ { return _M_alpha; }
+
+ _RealType
+ beta() const
+ { return _M_beta; }
+
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return (__p1._M_alpha == __p2._M_alpha
+ && __p1._M_beta == __p2._M_beta); }
+
+ private:
+ void
+ _M_initialize();
+
+ _RealType _M_alpha;
+ _RealType _M_beta;
+
+ _RealType _M_malpha, _M_a2;
+ };
+
+ public:
+ /**
+ * @brief Constructs a gamma distribution with parameters
+ * @f$\alpha@f$ and @f$\beta@f$.
+ */
+ explicit
+ gamma_distribution(_RealType __alpha_val = _RealType(1),
+ _RealType __beta_val = _RealType(1))
+ : _M_param(__alpha_val, __beta_val), _M_nd()
+ { }
+
+ explicit
+ gamma_distribution(const param_type& __p)
+ : _M_param(__p), _M_nd()
+ { }
+
+ /**
+ * @brief Resets the distribution state.
+ */
+ void
+ reset()
+ { _M_nd.reset(); }
+
+ /**
+ * @brief Returns the @f$\alpha@f$ of the distribution.
+ */
+ _RealType
+ alpha() const
+ { return _M_param.alpha(); }
+
+ /**
+ * @brief Returns the @f$\beta@f$ of the distribution.
+ */
+ _RealType
+ beta() const
+ { return _M_param.beta(); }
+
+ /**
+ * @brief Returns the parameter set of the distribution.
+ */
+ param_type
+ param() const
+ { return _M_param; }
+
+ /**
+ * @brief Sets the parameter set of the distribution.
+ * @param __param The new parameter set of the distribution.
+ */
+ void
+ param(const param_type& __param)
+ { _M_param = __param; }
+
+ /**
+ * @brief Returns the greatest lower bound value of the distribution.
+ */
+ result_type
+ min() const
+ { return result_type(0); }
+
+ /**
+ * @brief Returns the least upper bound value of the distribution.
+ */
+ result_type
+ max() const
+ { return std::numeric_limits<result_type>::max(); }
+
+ /**
+ * @brief Generating functions.
+ */
+ template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return this->operator()(__urng, _M_param); }
+
+ template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+ const param_type& __p);
+
+ /**
+ * @brief Return true if two gamma distributions have the same
+ * parameters and the sequences that would be generated
+ * are equal.
+ */
+ friend bool
+ operator==(const gamma_distribution& __d1,
+ const gamma_distribution& __d2)
+ { return (__d1._M_param == __d2._M_param
+ && __d1._M_nd == __d2._M_nd); }
+
+ /**
+ * @brief Inserts a %gamma_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %gamma_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const std::gamma_distribution<_RealType1>& __x);
+
+ /**
+ * @brief Extracts a %gamma_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %gamma_distribution random number generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ std::gamma_distribution<_RealType1>& __x);
+
+ private:
+ param_type _M_param;
+
+ std::normal_distribution<result_type> _M_nd;
+ };
/**
- * @brief Extracts a %lognormal_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %lognormal_distribution random number
- * generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
+ * @brief Return true if two gamma distributions are different.
*/
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- lognormal_distribution<_RealType>& __x);
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::gamma_distribution<_RealType>& __d1,
+ const std::gamma_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief A chi_squared_distribution random number distribution.
*
* The formula for the normal probability mass function is
- * @f$ p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}} @f$
+ * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
*/
template<typename _RealType = double>
class chi_squared_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
explicit
chi_squared_distribution(_RealType __n = _RealType(1))
- : _M_param(__n)
+ : _M_param(__n), _M_gd(__n / 2)
{ }
explicit
chi_squared_distribution(const param_type& __p)
- : _M_param(__p)
+ : _M_param(__p), _M_gd(__p.n() / 2)
{ }
/**
*/
void
reset()
- { }
+ { _M_gd.reset(); }
/**
*
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return 2 * _M_gd(__urng); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p);
+ const param_type& __p)
+ {
+ typedef typename std::gamma_distribution<result_type>::param_type
+ param_type;
+ return 2 * _M_gd(__urng, param_type(__p.n() / 2));
+ }
+
+ /**
+ * @brief Return true if two Chi-squared distributions have
+ * the same parameters and the sequences that would be
+ * generated are equal.
+ */
+ friend bool
+ operator==(const chi_squared_distribution& __d1,
+ const chi_squared_distribution& __d2)
+ { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
+
+ /**
+ * @brief Inserts a %chi_squared_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %chi_squared_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const std::chi_squared_distribution<_RealType1>& __x);
+
+ /**
+ * @brief Extracts a %chi_squared_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %chi_squared_distribution random number
+ * generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ std::chi_squared_distribution<_RealType1>& __x);
private:
param_type _M_param;
+
+ std::gamma_distribution<result_type> _M_gd;
};
/**
- * @brief Return true if two Chi-squared distributions have
- * the same parameters.
+ * @brief Return true if two Chi-squared distributions are different.
*/
template<typename _RealType>
- bool
- operator==(const chi_squared_distribution<_RealType>& __d1,
- const chi_squared_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
- /**
- * @brief Inserts a %chi_squared_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %chi_squared_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const chi_squared_distribution<_RealType>& __x);
-
- /**
- * @brief Extracts a %chi_squared_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %chi_squared_distribution random number
- * generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- chi_squared_distribution<_RealType>& __x);
+ inline bool
+ operator!=(const std::chi_squared_distribution<_RealType>& __d1,
+ const std::chi_squared_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief A cauchy_distribution random number distribution.
*
* The formula for the normal probability mass function is
- * @f$ p(x|a,b) = \( \pi b \( 1 + \( \frac{x-a}{b} \)^2 \) \)^{-1} @f$
+ * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
*/
template<typename _RealType = double>
class cauchy_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_a == __p2._M_a) && (__p1._M_b == __p2._M_b); }
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
private:
_RealType _M_a;
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
+ /**
+ * @brief Return true if two Cauchy distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const cauchy_distribution& __d1,
+ const cauchy_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
param_type _M_param;
};
/**
* @brief Return true if two Cauchy distributions have
- * the same parameters.
+ * different parameters.
*/
template<typename _RealType>
- bool
- operator==(const cauchy_distribution<_RealType>& __d1,
- const cauchy_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::cauchy_distribution<_RealType>& __d1,
+ const std::cauchy_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %cauchy_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const cauchy_distribution<_RealType>& __x);
+ const std::cauchy_distribution<_RealType>& __x);
/**
* @brief Extracts a %cauchy_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- cauchy_distribution<_RealType>& __x);
+ std::cauchy_distribution<_RealType>& __x);
/**
* @brief A fisher_f_distribution random number distribution.
*
* The formula for the normal probability mass function is
- * @f$ p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
- * \(\frac{m}{n}\)^{m/2} x^{(m/2)-1}
- * \( 1 + \frac{mx}{n} \)^{-(m+n)/2} @f$
+ * @f[
+ * p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
+ * (\frac{m}{n})^{m/2} x^{(m/2)-1}
+ * (1 + \frac{mx}{n})^{-(m+n)/2}
+ * @f]
*/
template<typename _RealType = double>
class fisher_f_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_m == __p2._M_m) && (__p1._M_n == __p2._M_n); }
+ { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
private:
_RealType _M_m;
explicit
fisher_f_distribution(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
- : _M_param(__m, __n)
+ : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
{ }
explicit
fisher_f_distribution(const param_type& __p)
- : _M_param(__p)
+ : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
{ }
/**
*/
void
reset()
- { }
+ {
+ _M_gd_x.reset();
+ _M_gd_y.reset();
+ }
/**
*
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p);
+ const param_type& __p)
+ {
+ typedef typename std::gamma_distribution<result_type>::param_type
+ param_type;
+ return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
+ / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
+ }
+
+ /**
+ * @brief Return true if two Fisher f distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ friend bool
+ operator==(const fisher_f_distribution& __d1,
+ const fisher_f_distribution& __d2)
+ { return (__d1._M_param == __d2._M_param
+ && __d1._M_gd_x == __d2._M_gd_x
+ && __d1._M_gd_y == __d2._M_gd_y); }
+
+ /**
+ * @brief Inserts a %fisher_f_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %fisher_f_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const std::fisher_f_distribution<_RealType1>& __x);
+
+ /**
+ * @brief Extracts a %fisher_f_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %fisher_f_distribution random number
+ * generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ std::fisher_f_distribution<_RealType1>& __x);
private:
param_type _M_param;
+
+ std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
};
/**
- * @brief Return true if two Fisher f distributions have
- * the same parameters.
+ * @brief Return true if two Fisher f distributions are diferent.
*/
template<typename _RealType>
- bool
- operator==(const fisher_f_distribution<_RealType>& __d1,
- const fisher_f_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
- /**
- * @brief Inserts a %fisher_f_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %fisher_f_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const fisher_f_distribution<_RealType>& __x);
-
- /**
- * @brief Extracts a %fisher_f_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %fisher_f_distribution random number
- * generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- fisher_f_distribution<_RealType>& __x);
-
+ inline bool
+ operator!=(const std::fisher_f_distribution<_RealType>& __d1,
+ const std::fisher_f_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief A student_t_distribution random number distribution.
*
- * The formula for the normal probability mass function is
- * @f$ p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
- * \( 1 + \frac{x^2}{n} \) ^{-(n+1)/2} @f$
+ * The formula for the normal probability mass function is:
+ * @f[
+ * p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
+ * (1 + \frac{x^2}{n}) ^{-(n+1)/2}
+ * @f]
*/
template<typename _RealType = double>
class student_t_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
explicit
student_t_distribution(_RealType __n = _RealType(1))
- : _M_param(__n)
+ : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
{ }
explicit
student_t_distribution(const param_type& __p)
- : _M_param(__p)
+ : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
{ }
/**
*/
void
reset()
- { }
+ {
+ _M_nd.reset();
+ _M_gd.reset();
+ }
/**
*
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p);
+ const param_type& __p)
+ {
+ typedef typename std::gamma_distribution<result_type>::param_type
+ param_type;
+
+ const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
+ return _M_nd(__urng) * std::sqrt(__p.n() / __g);
+ }
- private:
- template<typename _UniformRandomNumberGenerator>
- result_type
- _M_gaussian(_UniformRandomNumberGenerator& __urng,
- const result_type __sigma);
+ /**
+ * @brief Return true if two Student t distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ friend bool
+ operator==(const student_t_distribution& __d1,
+ const student_t_distribution& __d2)
+ { return (__d1._M_param == __d2._M_param
+ && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
+
+ /**
+ * @brief Inserts a %student_t_distribution random number distribution
+ * @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %student_t_distribution random number distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const std::student_t_distribution<_RealType1>& __x);
+
+ /**
+ * @brief Extracts a %student_t_distribution random number distribution
+ * @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %student_t_distribution random number
+ * generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ std::student_t_distribution<_RealType1>& __x);
+ private:
param_type _M_param;
+
+ std::normal_distribution<result_type> _M_nd;
+ std::gamma_distribution<result_type> _M_gd;
};
/**
- * @brief Return true if two Student t distributions have
- * the same parameters.
+ * @brief Return true if two Student t distributions are different.
*/
template<typename _RealType>
- bool
- operator==(const student_t_distribution<_RealType>& __d1,
- const student_t_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
- /**
- * @brief Inserts a %student_t_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %student_t_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const student_t_distribution<_RealType>& __x);
+ inline bool
+ operator!=(const std::student_t_distribution<_RealType>& __d1,
+ const std::student_t_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
- /**
- * @brief Extracts a %student_t_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %student_t_distribution random number
- * generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- student_t_distribution<_RealType>& __x);
- /* @} */ // group std_random_distributions_normal
+ /* @} */ // group random_distributions_normal
/**
- * @addtogroup std_random_distributions_bernoulli Bernoulli Distributions
- * @ingroup std_random_distributions
+ * @addtogroup random_distributions_bernoulli Bernoulli Distributions
+ * @ingroup random_distributions
* @{
*/
/**
* @brief A Bernoulli random number distribution.
*
- * Generates a sequence of true and false values with likelihood @f$ p @f$
- * that true will come up and @f$ (1 - p) @f$ that false will appear.
+ * Generates a sequence of true and false values with likelihood @f$p@f$
+ * that true will come up and @f$(1 - p)@f$ that false will appear.
*/
class bernoulli_distribution
{
* @brief Constructs a Bernoulli distribution with likelihood @p p.
*
* @param __p [IN] The likelihood of a true result being returned.
- * Must be in the interval @f$ [0, 1] @f$.
+ * Must be in the interval @f$[0, 1]@f$.
*/
explicit
bernoulli_distribution(double __p = 0.5)
{ return std::numeric_limits<result_type>::max(); }
/**
- * @brief Returns the next value in the Bernoullian sequence.
+ * @brief Generating functions.
*/
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- {
- __detail::_Adaptor<_UniformRandomNumberGenerator, double>
- __aurng(__urng);
- if ((__aurng() - __aurng.min())
- < this->p() * (__aurng.max() - __aurng.min()))
- return true;
- return false;
- }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
return false;
}
+ /**
+ * @brief Return true if two Bernoulli distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const bernoulli_distribution& __d1,
+ const bernoulli_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
param_type _M_param;
};
/**
* @brief Return true if two Bernoulli distributions have
- * the same parameters.
+ * different parameters.
*/
- bool
- operator==(const bernoulli_distribution& __d1,
- const bernoulli_distribution& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::bernoulli_distribution& __d1,
+ const std::bernoulli_distribution& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %bernoulli_distribution random number distribution
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const bernoulli_distribution& __x);
+ const std::bernoulli_distribution& __x);
/**
* @brief Extracts a %bernoulli_distribution random number distribution
template<typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- bernoulli_distribution& __x)
+ std::bernoulli_distribution& __x)
{
double __p;
__is >> __p;
* @brief A discrete binomial random number distribution.
*
* The formula for the binomial probability density function is
- * @f$ p(i|t,p) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
- * and @f$ p @f$ are the parameters of the distribution.
+ * @f$p(i|t,p) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
+ * and @f$p@f$ are the parameters of the distribution.
*/
template<typename _IntType = int>
class binomial_distribution
{
- __glibcxx_class_requires(_IntType, _IntegerConcept)
+ static_assert(std::is_integral<_IntType>::value,
+ "template argument not an integral type");
public:
/** The type of the range of the distribution. */
: _M_t(__t), _M_p(__p)
{
_GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
- && (_M_p >= 0.0)
- && (_M_p <= 1.0));
+ && (_M_p >= 0.0)
+ && (_M_p <= 1.0));
_M_initialize();
}
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_t == __p2._M_t) && (__p1._M_p == __p2._M_p); }
+ { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
private:
void
{ return _M_param.t(); }
/**
- * @brief Return true if two binomial distributions have
- * the same parameters.
+ * @brief Generating functions.
*/
- template<typename _IntType1>
- friend bool
- operator==(const binomial_distribution<_IntType1>& __d1,
- const binomial_distribution<_IntType1>& __d2)
- { return (__d1.param() == __d2.param())
- && (__d1._M_nd == __d2._M_nd); }
-
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
const param_type& __p);
/**
+ * @brief Return true if two binomial distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ friend bool
+ operator==(const binomial_distribution& __d1,
+ const binomial_distribution& __d2)
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+ { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
+#else
+ { return __d1._M_param == __d2._M_param; }
+#endif
+
+ /**
* @brief Inserts a %binomial_distribution random number distribution
* @p __x into the output stream @p __os.
*
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const binomial_distribution<_IntType1>& __x);
+ const std::binomial_distribution<_IntType1>& __x);
/**
* @brief Extracts a %binomial_distribution random number distribution
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- binomial_distribution<_IntType1>& __x);
+ std::binomial_distribution<_IntType1>& __x);
private:
template<typename _UniformRandomNumberGenerator>
param_type _M_param;
// NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
- normal_distribution<double> _M_nd;
+ std::normal_distribution<double> _M_nd;
};
+ /**
+ * @brief Return true if two binomial distributions are different.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::binomial_distribution<_IntType>& __d1,
+ const std::binomial_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A discrete geometric random number distribution.
*
* The formula for the geometric probability density function is
- * @f$ p(i|p) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
+ * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
* distribution.
*/
template<typename _IntType = int>
class geometric_distribution
{
- __glibcxx_class_requires(_IntType, _IntegerConcept)
+ static_assert(std::is_integral<_IntType>::value,
+ "template argument not an integral type");
public:
/** The type of the range of the distribution. */
param_type(double __p = 0.5)
: _M_p(__p)
{
- _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0)
- && (_M_p <= 1.0));
+ _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
_M_initialize();
}
private:
void
_M_initialize()
- { _M_log_p = std::log(_M_p); }
+ { _M_log_1_p = std::log(1.0 - _M_p); }
double _M_p;
- double _M_log_p;
+ double _M_log_1_p;
};
// constructors and member function
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
+ /**
+ * @brief Return true if two geometric distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const geometric_distribution& __d1,
+ const geometric_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
param_type _M_param;
};
/**
* @brief Return true if two geometric distributions have
- * the same parameters.
+ * different parameters.
*/
template<typename _IntType>
- bool
- operator==(const geometric_distribution<_IntType>& __d1,
- const geometric_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::geometric_distribution<_IntType>& __d1,
+ const std::geometric_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %geometric_distribution random number distribution
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const geometric_distribution<_IntType>& __x);
+ const std::geometric_distribution<_IntType>& __x);
/**
* @brief Extracts a %geometric_distribution random number distribution
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- geometric_distribution<_IntType>& __x);
+ std::geometric_distribution<_IntType>& __x);
/**
* @brief A negative_binomial_distribution random number distribution.
*
* The formula for the negative binomial probability mass function is
- * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
- * and @f$ p @f$ are the parameters of the distribution.
+ * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
+ * and @f$p@f$ are the parameters of the distribution.
*/
template<typename _IntType = int>
class negative_binomial_distribution
{
- __glibcxx_class_requires(_IntType, _IntegerConcept)
+ static_assert(std::is_integral<_IntType>::value,
+ "template argument not an integral type");
public:
/** The type of the range of the distribution. */
explicit
param_type(_IntType __k = 1, double __p = 0.5)
: _M_k(__k), _M_p(__p)
- { }
+ {
+ _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
+ }
_IntType
k() const
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_k == __p2._M_k) && (__p1._M_p == __p2._M_p); }
+ { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
private:
_IntType _M_k;
explicit
negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
- : _M_param(__k, __p)
+ : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
{ }
explicit
negative_binomial_distribution(const param_type& __p)
- : _M_param(__p)
+ : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
{ }
/**
*/
void
reset()
- { }
+ { _M_gd.reset(); }
/**
- * @brief Return the @f$ k @f$ parameter of the distribution.
+ * @brief Return the @f$k@f$ parameter of the distribution.
*/
_IntType
k() const
{ return _M_param.k(); }
/**
- * @brief Return the @f$ p @f$ parameter of the distribution.
+ * @brief Return the @f$p@f$ parameter of the distribution.
*/
double
p() const
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ operator()(_UniformRandomNumberGenerator& __urng);
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
+ /**
+ * @brief Return true if two negative binomial distributions have
+ * the same parameters and the sequences that would be
+ * generated are equal.
+ */
+ friend bool
+ operator==(const negative_binomial_distribution& __d1,
+ const negative_binomial_distribution& __d2)
+ { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
+
+ /**
+ * @brief Inserts a %negative_binomial_distribution random
+ * number distribution @p __x into the output stream @p __os.
+ *
+ * @param __os An output stream.
+ * @param __x A %negative_binomial_distribution random number
+ * distribution.
+ *
+ * @returns The output stream with the state of @p __x inserted or in
+ * an error state.
+ */
+ template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ const std::negative_binomial_distribution<_IntType1>& __x);
+
+ /**
+ * @brief Extracts a %negative_binomial_distribution random number
+ * distribution @p __x from the input stream @p __is.
+ *
+ * @param __is An input stream.
+ * @param __x A %negative_binomial_distribution random number
+ * generator engine.
+ *
+ * @returns The input stream with @p __x extracted or in an error state.
+ */
+ template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+ std::negative_binomial_distribution<_IntType1>& __x);
+
private:
param_type _M_param;
+
+ std::gamma_distribution<double> _M_gd;
};
/**
- * @brief Return true if two negative binomial distributions have
- * the same parameters.
+ * @brief Return true if two negative binomial distributions are different.
*/
template<typename _IntType>
- bool
- operator==(const negative_binomial_distribution<_IntType>& __d1,
- const negative_binomial_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
+ const std::negative_binomial_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
- /**
- * @brief Inserts a %negative_binomial_distribution random
- * number distribution @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %negative_binomial_distribution random number
- * distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _IntType, typename _CharT, typename _Traits>
- std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const negative_binomial_distribution<_IntType>& __x);
- /**
- * @brief Extracts a %negative_binomial_distribution random number
- * distribution @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %negative_binomial_distribution random number
- * generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _IntType, typename _CharT, typename _Traits>
- std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- negative_binomial_distribution<_IntType>& __x);
-
- /* @} */ // group std_random_distributions_bernoulli
+ /* @} */ // group random_distributions_bernoulli
/**
- * @addtogroup std_random_distributions_poisson Poisson Distributions
- * @ingroup std_random_distributions
+ * @addtogroup random_distributions_poisson Poisson Distributions
+ * @ingroup random_distributions
* @{
*/
* @brief A discrete Poisson random number distribution.
*
* The formula for the Poisson probability density function is
- * @f$ p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu} @f$ where @f$ \mu @f$ is the
+ * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
* parameter of the distribution.
*/
template<typename _IntType = int>
class poisson_distribution
{
- __glibcxx_class_requires(_IntType, _IntegerConcept)
+ static_assert(std::is_integral<_IntType>::value,
+ "template argument not an integral type");
public:
/** The type of the range of the distribution. */
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
- operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p);
-
- /**
- * @brief Return true if two Poisson distributions have the same
- * parameters.
- */
- template<typename _IntType1>
- friend bool
- operator==(const poisson_distribution<_IntType1>& __d1,
- const poisson_distribution<_IntType1>& __d2)
- { return (__d1.param() == __d2.param())
- && (__d1._M_nd == __d2._M_nd); }
+ operator()(_UniformRandomNumberGenerator& __urng,
+ const param_type& __p);
+
+ /**
+ * @brief Return true if two Poisson distributions have the same
+ * parameters and the sequences that would be generated
+ * are equal.
+ */
+ friend bool
+ operator==(const poisson_distribution& __d1,
+ const poisson_distribution& __d2)
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+ { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
+#else
+ { return __d1._M_param == __d2._M_param; }
+#endif
/**
* @brief Inserts a %poisson_distribution random number distribution
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const poisson_distribution<_IntType1>& __x);
+ const std::poisson_distribution<_IntType1>& __x);
/**
* @brief Extracts a %poisson_distribution random number distribution
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- poisson_distribution<_IntType1>& __x);
+ std::poisson_distribution<_IntType1>& __x);
private:
param_type _M_param;
// NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
- normal_distribution<double> _M_nd;
+ std::normal_distribution<double> _M_nd;
};
/**
+ * @brief Return true if two Poisson distributions are different.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::poisson_distribution<_IntType>& __d1,
+ const std::poisson_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
+
+ /**
* @brief An exponential continuous distribution for random numbers.
*
* The formula for the exponential probability density function is
- * @f$ p(x|\lambda) = \lambda e^{-\lambda x} @f$.
+ * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
*
* <table border=1 cellpadding=10 cellspacing=0>
* <caption align=top>Distribution Statistics</caption>
- * <tr><td>Mean</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
- * <tr><td>Median</td><td>@f$ \frac{\ln 2}{\lambda} @f$</td></tr>
- * <tr><td>Mode</td><td>@f$ zero @f$</td></tr>
+ * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
+ * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
+ * <tr><td>Mode</td><td>@f$zero@f$</td></tr>
* <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
- * <tr><td>Standard Deviation</td><td>@f$ \frac{1}{\lambda} @f$</td></tr>
+ * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
* </table>
*/
template<typename _RealType = double>
class exponential_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
public:
/**
* @brief Constructs an exponential distribution with inverse scale
- * parameter @f$ \lambda @f$.
+ * parameter @f$\lambda@f$.
*/
explicit
exponential_distribution(const result_type& __lambda = result_type(1))
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- {
- __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
- __aurng(__urng);
- return -std::log(__aurng()) / this->lambda();
- }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
{
__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
__aurng(__urng);
- return -std::log(__aurng()) / __p.lambda();
+ return -std::log(result_type(1) - __aurng()) / __p.lambda();
}
+ /**
+ * @brief Return true if two exponential distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const exponential_distribution& __d1,
+ const exponential_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
param_type _M_param;
};
/**
- * @brief Return true if two exponential distributions have the same
+ * @brief Return true if two exponential distributions have different
* parameters.
*/
template<typename _RealType>
- bool
- operator==(const exponential_distribution<_RealType>& __d1,
- const exponential_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::exponential_distribution<_RealType>& __d1,
+ const std::exponential_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %exponential_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const exponential_distribution<_RealType>& __x);
+ const std::exponential_distribution<_RealType>& __x);
/**
* @brief Extracts a %exponential_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- exponential_distribution<_RealType>& __x);
-
-
- /**
- * @brief A gamma continuous distribution for random numbers.
- *
- * The formula for the gamma probability density function is
- * @f$ p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
- * (x/\beta)^{\alpha - 1} e^{-x/\beta} @f$.
- */
- template<typename _RealType = double>
- class gamma_distribution
- {
- public:
- /** The type of the range of the distribution. */
- typedef _RealType result_type;
- /** Parameter type. */
- struct param_type
- {
- typedef gamma_distribution<_RealType> distribution_type;
- friend class gamma_distribution<_RealType>;
-
- explicit
- param_type(_RealType __alpha = _RealType(1),
- _RealType __beta = _RealType(1))
- : _M_alpha(__alpha), _M_beta(__beta)
- {
- _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
- _M_initialize();
- }
-
- _RealType
- alpha() const
- { return _M_alpha; }
-
- _RealType
- beta() const
- { return _M_beta; }
-
- friend bool
- operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_alpha == __p2._M_alpha)
- && (__p1._M_beta == __p2._M_beta); }
-
- private:
- void
- _M_initialize();
-
- _RealType _M_alpha;
- _RealType _M_beta;
-
- // Hosts either lambda of GB or d of modified Vaduva's.
- _RealType _M_l_d;
- };
-
- public:
- /**
- * @brief Constructs a gamma distribution with parameters
- * @f$ \alpha @f$ and @f$ \beta @f$.
- */
- explicit
- gamma_distribution(_RealType __alpha = _RealType(1),
- _RealType __beta = _RealType(1))
- : _M_param(__alpha, __beta)
- { }
-
- explicit
- gamma_distribution(const param_type& __p)
- : _M_param(__p)
- { }
-
- /**
- * @brief Resets the distribution state.
- *
- * Does nothing for the gamma distribution.
- */
- void
- reset() { }
-
- /**
- * @brief Returns the @f$ \alpha @f$ of the distribution.
- */
- _RealType
- alpha() const
- { return _M_param.alpha(); }
-
- /**
- * @brief Returns the @f$ \beta @f$ of the distribution.
- */
- _RealType
- beta() const
- { return _M_param.beta(); }
-
- /**
- * @brief Returns the parameter set of the distribution.
- */
- param_type
- param() const
- { return _M_param; }
-
- /**
- * @brief Sets the parameter set of the distribution.
- * @param __param The new parameter set of the distribution.
- */
- void
- param(const param_type& __param)
- { _M_param = __param; }
-
- /**
- * @brief Returns the greatest lower bound value of the distribution.
- */
- result_type
- min() const
- { return result_type(0); }
-
- /**
- * @brief Returns the least upper bound value of the distribution.
- */
- result_type
- max() const
- { return std::numeric_limits<result_type>::max(); }
-
- template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
-
- template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p);
-
- private:
- param_type _M_param;
- };
-
- /**
- * @brief Return true if two gamma distributions have the same
- * parameters.
- */
- template<typename _RealType>
- bool
- operator==(const gamma_distribution<_RealType>& __d1,
- const gamma_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
- /**
- * @brief Inserts a %gamma_distribution random number distribution
- * @p __x into the output stream @p __os.
- *
- * @param __os An output stream.
- * @param __x A %gamma_distribution random number distribution.
- *
- * @returns The output stream with the state of @p __x inserted or in
- * an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const gamma_distribution<_RealType>& __x);
-
- /**
- * @brief Extracts a %gamma_distribution random number distribution
- * @p __x from the input stream @p __is.
- *
- * @param __is An input stream.
- * @param __x A %gamma_distribution random number generator engine.
- *
- * @returns The input stream with @p __x extracted or in an error state.
- */
- template<typename _RealType, typename _CharT, typename _Traits>
- std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>& __is,
- gamma_distribution<_RealType>& __x);
+ std::exponential_distribution<_RealType>& __x);
/**
* @brief A weibull_distribution random number distribution.
*
- * The formula for the normal probability density function is
- * @f$ p(x|\alpha,\beta) = \frac{a}{b} (frac{x}{b})^{a-1}
- * \exp{(-(frac{x}{b})^a)} @f$.
+ * The formula for the normal probability density function is:
+ * @f[
+ * p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
+ * \exp{(-(\frac{x}{\beta})^\alpha)}
+ * @f]
*/
template<typename _RealType = double>
class weibull_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_a == __p2._M_a) && (__p1._M_b == __p2._M_b); }
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
private:
_RealType _M_a;
{ }
/**
- * @brief Return the @f$ a @f$ parameter of the distribution.
+ * @brief Return the @f$a@f$ parameter of the distribution.
*/
_RealType
a() const
{ return _M_param.a(); }
/**
- * @brief Return the @f$ b @f$ parameter of the distribution.
+ * @brief Return the @f$b@f$ parameter of the distribution.
*/
_RealType
b() const
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
- const param_type& __p)
- {
- __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
- __aurng(__urng);
- return __p.b() * std::pow(-std::log(__aurng()),
- result_type(1) / __p.a());
- }
+ const param_type& __p);
+
+ /**
+ * @brief Return true if two Weibull distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const weibull_distribution& __d1,
+ const weibull_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
private:
param_type _M_param;
};
- /**
- * @brief Return true if two Weibull distributions have the same
- * parameters.
- */
+ /**
+ * @brief Return true if two Weibull distributions have different
+ * parameters.
+ */
template<typename _RealType>
- bool
- operator==(const weibull_distribution<_RealType>& __d1,
- const weibull_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::weibull_distribution<_RealType>& __d1,
+ const std::weibull_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %weibull_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const weibull_distribution<_RealType>& __x);
+ const std::weibull_distribution<_RealType>& __x);
/**
* @brief Extracts a %weibull_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- weibull_distribution<_RealType>& __x);
+ std::weibull_distribution<_RealType>& __x);
/**
* @brief A extreme_value_distribution random number distribution.
*
* The formula for the normal probability mass function is
- * @f$ p(x|a,b) = \frac{1}{b}
- * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b})) @f$
+ * @f[
+ * p(x|a,b) = \frac{1}{b}
+ * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
+ * @f]
*/
template<typename _RealType = double>
class extreme_value_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_a == __p2._M_a) && (__p1._M_b == __p2._M_b); }
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
private:
_RealType _M_a;
{ }
/**
- * @brief Return the @f$ a @f$ parameter of the distribution.
+ * @brief Return the @f$a@f$ parameter of the distribution.
*/
_RealType
a() const
{ return _M_param.a(); }
/**
- * @brief Return the @f$ b @f$ parameter of the distribution.
+ * @brief Return the @f$b@f$ parameter of the distribution.
*/
_RealType
b() const
max() const
{ return std::numeric_limits<result_type>::max(); }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
+ /**
+ * @brief Return true if two extreme value distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const extreme_value_distribution& __d1,
+ const extreme_value_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
param_type _M_param;
};
/**
- *
+ * @brief Return true if two extreme value distributions have different
+ * parameters.
*/
template<typename _RealType>
- bool
- operator==(const extreme_value_distribution<_RealType>& __d1,
- const extreme_value_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::extreme_value_distribution<_RealType>& __d1,
+ const std::extreme_value_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief Inserts a %extreme_value_distribution random number distribution
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const extreme_value_distribution<_RealType>& __x);
+ const std::extreme_value_distribution<_RealType>& __x);
/**
* @brief Extracts a %extreme_value_distribution random number
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- extreme_value_distribution<_RealType>& __x);
+ std::extreme_value_distribution<_RealType>& __x);
/**
template<typename _IntType = int>
class discrete_distribution
{
- __glibcxx_class_requires(_IntType, _IntegerConcept)
+ static_assert(std::is_integral<_IntType>::value,
+ "template argument not an integral type");
public:
/** The type of the range of the distribution. */
param_type()
: _M_prob(), _M_cp()
- { _M_initialize(); }
+ { }
template<typename _InputIterator>
param_type(_InputIterator __wbegin,
param_type(size_t __nw, double __xmin, double __xmax,
_Func __fw);
+ // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
+ param_type(const param_type&) = default;
+ param_type& operator=(const param_type&) = default;
+
std::vector<double>
probabilities() const
- { return _M_prob; }
+ { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
: _M_param(__wbegin, __wend)
{ }
- discrete_distribution(initializer_list<double> __wil)
- : _M_param(__wil)
+ discrete_distribution(initializer_list<double> __wl)
+ : _M_param(__wl)
{ }
template<typename _Func>
*/
std::vector<double>
probabilities() const
- { return _M_param.probabilities(); }
+ {
+ return _M_param._M_prob.empty()
+ ? std::vector<double>(1, 1.0) : _M_param._M_prob;
+ }
/**
* @brief Returns the parameter set of the distribution.
*/
result_type
max() const
- { return this->_M_param._M_prob.size() - 1; }
+ {
+ return _M_param._M_prob.empty()
+ ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
+ }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
const param_type& __p);
/**
+ * @brief Return true if two discrete distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const discrete_distribution& __d1,
+ const discrete_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
+ /**
* @brief Inserts a %discrete_distribution random number distribution
* @p __x into the output stream @p __os.
*
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const discrete_distribution<_IntType1>& __x);
+ const std::discrete_distribution<_IntType1>& __x);
/**
* @brief Extracts a %discrete_distribution random number distribution
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- discrete_distribution<_IntType1>& __x);
+ std::discrete_distribution<_IntType1>& __x);
private:
param_type _M_param;
};
/**
- *
- */
+ * @brief Return true if two discrete distributions have different
+ * parameters.
+ */
template<typename _IntType>
- bool
- operator==(const discrete_distribution<_IntType>& __d1,
- const discrete_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::discrete_distribution<_IntType>& __d1,
+ const std::discrete_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
/**
template<typename _RealType = double>
class piecewise_constant_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
typedef piecewise_constant_distribution<_RealType> distribution_type;
friend class piecewise_constant_distribution<_RealType>;
- param_type();
+ param_type()
+ : _M_int(), _M_den(), _M_cp()
+ { }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorW __wbegin);
template<typename _Func>
- param_type(initializer_list<_RealType> __bil, _Func __fw);
+ param_type(initializer_list<_RealType> __bi, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
+ // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
+ param_type(const param_type&) = default;
+ param_type& operator=(const param_type&) = default;
+
std::vector<_RealType>
intervals() const
- { return _M_int; }
+ {
+ if (_M_int.empty())
+ {
+ std::vector<_RealType> __tmp(2);
+ __tmp[1] = _RealType(1);
+ return __tmp;
+ }
+ else
+ return _M_int;
+ }
std::vector<double>
densities() const
- { return _M_den; }
+ { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_int == __p2._M_int)
- && (__p1._M_den == __p2._M_den); }
+ { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
private:
void
{ }
template<typename _Func>
- piecewise_constant_distribution(initializer_list<_RealType> __bil,
+ piecewise_constant_distribution(initializer_list<_RealType> __bl,
_Func __fw)
- : _M_param(__bil, __fw)
+ : _M_param(__bl, __fw)
{ }
template<typename _Func>
*/
std::vector<_RealType>
intervals() const
- { return _M_param.intervals(); }
+ {
+ if (_M_param._M_int.empty())
+ {
+ std::vector<_RealType> __tmp(2);
+ __tmp[1] = _RealType(1);
+ return __tmp;
+ }
+ else
+ return _M_param._M_int;
+ }
/**
* @brief Returns a vector of the probability densities.
*/
std::vector<double>
densities() const
- { return _M_param.densities(); }
+ {
+ return _M_param._M_den.empty()
+ ? std::vector<double>(1, 1.0) : _M_param._M_den;
+ }
/**
* @brief Returns the parameter set of the distribution.
*/
result_type
min() const
- { return this->_M_param._M_int.front(); }
+ {
+ return _M_param._M_int.empty()
+ ? result_type(0) : _M_param._M_int.front();
+ }
/**
* @brief Returns the least upper bound value of the distribution.
*/
result_type
max() const
- { return this->_M_param._M_int.back(); }
+ {
+ return _M_param._M_int.empty()
+ ? result_type(1) : _M_param._M_int.back();
+ }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
const param_type& __p);
/**
+ * @brief Return true if two piecewise constant distributions have the
+ * same parameters.
+ */
+ friend bool
+ operator==(const piecewise_constant_distribution& __d1,
+ const piecewise_constant_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
+ /**
* @brief Inserts a %piecewise_constan_distribution random
* number distribution @p __x into the output stream @p __os.
*
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const piecewise_constant_distribution<_RealType1>& __x);
+ const std::piecewise_constant_distribution<_RealType1>& __x);
/**
* @brief Extracts a %piecewise_constan_distribution random
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- piecewise_constant_distribution<_RealType1>& __x);
+ std::piecewise_constant_distribution<_RealType1>& __x);
private:
param_type _M_param;
};
/**
- *
+ * @brief Return true if two piecewise constant distributions have
+ * different parameters.
*/
template<typename _RealType>
- bool
- operator==(const piecewise_constant_distribution<_RealType>& __d1,
- const piecewise_constant_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
+ const std::piecewise_constant_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
template<typename _RealType = double>
class piecewise_linear_distribution
{
+ static_assert(std::is_floating_point<_RealType>::value,
+ "template argument not a floating point type");
+
public:
/** The type of the range of the distribution. */
typedef _RealType result_type;
typedef piecewise_linear_distribution<_RealType> distribution_type;
friend class piecewise_linear_distribution<_RealType>;
- param_type();
+ param_type()
+ : _M_int(), _M_den(), _M_cp(), _M_m()
+ { }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorW __wbegin);
template<typename _Func>
- param_type(initializer_list<_RealType> __bil, _Func __fw);
+ param_type(initializer_list<_RealType> __bl, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
+ // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
+ param_type(const param_type&) = default;
+ param_type& operator=(const param_type&) = default;
+
std::vector<_RealType>
intervals() const
- { return _M_int; }
+ {
+ if (_M_int.empty())
+ {
+ std::vector<_RealType> __tmp(2);
+ __tmp[1] = _RealType(1);
+ return __tmp;
+ }
+ else
+ return _M_int;
+ }
std::vector<double>
densities() const
- { return _M_den; }
+ { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
- { return (__p1._M_int == __p2._M_int)
- && (__p1._M_den == __p2._M_den); }
+ { return (__p1._M_int == __p2._M_int
+ && __p1._M_den == __p2._M_den); }
private:
void
{ }
template<typename _Func>
- piecewise_linear_distribution(initializer_list<_RealType> __bil,
+ piecewise_linear_distribution(initializer_list<_RealType> __bl,
_Func __fw)
- : _M_param(__bil, __fw)
+ : _M_param(__bl, __fw)
{ }
template<typename _Func>
*/
std::vector<_RealType>
intervals() const
- { return _M_param.intervals(); }
+ {
+ if (_M_param._M_int.empty())
+ {
+ std::vector<_RealType> __tmp(2);
+ __tmp[1] = _RealType(1);
+ return __tmp;
+ }
+ else
+ return _M_param._M_int;
+ }
/**
* @brief Return a vector of the probability densities of the
*/
std::vector<double>
densities() const
- { return _M_param.densities(); }
+ {
+ return _M_param._M_den.empty()
+ ? std::vector<double>(2, 1.0) : _M_param._M_den;
+ }
/**
* @brief Returns the parameter set of the distribution.
*/
result_type
min() const
- { return this->_M_param._M_int.front(); }
+ {
+ return _M_param._M_int.empty()
+ ? result_type(0) : _M_param._M_int.front();
+ }
/**
* @brief Returns the least upper bound value of the distribution.
*/
result_type
max() const
- { return this->_M_param._M_int.back(); }
+ {
+ return _M_param._M_int.empty()
+ ? result_type(1) : _M_param._M_int.back();
+ }
+ /**
+ * @brief Generating functions.
+ */
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
const param_type& __p);
/**
+ * @brief Return true if two piecewise linear distributions have the
+ * same parameters.
+ */
+ friend bool
+ operator==(const piecewise_linear_distribution& __d1,
+ const piecewise_linear_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
+ /**
* @brief Inserts a %piecewise_linear_distribution random number
* distribution @p __x into the output stream @p __os.
*
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
- const piecewise_linear_distribution<_RealType1>& __x);
+ const std::piecewise_linear_distribution<_RealType1>& __x);
/**
* @brief Extracts a %piecewise_linear_distribution random number
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
- piecewise_linear_distribution<_RealType1>& __x);
+ std::piecewise_linear_distribution<_RealType1>& __x);
private:
param_type _M_param;
};
/**
- *
+ * @brief Return true if two piecewise linear distributions have
+ * different parameters.
*/
template<typename _RealType>
- bool
- operator==(const piecewise_linear_distribution<_RealType>& __d1,
- const piecewise_linear_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
+ inline bool
+ operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
+ const std::piecewise_linear_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
- /* @} */ // group std_random_distributions_poisson
- /* @} */ // group std_random_distributions
+ /* @} */ // group random_distributions_poisson
+
+ /* @} */ // group random_distributions
/**
- * @addtogroup std_random_utilities Random Number Utilities
- * @ingroup std_random
+ * @addtogroup random_utilities Random Number Utilities
+ * @ingroup random
* @{
*/
private:
///
- vector<result_type> _M_v;
+ std::vector<result_type> _M_v;
};
- /* @} */ // group std_random_utilities
+ /* @} */ // group random_utilities
- /* @} */ // group std_random
+ /* @} */ // group random
-}
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+#endif
OSDN Git Service
