diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -236,7 +236,41 @@ __mutex_base __node_handle __nullptr + __random/bernoulli_distribution.h + __random/binomial_distribution.h + __random/cauchy_distribution.h + __random/chi_squared_distribution.h + __random/default_random_engine.h + __random/discard_block_engine.h + __random/discrete_distribution.h + __random/exponential_distribution.h + __random/extreme_value_distribution.h + __random/fisher_f_distribution.h + __random/gamma_distribution.h + __random/generate_canonical.h + __random/geometric_distribution.h + __random/independent_bits_engine.h + __random/is_seed_sequence.h + __random/knuth_b.h + __random/linear_congruential_engine.h + __random/log2.h + __random/lognormal_distribution.h + __random/mersenne_twister_engine.h + __random/negative_binomial_distribution.h + __random/normal_distribution.h + __random/piecewise_constant_distribution.h + __random/piecewise_linear_distribution.h + __random/poisson_distribution.h + __random/random_device.h + __random/ranlux.h + __random/seed_seq.h + __random/shuffle_order_engine.h + __random/student_t_distribution.h + __random/subtract_with_carry_engine.h __random/uniform_int_distribution.h + __random/uniform_random_bit_generator.h + __random/uniform_real_distribution.h + __random/weibull_distribution.h __ranges/access.h __ranges/all.h __ranges/common_view.h diff --git a/libcxx/include/__random/bernoulli_distribution.h b/libcxx/include/__random/bernoulli_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/bernoulli_distribution.h @@ -0,0 +1,143 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H +#define _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H + +#include <__config> +#include <__random/uniform_real_distribution.h> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +class _LIBCPP_TEMPLATE_VIS bernoulli_distribution +{ +public: + // types + typedef bool result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + double __p_; + public: + typedef bernoulli_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(double __p = 0.5) : __p_(__p) {} + + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + bernoulli_distribution() : bernoulli_distribution(0.5) {} + _LIBCPP_INLINE_VISIBILITY + explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_.p();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return false;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return true;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const bernoulli_distribution& __x, + const bernoulli_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const bernoulli_distribution& __x, + const bernoulli_distribution& __y) + {return !(__x == __y);} +}; + +template +inline +bernoulli_distribution::result_type +bernoulli_distribution::operator()(_URNG& __g, const param_type& __p) +{ + uniform_real_distribution __gen; + return __gen(__g) < __p.p(); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + return __os << __x.p(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x) +{ + typedef bernoulli_distribution _Eng; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + double __p; + __is >> __p; + if (!__is.fail()) + __x.param(param_type(__p)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H diff --git a/libcxx/include/__random/binomial_distribution.h b/libcxx/include/__random/binomial_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/binomial_distribution.h @@ -0,0 +1,225 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H + +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS binomial_distribution +{ +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __t_; + double __p_; + double __pr_; + double __odds_ratio_; + result_type __r0_; + public: + typedef binomial_distribution distribution_type; + + explicit param_type(result_type __t = 1, double __p = 0.5); + + _LIBCPP_INLINE_VISIBILITY + result_type t() const {return __t_;} + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + + friend class binomial_distribution; + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + binomial_distribution() : binomial_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit binomial_distribution(result_type __t, double __p = 0.5) + : __p_(param_type(__t, __p)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit binomial_distribution(result_type __t = 1, double __p = 0.5) + : __p_(param_type(__t, __p)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit binomial_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type t() const {return __p_.t();} + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_.p();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return t();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const binomial_distribution& __x, + const binomial_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const binomial_distribution& __x, + const binomial_distribution& __y) + {return !(__x == __y);} +}; + +#ifndef _LIBCPP_MSVCRT_LIKE +extern "C" double lgamma_r(double, int *); +#endif + +inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) { +#if defined(_LIBCPP_MSVCRT_LIKE) + return lgamma(__d); +#else + int __sign; + return lgamma_r(__d, &__sign); +#endif +} + +template +binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p) + : __t_(__t), __p_(__p) +{ + if (0 < __p_ && __p_ < 1) + { + __r0_ = static_cast((__t_ + 1) * __p_); + __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) - + __libcpp_lgamma(__r0_ + 1.) - + __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) + + (__t_ - __r0_) * _VSTD::log(1 - __p_)); + __odds_ratio_ = __p_ / (1 - __p_); + } +} + +// Reference: Kemp, C.D. (1986). `A modal method for generating binomial +// variables', Commun. Statist. - Theor. Meth. 15(3), 805-813. +template +template +_IntType +binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr) +{ + if (__pr.__t_ == 0 || __pr.__p_ == 0) + return 0; + if (__pr.__p_ == 1) + return __pr.__t_; + uniform_real_distribution __gen; + double __u = __gen(__g) - __pr.__pr_; + if (__u < 0) + return __pr.__r0_; + double __pu = __pr.__pr_; + double __pd = __pu; + result_type __ru = __pr.__r0_; + result_type __rd = __ru; + while (true) + { + bool __break = true; + if (__rd >= 1) + { + __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1)); + __u -= __pd; + __break = false; + if (__u < 0) + return __rd - 1; + } + if ( __rd != 0 ) + --__rd; + ++__ru; + if (__ru <= __pr.__t_) + { + __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru; + __u -= __pu; + __break = false; + if (__u < 0) + return __ru; + } + if (__break) + return 0; + } +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const binomial_distribution<_IntType>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + return __os << __x.t() << __sp << __x.p(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + binomial_distribution<_IntType>& __x) +{ + typedef binomial_distribution<_IntType> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __t; + double __p; + __is >> __t >> __p; + if (!__is.fail()) + __x.param(param_type(__t, __p)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H diff --git a/libcxx/include/__random/cauchy_distribution.h b/libcxx/include/__random/cauchy_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/cauchy_distribution.h @@ -0,0 +1,162 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H +#define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H + +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS cauchy_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __a_; + result_type __b_; + public: + typedef cauchy_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __a = 0, result_type __b = 1) + : __a_(__a), __b_(__b) {} + + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __a_;} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __b_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + cauchy_distribution() : cauchy_distribution(0) {} + _LIBCPP_INLINE_VISIBILITY + explicit cauchy_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit cauchy_distribution(result_type __a = 0, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit cauchy_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __p_.a();} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __p_.b();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return -numeric_limits::infinity();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const cauchy_distribution& __x, + const cauchy_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const cauchy_distribution& __x, + const cauchy_distribution& __y) + {return !(__x == __y);} +}; + +template +template +inline +_RealType +cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + uniform_real_distribution __gen; + // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite + return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g)); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const cauchy_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.a() << __sp << __x.b(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + cauchy_distribution<_RT>& __x) +{ + typedef cauchy_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __a; + result_type __b; + __is >> __a >> __b; + if (!__is.fail()) + __x.param(param_type(__a, __b)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H diff --git a/libcxx/include/__random/chi_squared_distribution.h b/libcxx/include/__random/chi_squared_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/chi_squared_distribution.h @@ -0,0 +1,144 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_CHI_SQUARED_DISTRIBUTION_H +#define _LIBCPP___RANDOM_CHI_SQUARED_DISTRIBUTION_H + +#include <__config> +#include <__random/gamma_distribution.h> +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS chi_squared_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __n_; + public: + typedef chi_squared_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __n = 1) : __n_(__n) {} + + _LIBCPP_INLINE_VISIBILITY + result_type n() const {return __n_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__n_ == __y.__n_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + chi_squared_distribution() : chi_squared_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit chi_squared_distribution(result_type __n) + : __p_(param_type(__n)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit chi_squared_distribution(result_type __n = 1) + : __p_(param_type(__n)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit chi_squared_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g, const param_type& __p) + {return gamma_distribution(__p.n() / 2, 2)(__g);} + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type n() const {return __p_.n();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const chi_squared_distribution& __x, + const chi_squared_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const chi_squared_distribution& __x, + const chi_squared_distribution& __y) + {return !(__x == __y);} +}; + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const chi_squared_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + __os << __x.n(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + chi_squared_distribution<_RT>& __x) +{ + typedef chi_squared_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __n; + __is >> __n; + if (!__is.fail()) + __x.param(param_type(__n)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_CHI_SQUARED_DISTRIBUTION_H diff --git a/libcxx/include/__random/default_random_engine.h b/libcxx/include/__random/default_random_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/default_random_engine.h @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_DEFAULT_RANDOM_ENGINE_H +#define _LIBCPP___RANDOM_DEFAULT_RANDOM_ENGINE_H + +#include <__config> +#include <__random/linear_congruential_engine.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +typedef minstd_rand default_random_engine; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_DEFAULT_RANDOM_ENGINE_H diff --git a/libcxx/include/__random/discard_block_engine.h b/libcxx/include/__random/discard_block_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/discard_block_engine.h @@ -0,0 +1,203 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H +#define _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H + +#include <__config> +#include <__random/is_seed_sequence.h> +#include <__utility/move.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS discard_block_engine +{ + _Engine __e_; + int __n_; + + static_assert( 0 < __r, "discard_block_engine invalid parameters"); + static_assert(__r <= __p, "discard_block_engine invalid parameters"); + static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters"); +public: + // types + typedef typename _Engine::result_type result_type; + + // engine characteristics + static _LIBCPP_CONSTEXPR const size_t block_size = __p; + static _LIBCPP_CONSTEXPR const size_t used_block = __r; + +#ifdef _LIBCPP_CXX03_LANG + static const result_type _Min = _Engine::_Min; + static const result_type _Max = _Engine::_Max; +#else + static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min(); + static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max(); +#endif + + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); } + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); } + + // constructors and seeding functions + _LIBCPP_INLINE_VISIBILITY + discard_block_engine() : __n_(0) {} + _LIBCPP_INLINE_VISIBILITY + explicit discard_block_engine(const _Engine& __e) + : __e_(__e), __n_(0) {} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + explicit discard_block_engine(_Engine&& __e) + : __e_(_VSTD::move(__e)), __n_(0) {} +#endif // _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {} + template + _LIBCPP_INLINE_VISIBILITY + explicit discard_block_engine(_Sseq& __q, + typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value && + !is_convertible<_Sseq, _Engine>::value>::type* = 0) + : __e_(__q), __n_(0) {} + _LIBCPP_INLINE_VISIBILITY + void seed() {__e_.seed(); __n_ = 0;} + _LIBCPP_INLINE_VISIBILITY + void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;} + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __is_seed_sequence<_Sseq, discard_block_engine>::value, + void + >::type + seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;} + + // generating functions + result_type operator()(); + _LIBCPP_INLINE_VISIBILITY + void discard(unsigned long long __z) {for (; __z; --__z) operator()();} + + // property functions + _LIBCPP_INLINE_VISIBILITY + const _Engine& base() const _NOEXCEPT {return __e_;} + + template + friend + bool + operator==( + const discard_block_engine<_Eng, _Pp, _Rp>& __x, + const discard_block_engine<_Eng, _Pp, _Rp>& __y); + + template + friend + bool + operator!=( + const discard_block_engine<_Eng, _Pp, _Rp>& __x, + const discard_block_engine<_Eng, _Pp, _Rp>& __y); + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const discard_block_engine<_Eng, _Pp, _Rp>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + discard_block_engine<_Eng, _Pp, _Rp>& __x); +}; + +template + _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size; + +template + _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block; + +template +typename discard_block_engine<_Engine, __p, __r>::result_type +discard_block_engine<_Engine, __p, __r>::operator()() +{ + if (__n_ >= static_cast(__r)) + { + __e_.discard(__p - __r); + __n_ = 0; + } + ++__n_; + return __e_(); +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x, + const discard_block_engine<_Eng, _Pp, _Rp>& __y) +{ + return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x, + const discard_block_engine<_Eng, _Pp, _Rp>& __y) +{ + return !(__x == __y); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const discard_block_engine<_Eng, _Pp, _Rp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _Ostream; + __os.flags(_Ostream::dec | _Ostream::left); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + return __os << __x.__e_ << __sp << __x.__n_; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + discard_block_engine<_Eng, _Pp, _Rp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + _Eng __e; + int __n; + __is >> __e >> __n; + if (!__is.fail()) + { + __x.__e_ = __e; + __x.__n_ = __n; + } + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H diff --git a/libcxx/include/__random/discrete_distribution.h b/libcxx/include/__random/discrete_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/discrete_distribution.h @@ -0,0 +1,260 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H +#define _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H + +#include <__algorithm/upper_bound.h> +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS discrete_distribution +{ +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + vector __p_; + public: + typedef discrete_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + param_type() {} + template + _LIBCPP_INLINE_VISIBILITY + param_type(_InputIterator __f, _InputIterator __l) + : __p_(__f, __l) {__init();} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + param_type(initializer_list __wl) + : __p_(__wl.begin(), __wl.end()) {__init();} +#endif // _LIBCPP_CXX03_LANG + template + param_type(size_t __nw, double __xmin, double __xmax, + _UnaryOperation __fw); + + vector probabilities() const; + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + + private: + void __init(); + + friend class discrete_distribution; + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const discrete_distribution<_IT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + discrete_distribution<_IT>& __x); + }; + +private: + param_type __p_; + +public: + // constructor and reset functions + _LIBCPP_INLINE_VISIBILITY + discrete_distribution() {} + template + _LIBCPP_INLINE_VISIBILITY + discrete_distribution(_InputIterator __f, _InputIterator __l) + : __p_(__f, __l) {} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + discrete_distribution(initializer_list __wl) + : __p_(__wl) {} +#endif // _LIBCPP_CXX03_LANG + template + _LIBCPP_INLINE_VISIBILITY + discrete_distribution(size_t __nw, double __xmin, double __xmax, + _UnaryOperation __fw) + : __p_(__nw, __xmin, __xmax, __fw) {} + _LIBCPP_INLINE_VISIBILITY + explicit discrete_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + vector probabilities() const {return __p_.probabilities();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return __p_.__p_.size();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const discrete_distribution& __x, + const discrete_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const discrete_distribution& __x, + const discrete_distribution& __y) + {return !(__x == __y);} + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const discrete_distribution<_IT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + discrete_distribution<_IT>& __x); +}; + +template +template +discrete_distribution<_IntType>::param_type::param_type(size_t __nw, + double __xmin, + double __xmax, + _UnaryOperation __fw) +{ + if (__nw > 1) + { + __p_.reserve(__nw - 1); + double __d = (__xmax - __xmin) / __nw; + double __d2 = __d / 2; + for (size_t __k = 0; __k < __nw; ++__k) + __p_.push_back(__fw(__xmin + __k * __d + __d2)); + __init(); + } +} + +template +void +discrete_distribution<_IntType>::param_type::__init() +{ + if (!__p_.empty()) + { + if (__p_.size() > 1) + { + double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0); + for (vector::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i) + *__i /= __s; + vector __t(__p_.size() - 1); + _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin()); + swap(__p_, __t); + } + else + { + __p_.clear(); + __p_.shrink_to_fit(); + } + } +} + +template +vector +discrete_distribution<_IntType>::param_type::probabilities() const +{ + size_t __n = __p_.size(); + vector __p(__n+1); + _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin()); + if (__n > 0) + __p[__n] = 1 - __p_[__n-1]; + else + __p[0] = 1; + return __p; +} + +template +template +_IntType +discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) +{ + uniform_real_distribution __gen; + return static_cast<_IntType>( + _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) - + __p.__p_.begin()); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const discrete_distribution<_IT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + size_t __n = __x.__p_.__p_.size(); + __os << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__p_[__i]; + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + discrete_distribution<_IT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + size_t __n; + __is >> __n; + vector __p(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __p[__i]; + if (!__is.fail()) + swap(__x.__p_.__p_, __p); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H diff --git a/libcxx/include/__random/exponential_distribution.h b/libcxx/include/__random/exponential_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/exponential_distribution.h @@ -0,0 +1,155 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H + +#include <__config> +#include <__random/generate_canonical.h> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS exponential_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __lambda_; + public: + typedef exponential_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {} + + _LIBCPP_INLINE_VISIBILITY + result_type lambda() const {return __lambda_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__lambda_ == __y.__lambda_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + exponential_distribution() : exponential_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit exponential_distribution(result_type __lambda) + : __p_(param_type(__lambda)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit exponential_distribution(result_type __lambda = 1) + : __p_(param_type(__lambda)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit exponential_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type lambda() const {return __p_.lambda();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const exponential_distribution& __x, + const exponential_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const exponential_distribution& __x, + const exponential_distribution& __y) + {return !(__x == __y);} +}; + +template +template +_RealType +exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + return -_VSTD::log + ( + result_type(1) - + _VSTD::generate_canonical::digits>(__g) + ) + / __p.lambda(); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const exponential_distribution<_RealType>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + return __os << __x.lambda(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + exponential_distribution<_RealType>& __x) +{ + typedef exponential_distribution<_RealType> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __lambda; + __is >> __lambda; + if (!__is.fail()) + __x.param(param_type(__lambda)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H diff --git a/libcxx/include/__random/extreme_value_distribution.h b/libcxx/include/__random/extreme_value_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/extreme_value_distribution.h @@ -0,0 +1,161 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H +#define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H + +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS extreme_value_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __a_; + result_type __b_; + public: + typedef extreme_value_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __a = 0, result_type __b = 1) + : __a_(__a), __b_(__b) {} + + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __a_;} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __b_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + extreme_value_distribution() : extreme_value_distribution(0) {} + _LIBCPP_INLINE_VISIBILITY + explicit extreme_value_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit extreme_value_distribution(result_type __a = 0, + result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit extreme_value_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __p_.a();} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __p_.b();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return -numeric_limits::infinity();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const extreme_value_distribution& __x, + const extreme_value_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const extreme_value_distribution& __x, + const extreme_value_distribution& __y) + {return !(__x == __y);} +}; + +template +template +_RealType +extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + return __p.a() - __p.b() * + _VSTD::log(-_VSTD::log(1-uniform_real_distribution()(__g))); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const extreme_value_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.a() << __sp << __x.b(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + extreme_value_distribution<_RT>& __x) +{ + typedef extreme_value_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __a; + result_type __b; + __is >> __a >> __b; + if (!__is.fail()) + __x.param(param_type(__a, __b)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H diff --git a/libcxx/include/__random/fisher_f_distribution.h b/libcxx/include/__random/fisher_f_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/fisher_f_distribution.h @@ -0,0 +1,160 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H +#define _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H + +#include <__config> +#include <__random/gamma_distribution.h> +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS fisher_f_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __m_; + result_type __n_; + public: + typedef fisher_f_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __m = 1, result_type __n = 1) + : __m_(__m), __n_(__n) {} + + _LIBCPP_INLINE_VISIBILITY + result_type m() const {return __m_;} + _LIBCPP_INLINE_VISIBILITY + result_type n() const {return __n_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + fisher_f_distribution() : fisher_f_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit fisher_f_distribution(result_type __m, result_type __n = 1) + : __p_(param_type(__m, __n)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1) + : __p_(param_type(__m, __n)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit fisher_f_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type m() const {return __p_.m();} + _LIBCPP_INLINE_VISIBILITY + result_type n() const {return __p_.n();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const fisher_f_distribution& __x, + const fisher_f_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const fisher_f_distribution& __x, + const fisher_f_distribution& __y) + {return !(__x == __y);} +}; + +template +template +_RealType +fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + gamma_distribution __gdm(__p.m() * result_type(.5)); + gamma_distribution __gdn(__p.n() * result_type(.5)); + return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g)); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const fisher_f_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.m() << __sp << __x.n(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + fisher_f_distribution<_RT>& __x) +{ + typedef fisher_f_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __m; + result_type __n; + __is >> __m >> __n; + if (!__is.fail()) + __x.param(param_type(__m, __n)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H diff --git a/libcxx/include/__random/gamma_distribution.h b/libcxx/include/__random/gamma_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/gamma_distribution.h @@ -0,0 +1,213 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H +#define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H + +#include <__config> +#include <__random/uniform_real_distribution.h> +#include <__random/exponential_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS gamma_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __alpha_; + result_type __beta_; + public: + typedef gamma_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __alpha = 1, result_type __beta = 1) + : __alpha_(__alpha), __beta_(__beta) {} + + _LIBCPP_INLINE_VISIBILITY + result_type alpha() const {return __alpha_;} + _LIBCPP_INLINE_VISIBILITY + result_type beta() const {return __beta_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + gamma_distribution() : gamma_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit gamma_distribution(result_type __alpha, result_type __beta = 1) + : __p_(param_type(__alpha, __beta)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit gamma_distribution(result_type __alpha = 1, + result_type __beta = 1) + : __p_(param_type(__alpha, __beta)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit gamma_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type alpha() const {return __p_.alpha();} + _LIBCPP_INLINE_VISIBILITY + result_type beta() const {return __p_.beta();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const gamma_distribution& __x, + const gamma_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const gamma_distribution& __x, + const gamma_distribution& __y) + {return !(__x == __y);} +}; + +template +template +_RealType +gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + result_type __a = __p.alpha(); + uniform_real_distribution __gen(0, 1); + exponential_distribution __egen; + result_type __x; + if (__a == 1) + __x = __egen(__g); + else if (__a > 1) + { + const result_type __b = __a - 1; + const result_type __c = 3 * __a - result_type(0.75); + while (true) + { + const result_type __u = __gen(__g); + const result_type __v = __gen(__g); + const result_type __w = __u * (1 - __u); + if (__w != 0) + { + const result_type __y = _VSTD::sqrt(__c / __w) * + (__u - result_type(0.5)); + __x = __b + __y; + if (__x >= 0) + { + const result_type __z = 64 * __w * __w * __w * __v * __v; + if (__z <= 1 - 2 * __y * __y / __x) + break; + if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y)) + break; + } + } + } + } + else // __a < 1 + { + while (true) + { + const result_type __u = __gen(__g); + const result_type __es = __egen(__g); + if (__u <= 1 - __a) + { + __x = _VSTD::pow(__u, 1 / __a); + if (__x <= __es) + break; + } + else + { + const result_type __e = -_VSTD::log((1-__u)/__a); + __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a); + if (__x <= __e + __es) + break; + } + } + } + return __x * __p.beta(); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const gamma_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.alpha() << __sp << __x.beta(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + gamma_distribution<_RT>& __x) +{ + typedef gamma_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __alpha; + result_type __beta; + __is >> __alpha >> __beta; + if (!__is.fail()) + __x.param(param_type(__alpha, __beta)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H diff --git a/libcxx/include/__random/generate_canonical.h b/libcxx/include/__random/generate_canonical.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/generate_canonical.h @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_GENERATE_CANONICAL_H +#define _LIBCPP___RANDOM_GENERATE_CANONICAL_H + +#include <__config> +#include <__random/log2.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +// generate_canonical + +template +_RealType +generate_canonical(_URNG& __g) +{ + const size_t _Dt = numeric_limits<_RealType>::digits; + const size_t __b = _Dt < __bits ? _Dt : __bits; +#ifdef _LIBCPP_CXX03_LANG + const size_t __logR = __log2::value; +#else + const size_t __logR = __log2::value; +#endif + const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0); + const _RealType _Rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1); + _RealType __base = _Rp; + _RealType _Sp = __g() - _URNG::min(); + for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp) + _Sp += (__g() - _URNG::min()) * __base; + return _Sp / __base; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_GENERATE_CANONICAL_H diff --git a/libcxx/include/__random/geometric_distribution.h b/libcxx/include/__random/geometric_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/geometric_distribution.h @@ -0,0 +1,141 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H +#define _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H + +#include <__config> +#include <__random/negative_binomial_distribution.h> +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS geometric_distribution +{ +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + double __p_; + public: + typedef geometric_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(double __p = 0.5) : __p_(__p) {} + + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + geometric_distribution() : geometric_distribution(0.5) {} + _LIBCPP_INLINE_VISIBILITY + explicit geometric_distribution(double __p) + : __p_(__p) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit geometric_distribution(double __p = 0.5) + : __p_(__p) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit geometric_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g, const param_type& __p) + {return negative_binomial_distribution(1, __p.p())(__g);} + + // property functions + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_.p();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::max();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const geometric_distribution& __x, + const geometric_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const geometric_distribution& __x, + const geometric_distribution& __y) + {return !(__x == __y);} +}; + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const geometric_distribution<_IntType>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + return __os << __x.p(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + geometric_distribution<_IntType>& __x) +{ + typedef geometric_distribution<_IntType> _Eng; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + double __p; + __is >> __p; + if (!__is.fail()) + __x.param(param_type(__p)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H diff --git a/libcxx/include/__random/independent_bits_engine.h b/libcxx/include/__random/independent_bits_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/independent_bits_engine.h @@ -0,0 +1,271 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H +#define _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H + +#include <__config> +#include <__random/is_seed_sequence.h> +#include <__random/log2.h> +#include <__utility/move.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS independent_bits_engine +{ + template + class __get_n + { + static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits; + static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0); + static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np; + static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0; + public: + static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np; + }; +public: + // types + typedef _UIntType result_type; + +private: + _Engine __e_; + + static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits::digits; + static_assert( 0 < __w, "independent_bits_engine invalid parameters"); + static_assert(__w <= _Dt, "independent_bits_engine invalid parameters"); + + typedef typename _Engine::result_type _Engine_result_type; + typedef typename conditional + < + sizeof(_Engine_result_type) <= sizeof(result_type), + result_type, + _Engine_result_type + >::type _Working_result_type; +#ifdef _LIBCPP_CXX03_LANG + static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min + + _Working_result_type(1); +#else + static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() + + _Working_result_type(1); +#endif + static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value; + static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value; + static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n; + static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n; + static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits; + static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; + static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 : + (_Rp >> __w0) << __w0; + static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 : + (_Rp >> (__w0+1)) << (__w0+1); + static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ? + _Engine_result_type(~0) >> (_EDt - __w0) : + _Engine_result_type(0); + static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ? + _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) : + _Engine_result_type(~0); +public: + static _LIBCPP_CONSTEXPR const result_type _Min = 0; + static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) : + (result_type(1) << __w) - result_type(1); + static_assert(_Min < _Max, "independent_bits_engine invalid parameters"); + + // engine characteristics + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + + // constructors and seeding functions + _LIBCPP_INLINE_VISIBILITY + independent_bits_engine() {} + _LIBCPP_INLINE_VISIBILITY + explicit independent_bits_engine(const _Engine& __e) + : __e_(__e) {} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + explicit independent_bits_engine(_Engine&& __e) + : __e_(_VSTD::move(__e)) {} +#endif // _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + explicit independent_bits_engine(result_type __sd) : __e_(__sd) {} + template + _LIBCPP_INLINE_VISIBILITY + explicit independent_bits_engine(_Sseq& __q, + typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value && + !is_convertible<_Sseq, _Engine>::value>::type* = 0) + : __e_(__q) {} + _LIBCPP_INLINE_VISIBILITY + void seed() {__e_.seed();} + _LIBCPP_INLINE_VISIBILITY + void seed(result_type __sd) {__e_.seed(__sd);} + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __is_seed_sequence<_Sseq, independent_bits_engine>::value, + void + >::type + seed(_Sseq& __q) {__e_.seed(__q);} + + // generating functions + _LIBCPP_INLINE_VISIBILITY + result_type operator()() {return __eval(integral_constant());} + _LIBCPP_INLINE_VISIBILITY + void discard(unsigned long long __z) {for (; __z; --__z) operator()();} + + // property functions + _LIBCPP_INLINE_VISIBILITY + const _Engine& base() const _NOEXCEPT {return __e_;} + + template + friend + bool + operator==( + const independent_bits_engine<_Eng, _Wp, _UInt>& __x, + const independent_bits_engine<_Eng, _Wp, _UInt>& __y); + + template + friend + bool + operator!=( + const independent_bits_engine<_Eng, _Wp, _UInt>& __x, + const independent_bits_engine<_Eng, _Wp, _UInt>& __y); + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const independent_bits_engine<_Eng, _Wp, _UInt>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + independent_bits_engine<_Eng, _Wp, _UInt>& __x); + +private: + _LIBCPP_INLINE_VISIBILITY + result_type __eval(false_type); + result_type __eval(true_type); + + template + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + __count < _Dt, + result_type + >::type + __lshift(result_type __x) {return __x << __count;} + + template + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + (__count >= _Dt), + result_type + >::type + __lshift(result_type) {return result_type(0);} +}; + +template +inline +_UIntType +independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type) +{ + return static_cast(__e_() & __mask0); +} + +template +_UIntType +independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type) +{ + result_type _Sp = 0; + for (size_t __k = 0; __k < __n0; ++__k) + { + _Engine_result_type __u; + do + { + __u = __e_() - _Engine::min(); + } while (__u >= __y0); + _Sp = static_cast(__lshift<__w0>(_Sp) + (__u & __mask0)); + } + for (size_t __k = __n0; __k < __n; ++__k) + { + _Engine_result_type __u; + do + { + __u = __e_() - _Engine::min(); + } while (__u >= __y1); + _Sp = static_cast(__lshift<__w0+1>(_Sp) + (__u & __mask1)); + } + return _Sp; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==( + const independent_bits_engine<_Eng, _Wp, _UInt>& __x, + const independent_bits_engine<_Eng, _Wp, _UInt>& __y) +{ + return __x.base() == __y.base(); +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=( + const independent_bits_engine<_Eng, _Wp, _UInt>& __x, + const independent_bits_engine<_Eng, _Wp, _UInt>& __y) +{ + return !(__x == __y); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const independent_bits_engine<_Eng, _Wp, _UInt>& __x) +{ + return __os << __x.base(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + independent_bits_engine<_Eng, _Wp, _UInt>& __x) +{ + _Eng __e; + __is >> __e; + if (!__is.fail()) + __x.__e_ = __e; + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H diff --git a/libcxx/include/__random/is_seed_sequence.h b/libcxx/include/__random/is_seed_sequence.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/is_seed_sequence.h @@ -0,0 +1,31 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H +#define _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H + +#include <__config> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +struct __is_seed_sequence +{ + static _LIBCPP_CONSTEXPR const bool value = + !is_convertible<_Sseq, typename _Engine::result_type>::value && + !is_same::type, _Engine>::value; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H diff --git a/libcxx/include/__random/knuth_b.h b/libcxx/include/__random/knuth_b.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/knuth_b.h @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_KNUTH_B_H +#define _LIBCPP___RANDOM_KNUTH_B_H + +#include <__config> +#include <__random/linear_congruential_engine.h> +#include <__random/shuffle_order_engine.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +typedef shuffle_order_engine knuth_b; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_KNUTH_B_H diff --git a/libcxx/include/__random/linear_congruential_engine.h b/libcxx/include/__random/linear_congruential_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/linear_congruential_engine.h @@ -0,0 +1,398 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H +#define _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H + +#include <__config> +#include <__random/is_seed_sequence.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template (_Mp-__c)/__a), + bool _OverflowOK = ((__m | (__m-1)) > __m), // m = 2^n + bool _SchrageOK = (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q +struct __lce_alg_picker +{ + static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK || _SchrageOK, + "The current values of a, c, and m cannot generate a number " + "within bounds of linear_congruential_engine."); + + static _LIBCPP_CONSTEXPR const bool __use_schrage = _MightOverflow && + !_OverflowOK && + _SchrageOK; +}; + +template ::__use_schrage> +struct __lce_ta; + +// 64 + +template +struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true> +{ + typedef unsigned long long result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + // Schrage's algorithm + const result_type __q = __m / __a; + const result_type __r = __m % __a; + const result_type __t0 = __a * (__x % __q); + const result_type __t1 = __r * (__x / __q); + __x = __t0 + (__t0 < __t1) * __m - __t1; + __x += __c - (__x >= __m - __c) * __m; + return __x; + } +}; + +template +struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true> +{ + typedef unsigned long long result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + // Schrage's algorithm + const result_type __q = __m / __a; + const result_type __r = __m % __a; + const result_type __t0 = __a * (__x % __q); + const result_type __t1 = __r * (__x / __q); + __x = __t0 + (__t0 < __t1) * __m - __t1; + return __x; + } +}; + +template +struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false> +{ + typedef unsigned long long result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + return (__a * __x + __c) % __m; + } +}; + +template +struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false> +{ + typedef unsigned long long result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + return __a * __x + __c; + } +}; + +// 32 + +template +struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true> +{ + typedef unsigned result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + const result_type __a = static_cast(_Ap); + const result_type __c = static_cast(_Cp); + const result_type __m = static_cast(_Mp); + // Schrage's algorithm + const result_type __q = __m / __a; + const result_type __r = __m % __a; + const result_type __t0 = __a * (__x % __q); + const result_type __t1 = __r * (__x / __q); + __x = __t0 + (__t0 < __t1) * __m - __t1; + __x += __c - (__x >= __m - __c) * __m; + return __x; + } +}; + +template +struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true> +{ + typedef unsigned result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + const result_type __a = static_cast(_Ap); + const result_type __m = static_cast(_Mp); + // Schrage's algorithm + const result_type __q = __m / __a; + const result_type __r = __m % __a; + const result_type __t0 = __a * (__x % __q); + const result_type __t1 = __r * (__x / __q); + __x = __t0 + (__t0 < __t1) * __m - __t1; + return __x; + } +}; + +template +struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false> +{ + typedef unsigned result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + const result_type __a = static_cast(_Ap); + const result_type __c = static_cast(_Cp); + const result_type __m = static_cast(_Mp); + return (__a * __x + __c) % __m; + } +}; + +template +struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false> +{ + typedef unsigned result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + const result_type __a = static_cast(_Ap); + const result_type __c = static_cast(_Cp); + return __a * __x + __c; + } +}; + +// 16 + +template +struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b> +{ + typedef unsigned short result_type; + _LIBCPP_INLINE_VISIBILITY + static result_type next(result_type __x) + { + return static_cast(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x)); + } +}; + +template +class _LIBCPP_TEMPLATE_VIS linear_congruential_engine; + +template +_LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); + +template +class _LIBCPP_TEMPLATE_VIS linear_congruential_engine +{ +public: + // types + typedef _UIntType result_type; + +private: + result_type __x_; + + static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0); + + static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters"); + static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters"); + static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type"); +public: + static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u; + static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u; + static_assert(_Min < _Max, "linear_congruential_engine invalid parameters"); + + // engine characteristics + static _LIBCPP_CONSTEXPR const result_type multiplier = __a; + static _LIBCPP_CONSTEXPR const result_type increment = __c; + static _LIBCPP_CONSTEXPR const result_type modulus = __m; + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() {return _Min;} + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() {return _Max;} + static _LIBCPP_CONSTEXPR const result_type default_seed = 1u; + + // constructors and seeding functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + linear_congruential_engine() : linear_congruential_engine(default_seed) {} + _LIBCPP_INLINE_VISIBILITY + explicit linear_congruential_engine(result_type __s) { seed(__s); } +#else + _LIBCPP_INLINE_VISIBILITY + explicit linear_congruential_engine(result_type __s = default_seed) { + seed(__s); + } +#endif + template + _LIBCPP_INLINE_VISIBILITY + explicit linear_congruential_engine(_Sseq& __q, + typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0) + {seed(__q);} + _LIBCPP_INLINE_VISIBILITY + void seed(result_type __s = default_seed) + {seed(integral_constant(), + integral_constant(), __s);} + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __is_seed_sequence<_Sseq, linear_congruential_engine>::value, + void + >::type + seed(_Sseq& __q) + {__seed(__q, integral_constant 0x100000000ull))>());} + + // generating functions + _LIBCPP_INLINE_VISIBILITY + result_type operator()() + {return __x_ = static_cast(__lce_ta<__a, __c, __m, _Mp>::next(__x_));} + _LIBCPP_INLINE_VISIBILITY + void discard(unsigned long long __z) {for (; __z; --__z) operator()();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const linear_congruential_engine& __x, + const linear_congruential_engine& __y) + {return __x.__x_ == __y.__x_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const linear_congruential_engine& __x, + const linear_congruential_engine& __y) + {return !(__x == __y);} + +private: + + _LIBCPP_INLINE_VISIBILITY + void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;} + _LIBCPP_INLINE_VISIBILITY + void seed(true_type, false_type, result_type __s) {__x_ = __s;} + _LIBCPP_INLINE_VISIBILITY + void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ? + 1 : __s % __m;} + _LIBCPP_INLINE_VISIBILITY + void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;} + + template + void __seed(_Sseq& __q, integral_constant); + template + void __seed(_Sseq& __q, integral_constant); + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); +}; + +template + _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier; + +template + _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::increment; + +template + _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::modulus; + +template + _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed; + +template +template +void +linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, + integral_constant) +{ + const unsigned __k = 1; + uint32_t __ar[__k+3]; + __q.generate(__ar, __ar + __k + 3); + result_type __s = static_cast(__ar[3] % __m); + __x_ = __c == 0 && __s == 0 ? result_type(1) : __s; +} + +template +template +void +linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, + integral_constant) +{ + const unsigned __k = 2; + uint32_t __ar[__k+3]; + __q.generate(__ar, __ar + __k + 3); + result_type __s = static_cast((__ar[3] + + ((uint64_t)__ar[4] << 32)) % __m); + __x_ = __c == 0 && __s == 0 ? result_type(1) : __s; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const linear_congruential_engine<_UIntType, __a, __c, __m>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _Ostream; + __os.flags(_Ostream::dec | _Ostream::left); + __os.fill(__os.widen(' ')); + return __os << __x.__x_; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + linear_congruential_engine<_UIntType, __a, __c, __m>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + _UIntType __t; + __is >> __t; + if (!__is.fail()) + __x.__x_ = __t; + return __is; +} + +typedef linear_congruential_engine + minstd_rand0; +typedef linear_congruential_engine + minstd_rand; + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H diff --git a/libcxx/include/__random/log2.h b/libcxx/include/__random/log2.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/log2.h @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_LOG2_H +#define _LIBCPP___RANDOM_LOG2_H + +#include <__config> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +struct __log2_imp +{ + static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp + : __log2_imp<_Xp, _Rp - 1>::value; +}; + +template +struct __log2_imp<_Xp, 0> +{ + static const size_t value = 0; +}; + +template +struct __log2_imp<0, _Rp> +{ + static const size_t value = _Rp + 1; +}; + +template +struct __log2 +{ + static const size_t value = __log2_imp<_Xp, + sizeof(_UIntType) * __CHAR_BIT__ - 1>::value; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_LOG2_H diff --git a/libcxx/include/__random/lognormal_distribution.h b/libcxx/include/__random/lognormal_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/lognormal_distribution.h @@ -0,0 +1,163 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H + +#include <__config> +#include <__random/normal_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS lognormal_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + normal_distribution __nd_; + public: + typedef lognormal_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __m = 0, result_type __s = 1) + : __nd_(__m, __s) {} + + _LIBCPP_INLINE_VISIBILITY + result_type m() const {return __nd_.mean();} + _LIBCPP_INLINE_VISIBILITY + result_type s() const {return __nd_.stddev();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__nd_ == __y.__nd_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + friend class lognormal_distribution; + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const lognormal_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + lognormal_distribution<_RT>& __x); + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + lognormal_distribution() : lognormal_distribution(0) {} + _LIBCPP_INLINE_VISIBILITY + explicit lognormal_distribution(result_type __m, result_type __s = 1) + : __p_(param_type(__m, __s)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit lognormal_distribution(result_type __m = 0, + result_type __s = 1) + : __p_(param_type(__m, __s)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit lognormal_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {__p_.__nd_.reset();} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g, const param_type& __p) + {return _VSTD::exp(const_cast&>(__p.__nd_)(__g));} + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type m() const {return __p_.m();} + _LIBCPP_INLINE_VISIBILITY + result_type s() const {return __p_.s();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const lognormal_distribution& __x, + const lognormal_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const lognormal_distribution& __x, + const lognormal_distribution& __y) + {return !(__x == __y);} + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const lognormal_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + lognormal_distribution<_RT>& __x); +}; + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const lognormal_distribution<_RT>& __x) +{ + return __os << __x.__p_.__nd_; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + lognormal_distribution<_RT>& __x) +{ + return __is >> __x.__p_.__nd_; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H diff --git a/libcxx/include/__random/mersenne_twister_engine.h b/libcxx/include/__random/mersenne_twister_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/mersenne_twister_engine.h @@ -0,0 +1,534 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H +#define _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H + +#include <__algorithm/equal.h> +#include <__algorithm/min.h> +#include <__config> +#include <__random/is_seed_sequence.h> +#include +#include +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine; + +template +bool +operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __y); + +template +_LIBCPP_INLINE_VISIBILITY +bool +operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __y); + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x); + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x); + +template +class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine +{ +public: + // types + typedef _UIntType result_type; + +private: + result_type __x_[__n]; + size_t __i_; + + static_assert( 0 < __m, "mersenne_twister_engine invalid parameters"); + static_assert(__m <= __n, "mersenne_twister_engine invalid parameters"); + static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits::digits; + static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters"); + static_assert( 2 <= __w, "mersenne_twister_engine invalid parameters"); + static_assert(__r <= __w, "mersenne_twister_engine invalid parameters"); + static_assert(__u <= __w, "mersenne_twister_engine invalid parameters"); + static_assert(__s <= __w, "mersenne_twister_engine invalid parameters"); + static_assert(__t <= __w, "mersenne_twister_engine invalid parameters"); + static_assert(__l <= __w, "mersenne_twister_engine invalid parameters"); +public: + static _LIBCPP_CONSTEXPR const result_type _Min = 0; + static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) : + (result_type(1) << __w) - result_type(1); + static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters"); + static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters"); + static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters"); + static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters"); + static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters"); + static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters"); + + // engine characteristics + static _LIBCPP_CONSTEXPR const size_t word_size = __w; + static _LIBCPP_CONSTEXPR const size_t state_size = __n; + static _LIBCPP_CONSTEXPR const size_t shift_size = __m; + static _LIBCPP_CONSTEXPR const size_t mask_bits = __r; + static _LIBCPP_CONSTEXPR const result_type xor_mask = __a; + static _LIBCPP_CONSTEXPR const size_t tempering_u = __u; + static _LIBCPP_CONSTEXPR const result_type tempering_d = __d; + static _LIBCPP_CONSTEXPR const size_t tempering_s = __s; + static _LIBCPP_CONSTEXPR const result_type tempering_b = __b; + static _LIBCPP_CONSTEXPR const size_t tempering_t = __t; + static _LIBCPP_CONSTEXPR const result_type tempering_c = __c; + static _LIBCPP_CONSTEXPR const size_t tempering_l = __l; + static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f; + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u; + + // constructors and seeding functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} + _LIBCPP_INLINE_VISIBILITY + explicit mersenne_twister_engine(result_type __sd) { seed(__sd); } +#else + _LIBCPP_INLINE_VISIBILITY + explicit mersenne_twister_engine(result_type __sd = default_seed) { + seed(__sd); + } +#endif + template + _LIBCPP_INLINE_VISIBILITY + explicit mersenne_twister_engine(_Sseq& __q, + typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0) + {seed(__q);} + void seed(result_type __sd = default_seed); + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __is_seed_sequence<_Sseq, mersenne_twister_engine>::value, + void + >::type + seed(_Sseq& __q) + {__seed(__q, integral_constant());} + + // generating functions + result_type operator()(); + _LIBCPP_INLINE_VISIBILITY + void discard(unsigned long long __z) {for (; __z; --__z) operator()();} + + template + friend + bool + operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __y); + + template + friend + bool + operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __y); + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x); +private: + + template + void __seed(_Sseq& __q, integral_constant); + template + void __seed(_Sseq& __q, integral_constant); + + template + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + __count < __w, + result_type + >::type + __lshift(result_type __x) {return (__x << __count) & _Max;} + + template + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + (__count >= __w), + result_type + >::type + __lshift(result_type) {return result_type(0);} + + template + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + __count < _Dt, + result_type + >::type + __rshift(result_type __x) {return __x >> __count;} + + template + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + (__count >= _Dt), + result_type + >::type + __rshift(result_type) {return result_type(0);} +}; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits; + +template + _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u; + +template + _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s; + +template + _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t; + +template + _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c; + +template + _LIBCPP_CONSTEXPR const size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l; + +template + _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier; + +template + _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed; + +template +void +mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, + __t, __c, __l, __f>::seed(result_type __sd) + _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK +{ // __w >= 2 + __x_[0] = __sd & _Max; + for (size_t __i = 1; __i < __n; ++__i) + __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max; + __i_ = 0; +} + +template +template +void +mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, + __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant) +{ + const unsigned __k = 1; + uint32_t __ar[__n * __k]; + __q.generate(__ar, __ar + __n * __k); + for (size_t __i = 0; __i < __n; ++__i) + __x_[__i] = static_cast(__ar[__i] & _Max); + const result_type __mask = __r == _Dt ? result_type(~0) : + (result_type(1) << __r) - result_type(1); + __i_ = 0; + if ((__x_[0] & ~__mask) == 0) + { + for (size_t __i = 1; __i < __n; ++__i) + if (__x_[__i] != 0) + return; + __x_[0] = result_type(1) << (__w - 1); + } +} + +template +template +void +mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, + __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant) +{ + const unsigned __k = 2; + uint32_t __ar[__n * __k]; + __q.generate(__ar, __ar + __n * __k); + for (size_t __i = 0; __i < __n; ++__i) + __x_[__i] = static_cast( + (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max); + const result_type __mask = __r == _Dt ? result_type(~0) : + (result_type(1) << __r) - result_type(1); + __i_ = 0; + if ((__x_[0] & ~__mask) == 0) + { + for (size_t __i = 1; __i < __n; ++__i) + if (__x_[__i] != 0) + return; + __x_[0] = result_type(1) << (__w - 1); + } +} + +template +_UIntType +mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, + __t, __c, __l, __f>::operator()() +{ + const size_t __j = (__i_ + 1) % __n; + const result_type __mask = __r == _Dt ? result_type(~0) : + (result_type(1) << __r) - result_type(1); + const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask); + const size_t __k = (__i_ + __m) % __n; + __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1)); + result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d); + __i_ = __j; + __z ^= __lshift<__s>(__z) & __b; + __z ^= __lshift<__t>(__z) & __c; + return __z ^ __rshift<__l>(__z); +} + +template +bool +operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __y) +{ + if (__x.__i_ == __y.__i_) + return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_); + if (__x.__i_ == 0 || __y.__i_ == 0) + { + size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_); + if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, + __y.__x_ + __y.__i_)) + return false; + if (__x.__i_ == 0) + return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_); + return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j); + } + if (__x.__i_ < __y.__i_) + { + size_t __j = _Np - __y.__i_; + if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), + __y.__x_ + __y.__i_)) + return false; + if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, + __y.__x_)) + return false; + return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_, + __y.__x_ + (_Np - (__x.__i_ + __j))); + } + size_t __j = _Np - __x.__i_; + if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), + __x.__x_ + __x.__i_)) + return false; + if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, + __x.__x_)) + return false; + return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_, + __x.__x_ + (_Np - (__y.__i_ + __j))); +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __y) +{ + return !(__x == __y); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _Ostream; + __os.flags(_Ostream::dec | _Ostream::left); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.__x_[__x.__i_]; + for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j) + __os << __sp << __x.__x_[__j]; + for (size_t __j = 0; __j < __x.__i_; ++__j) + __os << __sp << __x.__x_[__j]; + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, + _Bp, _Tp, _Cp, _Lp, _Fp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + _UInt __t[_Np]; + for (size_t __i = 0; __i < _Np; ++__i) + __is >> __t[__i]; + if (!__is.fail()) + { + for (size_t __i = 0; __i < _Np; ++__i) + __x.__x_[__i] = __t[__i]; + __x.__i_ = 0; + } + return __is; +} + +typedef mersenne_twister_engine mt19937; +typedef mersenne_twister_engine mt19937_64; + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H diff --git a/libcxx/include/__random/negative_binomial_distribution.h b/libcxx/include/__random/negative_binomial_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/negative_binomial_distribution.h @@ -0,0 +1,176 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H + +#include <__config> +#include <__random/bernoulli_distribution.h> +#include <__random/gamma_distribution.h> +#include <__random/poisson_distribution.h> +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution +{ +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __k_; + double __p_; + public: + typedef negative_binomial_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __k = 1, double __p = 0.5) + : __k_(__k), __p_(__p) {} + + _LIBCPP_INLINE_VISIBILITY + result_type k() const {return __k_;} + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + negative_binomial_distribution() : negative_binomial_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit negative_binomial_distribution(result_type __k, double __p = 0.5) + : __p_(__k, __p) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit negative_binomial_distribution(result_type __k = 1, + double __p = 0.5) + : __p_(__k, __p) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type k() const {return __p_.k();} + _LIBCPP_INLINE_VISIBILITY + double p() const {return __p_.p();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::max();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const negative_binomial_distribution& __x, + const negative_binomial_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const negative_binomial_distribution& __x, + const negative_binomial_distribution& __y) + {return !(__x == __y);} +}; + +template +template +_IntType +negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) +{ + result_type __k = __pr.k(); + double __p = __pr.p(); + if (__k <= 21 * __p) + { + bernoulli_distribution __gen(__p); + result_type __f = 0; + result_type __s = 0; + while (__s < __k) + { + if (__gen(__urng)) + ++__s; + else + ++__f; + } + return __f; + } + return poisson_distribution(gamma_distribution + (__k, (1-__p)/__p)(__urng))(__urng); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const negative_binomial_distribution<_IntType>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + return __os << __x.k() << __sp << __x.p(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + negative_binomial_distribution<_IntType>& __x) +{ + typedef negative_binomial_distribution<_IntType> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __k; + double __p; + __is >> __k >> __p; + if (!__is.fail()) + __x.param(param_type(__k, __p)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H diff --git a/libcxx/include/__random/normal_distribution.h b/libcxx/include/__random/normal_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/normal_distribution.h @@ -0,0 +1,208 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H + +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS normal_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __mean_; + result_type __stddev_; + public: + typedef normal_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __mean = 0, result_type __stddev = 1) + : __mean_(__mean), __stddev_(__stddev) {} + + _LIBCPP_INLINE_VISIBILITY + result_type mean() const {return __mean_;} + _LIBCPP_INLINE_VISIBILITY + result_type stddev() const {return __stddev_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + result_type _V_; + bool _V_hot_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + normal_distribution() : normal_distribution(0) {} + _LIBCPP_INLINE_VISIBILITY + explicit normal_distribution(result_type __mean, result_type __stddev = 1) + : __p_(param_type(__mean, __stddev)), _V_hot_(false) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit normal_distribution(result_type __mean = 0, + result_type __stddev = 1) + : __p_(param_type(__mean, __stddev)), _V_hot_(false) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit normal_distribution(const param_type& __p) + : __p_(__p), _V_hot_(false) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {_V_hot_ = false;} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type mean() const {return __p_.mean();} + _LIBCPP_INLINE_VISIBILITY + result_type stddev() const {return __p_.stddev();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return -numeric_limits::infinity();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const normal_distribution& __x, + const normal_distribution& __y) + {return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ && + (!__x._V_hot_ || __x._V_ == __y._V_);} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const normal_distribution& __x, + const normal_distribution& __y) + {return !(__x == __y);} + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const normal_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + normal_distribution<_RT>& __x); +}; + +template +template +_RealType +normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + result_type _Up; + if (_V_hot_) + { + _V_hot_ = false; + _Up = _V_; + } + else + { + uniform_real_distribution _Uni(-1, 1); + result_type __u; + result_type __v; + result_type __s; + do + { + __u = _Uni(__g); + __v = _Uni(__g); + __s = __u * __u + __v * __v; + } while (__s > 1 || __s == 0); + result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s); + _V_ = __v * _Fp; + _V_hot_ = true; + _Up = __u * _Fp; + } + return _Up * __p.stddev() + __p.mean(); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const normal_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_; + if (__x._V_hot_) + __os << __sp << __x._V_; + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + normal_distribution<_RT>& __x) +{ + typedef normal_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __mean; + result_type __stddev; + result_type _Vp = 0; + bool _V_hot = false; + __is >> __mean >> __stddev >> _V_hot; + if (_V_hot) + __is >> _Vp; + if (!__is.fail()) + { + __x.param(param_type(__mean, __stddev)); + __x._V_hot_ = _V_hot; + __x._V_ = _Vp; + } + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H diff --git a/libcxx/include/__random/piecewise_constant_distribution.h b/libcxx/include/__random/piecewise_constant_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/piecewise_constant_distribution.h @@ -0,0 +1,356 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H +#define _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H + +#include <__algorithm/upper_bound.h> +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + vector __b_; + vector __densities_; + vector __areas_; + public: + typedef piecewise_constant_distribution distribution_type; + + param_type(); + template + param_type(_InputIteratorB __fB, _InputIteratorB __lB, + _InputIteratorW __fW); +#ifndef _LIBCPP_CXX03_LANG + template + param_type(initializer_list __bl, _UnaryOperation __fw); +#endif // _LIBCPP_CXX03_LANG + template + param_type(size_t __nw, result_type __xmin, result_type __xmax, + _UnaryOperation __fw); + param_type(param_type const&) = default; + param_type & operator=(const param_type& __rhs); + + _LIBCPP_INLINE_VISIBILITY + vector intervals() const {return __b_;} + _LIBCPP_INLINE_VISIBILITY + vector densities() const {return __densities_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + + private: + void __init(); + + friend class piecewise_constant_distribution; + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const piecewise_constant_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + piecewise_constant_distribution<_RT>& __x); + }; + +private: + param_type __p_; + +public: + // constructor and reset functions + _LIBCPP_INLINE_VISIBILITY + piecewise_constant_distribution() {} + template + _LIBCPP_INLINE_VISIBILITY + piecewise_constant_distribution(_InputIteratorB __fB, + _InputIteratorB __lB, + _InputIteratorW __fW) + : __p_(__fB, __lB, __fW) {} + +#ifndef _LIBCPP_CXX03_LANG + template + _LIBCPP_INLINE_VISIBILITY + piecewise_constant_distribution(initializer_list __bl, + _UnaryOperation __fw) + : __p_(__bl, __fw) {} +#endif // _LIBCPP_CXX03_LANG + + template + _LIBCPP_INLINE_VISIBILITY + piecewise_constant_distribution(size_t __nw, result_type __xmin, + result_type __xmax, _UnaryOperation __fw) + : __p_(__nw, __xmin, __xmax, __fw) {} + + _LIBCPP_INLINE_VISIBILITY + explicit piecewise_constant_distribution(const param_type& __p) + : __p_(__p) {} + + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + vector intervals() const {return __p_.intervals();} + _LIBCPP_INLINE_VISIBILITY + vector densities() const {return __p_.densities();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return __p_.__b_.front();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return __p_.__b_.back();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const piecewise_constant_distribution& __x, + const piecewise_constant_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const piecewise_constant_distribution& __x, + const piecewise_constant_distribution& __y) + {return !(__x == __y);} + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const piecewise_constant_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + piecewise_constant_distribution<_RT>& __x); +}; + +template +typename piecewise_constant_distribution<_RealType>::param_type & +piecewise_constant_distribution<_RealType>::param_type::operator= + (const param_type& __rhs) +{ +// These can throw + __b_.reserve (__rhs.__b_.size ()); + __densities_.reserve(__rhs.__densities_.size()); + __areas_.reserve (__rhs.__areas_.size()); + +// These can not throw + __b_ = __rhs.__b_; + __densities_ = __rhs.__densities_; + __areas_ = __rhs.__areas_; + return *this; +} + +template +void +piecewise_constant_distribution<_RealType>::param_type::__init() +{ + // __densities_ contains non-normalized areas + result_type __total_area = _VSTD::accumulate(__densities_.begin(), + __densities_.end(), + result_type()); + for (size_t __i = 0; __i < __densities_.size(); ++__i) + __densities_[__i] /= __total_area; + // __densities_ contains normalized areas + __areas_.assign(__densities_.size(), result_type()); + _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1, + __areas_.begin() + 1); + // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1] + __densities_.back() = 1 - __areas_.back(); // correct round off error + for (size_t __i = 0; __i < __densities_.size(); ++__i) + __densities_[__i] /= (__b_[__i+1] - __b_[__i]); + // __densities_ now contains __densities_ +} + +template +piecewise_constant_distribution<_RealType>::param_type::param_type() + : __b_(2), + __densities_(1, 1.0), + __areas_(1, 0.0) +{ + __b_[1] = 1; +} + +template +template +piecewise_constant_distribution<_RealType>::param_type::param_type( + _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW) + : __b_(__fB, __lB) +{ + if (__b_.size() < 2) + { + __b_.resize(2); + __b_[0] = 0; + __b_[1] = 1; + __densities_.assign(1, 1.0); + __areas_.assign(1, 0.0); + } + else + { + __densities_.reserve(__b_.size() - 1); + for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW) + __densities_.push_back(*__fW); + __init(); + } +} + +#ifndef _LIBCPP_CXX03_LANG + +template +template +piecewise_constant_distribution<_RealType>::param_type::param_type( + initializer_list __bl, _UnaryOperation __fw) + : __b_(__bl.begin(), __bl.end()) +{ + if (__b_.size() < 2) + { + __b_.resize(2); + __b_[0] = 0; + __b_[1] = 1; + __densities_.assign(1, 1.0); + __areas_.assign(1, 0.0); + } + else + { + __densities_.reserve(__b_.size() - 1); + for (size_t __i = 0; __i < __b_.size() - 1; ++__i) + __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5)); + __init(); + } +} + +#endif // _LIBCPP_CXX03_LANG + +template +template +piecewise_constant_distribution<_RealType>::param_type::param_type( + size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw) + : __b_(__nw == 0 ? 2 : __nw + 1) +{ + size_t __n = __b_.size() - 1; + result_type __d = (__xmax - __xmin) / __n; + __densities_.reserve(__n); + for (size_t __i = 0; __i < __n; ++__i) + { + __b_[__i] = __xmin + __i * __d; + __densities_.push_back(__fw(__b_[__i] + __d*.5)); + } + __b_[__n] = __xmax; + __init(); +} + +template +template +_RealType +piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + typedef uniform_real_distribution _Gen; + result_type __u = _Gen()(__g); + ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), + __u) - __p.__areas_.begin() - 1; + return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k]; +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const piecewise_constant_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + size_t __n = __x.__p_.__b_.size(); + __os << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__b_[__i]; + __n = __x.__p_.__densities_.size(); + __os << __sp << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__densities_[__i]; + __n = __x.__p_.__areas_.size(); + __os << __sp << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__areas_[__i]; + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + piecewise_constant_distribution<_RT>& __x) +{ + typedef piecewise_constant_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + size_t __n; + __is >> __n; + vector __b(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __b[__i]; + __is >> __n; + vector __densities(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __densities[__i]; + __is >> __n; + vector __areas(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __areas[__i]; + if (!__is.fail()) + { + swap(__x.__p_.__b_, __b); + swap(__x.__p_.__densities_, __densities); + swap(__x.__p_.__areas_, __areas); + } + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H diff --git a/libcxx/include/__random/piecewise_linear_distribution.h b/libcxx/include/__random/piecewise_linear_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/piecewise_linear_distribution.h @@ -0,0 +1,372 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H +#define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H + +#include <__algorithm/upper_bound.h> +#include <__config> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + vector __b_; + vector __densities_; + vector __areas_; + public: + typedef piecewise_linear_distribution distribution_type; + + param_type(); + template + param_type(_InputIteratorB __fB, _InputIteratorB __lB, + _InputIteratorW __fW); +#ifndef _LIBCPP_CXX03_LANG + template + param_type(initializer_list __bl, _UnaryOperation __fw); +#endif // _LIBCPP_CXX03_LANG + template + param_type(size_t __nw, result_type __xmin, result_type __xmax, + _UnaryOperation __fw); + param_type(param_type const&) = default; + param_type & operator=(const param_type& __rhs); + + _LIBCPP_INLINE_VISIBILITY + vector intervals() const {return __b_;} + _LIBCPP_INLINE_VISIBILITY + vector densities() const {return __densities_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + + private: + void __init(); + + friend class piecewise_linear_distribution; + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const piecewise_linear_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + piecewise_linear_distribution<_RT>& __x); + }; + +private: + param_type __p_; + +public: + // constructor and reset functions + _LIBCPP_INLINE_VISIBILITY + piecewise_linear_distribution() {} + template + _LIBCPP_INLINE_VISIBILITY + piecewise_linear_distribution(_InputIteratorB __fB, + _InputIteratorB __lB, + _InputIteratorW __fW) + : __p_(__fB, __lB, __fW) {} + +#ifndef _LIBCPP_CXX03_LANG + template + _LIBCPP_INLINE_VISIBILITY + piecewise_linear_distribution(initializer_list __bl, + _UnaryOperation __fw) + : __p_(__bl, __fw) {} +#endif // _LIBCPP_CXX03_LANG + + template + _LIBCPP_INLINE_VISIBILITY + piecewise_linear_distribution(size_t __nw, result_type __xmin, + result_type __xmax, _UnaryOperation __fw) + : __p_(__nw, __xmin, __xmax, __fw) {} + + _LIBCPP_INLINE_VISIBILITY + explicit piecewise_linear_distribution(const param_type& __p) + : __p_(__p) {} + + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + vector intervals() const {return __p_.intervals();} + _LIBCPP_INLINE_VISIBILITY + vector densities() const {return __p_.densities();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return __p_.__b_.front();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return __p_.__b_.back();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const piecewise_linear_distribution& __x, + const piecewise_linear_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const piecewise_linear_distribution& __x, + const piecewise_linear_distribution& __y) + {return !(__x == __y);} + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const piecewise_linear_distribution<_RT>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + piecewise_linear_distribution<_RT>& __x); +}; + +template +typename piecewise_linear_distribution<_RealType>::param_type & +piecewise_linear_distribution<_RealType>::param_type::operator= + (const param_type& __rhs) +{ +// These can throw + __b_.reserve (__rhs.__b_.size ()); + __densities_.reserve(__rhs.__densities_.size()); + __areas_.reserve (__rhs.__areas_.size()); + +// These can not throw + __b_ = __rhs.__b_; + __densities_ = __rhs.__densities_; + __areas_ = __rhs.__areas_; + return *this; +} + + +template +void +piecewise_linear_distribution<_RealType>::param_type::__init() +{ + __areas_.assign(__densities_.size() - 1, result_type()); + result_type _Sp = 0; + for (size_t __i = 0; __i < __areas_.size(); ++__i) + { + __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) * + (__b_[__i+1] - __b_[__i]) * .5; + _Sp += __areas_[__i]; + } + for (size_t __i = __areas_.size(); __i > 1;) + { + --__i; + __areas_[__i] = __areas_[__i-1] / _Sp; + } + __areas_[0] = 0; + for (size_t __i = 1; __i < __areas_.size(); ++__i) + __areas_[__i] += __areas_[__i-1]; + for (size_t __i = 0; __i < __densities_.size(); ++__i) + __densities_[__i] /= _Sp; +} + +template +piecewise_linear_distribution<_RealType>::param_type::param_type() + : __b_(2), + __densities_(2, 1.0), + __areas_(1, 0.0) +{ + __b_[1] = 1; +} + +template +template +piecewise_linear_distribution<_RealType>::param_type::param_type( + _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW) + : __b_(__fB, __lB) +{ + if (__b_.size() < 2) + { + __b_.resize(2); + __b_[0] = 0; + __b_[1] = 1; + __densities_.assign(2, 1.0); + __areas_.assign(1, 0.0); + } + else + { + __densities_.reserve(__b_.size()); + for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW) + __densities_.push_back(*__fW); + __init(); + } +} + +#ifndef _LIBCPP_CXX03_LANG + +template +template +piecewise_linear_distribution<_RealType>::param_type::param_type( + initializer_list __bl, _UnaryOperation __fw) + : __b_(__bl.begin(), __bl.end()) +{ + if (__b_.size() < 2) + { + __b_.resize(2); + __b_[0] = 0; + __b_[1] = 1; + __densities_.assign(2, 1.0); + __areas_.assign(1, 0.0); + } + else + { + __densities_.reserve(__b_.size()); + for (size_t __i = 0; __i < __b_.size(); ++__i) + __densities_.push_back(__fw(__b_[__i])); + __init(); + } +} + +#endif // _LIBCPP_CXX03_LANG + +template +template +piecewise_linear_distribution<_RealType>::param_type::param_type( + size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw) + : __b_(__nw == 0 ? 2 : __nw + 1) +{ + size_t __n = __b_.size() - 1; + result_type __d = (__xmax - __xmin) / __n; + __densities_.reserve(__b_.size()); + for (size_t __i = 0; __i < __n; ++__i) + { + __b_[__i] = __xmin + __i * __d; + __densities_.push_back(__fw(__b_[__i])); + } + __b_[__n] = __xmax; + __densities_.push_back(__fw(__b_[__n])); + __init(); +} + +template +template +_RealType +piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + typedef uniform_real_distribution _Gen; + result_type __u = _Gen()(__g); + ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), + __u) - __p.__areas_.begin() - 1; + __u -= __p.__areas_[__k]; + const result_type __dk = __p.__densities_[__k]; + const result_type __dk1 = __p.__densities_[__k+1]; + const result_type __deltad = __dk1 - __dk; + const result_type __bk = __p.__b_[__k]; + if (__deltad == 0) + return __u / __dk + __bk; + const result_type __bk1 = __p.__b_[__k+1]; + const result_type __deltab = __bk1 - __bk; + return (__bk * __dk1 - __bk1 * __dk + + _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / + __deltad; +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const piecewise_linear_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + size_t __n = __x.__p_.__b_.size(); + __os << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__b_[__i]; + __n = __x.__p_.__densities_.size(); + __os << __sp << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__densities_[__i]; + __n = __x.__p_.__areas_.size(); + __os << __sp << __n; + for (size_t __i = 0; __i < __n; ++__i) + __os << __sp << __x.__p_.__areas_[__i]; + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + piecewise_linear_distribution<_RT>& __x) +{ + typedef piecewise_linear_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + size_t __n; + __is >> __n; + vector __b(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __b[__i]; + __is >> __n; + vector __densities(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __densities[__i]; + __is >> __n; + vector __areas(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __areas[__i]; + if (!__is.fail()) + { + swap(__x.__p_.__b_, __b); + swap(__x.__p_.__densities_, __densities); + swap(__x.__p_.__areas_, __areas); + } + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H diff --git a/libcxx/include/__random/poisson_distribution.h b/libcxx/include/__random/poisson_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/poisson_distribution.h @@ -0,0 +1,276 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H +#define _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H + +#include <__config> +#include <__random/exponential_distribution.h> +#include <__random/normal_distribution.h> +#include <__random/uniform_real_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS poisson_distribution +{ +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + double __mean_; + double __s_; + double __d_; + double __l_; + double __omega_; + double __c0_; + double __c1_; + double __c2_; + double __c3_; + double __c_; + + public: + typedef poisson_distribution distribution_type; + + explicit param_type(double __mean = 1.0); + + _LIBCPP_INLINE_VISIBILITY + double mean() const {return __mean_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__mean_ == __y.__mean_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + + friend class poisson_distribution; + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + poisson_distribution() : poisson_distribution(1.0) {} + _LIBCPP_INLINE_VISIBILITY + explicit poisson_distribution(double __mean) + : __p_(__mean) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit poisson_distribution(double __mean = 1.0) + : __p_(__mean) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit poisson_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + double mean() const {return __p_.mean();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::max();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const poisson_distribution& __x, + const poisson_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const poisson_distribution& __x, + const poisson_distribution& __y) + {return !(__x == __y);} +}; + +template +poisson_distribution<_IntType>::param_type::param_type(double __mean) + // According to the standard `inf` is a valid input, but it causes the + // distribution to hang, so we replace it with the maximum representable + // mean. + : __mean_(isinf(__mean) ? numeric_limits::max() : __mean) +{ + if (__mean_ < 10) + { + __s_ = 0; + __d_ = 0; + __l_ = _VSTD::exp(-__mean_); + __omega_ = 0; + __c3_ = 0; + __c2_ = 0; + __c1_ = 0; + __c0_ = 0; + __c_ = 0; + } + else + { + __s_ = _VSTD::sqrt(__mean_); + __d_ = 6 * __mean_ * __mean_; + __l_ = _VSTD::trunc(__mean_ - 1.1484); + __omega_ = .3989423 / __s_; + double __b1_ = .4166667E-1 / __mean_; + double __b2_ = .3 * __b1_ * __b1_; + __c3_ = .1428571 * __b1_ * __b2_; + __c2_ = __b2_ - 15. * __c3_; + __c1_ = __b1_ - 6. * __b2_ + 45. * __c3_; + __c0_ = 1. - __b1_ + 3. * __b2_ - 15. * __c3_; + __c_ = .1069 / __mean_; + } +} + +template +template +_IntType +poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) +{ + double __tx; + uniform_real_distribution __urd; + if (__pr.__mean_ < 10) + { + __tx = 0; + for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx) + __p *= __urd(__urng); + } + else + { + double __difmuk; + double __g = __pr.__mean_ + __pr.__s_ * normal_distribution()(__urng); + double __u; + if (__g > 0) + { + __tx = _VSTD::trunc(__g); + if (__tx >= __pr.__l_) + return _VSTD::__clamp_to_integral(__tx); + __difmuk = __pr.__mean_ - __tx; + __u = __urd(__urng); + if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk) + return _VSTD::__clamp_to_integral(__tx); + } + exponential_distribution __edist; + for (bool __using_exp_dist = false; true; __using_exp_dist = true) + { + double __e; + if (__using_exp_dist || __g <= 0) + { + double __t; + do + { + __e = __edist(__urng); + __u = __urd(__urng); + __u += __u - 1; + __t = 1.8 + (__u < 0 ? -__e : __e); + } while (__t <= -.6744); + __tx = _VSTD::trunc(__pr.__mean_ + __pr.__s_ * __t); + __difmuk = __pr.__mean_ - __tx; + __using_exp_dist = true; + } + double __px; + double __py; + if (__tx < 10 && __tx >= 0) + { + const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, + 40320, 362880}; + __px = -__pr.__mean_; + __py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast(__tx)]; + } + else + { + double __del = .8333333E-1 / __tx; + __del -= 4.8 * __del * __del * __del; + double __v = __difmuk / __tx; + if (_VSTD::abs(__v) > 0.25) + __px = __tx * _VSTD::log(1 + __v) - __difmuk - __del; + else + __px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) * + __v + .1421878) * __v + -.1661269) * __v + .2000118) * + __v + -.2500068) * __v + .3333333) * __v + -.5) - __del; + __py = .3989423 / _VSTD::sqrt(__tx); + } + double __r = (0.5 - __difmuk) / __pr.__s_; + double __r2 = __r * __r; + double __fx = -0.5 * __r2; + double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) * + __r2 + __pr.__c1_) * __r2 + __pr.__c0_); + if (__using_exp_dist) + { + if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) - + __fy * _VSTD::exp(__fx + __e)) + break; + } + else + { + if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx)) + break; + } + } + } + return _VSTD::__clamp_to_integral(__tx); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const poisson_distribution<_IntType>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + return __os << __x.mean(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + poisson_distribution<_IntType>& __x) +{ + typedef poisson_distribution<_IntType> _Eng; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + double __mean; + __is >> __mean; + if (!__is.fail()) + __x.param(param_type(__mean)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H diff --git a/libcxx/include/__random/random_device.h b/libcxx/include/__random/random_device.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/random_device.h @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_RANDOM_DEVICE_H +#define _LIBCPP___RANDOM_RANDOM_DEVICE_H + +#include <__config> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE) + +class _LIBCPP_TYPE_VIS random_device +{ +#ifdef _LIBCPP_USING_DEV_RANDOM + int __f_; +#endif // defined(_LIBCPP_USING_DEV_RANDOM) +public: + // types + typedef unsigned result_type; + + // generator characteristics + static _LIBCPP_CONSTEXPR const result_type _Min = 0; + static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu; + + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() { return _Min;} + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() { return _Max;} + + // constructors +#ifndef _LIBCPP_CXX03_LANG + random_device() : random_device("/dev/urandom") {} + explicit random_device(const string& __token); +#else + explicit random_device(const string& __token = "/dev/urandom"); +#endif + ~random_device(); + + // generating functions + result_type operator()(); + + // property functions + double entropy() const _NOEXCEPT; + +private: + // no copy functions + random_device(const random_device&); // = delete; + random_device& operator=(const random_device&); // = delete; +}; + +#endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_RANDOM_DEVICE_H diff --git a/libcxx/include/__random/ranlux.h b/libcxx/include/__random/ranlux.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/ranlux.h @@ -0,0 +1,31 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_RANLUX_H +#define _LIBCPP___RANDOM_RANLUX_H + +#include <__config> +#include <__random/discard_block_engine.h> +#include <__random/subtract_with_carry_engine.h> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +typedef subtract_with_carry_engine ranlux24_base; +typedef subtract_with_carry_engine ranlux48_base; + +typedef discard_block_engine ranlux24; +typedef discard_block_engine ranlux48; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_RANLUX_H diff --git a/libcxx/include/__random/seed_seq.h b/libcxx/include/__random/seed_seq.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/seed_seq.h @@ -0,0 +1,150 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_SEED_SEQ_H +#define _LIBCPP___RANDOM_SEED_SEQ_H + +#include <__algorithm/copy.h> +#include <__algorithm/fill.h> +#include <__algorithm/max.h> +#include <__config> +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +class _LIBCPP_TEMPLATE_VIS seed_seq +{ +public: + // types + typedef uint32_t result_type; + +private: + vector __v_; + + template + void init(_InputIterator __first, _InputIterator __last); +public: + // constructors + _LIBCPP_INLINE_VISIBILITY + seed_seq() _NOEXCEPT {} +#ifndef _LIBCPP_CXX03_LANG + template + _LIBCPP_INLINE_VISIBILITY + seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());} +#endif // _LIBCPP_CXX03_LANG + + template + _LIBCPP_INLINE_VISIBILITY + seed_seq(_InputIterator __first, _InputIterator __last) + {init(__first, __last);} + + // generating functions + template + void generate(_RandomAccessIterator __first, _RandomAccessIterator __last); + + // property functions + _LIBCPP_INLINE_VISIBILITY + size_t size() const _NOEXCEPT {return __v_.size();} + template + _LIBCPP_INLINE_VISIBILITY + void param(_OutputIterator __dest) const + {_VSTD::copy(__v_.begin(), __v_.end(), __dest);} + +private: + // no copy functions + seed_seq(const seed_seq&); // = delete; + void operator=(const seed_seq&); // = delete; + + _LIBCPP_INLINE_VISIBILITY + static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);} +}; + +template +void +seed_seq::init(_InputIterator __first, _InputIterator __last) +{ + for (_InputIterator __s = __first; __s != __last; ++__s) + __v_.push_back(*__s & 0xFFFFFFFF); +} + +template +void +seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last) +{ + if (__first != __last) + { + _VSTD::fill(__first, __last, 0x8b8b8b8b); + const size_t __n = static_cast(__last - __first); + const size_t __s = __v_.size(); + const size_t __t = (__n >= 623) ? 11 + : (__n >= 68) ? 7 + : (__n >= 39) ? 5 + : (__n >= 7) ? 3 + : (__n - 1) / 2; + const size_t __p = (__n - __t) / 2; + const size_t __q = __p + __t; + const size_t __m = _VSTD::max(__s + 1, __n); + // __k = 0; + { + result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p] + ^ __first[__n - 1]); + __first[__p] += __r; + __r += __s; + __first[__q] += __r; + __first[0] = __r; + } + for (size_t __k = 1; __k <= __s; ++__k) + { + const size_t __kmodn = __k % __n; + const size_t __kpmodn = (__k + __p) % __n; + result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] + ^ __first[(__k - 1) % __n]); + __first[__kpmodn] += __r; + __r += __kmodn + __v_[__k-1]; + __first[(__k + __q) % __n] += __r; + __first[__kmodn] = __r; + } + for (size_t __k = __s + 1; __k < __m; ++__k) + { + const size_t __kmodn = __k % __n; + const size_t __kpmodn = (__k + __p) % __n; + result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] + ^ __first[(__k - 1) % __n]); + __first[__kpmodn] += __r; + __r += __kmodn; + __first[(__k + __q) % __n] += __r; + __first[__kmodn] = __r; + } + for (size_t __k = __m; __k < __m + __n; ++__k) + { + const size_t __kmodn = __k % __n; + const size_t __kpmodn = (__k + __p) % __n; + result_type __r = 1566083941 * _Tp(__first[__kmodn] + + __first[__kpmodn] + + __first[(__k - 1) % __n]); + __first[__kpmodn] ^= __r; + __r -= __kmodn; + __first[(__k + __q) % __n] ^= __r; + __first[__kmodn] = __r; + } + } +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_SEED_SEQ_H diff --git a/libcxx/include/__random/shuffle_order_engine.h b/libcxx/include/__random/shuffle_order_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/shuffle_order_engine.h @@ -0,0 +1,283 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H +#define _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H + +#include <__algorithm/equal.h> +#include <__config> +#include <__random/is_seed_sequence.h> +#include <__utility/move.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +struct __ugcd +{ + static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value; +}; + +template +struct __ugcd<_Xp, 0> +{ + static _LIBCPP_CONSTEXPR const uint64_t value = _Xp; +}; + +template +class __uratio +{ + static_assert(_Dp != 0, "__uratio divide by 0"); + static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value; +public: + static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd; + static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd; + + typedef __uratio type; +}; + +template +class _LIBCPP_TEMPLATE_VIS shuffle_order_engine +{ + static_assert(0 < __k, "shuffle_order_engine invalid parameters"); +public: + // types + typedef typename _Engine::result_type result_type; + +private: + _Engine __e_; + result_type _V_[__k]; + result_type _Y_; + +public: + // engine characteristics + static _LIBCPP_CONSTEXPR const size_t table_size = __k; + +#ifdef _LIBCPP_CXX03_LANG + static const result_type _Min = _Engine::_Min; + static const result_type _Max = _Engine::_Max; +#else + static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min(); + static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max(); +#endif + static_assert(_Min < _Max, "shuffle_order_engine invalid parameters"); + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + + static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull; + + // constructors and seeding functions + _LIBCPP_INLINE_VISIBILITY + shuffle_order_engine() {__init();} + _LIBCPP_INLINE_VISIBILITY + explicit shuffle_order_engine(const _Engine& __e) + : __e_(__e) {__init();} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + explicit shuffle_order_engine(_Engine&& __e) + : __e_(_VSTD::move(__e)) {__init();} +#endif // _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();} + template + _LIBCPP_INLINE_VISIBILITY + explicit shuffle_order_engine(_Sseq& __q, + typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value && + !is_convertible<_Sseq, _Engine>::value>::type* = 0) + : __e_(__q) {__init();} + _LIBCPP_INLINE_VISIBILITY + void seed() {__e_.seed(); __init();} + _LIBCPP_INLINE_VISIBILITY + void seed(result_type __sd) {__e_.seed(__sd); __init();} + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __is_seed_sequence<_Sseq, shuffle_order_engine>::value, + void + >::type + seed(_Sseq& __q) {__e_.seed(__q); __init();} + + // generating functions + _LIBCPP_INLINE_VISIBILITY + result_type operator()() {return __eval(integral_constant());} + _LIBCPP_INLINE_VISIBILITY + void discard(unsigned long long __z) {for (; __z; --__z) operator()();} + + // property functions + _LIBCPP_INLINE_VISIBILITY + const _Engine& base() const _NOEXCEPT {return __e_;} + +private: + template + friend + bool + operator==( + const shuffle_order_engine<_Eng, _Kp>& __x, + const shuffle_order_engine<_Eng, _Kp>& __y); + + template + friend + bool + operator!=( + const shuffle_order_engine<_Eng, _Kp>& __x, + const shuffle_order_engine<_Eng, _Kp>& __y); + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const shuffle_order_engine<_Eng, _Kp>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + shuffle_order_engine<_Eng, _Kp>& __x); + + _LIBCPP_INLINE_VISIBILITY + void __init() + { + for (size_t __i = 0; __i < __k; ++__i) + _V_[__i] = __e_(); + _Y_ = __e_(); + } + + _LIBCPP_INLINE_VISIBILITY + result_type __eval(false_type) {return __eval2(integral_constant());} + _LIBCPP_INLINE_VISIBILITY + result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());} + + _LIBCPP_INLINE_VISIBILITY + result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());} + _LIBCPP_INLINE_VISIBILITY + result_type __eval2(true_type) {return __evalf<__k, 0>();} + + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)), + result_type + >::type + __eval(__uratio<_Np, _Dp>) + {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();} + + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min), + result_type + >::type + __eval(__uratio<_Np, _Dp>) + { + const size_t __j = static_cast(__uratio<_Np, _Dp>::num * (_Y_ - _Min) + / __uratio<_Np, _Dp>::den); + _Y_ = _V_[__j]; + _V_[__j] = __e_(); + return _Y_; + } + + template + _LIBCPP_INLINE_VISIBILITY + result_type __evalf() + { + const double _Fp = __d == 0 ? + __n / (2. * 0x8000000000000000ull) : + __n / (double)__d; + const size_t __j = static_cast(_Fp * (_Y_ - _Min)); + _Y_ = _V_[__j]; + _V_[__j] = __e_(); + return _Y_; + } +}; + +template + _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size; + +template +bool +operator==( + const shuffle_order_engine<_Eng, _Kp>& __x, + const shuffle_order_engine<_Eng, _Kp>& __y) +{ + return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) && + __x.__e_ == __y.__e_; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=( + const shuffle_order_engine<_Eng, _Kp>& __x, + const shuffle_order_engine<_Eng, _Kp>& __y) +{ + return !(__x == __y); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const shuffle_order_engine<_Eng, _Kp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _Ostream; + __os.flags(_Ostream::dec | _Ostream::left); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.__e_ << __sp << __x._V_[0]; + for (size_t __i = 1; __i < _Kp; ++__i) + __os << __sp << __x._V_[__i]; + return __os << __sp << __x._Y_; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + shuffle_order_engine<_Eng, _Kp>& __x) +{ + typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + _Eng __e; + result_type _Vp[_Kp+1]; + __is >> __e; + for (size_t __i = 0; __i < _Kp+1; ++__i) + __is >> _Vp[__i]; + if (!__is.fail()) + { + __x.__e_ = __e; + for (size_t __i = 0; __i < _Kp; ++__i) + __x._V_[__i] = _Vp[__i]; + __x._Y_ = _Vp[_Kp]; + } + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H diff --git a/libcxx/include/__random/student_t_distribution.h b/libcxx/include/__random/student_t_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/student_t_distribution.h @@ -0,0 +1,153 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H +#define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H + +#include <__config> +#include <__random/gamma_distribution.h> +#include <__random/normal_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS student_t_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __n_; + public: + typedef student_t_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __n = 1) : __n_(__n) {} + + _LIBCPP_INLINE_VISIBILITY + result_type n() const {return __n_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__n_ == __y.__n_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + normal_distribution __nd_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + student_t_distribution() : student_t_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit student_t_distribution(result_type __n) + : __p_(param_type(__n)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit student_t_distribution(result_type __n = 1) + : __p_(param_type(__n)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit student_t_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {__nd_.reset();} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type n() const {return __p_.n();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return -numeric_limits::infinity();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const student_t_distribution& __x, + const student_t_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const student_t_distribution& __x, + const student_t_distribution& __y) + {return !(__x == __y);} +}; + +template +template +_RealType +student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + gamma_distribution __gd(__p.n() * .5, 2); + return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g)); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const student_t_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + __os << __x.n(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + student_t_distribution<_RT>& __x) +{ + typedef student_t_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __n; + __is >> __n; + if (!__is.fail()) + __x.param(param_type(__n)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H diff --git a/libcxx/include/__random/subtract_with_carry_engine.h b/libcxx/include/__random/subtract_with_carry_engine.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/subtract_with_carry_engine.h @@ -0,0 +1,352 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_SUBTRACT_WITH_CARRY_ENGINE_H +#define _LIBCPP___RANDOM_SUBTRACT_WITH_CARRY_ENGINE_H + +#include <__algorithm/equal.h> +#include <__algorithm/min.h> +#include <__config> +#include <__random/is_seed_sequence.h> +#include <__random/linear_congruential_engine.h> +#include +#include +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine; + +template +bool +operator==( + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + +template +_LIBCPP_INLINE_VISIBILITY +bool +operator!=( + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + +template +class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine +{ +public: + // types + typedef _UIntType result_type; + +private: + result_type __x_[__r]; + result_type __c_; + size_t __i_; + + static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits::digits; + static_assert( 0 < __w, "subtract_with_carry_engine invalid parameters"); + static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters"); + static_assert( 0 < __s, "subtract_with_carry_engine invalid parameters"); + static_assert(__s < __r, "subtract_with_carry_engine invalid parameters"); +public: + static _LIBCPP_CONSTEXPR const result_type _Min = 0; + static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) : + (result_type(1) << __w) - result_type(1); + static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters"); + + // engine characteristics + static _LIBCPP_CONSTEXPR const size_t word_size = __w; + static _LIBCPP_CONSTEXPR const size_t short_lag = __s; + static _LIBCPP_CONSTEXPR const size_t long_lag = __r; + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_INLINE_VISIBILITY + static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u; + + // constructors and seeding functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} + _LIBCPP_INLINE_VISIBILITY + explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); } +#else + _LIBCPP_INLINE_VISIBILITY + explicit subtract_with_carry_engine(result_type __sd = default_seed) { + seed(__sd); + } +#endif + template + _LIBCPP_INLINE_VISIBILITY + explicit subtract_with_carry_engine(_Sseq& __q, + typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0) + {seed(__q);} + _LIBCPP_INLINE_VISIBILITY + void seed(result_type __sd = default_seed) + {seed(__sd, integral_constant());} + template + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, + void + >::type + seed(_Sseq& __q) + {__seed(__q, integral_constant());} + + // generating functions + result_type operator()(); + _LIBCPP_INLINE_VISIBILITY + void discard(unsigned long long __z) {for (; __z; --__z) operator()();} + + template + friend + bool + operator==( + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + + template + friend + bool + operator!=( + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + + template + friend + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + + template + friend + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + +private: + + void seed(result_type __sd, integral_constant); + void seed(result_type __sd, integral_constant); + template + void __seed(_Sseq& __q, integral_constant); + template + void __seed(_Sseq& __q, integral_constant); +}; + +template + _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size; + +template + _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag; + +template + _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag; + +template + _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type + subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed; + +template +void +subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, + integral_constant) +{ + linear_congruential_engine + __e(__sd == 0u ? default_seed : __sd); + for (size_t __i = 0; __i < __r; ++__i) + __x_[__i] = static_cast(__e() & _Max); + __c_ = __x_[__r-1] == 0; + __i_ = 0; +} + +template +void +subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, + integral_constant) +{ + linear_congruential_engine + __e(__sd == 0u ? default_seed : __sd); + for (size_t __i = 0; __i < __r; ++__i) + { + result_type __e0 = __e(); + __x_[__i] = static_cast( + (__e0 + ((uint64_t)__e() << 32)) & _Max); + } + __c_ = __x_[__r-1] == 0; + __i_ = 0; +} + +template +template +void +subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, + integral_constant) +{ + const unsigned __k = 1; + uint32_t __ar[__r * __k]; + __q.generate(__ar, __ar + __r * __k); + for (size_t __i = 0; __i < __r; ++__i) + __x_[__i] = static_cast(__ar[__i] & _Max); + __c_ = __x_[__r-1] == 0; + __i_ = 0; +} + +template +template +void +subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, + integral_constant) +{ + const unsigned __k = 2; + uint32_t __ar[__r * __k]; + __q.generate(__ar, __ar + __r * __k); + for (size_t __i = 0; __i < __r; ++__i) + __x_[__i] = static_cast( + (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max); + __c_ = __x_[__r-1] == 0; + __i_ = 0; +} + +template +_UIntType +subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()() +{ + const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r]; + result_type& __xr = __x_[__i_]; + result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1; + __xr = (__xs - __xr - __c_) & _Max; + __c_ = __new_c; + __i_ = (__i_ + 1) % __r; + return __xr; +} + +template +bool +operator==( + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) +{ + if (__x.__c_ != __y.__c_) + return false; + if (__x.__i_ == __y.__i_) + return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_); + if (__x.__i_ == 0 || __y.__i_ == 0) + { + size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_); + if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, + __y.__x_ + __y.__i_)) + return false; + if (__x.__i_ == 0) + return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_); + return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j); + } + if (__x.__i_ < __y.__i_) + { + size_t __j = _Rp - __y.__i_; + if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), + __y.__x_ + __y.__i_)) + return false; + if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, + __y.__x_)) + return false; + return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_, + __y.__x_ + (_Rp - (__x.__i_ + __j))); + } + size_t __j = _Rp - __x.__i_; + if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), + __x.__x_ + __x.__i_)) + return false; + if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, + __x.__x_)) + return false; + return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_, + __x.__x_ + (_Rp - (__y.__i_ + __j))); +} + +template +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=( + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) +{ + return !(__x == __y); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _Ostream; + __os.flags(_Ostream::dec | _Ostream::left); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.__x_[__x.__i_]; + for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j) + __os << __sp << __x.__x_[__j]; + for (size_t __j = 0; __j < __x.__i_; ++__j) + __os << __sp << __x.__x_[__j]; + __os << __sp << __x.__c_; + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + _UInt __t[_Rp+1]; + for (size_t __i = 0; __i < _Rp+1; ++__i) + __is >> __t[__i]; + if (!__is.fail()) + { + for (size_t __i = 0; __i < _Rp; ++__i) + __x.__x_[__i] = __t[__i]; + __x.__c_ = __t[_Rp]; + __x.__i_ = 0; + } + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_SUBTRACT_WITH_CARRY_ENGINE_H diff --git a/libcxx/include/__random/uniform_int_distribution.h b/libcxx/include/__random/uniform_int_distribution.h --- a/libcxx/include/__random/uniform_int_distribution.h +++ b/libcxx/include/__random/uniform_int_distribution.h @@ -11,6 +11,7 @@ #include <__bits> #include <__config> +#include <__random/log2.h> #include #include #include @@ -26,34 +27,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD -// __independent_bits_engine - -template -struct __log2_imp -{ - static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp - : __log2_imp<_Xp, _Rp - 1>::value; -}; - -template -struct __log2_imp<_Xp, 0> -{ - static const size_t value = 0; -}; - -template -struct __log2_imp<0, _Rp> -{ - static const size_t value = _Rp + 1; -}; - -template -struct __log2 -{ - static const size_t value = __log2_imp<_Xp, - sizeof(_UIntType) * __CHAR_BIT__ - 1>::value; -}; - template class __independent_bits_engine { diff --git a/libcxx/include/__random/uniform_random_bit_generator.h b/libcxx/include/__random/uniform_random_bit_generator.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/uniform_random_bit_generator.h @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H +#define _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H + +#include <__concepts/arithmetic.h> +#include <__concepts/invocable.h> +#include <__concepts/same_as.h> +#include <__config> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) + +// [rand.req.urng] +template +concept uniform_random_bit_generator = + invocable<_Gen&> && unsigned_integral> && + requires { + { _Gen::min() } -> same_as>; + { _Gen::max() } -> same_as>; + requires bool_constant<(_Gen::min() < _Gen::max())>::value; + }; + +#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H diff --git a/libcxx/include/__random/uniform_real_distribution.h b/libcxx/include/__random/uniform_real_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/uniform_real_distribution.h @@ -0,0 +1,160 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H + +#include <__config> +#include <__random/generate_canonical.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS uniform_real_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __a_; + result_type __b_; + public: + typedef uniform_real_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __a = 0, + result_type __b = 1) + : __a_(__a), __b_(__b) {} + + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __a_;} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __b_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructors and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + uniform_real_distribution() : uniform_real_distribution(0) {} + explicit uniform_real_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __p_.a();} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __p_.b();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return a();} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return b();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const uniform_real_distribution& __x, + const uniform_real_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const uniform_real_distribution& __x, + const uniform_real_distribution& __y) + {return !(__x == __y);} +}; + +template +template +inline +typename uniform_real_distribution<_RealType>::result_type +uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) +{ + return (__p.b() - __p.a()) + * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g) + + __p.a(); +} + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const uniform_real_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + return __os << __x.a() << __sp << __x.b(); +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + uniform_real_distribution<_RT>& __x) +{ + typedef uniform_real_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __a; + result_type __b; + __is >> __a >> __b; + if (!__is.fail()) + __x.param(param_type(__a, __b)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H diff --git a/libcxx/include/__random/weibull_distribution.h b/libcxx/include/__random/weibull_distribution.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__random/weibull_distribution.h @@ -0,0 +1,155 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H + +#include <__config> +#include <__random/exponential_distribution.h> +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS weibull_distribution +{ +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type + { + result_type __a_; + result_type __b_; + public: + typedef weibull_distribution distribution_type; + + _LIBCPP_INLINE_VISIBILITY + explicit param_type(result_type __a = 1, result_type __b = 1) + : __a_(__a), __b_(__b) {} + + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __a_;} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __b_;} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const param_type& __x, const param_type& __y) + {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const param_type& __x, const param_type& __y) + {return !(__x == __y);} + }; + +private: + param_type __p_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_INLINE_VISIBILITY + weibull_distribution() : weibull_distribution(1) {} + _LIBCPP_INLINE_VISIBILITY + explicit weibull_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_INLINE_VISIBILITY + explicit weibull_distribution(result_type __a = 1, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_INLINE_VISIBILITY + explicit weibull_distribution(const param_type& __p) + : __p_(__p) {} + _LIBCPP_INLINE_VISIBILITY + void reset() {} + + // generating functions + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g) + {return (*this)(__g, __p_);} + template + _LIBCPP_INLINE_VISIBILITY + result_type operator()(_URNG& __g, const param_type& __p) + {return __p.b() * + _VSTD::pow(exponential_distribution()(__g), 1/__p.a());} + + // property functions + _LIBCPP_INLINE_VISIBILITY + result_type a() const {return __p_.a();} + _LIBCPP_INLINE_VISIBILITY + result_type b() const {return __p_.b();} + + _LIBCPP_INLINE_VISIBILITY + param_type param() const {return __p_;} + _LIBCPP_INLINE_VISIBILITY + void param(const param_type& __p) {__p_ = __p;} + + _LIBCPP_INLINE_VISIBILITY + result_type min() const {return 0;} + _LIBCPP_INLINE_VISIBILITY + result_type max() const {return numeric_limits::infinity();} + + friend _LIBCPP_INLINE_VISIBILITY + bool operator==(const weibull_distribution& __x, + const weibull_distribution& __y) + {return __x.__p_ == __y.__p_;} + friend _LIBCPP_INLINE_VISIBILITY + bool operator!=(const weibull_distribution& __x, + const weibull_distribution& __y) + {return !(__x == __y);} +}; + +template +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, + const weibull_distribution<_RT>& __x) +{ + __save_flags<_CharT, _Traits> __lx(__os); + typedef basic_ostream<_CharT, _Traits> _OStream; + __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | + _OStream::scientific); + _CharT __sp = __os.widen(' '); + __os.fill(__sp); + __os << __x.a() << __sp << __x.b(); + return __os; +} + +template +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + weibull_distribution<_RT>& __x) +{ + typedef weibull_distribution<_RT> _Eng; + typedef typename _Eng::result_type result_type; + typedef typename _Eng::param_type param_type; + __save_flags<_CharT, _Traits> __lx(__is); + typedef basic_istream<_CharT, _Traits> _Istream; + __is.flags(_Istream::dec | _Istream::skipws); + result_type __a; + result_type __b; + __is >> __a >> __b; + if (!__is.fail()) + __x.param(param_type(__a, __b)); + return __is; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -680,7 +680,41 @@ export * module __random { - module uniform_int_distribution { private header "__random/uniform_int_distribution.h" } + module bernoulli_distribution { private header "__random/bernoulli_distribution.h" } + module binomial_distribution { private header "__random/binomial_distribution.h" } + module cauchy_distribution { private header "__random/cauchy_distribution.h" } + module chi_squared_distribution { private header "__random/chi_squared_distribution.h" } + module default_random_engine { private header "__random/default_random_engine.h" } + module discard_block_engine { private header "__random/discard_block_engine.h" } + module discrete_distribution { private header "__random/discrete_distribution.h" } + module exponential_distribution { private header "__random/exponential_distribution.h" } + module extreme_value_distribution { private header "__random/extreme_value_distribution.h" } + module fisher_f_distribution { private header "__random/fisher_f_distribution.h" } + module gamma_distribution { private header "__random/gamma_distribution.h" } + module generate_canonical { private header "__random/generate_canonical.h" } + module geometric_distribution { private header "__random/geometric_distribution.h" } + module independent_bits_engine { private header "__random/independent_bits_engine.h" } + module is_seed_sequence { private header "__random/is_seed_sequence.h" } + module knuth_b { private header "__random/knuth_b.h" } + module linear_congruential_engine { private header "__random/linear_congruential_engine.h" } + module log2 { private header "__random/log2.h" } + module lognormal_distribution { private header "__random/lognormal_distribution.h" } + module mersenne_twister_engine { private header "__random/mersenne_twister_engine.h" } + module negative_binomial_distribution { private header "__random/negative_binomial_distribution.h" } + module normal_distribution { private header "__random/normal_distribution.h" } + module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" } + module piecewise_linear_distribution { private header "__random/piecewise_linear_distribution.h" } + module poisson_distribution { private header "__random/poisson_distribution.h" } + module random_device { private header "__random/random_device.h" } + module ranlux { private header "__random/ranlux.h" } + module seed_seq { private header "__random/seed_seq.h" } + module shuffle_order_engine { private header "__random/shuffle_order_engine.h" } + module student_t_distribution { private header "__random/student_t_distribution.h" } + module subtract_with_carry_engine { private header "__random/subtract_with_carry_engine.h" } + module uniform_int_distribution { private header "__random/uniform_int_distribution.h" } + module uniform_random_bit_generator { private header "__random/uniform_random_bit_generator.h" } + module uniform_real_distribution { private header "__random/uniform_real_distribution.h" } + module weibull_distribution { private header "__random/weibull_distribution.h" } } } module ranges { diff --git a/libcxx/include/random b/libcxx/include/random --- a/libcxx/include/random +++ b/libcxx/include/random @@ -1678,5330 +1678,56 @@ */ #include <__config> +#include <__random/bernoulli_distribution.h> +#include <__random/binomial_distribution.h> +#include <__random/cauchy_distribution.h> +#include <__random/chi_squared_distribution.h> +#include <__random/default_random_engine.h> +#include <__random/discard_block_engine.h> +#include <__random/discrete_distribution.h> +#include <__random/exponential_distribution.h> +#include <__random/extreme_value_distribution.h> +#include <__random/fisher_f_distribution.h> +#include <__random/gamma_distribution.h> +#include <__random/generate_canonical.h> +#include <__random/geometric_distribution.h> +#include <__random/independent_bits_engine.h> +#include <__random/is_seed_sequence.h> +#include <__random/knuth_b.h> +#include <__random/linear_congruential_engine.h> +#include <__random/log2.h> +#include <__random/lognormal_distribution.h> +#include <__random/mersenne_twister_engine.h> +#include <__random/negative_binomial_distribution.h> +#include <__random/normal_distribution.h> +#include <__random/piecewise_constant_distribution.h> +#include <__random/piecewise_linear_distribution.h> +#include <__random/poisson_distribution.h> +#include <__random/random_device.h> +#include <__random/ranlux.h> +#include <__random/seed_seq.h> +#include <__random/shuffle_order_engine.h> +#include <__random/student_t_distribution.h> +#include <__random/subtract_with_carry_engine.h> #include <__random/uniform_int_distribution.h> -#include -#include -#include -#include -#include +#include <__random/uniform_random_bit_generator.h> +#include <__random/uniform_real_distribution.h> +#include <__random/weibull_distribution.h> #include -#include -#include -#include -#include -#include -#include + +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it +#include // for backward compatibility; TODO remove it #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - - -_LIBCPP_BEGIN_NAMESPACE_STD - -#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) - -// [rand.req.urng] -template -concept uniform_random_bit_generator = - invocable<_Gen&> && unsigned_integral> && - requires { - { _Gen::min() } -> same_as>; - { _Gen::max() } -> same_as>; - requires bool_constant<(_Gen::min() < _Gen::max())>::value; - }; - -#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) - -// __is_seed_sequence - -template -struct __is_seed_sequence -{ - static _LIBCPP_CONSTEXPR const bool value = - !is_convertible<_Sseq, typename _Engine::result_type>::value && - !is_same::type, _Engine>::value; -}; - -// linear_congruential_engine - -template (_Mp-__c)/__a), - bool _OverflowOK = ((__m | (__m-1)) > __m), // m = 2^n - bool _SchrageOK = (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q -struct __lce_alg_picker -{ - static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK || _SchrageOK, - "The current values of a, c, and m cannot generate a number " - "within bounds of linear_congruential_engine."); - - static _LIBCPP_CONSTEXPR const bool __use_schrage = _MightOverflow && - !_OverflowOK && - _SchrageOK; -}; - -template ::__use_schrage> -struct __lce_ta; - -// 64 - -template -struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true> -{ - typedef unsigned long long result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - // Schrage's algorithm - const result_type __q = __m / __a; - const result_type __r = __m % __a; - const result_type __t0 = __a * (__x % __q); - const result_type __t1 = __r * (__x / __q); - __x = __t0 + (__t0 < __t1) * __m - __t1; - __x += __c - (__x >= __m - __c) * __m; - return __x; - } -}; - -template -struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true> -{ - typedef unsigned long long result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - // Schrage's algorithm - const result_type __q = __m / __a; - const result_type __r = __m % __a; - const result_type __t0 = __a * (__x % __q); - const result_type __t1 = __r * (__x / __q); - __x = __t0 + (__t0 < __t1) * __m - __t1; - return __x; - } -}; - -template -struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false> -{ - typedef unsigned long long result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - return (__a * __x + __c) % __m; - } -}; - -template -struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false> -{ - typedef unsigned long long result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - return __a * __x + __c; - } -}; - -// 32 - -template -struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true> -{ - typedef unsigned result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - const result_type __a = static_cast(_Ap); - const result_type __c = static_cast(_Cp); - const result_type __m = static_cast(_Mp); - // Schrage's algorithm - const result_type __q = __m / __a; - const result_type __r = __m % __a; - const result_type __t0 = __a * (__x % __q); - const result_type __t1 = __r * (__x / __q); - __x = __t0 + (__t0 < __t1) * __m - __t1; - __x += __c - (__x >= __m - __c) * __m; - return __x; - } -}; - -template -struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true> -{ - typedef unsigned result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - const result_type __a = static_cast(_Ap); - const result_type __m = static_cast(_Mp); - // Schrage's algorithm - const result_type __q = __m / __a; - const result_type __r = __m % __a; - const result_type __t0 = __a * (__x % __q); - const result_type __t1 = __r * (__x / __q); - __x = __t0 + (__t0 < __t1) * __m - __t1; - return __x; - } -}; - -template -struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false> -{ - typedef unsigned result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - const result_type __a = static_cast(_Ap); - const result_type __c = static_cast(_Cp); - const result_type __m = static_cast(_Mp); - return (__a * __x + __c) % __m; - } -}; - -template -struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false> -{ - typedef unsigned result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - const result_type __a = static_cast(_Ap); - const result_type __c = static_cast(_Cp); - return __a * __x + __c; - } -}; - -// 16 - -template -struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b> -{ - typedef unsigned short result_type; - _LIBCPP_INLINE_VISIBILITY - static result_type next(result_type __x) - { - return static_cast(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x)); - } -}; - -template -class _LIBCPP_TEMPLATE_VIS linear_congruential_engine; - -template -_LIBCPP_INLINE_VISIBILITY -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); - -template -class _LIBCPP_TEMPLATE_VIS linear_congruential_engine -{ -public: - // types - typedef _UIntType result_type; - -private: - result_type __x_; - - static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0); - - static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters"); - static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters"); - static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type"); -public: - static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u; - static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u; - static_assert(_Min < _Max, "linear_congruential_engine invalid parameters"); - - // engine characteristics - static _LIBCPP_CONSTEXPR const result_type multiplier = __a; - static _LIBCPP_CONSTEXPR const result_type increment = __c; - static _LIBCPP_CONSTEXPR const result_type modulus = __m; - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() {return _Min;} - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() {return _Max;} - static _LIBCPP_CONSTEXPR const result_type default_seed = 1u; - - // constructors and seeding functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - linear_congruential_engine() : linear_congruential_engine(default_seed) {} - _LIBCPP_INLINE_VISIBILITY - explicit linear_congruential_engine(result_type __s) { seed(__s); } -#else - _LIBCPP_INLINE_VISIBILITY - explicit linear_congruential_engine(result_type __s = default_seed) { - seed(__s); - } -#endif - template - _LIBCPP_INLINE_VISIBILITY - explicit linear_congruential_engine(_Sseq& __q, - typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0) - {seed(__q);} - _LIBCPP_INLINE_VISIBILITY - void seed(result_type __s = default_seed) - {seed(integral_constant(), - integral_constant(), __s);} - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __is_seed_sequence<_Sseq, linear_congruential_engine>::value, - void - >::type - seed(_Sseq& __q) - {__seed(__q, integral_constant 0x100000000ull))>());} - - // generating functions - _LIBCPP_INLINE_VISIBILITY - result_type operator()() - {return __x_ = static_cast(__lce_ta<__a, __c, __m, _Mp>::next(__x_));} - _LIBCPP_INLINE_VISIBILITY - void discard(unsigned long long __z) {for (; __z; --__z) operator()();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const linear_congruential_engine& __x, - const linear_congruential_engine& __y) - {return __x.__x_ == __y.__x_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const linear_congruential_engine& __x, - const linear_congruential_engine& __y) - {return !(__x == __y);} - -private: - - _LIBCPP_INLINE_VISIBILITY - void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;} - _LIBCPP_INLINE_VISIBILITY - void seed(true_type, false_type, result_type __s) {__x_ = __s;} - _LIBCPP_INLINE_VISIBILITY - void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ? - 1 : __s % __m;} - _LIBCPP_INLINE_VISIBILITY - void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;} - - template - void __seed(_Sseq& __q, integral_constant); - template - void __seed(_Sseq& __q, integral_constant); - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); -}; - -template - _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type - linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier; - -template - _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type - linear_congruential_engine<_UIntType, __a, __c, __m>::increment; - -template - _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type - linear_congruential_engine<_UIntType, __a, __c, __m>::modulus; - -template - _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type - linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed; - -template -template -void -linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, - integral_constant) -{ - const unsigned __k = 1; - uint32_t __ar[__k+3]; - __q.generate(__ar, __ar + __k + 3); - result_type __s = static_cast(__ar[3] % __m); - __x_ = __c == 0 && __s == 0 ? result_type(1) : __s; -} - -template -template -void -linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, - integral_constant) -{ - const unsigned __k = 2; - uint32_t __ar[__k+3]; - __q.generate(__ar, __ar + __k + 3); - result_type __s = static_cast((__ar[3] + - ((uint64_t)__ar[4] << 32)) % __m); - __x_ = __c == 0 && __s == 0 ? result_type(1) : __s; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const linear_congruential_engine<_UIntType, __a, __c, __m>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _Ostream; - __os.flags(_Ostream::dec | _Ostream::left); - __os.fill(__os.widen(' ')); - return __os << __x.__x_; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - linear_congruential_engine<_UIntType, __a, __c, __m>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - _UIntType __t; - __is >> __t; - if (!__is.fail()) - __x.__x_ = __t; - return __is; -} - -typedef linear_congruential_engine - minstd_rand0; -typedef linear_congruential_engine - minstd_rand; -typedef minstd_rand default_random_engine; -// mersenne_twister_engine - -template -class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine; - -template -bool -operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __y); - -template -_LIBCPP_INLINE_VISIBILITY -bool -operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __y); - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x); - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x); - -template -class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine -{ -public: - // types - typedef _UIntType result_type; - -private: - result_type __x_[__n]; - size_t __i_; - - static_assert( 0 < __m, "mersenne_twister_engine invalid parameters"); - static_assert(__m <= __n, "mersenne_twister_engine invalid parameters"); - static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits::digits; - static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters"); - static_assert( 2 <= __w, "mersenne_twister_engine invalid parameters"); - static_assert(__r <= __w, "mersenne_twister_engine invalid parameters"); - static_assert(__u <= __w, "mersenne_twister_engine invalid parameters"); - static_assert(__s <= __w, "mersenne_twister_engine invalid parameters"); - static_assert(__t <= __w, "mersenne_twister_engine invalid parameters"); - static_assert(__l <= __w, "mersenne_twister_engine invalid parameters"); -public: - static _LIBCPP_CONSTEXPR const result_type _Min = 0; - static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) : - (result_type(1) << __w) - result_type(1); - static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters"); - static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters"); - static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters"); - static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters"); - static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters"); - static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters"); - - // engine characteristics - static _LIBCPP_CONSTEXPR const size_t word_size = __w; - static _LIBCPP_CONSTEXPR const size_t state_size = __n; - static _LIBCPP_CONSTEXPR const size_t shift_size = __m; - static _LIBCPP_CONSTEXPR const size_t mask_bits = __r; - static _LIBCPP_CONSTEXPR const result_type xor_mask = __a; - static _LIBCPP_CONSTEXPR const size_t tempering_u = __u; - static _LIBCPP_CONSTEXPR const result_type tempering_d = __d; - static _LIBCPP_CONSTEXPR const size_t tempering_s = __s; - static _LIBCPP_CONSTEXPR const result_type tempering_b = __b; - static _LIBCPP_CONSTEXPR const size_t tempering_t = __t; - static _LIBCPP_CONSTEXPR const result_type tempering_c = __c; - static _LIBCPP_CONSTEXPR const size_t tempering_l = __l; - static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f; - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() { return _Min; } - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() { return _Max; } - static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u; - - // constructors and seeding functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} - _LIBCPP_INLINE_VISIBILITY - explicit mersenne_twister_engine(result_type __sd) { seed(__sd); } -#else - _LIBCPP_INLINE_VISIBILITY - explicit mersenne_twister_engine(result_type __sd = default_seed) { - seed(__sd); - } -#endif - template - _LIBCPP_INLINE_VISIBILITY - explicit mersenne_twister_engine(_Sseq& __q, - typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0) - {seed(__q);} - void seed(result_type __sd = default_seed); - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __is_seed_sequence<_Sseq, mersenne_twister_engine>::value, - void - >::type - seed(_Sseq& __q) - {__seed(__q, integral_constant());} - - // generating functions - result_type operator()(); - _LIBCPP_INLINE_VISIBILITY - void discard(unsigned long long __z) {for (; __z; --__z) operator()();} - - template - friend - bool - operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __y); - - template - friend - bool - operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __y); - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x); -private: - - template - void __seed(_Sseq& __q, integral_constant); - template - void __seed(_Sseq& __q, integral_constant); - - template - _LIBCPP_INLINE_VISIBILITY - static - typename enable_if - < - __count < __w, - result_type - >::type - __lshift(result_type __x) {return (__x << __count) & _Max;} - - template - _LIBCPP_INLINE_VISIBILITY - static - typename enable_if - < - (__count >= __w), - result_type - >::type - __lshift(result_type) {return result_type(0);} - - template - _LIBCPP_INLINE_VISIBILITY - static - typename enable_if - < - __count < _Dt, - result_type - >::type - __rshift(result_type __x) {return __x >> __count;} - - template - _LIBCPP_INLINE_VISIBILITY - static - typename enable_if - < - (__count >= _Dt), - result_type - >::type - __rshift(result_type) {return result_type(0);} -}; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits; - -template - _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u; - -template - _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s; - -template - _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t; - -template - _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c; - -template - _LIBCPP_CONSTEXPR const size_t - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l; - -template - _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier; - -template - _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type - mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed; - -template -void -mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, - __t, __c, __l, __f>::seed(result_type __sd) - _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK -{ // __w >= 2 - __x_[0] = __sd & _Max; - for (size_t __i = 1; __i < __n; ++__i) - __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max; - __i_ = 0; -} - -template -template -void -mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, - __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant) -{ - const unsigned __k = 1; - uint32_t __ar[__n * __k]; - __q.generate(__ar, __ar + __n * __k); - for (size_t __i = 0; __i < __n; ++__i) - __x_[__i] = static_cast(__ar[__i] & _Max); - const result_type __mask = __r == _Dt ? result_type(~0) : - (result_type(1) << __r) - result_type(1); - __i_ = 0; - if ((__x_[0] & ~__mask) == 0) - { - for (size_t __i = 1; __i < __n; ++__i) - if (__x_[__i] != 0) - return; - __x_[0] = result_type(1) << (__w - 1); - } -} - -template -template -void -mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, - __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant) -{ - const unsigned __k = 2; - uint32_t __ar[__n * __k]; - __q.generate(__ar, __ar + __n * __k); - for (size_t __i = 0; __i < __n; ++__i) - __x_[__i] = static_cast( - (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max); - const result_type __mask = __r == _Dt ? result_type(~0) : - (result_type(1) << __r) - result_type(1); - __i_ = 0; - if ((__x_[0] & ~__mask) == 0) - { - for (size_t __i = 1; __i < __n; ++__i) - if (__x_[__i] != 0) - return; - __x_[0] = result_type(1) << (__w - 1); - } -} - -template -_UIntType -mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, - __t, __c, __l, __f>::operator()() -{ - const size_t __j = (__i_ + 1) % __n; - const result_type __mask = __r == _Dt ? result_type(~0) : - (result_type(1) << __r) - result_type(1); - const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask); - const size_t __k = (__i_ + __m) % __n; - __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1)); - result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d); - __i_ = __j; - __z ^= __lshift<__s>(__z) & __b; - __z ^= __lshift<__t>(__z) & __c; - return __z ^ __rshift<__l>(__z); -} - -template -bool -operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __y) -{ - if (__x.__i_ == __y.__i_) - return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_); - if (__x.__i_ == 0 || __y.__i_ == 0) - { - size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_); - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, - __y.__x_ + __y.__i_)) - return false; - if (__x.__i_ == 0) - return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_); - return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j); - } - if (__x.__i_ < __y.__i_) - { - size_t __j = _Np - __y.__i_; - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), - __y.__x_ + __y.__i_)) - return false; - if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, - __y.__x_)) - return false; - return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_, - __y.__x_ + (_Np - (__x.__i_ + __j))); - } - size_t __j = _Np - __x.__i_; - if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), - __x.__x_ + __x.__i_)) - return false; - if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, - __x.__x_)) - return false; - return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_, - __x.__x_ + (_Np - (__y.__i_ + __j))); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __y) -{ - return !(__x == __y); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _Ostream; - __os.flags(_Ostream::dec | _Ostream::left); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.__x_[__x.__i_]; - for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j) - __os << __sp << __x.__x_[__j]; - for (size_t __j = 0; __j < __x.__i_; ++__j) - __os << __sp << __x.__x_[__j]; - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, - _Bp, _Tp, _Cp, _Lp, _Fp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - _UInt __t[_Np]; - for (size_t __i = 0; __i < _Np; ++__i) - __is >> __t[__i]; - if (!__is.fail()) - { - for (size_t __i = 0; __i < _Np; ++__i) - __x.__x_[__i] = __t[__i]; - __x.__i_ = 0; - } - return __is; -} - -typedef mersenne_twister_engine mt19937; -typedef mersenne_twister_engine mt19937_64; - -// subtract_with_carry_engine - -template -class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine; - -template -bool -operator==( - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); - -template -_LIBCPP_INLINE_VISIBILITY -bool -operator!=( - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); - -template -class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine -{ -public: - // types - typedef _UIntType result_type; - -private: - result_type __x_[__r]; - result_type __c_; - size_t __i_; - - static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits::digits; - static_assert( 0 < __w, "subtract_with_carry_engine invalid parameters"); - static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters"); - static_assert( 0 < __s, "subtract_with_carry_engine invalid parameters"); - static_assert(__s < __r, "subtract_with_carry_engine invalid parameters"); -public: - static _LIBCPP_CONSTEXPR const result_type _Min = 0; - static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) : - (result_type(1) << __w) - result_type(1); - static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters"); - - // engine characteristics - static _LIBCPP_CONSTEXPR const size_t word_size = __w; - static _LIBCPP_CONSTEXPR const size_t short_lag = __s; - static _LIBCPP_CONSTEXPR const size_t long_lag = __r; - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() { return _Min; } - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() { return _Max; } - static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u; - - // constructors and seeding functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} - _LIBCPP_INLINE_VISIBILITY - explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); } -#else - _LIBCPP_INLINE_VISIBILITY - explicit subtract_with_carry_engine(result_type __sd = default_seed) { - seed(__sd); - } -#endif - template - _LIBCPP_INLINE_VISIBILITY - explicit subtract_with_carry_engine(_Sseq& __q, - typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0) - {seed(__q);} - _LIBCPP_INLINE_VISIBILITY - void seed(result_type __sd = default_seed) - {seed(__sd, integral_constant());} - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, - void - >::type - seed(_Sseq& __q) - {__seed(__q, integral_constant());} - - // generating functions - result_type operator()(); - _LIBCPP_INLINE_VISIBILITY - void discard(unsigned long long __z) {for (; __z; --__z) operator()();} - - template - friend - bool - operator==( - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); - - template - friend - bool - operator!=( - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); - -private: - - void seed(result_type __sd, integral_constant); - void seed(result_type __sd, integral_constant); - template - void __seed(_Sseq& __q, integral_constant); - template - void __seed(_Sseq& __q, integral_constant); -}; - -template - _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size; - -template - _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag; - -template - _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag; - -template - _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type - subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed; - -template -void -subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, - integral_constant) -{ - linear_congruential_engine - __e(__sd == 0u ? default_seed : __sd); - for (size_t __i = 0; __i < __r; ++__i) - __x_[__i] = static_cast(__e() & _Max); - __c_ = __x_[__r-1] == 0; - __i_ = 0; -} - -template -void -subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, - integral_constant) -{ - linear_congruential_engine - __e(__sd == 0u ? default_seed : __sd); - for (size_t __i = 0; __i < __r; ++__i) - { - result_type __e0 = __e(); - __x_[__i] = static_cast( - (__e0 + ((uint64_t)__e() << 32)) & _Max); - } - __c_ = __x_[__r-1] == 0; - __i_ = 0; -} - -template -template -void -subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, - integral_constant) -{ - const unsigned __k = 1; - uint32_t __ar[__r * __k]; - __q.generate(__ar, __ar + __r * __k); - for (size_t __i = 0; __i < __r; ++__i) - __x_[__i] = static_cast(__ar[__i] & _Max); - __c_ = __x_[__r-1] == 0; - __i_ = 0; -} - -template -template -void -subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, - integral_constant) -{ - const unsigned __k = 2; - uint32_t __ar[__r * __k]; - __q.generate(__ar, __ar + __r * __k); - for (size_t __i = 0; __i < __r; ++__i) - __x_[__i] = static_cast( - (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max); - __c_ = __x_[__r-1] == 0; - __i_ = 0; -} - -template -_UIntType -subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()() -{ - const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r]; - result_type& __xr = __x_[__i_]; - result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1; - __xr = (__xs - __xr - __c_) & _Max; - __c_ = __new_c; - __i_ = (__i_ + 1) % __r; - return __xr; -} - -template -bool -operator==( - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) -{ - if (__x.__c_ != __y.__c_) - return false; - if (__x.__i_ == __y.__i_) - return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_); - if (__x.__i_ == 0 || __y.__i_ == 0) - { - size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_); - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, - __y.__x_ + __y.__i_)) - return false; - if (__x.__i_ == 0) - return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_); - return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j); - } - if (__x.__i_ < __y.__i_) - { - size_t __j = _Rp - __y.__i_; - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), - __y.__x_ + __y.__i_)) - return false; - if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, - __y.__x_)) - return false; - return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_, - __y.__x_ + (_Rp - (__x.__i_ + __j))); - } - size_t __j = _Rp - __x.__i_; - if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), - __x.__x_ + __x.__i_)) - return false; - if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, - __x.__x_)) - return false; - return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_, - __x.__x_ + (_Rp - (__y.__i_ + __j))); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=( - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) -{ - return !(__x == __y); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _Ostream; - __os.flags(_Ostream::dec | _Ostream::left); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.__x_[__x.__i_]; - for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j) - __os << __sp << __x.__x_[__j]; - for (size_t __j = 0; __j < __x.__i_; ++__j) - __os << __sp << __x.__x_[__j]; - __os << __sp << __x.__c_; - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - _UInt __t[_Rp+1]; - for (size_t __i = 0; __i < _Rp+1; ++__i) - __is >> __t[__i]; - if (!__is.fail()) - { - for (size_t __i = 0; __i < _Rp; ++__i) - __x.__x_[__i] = __t[__i]; - __x.__c_ = __t[_Rp]; - __x.__i_ = 0; - } - return __is; -} - -typedef subtract_with_carry_engine ranlux24_base; -typedef subtract_with_carry_engine ranlux48_base; - -// discard_block_engine - -template -class _LIBCPP_TEMPLATE_VIS discard_block_engine -{ - _Engine __e_; - int __n_; - - static_assert( 0 < __r, "discard_block_engine invalid parameters"); - static_assert(__r <= __p, "discard_block_engine invalid parameters"); - static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters"); -public: - // types - typedef typename _Engine::result_type result_type; - - // engine characteristics - static _LIBCPP_CONSTEXPR const size_t block_size = __p; - static _LIBCPP_CONSTEXPR const size_t used_block = __r; - -#ifdef _LIBCPP_CXX03_LANG - static const result_type _Min = _Engine::_Min; - static const result_type _Max = _Engine::_Max; -#else - static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min(); - static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max(); -#endif - - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); } - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); } - - // constructors and seeding functions - _LIBCPP_INLINE_VISIBILITY - discard_block_engine() : __n_(0) {} - _LIBCPP_INLINE_VISIBILITY - explicit discard_block_engine(const _Engine& __e) - : __e_(__e), __n_(0) {} -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - explicit discard_block_engine(_Engine&& __e) - : __e_(_VSTD::move(__e)), __n_(0) {} -#endif // _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {} - template - _LIBCPP_INLINE_VISIBILITY - explicit discard_block_engine(_Sseq& __q, - typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value && - !is_convertible<_Sseq, _Engine>::value>::type* = 0) - : __e_(__q), __n_(0) {} - _LIBCPP_INLINE_VISIBILITY - void seed() {__e_.seed(); __n_ = 0;} - _LIBCPP_INLINE_VISIBILITY - void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;} - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __is_seed_sequence<_Sseq, discard_block_engine>::value, - void - >::type - seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;} - - // generating functions - result_type operator()(); - _LIBCPP_INLINE_VISIBILITY - void discard(unsigned long long __z) {for (; __z; --__z) operator()();} - - // property functions - _LIBCPP_INLINE_VISIBILITY - const _Engine& base() const _NOEXCEPT {return __e_;} - - template - friend - bool - operator==( - const discard_block_engine<_Eng, _Pp, _Rp>& __x, - const discard_block_engine<_Eng, _Pp, _Rp>& __y); - - template - friend - bool - operator!=( - const discard_block_engine<_Eng, _Pp, _Rp>& __x, - const discard_block_engine<_Eng, _Pp, _Rp>& __y); - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const discard_block_engine<_Eng, _Pp, _Rp>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - discard_block_engine<_Eng, _Pp, _Rp>& __x); -}; - -template - _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size; - -template - _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block; - -template -typename discard_block_engine<_Engine, __p, __r>::result_type -discard_block_engine<_Engine, __p, __r>::operator()() -{ - if (__n_ >= static_cast(__r)) - { - __e_.discard(__p - __r); - __n_ = 0; - } - ++__n_; - return __e_(); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x, - const discard_block_engine<_Eng, _Pp, _Rp>& __y) -{ - return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x, - const discard_block_engine<_Eng, _Pp, _Rp>& __y) -{ - return !(__x == __y); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const discard_block_engine<_Eng, _Pp, _Rp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _Ostream; - __os.flags(_Ostream::dec | _Ostream::left); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - return __os << __x.__e_ << __sp << __x.__n_; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - discard_block_engine<_Eng, _Pp, _Rp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - _Eng __e; - int __n; - __is >> __e >> __n; - if (!__is.fail()) - { - __x.__e_ = __e; - __x.__n_ = __n; - } - return __is; -} - -typedef discard_block_engine ranlux24; -typedef discard_block_engine ranlux48; - -// independent_bits_engine - -template -class _LIBCPP_TEMPLATE_VIS independent_bits_engine -{ - template - class __get_n - { - static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits; - static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0); - static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np; - static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0; - public: - static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np; - }; -public: - // types - typedef _UIntType result_type; - -private: - _Engine __e_; - - static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits::digits; - static_assert( 0 < __w, "independent_bits_engine invalid parameters"); - static_assert(__w <= _Dt, "independent_bits_engine invalid parameters"); - - typedef typename _Engine::result_type _Engine_result_type; - typedef typename conditional - < - sizeof(_Engine_result_type) <= sizeof(result_type), - result_type, - _Engine_result_type - >::type _Working_result_type; -#ifdef _LIBCPP_CXX03_LANG - static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min - + _Working_result_type(1); -#else - static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() - + _Working_result_type(1); -#endif - static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value; - static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value; - static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n; - static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n; - static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits; - static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; - static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 : - (_Rp >> __w0) << __w0; - static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 : - (_Rp >> (__w0+1)) << (__w0+1); - static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ? - _Engine_result_type(~0) >> (_EDt - __w0) : - _Engine_result_type(0); - static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ? - _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) : - _Engine_result_type(~0); -public: - static _LIBCPP_CONSTEXPR const result_type _Min = 0; - static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) : - (result_type(1) << __w) - result_type(1); - static_assert(_Min < _Max, "independent_bits_engine invalid parameters"); - - // engine characteristics - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() { return _Min; } - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() { return _Max; } - - // constructors and seeding functions - _LIBCPP_INLINE_VISIBILITY - independent_bits_engine() {} - _LIBCPP_INLINE_VISIBILITY - explicit independent_bits_engine(const _Engine& __e) - : __e_(__e) {} -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - explicit independent_bits_engine(_Engine&& __e) - : __e_(_VSTD::move(__e)) {} -#endif // _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - explicit independent_bits_engine(result_type __sd) : __e_(__sd) {} - template - _LIBCPP_INLINE_VISIBILITY - explicit independent_bits_engine(_Sseq& __q, - typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value && - !is_convertible<_Sseq, _Engine>::value>::type* = 0) - : __e_(__q) {} - _LIBCPP_INLINE_VISIBILITY - void seed() {__e_.seed();} - _LIBCPP_INLINE_VISIBILITY - void seed(result_type __sd) {__e_.seed(__sd);} - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __is_seed_sequence<_Sseq, independent_bits_engine>::value, - void - >::type - seed(_Sseq& __q) {__e_.seed(__q);} - - // generating functions - _LIBCPP_INLINE_VISIBILITY - result_type operator()() {return __eval(integral_constant());} - _LIBCPP_INLINE_VISIBILITY - void discard(unsigned long long __z) {for (; __z; --__z) operator()();} - - // property functions - _LIBCPP_INLINE_VISIBILITY - const _Engine& base() const _NOEXCEPT {return __e_;} - - template - friend - bool - operator==( - const independent_bits_engine<_Eng, _Wp, _UInt>& __x, - const independent_bits_engine<_Eng, _Wp, _UInt>& __y); - - template - friend - bool - operator!=( - const independent_bits_engine<_Eng, _Wp, _UInt>& __x, - const independent_bits_engine<_Eng, _Wp, _UInt>& __y); - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const independent_bits_engine<_Eng, _Wp, _UInt>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - independent_bits_engine<_Eng, _Wp, _UInt>& __x); - -private: - _LIBCPP_INLINE_VISIBILITY - result_type __eval(false_type); - result_type __eval(true_type); - - template - _LIBCPP_INLINE_VISIBILITY - static - typename enable_if - < - __count < _Dt, - result_type - >::type - __lshift(result_type __x) {return __x << __count;} - - template - _LIBCPP_INLINE_VISIBILITY - static - typename enable_if - < - (__count >= _Dt), - result_type - >::type - __lshift(result_type) {return result_type(0);} -}; - -template -inline -_UIntType -independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type) -{ - return static_cast(__e_() & __mask0); -} - -template -_UIntType -independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type) -{ - result_type _Sp = 0; - for (size_t __k = 0; __k < __n0; ++__k) - { - _Engine_result_type __u; - do - { - __u = __e_() - _Engine::min(); - } while (__u >= __y0); - _Sp = static_cast(__lshift<__w0>(_Sp) + (__u & __mask0)); - } - for (size_t __k = __n0; __k < __n; ++__k) - { - _Engine_result_type __u; - do - { - __u = __e_() - _Engine::min(); - } while (__u >= __y1); - _Sp = static_cast(__lshift<__w0+1>(_Sp) + (__u & __mask1)); - } - return _Sp; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==( - const independent_bits_engine<_Eng, _Wp, _UInt>& __x, - const independent_bits_engine<_Eng, _Wp, _UInt>& __y) -{ - return __x.base() == __y.base(); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=( - const independent_bits_engine<_Eng, _Wp, _UInt>& __x, - const independent_bits_engine<_Eng, _Wp, _UInt>& __y) -{ - return !(__x == __y); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const independent_bits_engine<_Eng, _Wp, _UInt>& __x) -{ - return __os << __x.base(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - independent_bits_engine<_Eng, _Wp, _UInt>& __x) -{ - _Eng __e; - __is >> __e; - if (!__is.fail()) - __x.__e_ = __e; - return __is; -} - -// shuffle_order_engine - -template -struct __ugcd -{ - static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value; -}; - -template -struct __ugcd<_Xp, 0> -{ - static _LIBCPP_CONSTEXPR const uint64_t value = _Xp; -}; - -template -class __uratio -{ - static_assert(_Dp != 0, "__uratio divide by 0"); - static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value; -public: - static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd; - static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd; - - typedef __uratio type; -}; - -template -class _LIBCPP_TEMPLATE_VIS shuffle_order_engine -{ - static_assert(0 < __k, "shuffle_order_engine invalid parameters"); -public: - // types - typedef typename _Engine::result_type result_type; - -private: - _Engine __e_; - result_type _V_[__k]; - result_type _Y_; - -public: - // engine characteristics - static _LIBCPP_CONSTEXPR const size_t table_size = __k; - -#ifdef _LIBCPP_CXX03_LANG - static const result_type _Min = _Engine::_Min; - static const result_type _Max = _Engine::_Max; -#else - static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min(); - static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max(); -#endif - static_assert(_Min < _Max, "shuffle_order_engine invalid parameters"); - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() { return _Min; } - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() { return _Max; } - - static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull; - - // constructors and seeding functions - _LIBCPP_INLINE_VISIBILITY - shuffle_order_engine() {__init();} - _LIBCPP_INLINE_VISIBILITY - explicit shuffle_order_engine(const _Engine& __e) - : __e_(__e) {__init();} -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - explicit shuffle_order_engine(_Engine&& __e) - : __e_(_VSTD::move(__e)) {__init();} -#endif // _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();} - template - _LIBCPP_INLINE_VISIBILITY - explicit shuffle_order_engine(_Sseq& __q, - typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value && - !is_convertible<_Sseq, _Engine>::value>::type* = 0) - : __e_(__q) {__init();} - _LIBCPP_INLINE_VISIBILITY - void seed() {__e_.seed(); __init();} - _LIBCPP_INLINE_VISIBILITY - void seed(result_type __sd) {__e_.seed(__sd); __init();} - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __is_seed_sequence<_Sseq, shuffle_order_engine>::value, - void - >::type - seed(_Sseq& __q) {__e_.seed(__q); __init();} - - // generating functions - _LIBCPP_INLINE_VISIBILITY - result_type operator()() {return __eval(integral_constant());} - _LIBCPP_INLINE_VISIBILITY - void discard(unsigned long long __z) {for (; __z; --__z) operator()();} - - // property functions - _LIBCPP_INLINE_VISIBILITY - const _Engine& base() const _NOEXCEPT {return __e_;} - -private: - template - friend - bool - operator==( - const shuffle_order_engine<_Eng, _Kp>& __x, - const shuffle_order_engine<_Eng, _Kp>& __y); - - template - friend - bool - operator!=( - const shuffle_order_engine<_Eng, _Kp>& __x, - const shuffle_order_engine<_Eng, _Kp>& __y); - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const shuffle_order_engine<_Eng, _Kp>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - shuffle_order_engine<_Eng, _Kp>& __x); - - _LIBCPP_INLINE_VISIBILITY - void __init() - { - for (size_t __i = 0; __i < __k; ++__i) - _V_[__i] = __e_(); - _Y_ = __e_(); - } - - _LIBCPP_INLINE_VISIBILITY - result_type __eval(false_type) {return __eval2(integral_constant());} - _LIBCPP_INLINE_VISIBILITY - result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());} - - _LIBCPP_INLINE_VISIBILITY - result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());} - _LIBCPP_INLINE_VISIBILITY - result_type __eval2(true_type) {return __evalf<__k, 0>();} - - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)), - result_type - >::type - __eval(__uratio<_Np, _Dp>) - {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();} - - template - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min), - result_type - >::type - __eval(__uratio<_Np, _Dp>) - { - const size_t __j = static_cast(__uratio<_Np, _Dp>::num * (_Y_ - _Min) - / __uratio<_Np, _Dp>::den); - _Y_ = _V_[__j]; - _V_[__j] = __e_(); - return _Y_; - } - - template - _LIBCPP_INLINE_VISIBILITY - result_type __evalf() - { - const double _Fp = __d == 0 ? - __n / (2. * 0x8000000000000000ull) : - __n / (double)__d; - const size_t __j = static_cast(_Fp * (_Y_ - _Min)); - _Y_ = _V_[__j]; - _V_[__j] = __e_(); - return _Y_; - } -}; - -template - _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size; - -template -bool -operator==( - const shuffle_order_engine<_Eng, _Kp>& __x, - const shuffle_order_engine<_Eng, _Kp>& __y) -{ - return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) && - __x.__e_ == __y.__e_; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=( - const shuffle_order_engine<_Eng, _Kp>& __x, - const shuffle_order_engine<_Eng, _Kp>& __y) -{ - return !(__x == __y); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const shuffle_order_engine<_Eng, _Kp>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _Ostream; - __os.flags(_Ostream::dec | _Ostream::left); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.__e_ << __sp << __x._V_[0]; - for (size_t __i = 1; __i < _Kp; ++__i) - __os << __sp << __x._V_[__i]; - return __os << __sp << __x._Y_; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - shuffle_order_engine<_Eng, _Kp>& __x) -{ - typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - _Eng __e; - result_type _Vp[_Kp+1]; - __is >> __e; - for (size_t __i = 0; __i < _Kp+1; ++__i) - __is >> _Vp[__i]; - if (!__is.fail()) - { - __x.__e_ = __e; - for (size_t __i = 0; __i < _Kp; ++__i) - __x._V_[__i] = _Vp[__i]; - __x._Y_ = _Vp[_Kp]; - } - return __is; -} - -typedef shuffle_order_engine knuth_b; - -// random_device - -#if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE) - -class _LIBCPP_TYPE_VIS random_device -{ -#ifdef _LIBCPP_USING_DEV_RANDOM - int __f_; -#endif // defined(_LIBCPP_USING_DEV_RANDOM) -public: - // types - typedef unsigned result_type; - - // generator characteristics - static _LIBCPP_CONSTEXPR const result_type _Min = 0; - static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu; - - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type min() { return _Min;} - _LIBCPP_INLINE_VISIBILITY - static _LIBCPP_CONSTEXPR result_type max() { return _Max;} - - // constructors -#ifndef _LIBCPP_CXX03_LANG - random_device() : random_device("/dev/urandom") {} - explicit random_device(const string& __token); -#else - explicit random_device(const string& __token = "/dev/urandom"); -#endif - ~random_device(); - - // generating functions - result_type operator()(); - - // property functions - double entropy() const _NOEXCEPT; - -private: - // no copy functions - random_device(const random_device&); // = delete; - random_device& operator=(const random_device&); // = delete; -}; - -#endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE - -// seed_seq - -class _LIBCPP_TEMPLATE_VIS seed_seq -{ -public: - // types - typedef uint32_t result_type; - -private: - vector __v_; - - template - void init(_InputIterator __first, _InputIterator __last); -public: - // constructors - _LIBCPP_INLINE_VISIBILITY - seed_seq() _NOEXCEPT {} -#ifndef _LIBCPP_CXX03_LANG - template - _LIBCPP_INLINE_VISIBILITY - seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());} -#endif // _LIBCPP_CXX03_LANG - - template - _LIBCPP_INLINE_VISIBILITY - seed_seq(_InputIterator __first, _InputIterator __last) - {init(__first, __last);} - - // generating functions - template - void generate(_RandomAccessIterator __first, _RandomAccessIterator __last); - - // property functions - _LIBCPP_INLINE_VISIBILITY - size_t size() const _NOEXCEPT {return __v_.size();} - template - _LIBCPP_INLINE_VISIBILITY - void param(_OutputIterator __dest) const - {_VSTD::copy(__v_.begin(), __v_.end(), __dest);} - -private: - // no copy functions - seed_seq(const seed_seq&); // = delete; - void operator=(const seed_seq&); // = delete; - - _LIBCPP_INLINE_VISIBILITY - static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);} -}; - -template -void -seed_seq::init(_InputIterator __first, _InputIterator __last) -{ - for (_InputIterator __s = __first; __s != __last; ++__s) - __v_.push_back(*__s & 0xFFFFFFFF); -} - -template -void -seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last) -{ - if (__first != __last) - { - _VSTD::fill(__first, __last, 0x8b8b8b8b); - const size_t __n = static_cast(__last - __first); - const size_t __s = __v_.size(); - const size_t __t = (__n >= 623) ? 11 - : (__n >= 68) ? 7 - : (__n >= 39) ? 5 - : (__n >= 7) ? 3 - : (__n - 1) / 2; - const size_t __p = (__n - __t) / 2; - const size_t __q = __p + __t; - const size_t __m = _VSTD::max(__s + 1, __n); - // __k = 0; - { - result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p] - ^ __first[__n - 1]); - __first[__p] += __r; - __r += __s; - __first[__q] += __r; - __first[0] = __r; - } - for (size_t __k = 1; __k <= __s; ++__k) - { - const size_t __kmodn = __k % __n; - const size_t __kpmodn = (__k + __p) % __n; - result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] - ^ __first[(__k - 1) % __n]); - __first[__kpmodn] += __r; - __r += __kmodn + __v_[__k-1]; - __first[(__k + __q) % __n] += __r; - __first[__kmodn] = __r; - } - for (size_t __k = __s + 1; __k < __m; ++__k) - { - const size_t __kmodn = __k % __n; - const size_t __kpmodn = (__k + __p) % __n; - result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] - ^ __first[(__k - 1) % __n]); - __first[__kpmodn] += __r; - __r += __kmodn; - __first[(__k + __q) % __n] += __r; - __first[__kmodn] = __r; - } - for (size_t __k = __m; __k < __m + __n; ++__k) - { - const size_t __kmodn = __k % __n; - const size_t __kpmodn = (__k + __p) % __n; - result_type __r = 1566083941 * _Tp(__first[__kmodn] + - __first[__kpmodn] + - __first[(__k - 1) % __n]); - __first[__kpmodn] ^= __r; - __r -= __kmodn; - __first[(__k + __q) % __n] ^= __r; - __first[__kmodn] = __r; - } - } -} - -// generate_canonical - -template -_RealType -generate_canonical(_URNG& __g) -{ - const size_t _Dt = numeric_limits<_RealType>::digits; - const size_t __b = _Dt < __bits ? _Dt : __bits; -#ifdef _LIBCPP_CXX03_LANG - const size_t __logR = __log2::value; -#else - const size_t __logR = __log2::value; -#endif - const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0); - const _RealType _Rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1); - _RealType __base = _Rp; - _RealType _Sp = __g() - _URNG::min(); - for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp) - _Sp += (__g() - _URNG::min()) * __base; - return _Sp / __base; -} - -// uniform_real_distribution - -template -class _LIBCPP_TEMPLATE_VIS uniform_real_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __a_; - result_type __b_; - public: - typedef uniform_real_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __a = 0, - result_type __b = 1) - : __a_(__a), __b_(__b) {} - - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __a_;} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __b_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - uniform_real_distribution() : uniform_real_distribution(0) {} - explicit uniform_real_distribution(result_type __a, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __p_.a();} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __p_.b();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return a();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return b();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const uniform_real_distribution& __x, - const uniform_real_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const uniform_real_distribution& __x, - const uniform_real_distribution& __y) - {return !(__x == __y);} -}; - -template -template -inline -typename uniform_real_distribution<_RealType>::result_type -uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - return (__p.b() - __p.a()) - * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g) - + __p.a(); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const uniform_real_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - return __os << __x.a() << __sp << __x.b(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - uniform_real_distribution<_RT>& __x) -{ - typedef uniform_real_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __a; - result_type __b; - __is >> __a >> __b; - if (!__is.fail()) - __x.param(param_type(__a, __b)); - return __is; -} - -// bernoulli_distribution - -class _LIBCPP_TEMPLATE_VIS bernoulli_distribution -{ -public: - // types - typedef bool result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - double __p_; - public: - typedef bernoulli_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(double __p = 0.5) : __p_(__p) {} - - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - bernoulli_distribution() : bernoulli_distribution(0.5) {} - _LIBCPP_INLINE_VISIBILITY - explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_.p();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return false;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return true;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const bernoulli_distribution& __x, - const bernoulli_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const bernoulli_distribution& __x, - const bernoulli_distribution& __y) - {return !(__x == __y);} -}; - -template -inline -bernoulli_distribution::result_type -bernoulli_distribution::operator()(_URNG& __g, const param_type& __p) -{ - uniform_real_distribution __gen; - return __gen(__g) < __p.p(); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - return __os << __x.p(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x) -{ - typedef bernoulli_distribution _Eng; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - double __p; - __is >> __p; - if (!__is.fail()) - __x.param(param_type(__p)); - return __is; -} - -// binomial_distribution - -template -class _LIBCPP_TEMPLATE_VIS binomial_distribution -{ -public: - // types - typedef _IntType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __t_; - double __p_; - double __pr_; - double __odds_ratio_; - result_type __r0_; - public: - typedef binomial_distribution distribution_type; - - explicit param_type(result_type __t = 1, double __p = 0.5); - - _LIBCPP_INLINE_VISIBILITY - result_type t() const {return __t_;} - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - - friend class binomial_distribution; - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - binomial_distribution() : binomial_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit binomial_distribution(result_type __t, double __p = 0.5) - : __p_(param_type(__t, __p)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit binomial_distribution(result_type __t = 1, double __p = 0.5) - : __p_(param_type(__t, __p)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit binomial_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type t() const {return __p_.t();} - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_.p();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return t();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const binomial_distribution& __x, - const binomial_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const binomial_distribution& __x, - const binomial_distribution& __y) - {return !(__x == __y);} -}; - -#ifndef _LIBCPP_MSVCRT_LIKE -extern "C" double lgamma_r(double, int *); -#endif - -inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) { -#if defined(_LIBCPP_MSVCRT_LIKE) - return lgamma(__d); -#else - int __sign; - return lgamma_r(__d, &__sign); -#endif -} - -template -binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p) - : __t_(__t), __p_(__p) -{ - if (0 < __p_ && __p_ < 1) - { - __r0_ = static_cast((__t_ + 1) * __p_); - __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) - - __libcpp_lgamma(__r0_ + 1.) - - __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) + - (__t_ - __r0_) * _VSTD::log(1 - __p_)); - __odds_ratio_ = __p_ / (1 - __p_); - } -} - -// Reference: Kemp, C.D. (1986). `A modal method for generating binomial -// variables', Commun. Statist. - Theor. Meth. 15(3), 805-813. -template -template -_IntType -binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr) -{ - if (__pr.__t_ == 0 || __pr.__p_ == 0) - return 0; - if (__pr.__p_ == 1) - return __pr.__t_; - uniform_real_distribution __gen; - double __u = __gen(__g) - __pr.__pr_; - if (__u < 0) - return __pr.__r0_; - double __pu = __pr.__pr_; - double __pd = __pu; - result_type __ru = __pr.__r0_; - result_type __rd = __ru; - while (true) - { - bool __break = true; - if (__rd >= 1) - { - __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1)); - __u -= __pd; - __break = false; - if (__u < 0) - return __rd - 1; - } - if ( __rd != 0 ) - --__rd; - ++__ru; - if (__ru <= __pr.__t_) - { - __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru; - __u -= __pu; - __break = false; - if (__u < 0) - return __ru; - } - if (__break) - return 0; - } -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const binomial_distribution<_IntType>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - return __os << __x.t() << __sp << __x.p(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - binomial_distribution<_IntType>& __x) -{ - typedef binomial_distribution<_IntType> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __t; - double __p; - __is >> __t >> __p; - if (!__is.fail()) - __x.param(param_type(__t, __p)); - return __is; -} - -// exponential_distribution - -template -class _LIBCPP_TEMPLATE_VIS exponential_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __lambda_; - public: - typedef exponential_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {} - - _LIBCPP_INLINE_VISIBILITY - result_type lambda() const {return __lambda_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__lambda_ == __y.__lambda_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - exponential_distribution() : exponential_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit exponential_distribution(result_type __lambda) - : __p_(param_type(__lambda)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit exponential_distribution(result_type __lambda = 1) - : __p_(param_type(__lambda)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit exponential_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type lambda() const {return __p_.lambda();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const exponential_distribution& __x, - const exponential_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const exponential_distribution& __x, - const exponential_distribution& __y) - {return !(__x == __y);} -}; - -template -template -_RealType -exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - return -_VSTD::log - ( - result_type(1) - - _VSTD::generate_canonical::digits>(__g) - ) - / __p.lambda(); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const exponential_distribution<_RealType>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - return __os << __x.lambda(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - exponential_distribution<_RealType>& __x) -{ - typedef exponential_distribution<_RealType> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __lambda; - __is >> __lambda; - if (!__is.fail()) - __x.param(param_type(__lambda)); - return __is; -} - -// normal_distribution - -template -class _LIBCPP_TEMPLATE_VIS normal_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __mean_; - result_type __stddev_; - public: - typedef normal_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __mean = 0, result_type __stddev = 1) - : __mean_(__mean), __stddev_(__stddev) {} - - _LIBCPP_INLINE_VISIBILITY - result_type mean() const {return __mean_;} - _LIBCPP_INLINE_VISIBILITY - result_type stddev() const {return __stddev_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - result_type _V_; - bool _V_hot_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - normal_distribution() : normal_distribution(0) {} - _LIBCPP_INLINE_VISIBILITY - explicit normal_distribution(result_type __mean, result_type __stddev = 1) - : __p_(param_type(__mean, __stddev)), _V_hot_(false) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit normal_distribution(result_type __mean = 0, - result_type __stddev = 1) - : __p_(param_type(__mean, __stddev)), _V_hot_(false) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit normal_distribution(const param_type& __p) - : __p_(__p), _V_hot_(false) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {_V_hot_ = false;} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type mean() const {return __p_.mean();} - _LIBCPP_INLINE_VISIBILITY - result_type stddev() const {return __p_.stddev();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return -numeric_limits::infinity();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const normal_distribution& __x, - const normal_distribution& __y) - {return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ && - (!__x._V_hot_ || __x._V_ == __y._V_);} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const normal_distribution& __x, - const normal_distribution& __y) - {return !(__x == __y);} - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const normal_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - normal_distribution<_RT>& __x); -}; - -template -template -_RealType -normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - result_type _Up; - if (_V_hot_) - { - _V_hot_ = false; - _Up = _V_; - } - else - { - uniform_real_distribution _Uni(-1, 1); - result_type __u; - result_type __v; - result_type __s; - do - { - __u = _Uni(__g); - __v = _Uni(__g); - __s = __u * __u + __v * __v; - } while (__s > 1 || __s == 0); - result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s); - _V_ = __v * _Fp; - _V_hot_ = true; - _Up = __u * _Fp; - } - return _Up * __p.stddev() + __p.mean(); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const normal_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_; - if (__x._V_hot_) - __os << __sp << __x._V_; - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - normal_distribution<_RT>& __x) -{ - typedef normal_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __mean; - result_type __stddev; - result_type _Vp = 0; - bool _V_hot = false; - __is >> __mean >> __stddev >> _V_hot; - if (_V_hot) - __is >> _Vp; - if (!__is.fail()) - { - __x.param(param_type(__mean, __stddev)); - __x._V_hot_ = _V_hot; - __x._V_ = _Vp; - } - return __is; -} - -// lognormal_distribution - -template -class _LIBCPP_TEMPLATE_VIS lognormal_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - normal_distribution __nd_; - public: - typedef lognormal_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __m = 0, result_type __s = 1) - : __nd_(__m, __s) {} - - _LIBCPP_INLINE_VISIBILITY - result_type m() const {return __nd_.mean();} - _LIBCPP_INLINE_VISIBILITY - result_type s() const {return __nd_.stddev();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__nd_ == __y.__nd_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - friend class lognormal_distribution; - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const lognormal_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - lognormal_distribution<_RT>& __x); - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - lognormal_distribution() : lognormal_distribution(0) {} - _LIBCPP_INLINE_VISIBILITY - explicit lognormal_distribution(result_type __m, result_type __s = 1) - : __p_(param_type(__m, __s)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit lognormal_distribution(result_type __m = 0, - result_type __s = 1) - : __p_(param_type(__m, __s)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit lognormal_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {__p_.__nd_.reset();} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g, const param_type& __p) - {return _VSTD::exp(const_cast&>(__p.__nd_)(__g));} - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type m() const {return __p_.m();} - _LIBCPP_INLINE_VISIBILITY - result_type s() const {return __p_.s();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const lognormal_distribution& __x, - const lognormal_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const lognormal_distribution& __x, - const lognormal_distribution& __y) - {return !(__x == __y);} - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const lognormal_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - lognormal_distribution<_RT>& __x); -}; - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const lognormal_distribution<_RT>& __x) -{ - return __os << __x.__p_.__nd_; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - lognormal_distribution<_RT>& __x) -{ - return __is >> __x.__p_.__nd_; -} - -// poisson_distribution - -template -class _LIBCPP_TEMPLATE_VIS poisson_distribution -{ -public: - // types - typedef _IntType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - double __mean_; - double __s_; - double __d_; - double __l_; - double __omega_; - double __c0_; - double __c1_; - double __c2_; - double __c3_; - double __c_; - - public: - typedef poisson_distribution distribution_type; - - explicit param_type(double __mean = 1.0); - - _LIBCPP_INLINE_VISIBILITY - double mean() const {return __mean_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__mean_ == __y.__mean_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - - friend class poisson_distribution; - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - poisson_distribution() : poisson_distribution(1.0) {} - _LIBCPP_INLINE_VISIBILITY - explicit poisson_distribution(double __mean) - : __p_(__mean) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit poisson_distribution(double __mean = 1.0) - : __p_(__mean) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit poisson_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - double mean() const {return __p_.mean();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::max();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const poisson_distribution& __x, - const poisson_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const poisson_distribution& __x, - const poisson_distribution& __y) - {return !(__x == __y);} -}; - -template -poisson_distribution<_IntType>::param_type::param_type(double __mean) - // According to the standard `inf` is a valid input, but it causes the - // distribution to hang, so we replace it with the maximum representable - // mean. - : __mean_(isinf(__mean) ? numeric_limits::max() : __mean) -{ - if (__mean_ < 10) - { - __s_ = 0; - __d_ = 0; - __l_ = _VSTD::exp(-__mean_); - __omega_ = 0; - __c3_ = 0; - __c2_ = 0; - __c1_ = 0; - __c0_ = 0; - __c_ = 0; - } - else - { - __s_ = _VSTD::sqrt(__mean_); - __d_ = 6 * __mean_ * __mean_; - __l_ = _VSTD::trunc(__mean_ - 1.1484); - __omega_ = .3989423 / __s_; - double __b1_ = .4166667E-1 / __mean_; - double __b2_ = .3 * __b1_ * __b1_; - __c3_ = .1428571 * __b1_ * __b2_; - __c2_ = __b2_ - 15. * __c3_; - __c1_ = __b1_ - 6. * __b2_ + 45. * __c3_; - __c0_ = 1. - __b1_ + 3. * __b2_ - 15. * __c3_; - __c_ = .1069 / __mean_; - } -} - -template -template -_IntType -poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) -{ - double __tx; - uniform_real_distribution __urd; - if (__pr.__mean_ < 10) - { - __tx = 0; - for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx) - __p *= __urd(__urng); - } - else - { - double __difmuk; - double __g = __pr.__mean_ + __pr.__s_ * normal_distribution()(__urng); - double __u; - if (__g > 0) - { - __tx = _VSTD::trunc(__g); - if (__tx >= __pr.__l_) - return _VSTD::__clamp_to_integral(__tx); - __difmuk = __pr.__mean_ - __tx; - __u = __urd(__urng); - if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk) - return _VSTD::__clamp_to_integral(__tx); - } - exponential_distribution __edist; - for (bool __using_exp_dist = false; true; __using_exp_dist = true) - { - double __e; - if (__using_exp_dist || __g <= 0) - { - double __t; - do - { - __e = __edist(__urng); - __u = __urd(__urng); - __u += __u - 1; - __t = 1.8 + (__u < 0 ? -__e : __e); - } while (__t <= -.6744); - __tx = _VSTD::trunc(__pr.__mean_ + __pr.__s_ * __t); - __difmuk = __pr.__mean_ - __tx; - __using_exp_dist = true; - } - double __px; - double __py; - if (__tx < 10 && __tx >= 0) - { - const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, - 40320, 362880}; - __px = -__pr.__mean_; - __py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast(__tx)]; - } - else - { - double __del = .8333333E-1 / __tx; - __del -= 4.8 * __del * __del * __del; - double __v = __difmuk / __tx; - if (_VSTD::abs(__v) > 0.25) - __px = __tx * _VSTD::log(1 + __v) - __difmuk - __del; - else - __px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) * - __v + .1421878) * __v + -.1661269) * __v + .2000118) * - __v + -.2500068) * __v + .3333333) * __v + -.5) - __del; - __py = .3989423 / _VSTD::sqrt(__tx); - } - double __r = (0.5 - __difmuk) / __pr.__s_; - double __r2 = __r * __r; - double __fx = -0.5 * __r2; - double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) * - __r2 + __pr.__c1_) * __r2 + __pr.__c0_); - if (__using_exp_dist) - { - if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) - - __fy * _VSTD::exp(__fx + __e)) - break; - } - else - { - if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx)) - break; - } - } - } - return _VSTD::__clamp_to_integral(__tx); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const poisson_distribution<_IntType>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - return __os << __x.mean(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - poisson_distribution<_IntType>& __x) -{ - typedef poisson_distribution<_IntType> _Eng; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - double __mean; - __is >> __mean; - if (!__is.fail()) - __x.param(param_type(__mean)); - return __is; -} - -// weibull_distribution - -template -class _LIBCPP_TEMPLATE_VIS weibull_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __a_; - result_type __b_; - public: - typedef weibull_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __a = 1, result_type __b = 1) - : __a_(__a), __b_(__b) {} - - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __a_;} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __b_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - weibull_distribution() : weibull_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit weibull_distribution(result_type __a, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit weibull_distribution(result_type __a = 1, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit weibull_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g, const param_type& __p) - {return __p.b() * - _VSTD::pow(exponential_distribution()(__g), 1/__p.a());} - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __p_.a();} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __p_.b();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const weibull_distribution& __x, - const weibull_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const weibull_distribution& __x, - const weibull_distribution& __y) - {return !(__x == __y);} -}; - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const weibull_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.a() << __sp << __x.b(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - weibull_distribution<_RT>& __x) -{ - typedef weibull_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __a; - result_type __b; - __is >> __a >> __b; - if (!__is.fail()) - __x.param(param_type(__a, __b)); - return __is; -} - -template -class _LIBCPP_TEMPLATE_VIS extreme_value_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __a_; - result_type __b_; - public: - typedef extreme_value_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __a = 0, result_type __b = 1) - : __a_(__a), __b_(__b) {} - - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __a_;} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __b_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - extreme_value_distribution() : extreme_value_distribution(0) {} - _LIBCPP_INLINE_VISIBILITY - explicit extreme_value_distribution(result_type __a, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit extreme_value_distribution(result_type __a = 0, - result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit extreme_value_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __p_.a();} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __p_.b();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return -numeric_limits::infinity();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const extreme_value_distribution& __x, - const extreme_value_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const extreme_value_distribution& __x, - const extreme_value_distribution& __y) - {return !(__x == __y);} -}; - -template -template -_RealType -extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - return __p.a() - __p.b() * - _VSTD::log(-_VSTD::log(1-uniform_real_distribution()(__g))); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const extreme_value_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.a() << __sp << __x.b(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - extreme_value_distribution<_RT>& __x) -{ - typedef extreme_value_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __a; - result_type __b; - __is >> __a >> __b; - if (!__is.fail()) - __x.param(param_type(__a, __b)); - return __is; -} - -// gamma_distribution - -template -class _LIBCPP_TEMPLATE_VIS gamma_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __alpha_; - result_type __beta_; - public: - typedef gamma_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __alpha = 1, result_type __beta = 1) - : __alpha_(__alpha), __beta_(__beta) {} - - _LIBCPP_INLINE_VISIBILITY - result_type alpha() const {return __alpha_;} - _LIBCPP_INLINE_VISIBILITY - result_type beta() const {return __beta_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - gamma_distribution() : gamma_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit gamma_distribution(result_type __alpha, result_type __beta = 1) - : __p_(param_type(__alpha, __beta)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit gamma_distribution(result_type __alpha = 1, - result_type __beta = 1) - : __p_(param_type(__alpha, __beta)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit gamma_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type alpha() const {return __p_.alpha();} - _LIBCPP_INLINE_VISIBILITY - result_type beta() const {return __p_.beta();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const gamma_distribution& __x, - const gamma_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const gamma_distribution& __x, - const gamma_distribution& __y) - {return !(__x == __y);} -}; - -template -template -_RealType -gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - result_type __a = __p.alpha(); - uniform_real_distribution __gen(0, 1); - exponential_distribution __egen; - result_type __x; - if (__a == 1) - __x = __egen(__g); - else if (__a > 1) - { - const result_type __b = __a - 1; - const result_type __c = 3 * __a - result_type(0.75); - while (true) - { - const result_type __u = __gen(__g); - const result_type __v = __gen(__g); - const result_type __w = __u * (1 - __u); - if (__w != 0) - { - const result_type __y = _VSTD::sqrt(__c / __w) * - (__u - result_type(0.5)); - __x = __b + __y; - if (__x >= 0) - { - const result_type __z = 64 * __w * __w * __w * __v * __v; - if (__z <= 1 - 2 * __y * __y / __x) - break; - if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y)) - break; - } - } - } - } - else // __a < 1 - { - while (true) - { - const result_type __u = __gen(__g); - const result_type __es = __egen(__g); - if (__u <= 1 - __a) - { - __x = _VSTD::pow(__u, 1 / __a); - if (__x <= __es) - break; - } - else - { - const result_type __e = -_VSTD::log((1-__u)/__a); - __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a); - if (__x <= __e + __es) - break; - } - } - } - return __x * __p.beta(); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const gamma_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.alpha() << __sp << __x.beta(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - gamma_distribution<_RT>& __x) -{ - typedef gamma_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __alpha; - result_type __beta; - __is >> __alpha >> __beta; - if (!__is.fail()) - __x.param(param_type(__alpha, __beta)); - return __is; -} - -// negative_binomial_distribution - -template -class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution -{ -public: - // types - typedef _IntType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __k_; - double __p_; - public: - typedef negative_binomial_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __k = 1, double __p = 0.5) - : __k_(__k), __p_(__p) {} - - _LIBCPP_INLINE_VISIBILITY - result_type k() const {return __k_;} - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - negative_binomial_distribution() : negative_binomial_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit negative_binomial_distribution(result_type __k, double __p = 0.5) - : __p_(__k, __p) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit negative_binomial_distribution(result_type __k = 1, - double __p = 0.5) - : __p_(__k, __p) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type k() const {return __p_.k();} - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_.p();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::max();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const negative_binomial_distribution& __x, - const negative_binomial_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const negative_binomial_distribution& __x, - const negative_binomial_distribution& __y) - {return !(__x == __y);} -}; - -template -template -_IntType -negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) -{ - result_type __k = __pr.k(); - double __p = __pr.p(); - if (__k <= 21 * __p) - { - bernoulli_distribution __gen(__p); - result_type __f = 0; - result_type __s = 0; - while (__s < __k) - { - if (__gen(__urng)) - ++__s; - else - ++__f; - } - return __f; - } - return poisson_distribution(gamma_distribution - (__k, (1-__p)/__p)(__urng))(__urng); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const negative_binomial_distribution<_IntType>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - return __os << __x.k() << __sp << __x.p(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - negative_binomial_distribution<_IntType>& __x) -{ - typedef negative_binomial_distribution<_IntType> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __k; - double __p; - __is >> __k >> __p; - if (!__is.fail()) - __x.param(param_type(__k, __p)); - return __is; -} - -// geometric_distribution - -template -class _LIBCPP_TEMPLATE_VIS geometric_distribution -{ -public: - // types - typedef _IntType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - double __p_; - public: - typedef geometric_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(double __p = 0.5) : __p_(__p) {} - - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructors and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - geometric_distribution() : geometric_distribution(0.5) {} - _LIBCPP_INLINE_VISIBILITY - explicit geometric_distribution(double __p) - : __p_(__p) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit geometric_distribution(double __p = 0.5) - : __p_(__p) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit geometric_distribution(const param_type& __p) : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g, const param_type& __p) - {return negative_binomial_distribution(1, __p.p())(__g);} - - // property functions - _LIBCPP_INLINE_VISIBILITY - double p() const {return __p_.p();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::max();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const geometric_distribution& __x, - const geometric_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const geometric_distribution& __x, - const geometric_distribution& __y) - {return !(__x == __y);} -}; - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const geometric_distribution<_IntType>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - return __os << __x.p(); -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - geometric_distribution<_IntType>& __x) -{ - typedef geometric_distribution<_IntType> _Eng; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - double __p; - __is >> __p; - if (!__is.fail()) - __x.param(param_type(__p)); - return __is; -} - -// chi_squared_distribution - -template -class _LIBCPP_TEMPLATE_VIS chi_squared_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __n_; - public: - typedef chi_squared_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __n = 1) : __n_(__n) {} - - _LIBCPP_INLINE_VISIBILITY - result_type n() const {return __n_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__n_ == __y.__n_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - chi_squared_distribution() : chi_squared_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit chi_squared_distribution(result_type __n) - : __p_(param_type(__n)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit chi_squared_distribution(result_type __n = 1) - : __p_(param_type(__n)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit chi_squared_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g, const param_type& __p) - {return gamma_distribution(__p.n() / 2, 2)(__g);} - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type n() const {return __p_.n();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const chi_squared_distribution& __x, - const chi_squared_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const chi_squared_distribution& __x, - const chi_squared_distribution& __y) - {return !(__x == __y);} -}; - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const chi_squared_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - __os << __x.n(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - chi_squared_distribution<_RT>& __x) -{ - typedef chi_squared_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __n; - __is >> __n; - if (!__is.fail()) - __x.param(param_type(__n)); - return __is; -} - -// cauchy_distribution - -template -class _LIBCPP_TEMPLATE_VIS cauchy_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __a_; - result_type __b_; - public: - typedef cauchy_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __a = 0, result_type __b = 1) - : __a_(__a), __b_(__b) {} - - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __a_;} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __b_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - cauchy_distribution() : cauchy_distribution(0) {} - _LIBCPP_INLINE_VISIBILITY - explicit cauchy_distribution(result_type __a, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit cauchy_distribution(result_type __a = 0, result_type __b = 1) - : __p_(param_type(__a, __b)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit cauchy_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type a() const {return __p_.a();} - _LIBCPP_INLINE_VISIBILITY - result_type b() const {return __p_.b();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return -numeric_limits::infinity();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const cauchy_distribution& __x, - const cauchy_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const cauchy_distribution& __x, - const cauchy_distribution& __y) - {return !(__x == __y);} -}; - -template -template -inline -_RealType -cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - uniform_real_distribution __gen; - // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite - return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g)); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const cauchy_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.a() << __sp << __x.b(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - cauchy_distribution<_RT>& __x) -{ - typedef cauchy_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __a; - result_type __b; - __is >> __a >> __b; - if (!__is.fail()) - __x.param(param_type(__a, __b)); - return __is; -} - -// fisher_f_distribution - -template -class _LIBCPP_TEMPLATE_VIS fisher_f_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __m_; - result_type __n_; - public: - typedef fisher_f_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __m = 1, result_type __n = 1) - : __m_(__m), __n_(__n) {} - - _LIBCPP_INLINE_VISIBILITY - result_type m() const {return __m_;} - _LIBCPP_INLINE_VISIBILITY - result_type n() const {return __n_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - fisher_f_distribution() : fisher_f_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit fisher_f_distribution(result_type __m, result_type __n = 1) - : __p_(param_type(__m, __n)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1) - : __p_(param_type(__m, __n)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit fisher_f_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type m() const {return __p_.m();} - _LIBCPP_INLINE_VISIBILITY - result_type n() const {return __p_.n();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const fisher_f_distribution& __x, - const fisher_f_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const fisher_f_distribution& __x, - const fisher_f_distribution& __y) - {return !(__x == __y);} -}; - -template -template -_RealType -fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - gamma_distribution __gdm(__p.m() * result_type(.5)); - gamma_distribution __gdn(__p.n() * result_type(.5)); - return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g)); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const fisher_f_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - __os << __x.m() << __sp << __x.n(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - fisher_f_distribution<_RT>& __x) -{ - typedef fisher_f_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __m; - result_type __n; - __is >> __m >> __n; - if (!__is.fail()) - __x.param(param_type(__m, __n)); - return __is; -} - -// student_t_distribution - -template -class _LIBCPP_TEMPLATE_VIS student_t_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - result_type __n_; - public: - typedef student_t_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - explicit param_type(result_type __n = 1) : __n_(__n) {} - - _LIBCPP_INLINE_VISIBILITY - result_type n() const {return __n_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__n_ == __y.__n_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - }; - -private: - param_type __p_; - normal_distribution __nd_; - -public: - // constructor and reset functions -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - student_t_distribution() : student_t_distribution(1) {} - _LIBCPP_INLINE_VISIBILITY - explicit student_t_distribution(result_type __n) - : __p_(param_type(__n)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit student_t_distribution(result_type __n = 1) - : __p_(param_type(__n)) {} -#endif - _LIBCPP_INLINE_VISIBILITY - explicit student_t_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {__nd_.reset();} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - result_type n() const {return __p_.n();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return -numeric_limits::infinity();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return numeric_limits::infinity();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const student_t_distribution& __x, - const student_t_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const student_t_distribution& __x, - const student_t_distribution& __y) - {return !(__x == __y);} -}; - -template -template -_RealType -student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - gamma_distribution __gd(__p.n() * .5, 2); - return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g)); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const student_t_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - __os << __x.n(); - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - student_t_distribution<_RT>& __x) -{ - typedef student_t_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - typedef typename _Eng::param_type param_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - result_type __n; - __is >> __n; - if (!__is.fail()) - __x.param(param_type(__n)); - return __is; -} - -// discrete_distribution - -template -class _LIBCPP_TEMPLATE_VIS discrete_distribution -{ -public: - // types - typedef _IntType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - vector __p_; - public: - typedef discrete_distribution distribution_type; - - _LIBCPP_INLINE_VISIBILITY - param_type() {} - template - _LIBCPP_INLINE_VISIBILITY - param_type(_InputIterator __f, _InputIterator __l) - : __p_(__f, __l) {__init();} -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - param_type(initializer_list __wl) - : __p_(__wl.begin(), __wl.end()) {__init();} -#endif // _LIBCPP_CXX03_LANG - template - param_type(size_t __nw, double __xmin, double __xmax, - _UnaryOperation __fw); - - vector probabilities() const; - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - - private: - void __init(); - - friend class discrete_distribution; - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const discrete_distribution<_IT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - discrete_distribution<_IT>& __x); - }; - -private: - param_type __p_; - -public: - // constructor and reset functions - _LIBCPP_INLINE_VISIBILITY - discrete_distribution() {} - template - _LIBCPP_INLINE_VISIBILITY - discrete_distribution(_InputIterator __f, _InputIterator __l) - : __p_(__f, __l) {} -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY - discrete_distribution(initializer_list __wl) - : __p_(__wl) {} -#endif // _LIBCPP_CXX03_LANG - template - _LIBCPP_INLINE_VISIBILITY - discrete_distribution(size_t __nw, double __xmin, double __xmax, - _UnaryOperation __fw) - : __p_(__nw, __xmin, __xmax, __fw) {} - _LIBCPP_INLINE_VISIBILITY - explicit discrete_distribution(const param_type& __p) - : __p_(__p) {} - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - vector probabilities() const {return __p_.probabilities();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return 0;} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return __p_.__p_.size();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const discrete_distribution& __x, - const discrete_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const discrete_distribution& __x, - const discrete_distribution& __y) - {return !(__x == __y);} - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const discrete_distribution<_IT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - discrete_distribution<_IT>& __x); -}; - -template -template -discrete_distribution<_IntType>::param_type::param_type(size_t __nw, - double __xmin, - double __xmax, - _UnaryOperation __fw) -{ - if (__nw > 1) - { - __p_.reserve(__nw - 1); - double __d = (__xmax - __xmin) / __nw; - double __d2 = __d / 2; - for (size_t __k = 0; __k < __nw; ++__k) - __p_.push_back(__fw(__xmin + __k * __d + __d2)); - __init(); - } -} - -template -void -discrete_distribution<_IntType>::param_type::__init() -{ - if (!__p_.empty()) - { - if (__p_.size() > 1) - { - double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0); - for (vector::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i) - *__i /= __s; - vector __t(__p_.size() - 1); - _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin()); - swap(__p_, __t); - } - else - { - __p_.clear(); - __p_.shrink_to_fit(); - } - } -} - -template -vector -discrete_distribution<_IntType>::param_type::probabilities() const -{ - size_t __n = __p_.size(); - vector __p(__n+1); - _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin()); - if (__n > 0) - __p[__n] = 1 - __p_[__n-1]; - else - __p[0] = 1; - return __p; -} - -template -template -_IntType -discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) -{ - uniform_real_distribution __gen; - return static_cast<_IntType>( - _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) - - __p.__p_.begin()); -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const discrete_distribution<_IT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - size_t __n = __x.__p_.__p_.size(); - __os << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__p_[__i]; - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - discrete_distribution<_IT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - size_t __n; - __is >> __n; - vector __p(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __p[__i]; - if (!__is.fail()) - swap(__x.__p_.__p_, __p); - return __is; -} - -// piecewise_constant_distribution - -template -class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - vector __b_; - vector __densities_; - vector __areas_; - public: - typedef piecewise_constant_distribution distribution_type; - - param_type(); - template - param_type(_InputIteratorB __fB, _InputIteratorB __lB, - _InputIteratorW __fW); -#ifndef _LIBCPP_CXX03_LANG - template - param_type(initializer_list __bl, _UnaryOperation __fw); -#endif // _LIBCPP_CXX03_LANG - template - param_type(size_t __nw, result_type __xmin, result_type __xmax, - _UnaryOperation __fw); - param_type(param_type const&) = default; - param_type & operator=(const param_type& __rhs); - - _LIBCPP_INLINE_VISIBILITY - vector intervals() const {return __b_;} - _LIBCPP_INLINE_VISIBILITY - vector densities() const {return __densities_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - - private: - void __init(); - - friend class piecewise_constant_distribution; - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const piecewise_constant_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - piecewise_constant_distribution<_RT>& __x); - }; - -private: - param_type __p_; - -public: - // constructor and reset functions - _LIBCPP_INLINE_VISIBILITY - piecewise_constant_distribution() {} - template - _LIBCPP_INLINE_VISIBILITY - piecewise_constant_distribution(_InputIteratorB __fB, - _InputIteratorB __lB, - _InputIteratorW __fW) - : __p_(__fB, __lB, __fW) {} - -#ifndef _LIBCPP_CXX03_LANG - template - _LIBCPP_INLINE_VISIBILITY - piecewise_constant_distribution(initializer_list __bl, - _UnaryOperation __fw) - : __p_(__bl, __fw) {} -#endif // _LIBCPP_CXX03_LANG - - template - _LIBCPP_INLINE_VISIBILITY - piecewise_constant_distribution(size_t __nw, result_type __xmin, - result_type __xmax, _UnaryOperation __fw) - : __p_(__nw, __xmin, __xmax, __fw) {} - - _LIBCPP_INLINE_VISIBILITY - explicit piecewise_constant_distribution(const param_type& __p) - : __p_(__p) {} - - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - vector intervals() const {return __p_.intervals();} - _LIBCPP_INLINE_VISIBILITY - vector densities() const {return __p_.densities();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return __p_.__b_.front();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return __p_.__b_.back();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const piecewise_constant_distribution& __x, - const piecewise_constant_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const piecewise_constant_distribution& __x, - const piecewise_constant_distribution& __y) - {return !(__x == __y);} - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const piecewise_constant_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - piecewise_constant_distribution<_RT>& __x); -}; - -template -typename piecewise_constant_distribution<_RealType>::param_type & -piecewise_constant_distribution<_RealType>::param_type::operator= - (const param_type& __rhs) -{ -// These can throw - __b_.reserve (__rhs.__b_.size ()); - __densities_.reserve(__rhs.__densities_.size()); - __areas_.reserve (__rhs.__areas_.size()); - -// These can not throw - __b_ = __rhs.__b_; - __densities_ = __rhs.__densities_; - __areas_ = __rhs.__areas_; - return *this; -} - -template -void -piecewise_constant_distribution<_RealType>::param_type::__init() -{ - // __densities_ contains non-normalized areas - result_type __total_area = _VSTD::accumulate(__densities_.begin(), - __densities_.end(), - result_type()); - for (size_t __i = 0; __i < __densities_.size(); ++__i) - __densities_[__i] /= __total_area; - // __densities_ contains normalized areas - __areas_.assign(__densities_.size(), result_type()); - _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1, - __areas_.begin() + 1); - // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1] - __densities_.back() = 1 - __areas_.back(); // correct round off error - for (size_t __i = 0; __i < __densities_.size(); ++__i) - __densities_[__i] /= (__b_[__i+1] - __b_[__i]); - // __densities_ now contains __densities_ -} - -template -piecewise_constant_distribution<_RealType>::param_type::param_type() - : __b_(2), - __densities_(1, 1.0), - __areas_(1, 0.0) -{ - __b_[1] = 1; -} - -template -template -piecewise_constant_distribution<_RealType>::param_type::param_type( - _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW) - : __b_(__fB, __lB) -{ - if (__b_.size() < 2) - { - __b_.resize(2); - __b_[0] = 0; - __b_[1] = 1; - __densities_.assign(1, 1.0); - __areas_.assign(1, 0.0); - } - else - { - __densities_.reserve(__b_.size() - 1); - for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW) - __densities_.push_back(*__fW); - __init(); - } -} - -#ifndef _LIBCPP_CXX03_LANG - -template -template -piecewise_constant_distribution<_RealType>::param_type::param_type( - initializer_list __bl, _UnaryOperation __fw) - : __b_(__bl.begin(), __bl.end()) -{ - if (__b_.size() < 2) - { - __b_.resize(2); - __b_[0] = 0; - __b_[1] = 1; - __densities_.assign(1, 1.0); - __areas_.assign(1, 0.0); - } - else - { - __densities_.reserve(__b_.size() - 1); - for (size_t __i = 0; __i < __b_.size() - 1; ++__i) - __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5)); - __init(); - } -} - -#endif // _LIBCPP_CXX03_LANG - -template -template -piecewise_constant_distribution<_RealType>::param_type::param_type( - size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw) - : __b_(__nw == 0 ? 2 : __nw + 1) -{ - size_t __n = __b_.size() - 1; - result_type __d = (__xmax - __xmin) / __n; - __densities_.reserve(__n); - for (size_t __i = 0; __i < __n; ++__i) - { - __b_[__i] = __xmin + __i * __d; - __densities_.push_back(__fw(__b_[__i] + __d*.5)); - } - __b_[__n] = __xmax; - __init(); -} - -template -template -_RealType -piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - typedef uniform_real_distribution _Gen; - result_type __u = _Gen()(__g); - ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), - __u) - __p.__areas_.begin() - 1; - return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k]; -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const piecewise_constant_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - size_t __n = __x.__p_.__b_.size(); - __os << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__b_[__i]; - __n = __x.__p_.__densities_.size(); - __os << __sp << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__densities_[__i]; - __n = __x.__p_.__areas_.size(); - __os << __sp << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__areas_[__i]; - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - piecewise_constant_distribution<_RT>& __x) -{ - typedef piecewise_constant_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - size_t __n; - __is >> __n; - vector __b(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __b[__i]; - __is >> __n; - vector __densities(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __densities[__i]; - __is >> __n; - vector __areas(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __areas[__i]; - if (!__is.fail()) - { - swap(__x.__p_.__b_, __b); - swap(__x.__p_.__densities_, __densities); - swap(__x.__p_.__areas_, __areas); - } - return __is; -} - -// piecewise_linear_distribution - -template -class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution -{ -public: - // types - typedef _RealType result_type; - - class _LIBCPP_TEMPLATE_VIS param_type - { - vector __b_; - vector __densities_; - vector __areas_; - public: - typedef piecewise_linear_distribution distribution_type; - - param_type(); - template - param_type(_InputIteratorB __fB, _InputIteratorB __lB, - _InputIteratorW __fW); -#ifndef _LIBCPP_CXX03_LANG - template - param_type(initializer_list __bl, _UnaryOperation __fw); -#endif // _LIBCPP_CXX03_LANG - template - param_type(size_t __nw, result_type __xmin, result_type __xmax, - _UnaryOperation __fw); - param_type(param_type const&) = default; - param_type & operator=(const param_type& __rhs); - - _LIBCPP_INLINE_VISIBILITY - vector intervals() const {return __b_;} - _LIBCPP_INLINE_VISIBILITY - vector densities() const {return __densities_;} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const param_type& __x, const param_type& __y) - {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const param_type& __x, const param_type& __y) - {return !(__x == __y);} - - private: - void __init(); - - friend class piecewise_linear_distribution; - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const piecewise_linear_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - piecewise_linear_distribution<_RT>& __x); - }; - -private: - param_type __p_; - -public: - // constructor and reset functions - _LIBCPP_INLINE_VISIBILITY - piecewise_linear_distribution() {} - template - _LIBCPP_INLINE_VISIBILITY - piecewise_linear_distribution(_InputIteratorB __fB, - _InputIteratorB __lB, - _InputIteratorW __fW) - : __p_(__fB, __lB, __fW) {} - -#ifndef _LIBCPP_CXX03_LANG - template - _LIBCPP_INLINE_VISIBILITY - piecewise_linear_distribution(initializer_list __bl, - _UnaryOperation __fw) - : __p_(__bl, __fw) {} -#endif // _LIBCPP_CXX03_LANG - - template - _LIBCPP_INLINE_VISIBILITY - piecewise_linear_distribution(size_t __nw, result_type __xmin, - result_type __xmax, _UnaryOperation __fw) - : __p_(__nw, __xmin, __xmax, __fw) {} - - _LIBCPP_INLINE_VISIBILITY - explicit piecewise_linear_distribution(const param_type& __p) - : __p_(__p) {} - - _LIBCPP_INLINE_VISIBILITY - void reset() {} - - // generating functions - template - _LIBCPP_INLINE_VISIBILITY - result_type operator()(_URNG& __g) - {return (*this)(__g, __p_);} - template result_type operator()(_URNG& __g, const param_type& __p); - - // property functions - _LIBCPP_INLINE_VISIBILITY - vector intervals() const {return __p_.intervals();} - _LIBCPP_INLINE_VISIBILITY - vector densities() const {return __p_.densities();} - - _LIBCPP_INLINE_VISIBILITY - param_type param() const {return __p_;} - _LIBCPP_INLINE_VISIBILITY - void param(const param_type& __p) {__p_ = __p;} - - _LIBCPP_INLINE_VISIBILITY - result_type min() const {return __p_.__b_.front();} - _LIBCPP_INLINE_VISIBILITY - result_type max() const {return __p_.__b_.back();} - - friend _LIBCPP_INLINE_VISIBILITY - bool operator==(const piecewise_linear_distribution& __x, - const piecewise_linear_distribution& __y) - {return __x.__p_ == __y.__p_;} - friend _LIBCPP_INLINE_VISIBILITY - bool operator!=(const piecewise_linear_distribution& __x, - const piecewise_linear_distribution& __y) - {return !(__x == __y);} - - template - friend - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const piecewise_linear_distribution<_RT>& __x); - - template - friend - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - piecewise_linear_distribution<_RT>& __x); -}; - -template -typename piecewise_linear_distribution<_RealType>::param_type & -piecewise_linear_distribution<_RealType>::param_type::operator= - (const param_type& __rhs) -{ -// These can throw - __b_.reserve (__rhs.__b_.size ()); - __densities_.reserve(__rhs.__densities_.size()); - __areas_.reserve (__rhs.__areas_.size()); - -// These can not throw - __b_ = __rhs.__b_; - __densities_ = __rhs.__densities_; - __areas_ = __rhs.__areas_; - return *this; -} - - -template -void -piecewise_linear_distribution<_RealType>::param_type::__init() -{ - __areas_.assign(__densities_.size() - 1, result_type()); - result_type _Sp = 0; - for (size_t __i = 0; __i < __areas_.size(); ++__i) - { - __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) * - (__b_[__i+1] - __b_[__i]) * .5; - _Sp += __areas_[__i]; - } - for (size_t __i = __areas_.size(); __i > 1;) - { - --__i; - __areas_[__i] = __areas_[__i-1] / _Sp; - } - __areas_[0] = 0; - for (size_t __i = 1; __i < __areas_.size(); ++__i) - __areas_[__i] += __areas_[__i-1]; - for (size_t __i = 0; __i < __densities_.size(); ++__i) - __densities_[__i] /= _Sp; -} - -template -piecewise_linear_distribution<_RealType>::param_type::param_type() - : __b_(2), - __densities_(2, 1.0), - __areas_(1, 0.0) -{ - __b_[1] = 1; -} - -template -template -piecewise_linear_distribution<_RealType>::param_type::param_type( - _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW) - : __b_(__fB, __lB) -{ - if (__b_.size() < 2) - { - __b_.resize(2); - __b_[0] = 0; - __b_[1] = 1; - __densities_.assign(2, 1.0); - __areas_.assign(1, 0.0); - } - else - { - __densities_.reserve(__b_.size()); - for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW) - __densities_.push_back(*__fW); - __init(); - } -} - -#ifndef _LIBCPP_CXX03_LANG - -template -template -piecewise_linear_distribution<_RealType>::param_type::param_type( - initializer_list __bl, _UnaryOperation __fw) - : __b_(__bl.begin(), __bl.end()) -{ - if (__b_.size() < 2) - { - __b_.resize(2); - __b_[0] = 0; - __b_[1] = 1; - __densities_.assign(2, 1.0); - __areas_.assign(1, 0.0); - } - else - { - __densities_.reserve(__b_.size()); - for (size_t __i = 0; __i < __b_.size(); ++__i) - __densities_.push_back(__fw(__b_[__i])); - __init(); - } -} - -#endif // _LIBCPP_CXX03_LANG - -template -template -piecewise_linear_distribution<_RealType>::param_type::param_type( - size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw) - : __b_(__nw == 0 ? 2 : __nw + 1) -{ - size_t __n = __b_.size() - 1; - result_type __d = (__xmax - __xmin) / __n; - __densities_.reserve(__b_.size()); - for (size_t __i = 0; __i < __n; ++__i) - { - __b_[__i] = __xmin + __i * __d; - __densities_.push_back(__fw(__b_[__i])); - } - __b_[__n] = __xmax; - __densities_.push_back(__fw(__b_[__n])); - __init(); -} - -template -template -_RealType -piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) -{ - typedef uniform_real_distribution _Gen; - result_type __u = _Gen()(__g); - ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), - __u) - __p.__areas_.begin() - 1; - __u -= __p.__areas_[__k]; - const result_type __dk = __p.__densities_[__k]; - const result_type __dk1 = __p.__densities_[__k+1]; - const result_type __deltad = __dk1 - __dk; - const result_type __bk = __p.__b_[__k]; - if (__deltad == 0) - return __u / __dk + __bk; - const result_type __bk1 = __p.__b_[__k+1]; - const result_type __deltab = __bk1 - __bk; - return (__bk * __dk1 - __bk1 * __dk + - _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / - __deltad; -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, - const piecewise_linear_distribution<_RT>& __x) -{ - __save_flags<_CharT, _Traits> __lx(__os); - typedef basic_ostream<_CharT, _Traits> _OStream; - __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | - _OStream::scientific); - _CharT __sp = __os.widen(' '); - __os.fill(__sp); - size_t __n = __x.__p_.__b_.size(); - __os << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__b_[__i]; - __n = __x.__p_.__densities_.size(); - __os << __sp << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__densities_[__i]; - __n = __x.__p_.__areas_.size(); - __os << __sp << __n; - for (size_t __i = 0; __i < __n; ++__i) - __os << __sp << __x.__p_.__areas_[__i]; - return __os; -} - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - piecewise_linear_distribution<_RT>& __x) -{ - typedef piecewise_linear_distribution<_RT> _Eng; - typedef typename _Eng::result_type result_type; - __save_flags<_CharT, _Traits> __lx(__is); - typedef basic_istream<_CharT, _Traits> _Istream; - __is.flags(_Istream::dec | _Istream::skipws); - size_t __n; - __is >> __n; - vector __b(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __b[__i]; - __is >> __n; - vector __densities(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __densities[__i]; - __is >> __n; - vector __areas(__n); - for (size_t __i = 0; __i < __n; ++__i) - __is >> __areas[__i]; - if (!__is.fail()) - { - swap(__x.__p_.__b_, __b); - swap(__x.__p_.__densities_, __densities); - swap(__x.__p_.__areas_, __areas); - } - return __is; -} - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - #endif // _LIBCPP_RANDOM diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/bernoulli_distribution.h'}} +#include <__random/bernoulli_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/binomial_distribution.h'}} +#include <__random/binomial_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/cauchy_distribution.h'}} +#include <__random/cauchy_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/chi_squared_distribution.h'}} +#include <__random/chi_squared_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/default_random_engine.h'}} +#include <__random/default_random_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/discard_block_engine.h'}} +#include <__random/discard_block_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/discrete_distribution.h'}} +#include <__random/discrete_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/exponential_distribution.h'}} +#include <__random/exponential_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/extreme_value_distribution.h'}} +#include <__random/extreme_value_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/fisher_f_distribution.h'}} +#include <__random/fisher_f_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/gamma_distribution.h'}} +#include <__random/gamma_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/generate_canonical.h'}} +#include <__random/generate_canonical.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/geometric_distribution.h'}} +#include <__random/geometric_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/independent_bits_engine.h'}} +#include <__random/independent_bits_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/is_seed_sequence.h'}} +#include <__random/is_seed_sequence.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/knuth_b.h'}} +#include <__random/knuth_b.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/linear_congruential_engine.h'}} +#include <__random/linear_congruential_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/log2.h'}} +#include <__random/log2.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/lognormal_distribution.h'}} +#include <__random/lognormal_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/mersenne_twister_engine.h'}} +#include <__random/mersenne_twister_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/negative_binomial_distribution.h'}} +#include <__random/negative_binomial_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/normal_distribution.h'}} +#include <__random/normal_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/piecewise_constant_distribution.h'}} +#include <__random/piecewise_constant_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/piecewise_linear_distribution.h'}} +#include <__random/piecewise_linear_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/poisson_distribution.h'}} +#include <__random/poisson_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/random_device.h'}} +#include <__random/random_device.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/ranlux.h'}} +#include <__random/ranlux.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/seed_seq.h'}} +#include <__random/seed_seq.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/shuffle_order_engine.h'}} +#include <__random/shuffle_order_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/student_t_distribution.h'}} +#include <__random/student_t_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/subtract_with_carry_engine.h'}} +#include <__random/subtract_with_carry_engine.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/uniform_random_bit_generator.h'}} +#include <__random/uniform_random_bit_generator.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/uniform_real_distribution.h'}} +#include <__random/uniform_real_distribution.h> diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp new file mode 100644 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp @@ -0,0 +1,15 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: modules-build + +// WARNING: This test was generated by 'generate_private_header_tests.py' +// and should not be edited manually. + +// expected-error@*:* {{use of private header from outside its module: '__random/weibull_distribution.h'}} +#include <__random/weibull_distribution.h> diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp --- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp +++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp @@ -19,12 +19,12 @@ { typedef unsigned long long T; - // expected-error@random:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}} + // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}} std::linear_congruential_engine e2; - // expected-error@random:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}} + // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}} std::linear_congruential_engine e3; std::linear_congruential_engine e4; - // expected-error@random:* {{static_assert failed due to requirement 'is_unsigned::value' "_UIntType must be unsigned type"}} + // expected-error@*:* {{static_assert failed due to requirement 'is_unsigned::value' "_UIntType must be unsigned type"}} std::linear_congruential_engine e5; return 0;