diff options
Diffstat (limited to 'contrib/llvm-project/libcxx/include/__random')
37 files changed, 6348 insertions, 0 deletions
diff --git a/contrib/llvm-project/libcxx/include/__random/bernoulli_distribution.h b/contrib/llvm-project/libcxx/include/__random/bernoulli_distribution.h new file mode 100644 index 000000000000..4f33dca132d1 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/bernoulli_distribution.h @@ -0,0 +1,123 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <iosfwd> + +#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_HIDE_FROM_ABI explicit param_type(double __p = 0.5) : __p_(__p) {} + + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI bernoulli_distribution() : bernoulli_distribution(0.5) {} + _LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return false; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return true; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const bernoulli_distribution& __x, const bernoulli_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const bernoulli_distribution& __x, const bernoulli_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _URNG> +inline bernoulli_distribution::result_type bernoulli_distribution::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + uniform_real_distribution<double> __gen; + return __gen(__g) < __p.p(); +} + +template <class _CharT, class _Traits> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/binomial_distribution.h b/contrib/llvm-project/libcxx/include/__random/binomial_distribution.h new file mode 100644 index 000000000000..e8774bb8d67e --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/binomial_distribution.h @@ -0,0 +1,198 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> + +#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 _IntType = int> +class _LIBCPP_TEMPLATE_VIS binomial_distribution { + static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); + +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; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __t = 1, double __p = 0.5); + + _LIBCPP_HIDE_FROM_ABI result_type t() const { return __t_; } + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI binomial_distribution() : binomial_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(result_type __t, double __p = 0.5) + : __p_(param_type(__t, __p)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(result_type __t = 1, double __p = 0.5) + : __p_(param_type(__t, __p)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type t() const { return __p_.t(); } + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return t(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const binomial_distribution& __x, const binomial_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI double __libcpp_lgamma(double __d) { +#if defined(_LIBCPP_MSVCRT_LIKE) + return lgamma(__d); +#else + int __sign; + return lgamma_r(__d, &__sign); +#endif +} + +template <class _IntType> +binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p) : __t_(__t), __p_(__p) { + if (0 < __p_ && __p_ < 1) { + __r0_ = static_cast<result_type>((__t_ + 1) * __p_); + __pr_ = std::exp( + std::__libcpp_lgamma(__t_ + 1.) - std::__libcpp_lgamma(__r0_ + 1.) - std::__libcpp_lgamma(__t_ - __r0_ + 1.) + + __r0_ * std::log(__p_) + (__t_ - __r0_) * std::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 <class _IntType> +template <class _URNG> +_IntType binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + if (__pr.__t_ == 0 || __pr.__p_ == 0) + return 0; + if (__pr.__p_ == 1) + return __pr.__t_; + uniform_real_distribution<double> __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 <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/cauchy_distribution.h b/contrib/llvm-project/libcxx/include/__random/cauchy_distribution.h new file mode 100644 index 000000000000..bd341427a152 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/cauchy_distribution.h @@ -0,0 +1,139 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS cauchy_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {} + + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI cauchy_distribution() : cauchy_distribution(0) {} + _LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(result_type __a = 0, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const cauchy_distribution& __x, const cauchy_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const cauchy_distribution& __x, const cauchy_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +inline _RealType cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + uniform_real_distribution<result_type> __gen; + // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite + return __p.a() + __p.b() * std::tan(3.1415926535897932384626433832795 * __gen(__g)); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/chi_squared_distribution.h b/contrib/llvm-project/libcxx/include/__random/chi_squared_distribution.h new file mode 100644 index 000000000000..efa96dcdaafb --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/chi_squared_distribution.h @@ -0,0 +1,125 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__random/is_valid.h> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS chi_squared_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + result_type __n_; + + public: + typedef chi_squared_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __n = 1) : __n_(__n) {} + + _LIBCPP_HIDE_FROM_ABI result_type n() const { return __n_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__n_ == __y.__n_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI chi_squared_distribution() : chi_squared_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(result_type __n) : __p_(param_type(__n)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(result_type __n = 1) : __p_(param_type(__n)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) { + return gamma_distribution<result_type>(__p.n() / 2, 2)(__g); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const chi_squared_distribution& __x, const chi_squared_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const chi_squared_distribution& __x, const chi_squared_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/clamp_to_integral.h b/contrib/llvm-project/libcxx/include/__random/clamp_to_integral.h new file mode 100644 index 000000000000..d9bfd31b7f01 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/clamp_to_integral.h @@ -0,0 +1,59 @@ +//===----------------------------------------------------------------------===// +// +// 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_CLAMP_TO_INTEGRAL_H +#define _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H + +#include <__config> +#include <cmath> +#include <limits> + +#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 _IntT, + class _FloatT, + bool _FloatBigger = (numeric_limits<_FloatT>::digits > numeric_limits<_IntT>::digits), + int _Bits = (numeric_limits<_IntT>::digits - numeric_limits<_FloatT>::digits)> +_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT { + static_assert(is_floating_point<_FloatT>::value, "must be a floating point type"); + static_assert(is_integral<_IntT>::value, "must be an integral type"); + static_assert(numeric_limits<_FloatT>::radix == 2, "FloatT has incorrect radix"); + static_assert( + (_IsSame<_FloatT, float>::value || _IsSame<_FloatT, double>::value || _IsSame<_FloatT, long double>::value), + "unsupported floating point type"); + return _FloatBigger ? numeric_limits<_IntT>::max() : (numeric_limits<_IntT>::max() >> _Bits << _Bits); +} + +// Convert a floating point number to the specified integral type after +// clamping to the integral type's representable range. +// +// The behavior is undefined if `__r` is NaN. +template <class _IntT, class _RealT> +_LIBCPP_HIDE_FROM_ABI _IntT __clamp_to_integral(_RealT __r) _NOEXCEPT { + using _Lim = numeric_limits<_IntT>; + const _IntT __max_val = __max_representable_int_for_float<_IntT, _RealT>(); + if (__r >= ::nextafter(static_cast<_RealT>(__max_val), INFINITY)) { + return _Lim::max(); + } else if (__r <= _Lim::lowest()) { + return _Lim::min(); + } + return static_cast<_IntT>(__r); +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H diff --git a/contrib/llvm-project/libcxx/include/__random/default_random_engine.h b/contrib/llvm-project/libcxx/include/__random/default_random_engine.h new file mode 100644 index 000000000000..89792f4f0d43 --- /dev/null +++ b/contrib/llvm-project/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/contrib/llvm-project/libcxx/include/__random/discard_block_engine.h b/contrib/llvm-project/libcxx/include/__random/discard_block_engine.h new file mode 100644 index 000000000000..07f599067279 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/discard_block_engine.h @@ -0,0 +1,172 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__type_traits/enable_if.h> +#include <__type_traits/is_convertible.h> +#include <__utility/move.h> +#include <cstddef> +#include <iosfwd> +#include <limits> + +#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 _Engine, size_t __p, size_t __r> +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"); +#ifndef _LIBCPP_CXX03_LANG // numeric_limits::max() is not constexpr in C++03 + static_assert(__r <= numeric_limits<int>::max(), "discard_block_engine invalid parameters"); +#endif + +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 constexpr result_type _Min = _Engine::min(); + static constexpr result_type _Max = _Engine::max(); +#endif + + _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); } + _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); } + + // constructors and seeding functions + _LIBCPP_HIDE_FROM_ABI discard_block_engine() : __n_(0) {} + _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(const _Engine& __e) : __e_(__e), __n_(0) {} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(_Engine&& __e) : __e_(std::move(__e)), __n_(0) {} +#endif // _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {} + template < + class _Sseq, + __enable_if_t<__is_seed_sequence<_Sseq, discard_block_engine>::value && !is_convertible<_Sseq, _Engine>::value, + int> = 0> + _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(_Sseq& __q) : __e_(__q), __n_(0) {} + _LIBCPP_HIDE_FROM_ABI void seed() { + __e_.seed(); + __n_ = 0; + } + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd) { + __e_.seed(__sd); + __n_ = 0; + } + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, discard_block_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) { + __e_.seed(__q); + __n_ = 0; + } + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()(); + _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) { + for (; __z; --__z) + operator()(); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI const _Engine& base() const _NOEXCEPT { return __e_; } + + template <class _Eng, size_t _Pp, size_t _Rp> + friend bool + operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y); + + template <class _Eng, size_t _Pp, size_t _Rp> + friend bool + operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y); + + template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const discard_block_engine<_Eng, _Pp, _Rp>& __x); + + template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, discard_block_engine<_Eng, _Pp, _Rp>& __x); +}; + +template <class _Engine, size_t __p, size_t __r> +_LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size; + +template <class _Engine, size_t __p, size_t __r> +_LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block; + +template <class _Engine, size_t __p, size_t __r> +typename discard_block_engine<_Engine, __p, __r>::result_type discard_block_engine<_Engine, __p, __r>::operator()() { + if (__n_ >= static_cast<int>(__r)) { + __e_.discard(__p - __r); + __n_ = 0; + } + ++__n_; + return __e_(); +} + +template <class _Eng, size_t _Pp, size_t _Rp> +inline _LIBCPP_HIDE_FROM_ABI 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 <class _Eng, size_t _Pp, size_t _Rp> +inline _LIBCPP_HIDE_FROM_ABI bool +operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y) { + return !(__x == __y); +} + +template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/discrete_distribution.h b/contrib/llvm-project/libcxx/include/__random/discrete_distribution.h new file mode 100644 index 000000000000..bb72dd6cb507 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/discrete_distribution.h @@ -0,0 +1,212 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cstddef> +#include <iosfwd> +#include <numeric> +#include <vector> + +#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 _IntType = int> +class _LIBCPP_TEMPLATE_VIS discrete_distribution { + static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); + +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + vector<double> __p_; + + public: + typedef discrete_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI param_type() {} + template <class _InputIterator> + _LIBCPP_HIDE_FROM_ABI param_type(_InputIterator __f, _InputIterator __l) : __p_(__f, __l) { + __init(); + } +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<double> __wl) : __p_(__wl.begin(), __wl.end()) { __init(); } +#endif // _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, double __xmin, double __xmax, _UnaryOperation __fw); + + _LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const; + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); } + + private: + _LIBCPP_HIDE_FROM_ABI void __init(); + + friend class discrete_distribution; + + template <class _CharT, class _Traits, class _IT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const discrete_distribution<_IT>& __x); + + template <class _CharT, class _Traits, class _IT> + 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_HIDE_FROM_ABI discrete_distribution() {} + template <class _InputIterator> + _LIBCPP_HIDE_FROM_ABI discrete_distribution(_InputIterator __f, _InputIterator __l) : __p_(__f, __l) {} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI discrete_distribution(initializer_list<double> __wl) : __p_(__wl) {} +#endif // _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI discrete_distribution(size_t __nw, double __xmin, double __xmax, _UnaryOperation __fw) + : __p_(__nw, __xmin, __xmax, __fw) {} + _LIBCPP_HIDE_FROM_ABI explicit discrete_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const { return __p_.probabilities(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__p_.size(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const discrete_distribution& __x, const discrete_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const discrete_distribution& __x, const discrete_distribution& __y) { + return !(__x == __y); + } + + template <class _CharT, class _Traits, class _IT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const discrete_distribution<_IT>& __x); + + template <class _CharT, class _Traits, class _IT> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, discrete_distribution<_IT>& __x); +}; + +template <class _IntType> +template <class _UnaryOperation> +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 <class _IntType> +void discrete_distribution<_IntType>::param_type::__init() { + if (!__p_.empty()) { + if (__p_.size() > 1) { + double __s = std::accumulate(__p_.begin(), __p_.end(), 0.0); + for (vector<double>::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i) + *__i /= __s; + vector<double> __t(__p_.size() - 1); + std::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin()); + swap(__p_, __t); + } else { + __p_.clear(); + __p_.shrink_to_fit(); + } + } +} + +template <class _IntType> +vector<double> discrete_distribution<_IntType>::param_type::probabilities() const { + size_t __n = __p_.size(); + vector<double> __p(__n + 1); + std::adjacent_difference(__p_.begin(), __p_.end(), __p.begin()); + if (__n > 0) + __p[__n] = 1 - __p_[__n - 1]; + else + __p[0] = 1; + return __p; +} + +template <class _IntType> +template <class _URNG> +_IntType discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + uniform_real_distribution<double> __gen; + return static_cast<_IntType>(std::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) - __p.__p_.begin()); +} + +template <class _CharT, class _Traits, class _IT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _IT> +_LIBCPP_HIDE_FROM_ABI 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<double> __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/contrib/llvm-project/libcxx/include/__random/exponential_distribution.h b/contrib/llvm-project/libcxx/include/__random/exponential_distribution.h new file mode 100644 index 000000000000..e0e38841172f --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/exponential_distribution.h @@ -0,0 +1,132 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS exponential_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + result_type __lambda_; + + public: + typedef exponential_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {} + + _LIBCPP_HIDE_FROM_ABI result_type lambda() const { return __lambda_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__lambda_ == __y.__lambda_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI exponential_distribution() : exponential_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(result_type __lambda) : __p_(param_type(__lambda)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(result_type __lambda = 1) : __p_(param_type(__lambda)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type lambda() const { return __p_.lambda(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const exponential_distribution& __x, const exponential_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const exponential_distribution& __x, const exponential_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +_RealType exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + return -std::log(result_type(1) - std::generate_canonical<result_type, numeric_limits<result_type>::digits>(__g)) / + __p.lambda(); +} + +template <class _CharT, class _Traits, class _RealType> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RealType> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/extreme_value_distribution.h b/contrib/llvm-project/libcxx/include/__random/extreme_value_distribution.h new file mode 100644 index 000000000000..5505f93274f5 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/extreme_value_distribution.h @@ -0,0 +1,139 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS extreme_value_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {} + + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI extreme_value_distribution() : extreme_value_distribution(0) {} + _LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const extreme_value_distribution& __x, const extreme_value_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const extreme_value_distribution& __x, const extreme_value_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +_RealType extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + return __p.a() - __p.b() * std::log(-std::log(1 - uniform_real_distribution<result_type>()(__g))); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/fisher_f_distribution.h b/contrib/llvm-project/libcxx/include/__random/fisher_f_distribution.h new file mode 100644 index 000000000000..cd170b3af388 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/fisher_f_distribution.h @@ -0,0 +1,138 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__random/is_valid.h> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS fisher_f_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __m = 1, result_type __n = 1) : __m_(__m), __n_(__n) {} + + _LIBCPP_HIDE_FROM_ABI result_type m() const { return __m_; } + _LIBCPP_HIDE_FROM_ABI result_type n() const { return __n_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI fisher_f_distribution() : fisher_f_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(result_type __m, result_type __n = 1) + : __p_(param_type(__m, __n)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1) + : __p_(param_type(__m, __n)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type m() const { return __p_.m(); } + _LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const fisher_f_distribution& __x, const fisher_f_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const fisher_f_distribution& __x, const fisher_f_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +_RealType fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + gamma_distribution<result_type> __gdm(__p.m() * result_type(.5)); + gamma_distribution<result_type> __gdn(__p.n() * result_type(.5)); + return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g)); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/gamma_distribution.h b/contrib/llvm-project/libcxx/include/__random/gamma_distribution.h new file mode 100644 index 000000000000..986e42c1c7f5 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/gamma_distribution.h @@ -0,0 +1,181 @@ +//===----------------------------------------------------------------------===// +// +// 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/exponential_distribution.h> +#include <__random/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS gamma_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __alpha = 1, result_type __beta = 1) + : __alpha_(__alpha), __beta_(__beta) {} + + _LIBCPP_HIDE_FROM_ABI result_type alpha() const { return __alpha_; } + _LIBCPP_HIDE_FROM_ABI result_type beta() const { return __beta_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI gamma_distribution() : gamma_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(result_type __alpha, result_type __beta = 1) + : __p_(param_type(__alpha, __beta)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1) + : __p_(param_type(__alpha, __beta)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type alpha() const { return __p_.alpha(); } + _LIBCPP_HIDE_FROM_ABI result_type beta() const { return __p_.beta(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const gamma_distribution& __x, const gamma_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const gamma_distribution& __x, const gamma_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +_RealType gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + result_type __a = __p.alpha(); + uniform_real_distribution<result_type> __gen(0, 1); + exponential_distribution<result_type> __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 = std::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 (std::log(__z) <= 2 * (__b * std::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 = std::pow(__u, 1 / __a); + if (__x <= __es) + break; + } else { + const result_type __e = -std::log((1 - __u) / __a); + __x = std::pow(1 - __a + __a * __e, 1 / __a); + if (__x <= __e + __es) + break; + } + } + } + return __x * __p.beta(); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/generate_canonical.h b/contrib/llvm-project/libcxx/include/__random/generate_canonical.h new file mode 100644 index 000000000000..738de1517e28 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/generate_canonical.h @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// 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 <cstdint> +#include <initializer_list> +#include <limits> + +#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 <class _RealType, size_t __bits, class _URNG> +_LIBCPP_HIDE_FROM_ABI _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 __log_r = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value; +#else + const size_t __log_r = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value; +#endif + const size_t __k = __b / __log_r + (__b % __log_r != 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/contrib/llvm-project/libcxx/include/__random/geometric_distribution.h b/contrib/llvm-project/libcxx/include/__random/geometric_distribution.h new file mode 100644 index 000000000000..cecd7e57cfa6 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/geometric_distribution.h @@ -0,0 +1,120 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/negative_binomial_distribution.h> +#include <iosfwd> +#include <limits> + +#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 _IntType = int> +class _LIBCPP_TEMPLATE_VIS geometric_distribution { + static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); + +public: + // types + typedef _IntType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + double __p_; + + public: + typedef geometric_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(double __p = 0.5) : __p_(__p) {} + + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI geometric_distribution() : geometric_distribution(0.5) {} + _LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(double __p) : __p_(__p) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(double __p = 0.5) : __p_(__p) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) { + return negative_binomial_distribution<result_type>(1, __p.p())(__g); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::max(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const geometric_distribution& __x, const geometric_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const geometric_distribution& __x, const geometric_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/independent_bits_engine.h b/contrib/llvm-project/libcxx/include/__random/independent_bits_engine.h new file mode 100644 index 000000000000..0f4a7b82b98f --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/independent_bits_engine.h @@ -0,0 +1,205 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__fwd/istream.h> +#include <__fwd/ostream.h> +#include <__random/is_seed_sequence.h> +#include <__random/log2.h> +#include <__type_traits/conditional.h> +#include <__type_traits/enable_if.h> +#include <__type_traits/is_convertible.h> +#include <__utility/move.h> +#include <cstddef> +#include <limits> + +#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 _Engine, size_t __w, class _UIntType> +class _LIBCPP_TEMPLATE_VIS independent_bits_engine { + template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp> + 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<result_type>::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 __conditional_t<sizeof(_Engine_result_type) <= sizeof(result_type), result_type, _Engine_result_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_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + + // constructors and seeding functions + _LIBCPP_HIDE_FROM_ABI independent_bits_engine() {} + _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(const _Engine& __e) : __e_(__e) {} +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(_Engine&& __e) : __e_(std::move(__e)) {} +#endif // _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(result_type __sd) : __e_(__sd) {} + template < + class _Sseq, + __enable_if_t<__is_seed_sequence<_Sseq, independent_bits_engine>::value && !is_convertible<_Sseq, _Engine>::value, + int> = 0> + _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(_Sseq& __q) : __e_(__q) {} + _LIBCPP_HIDE_FROM_ABI void seed() { __e_.seed(); } + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd) { __e_.seed(__sd); } + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, independent_bits_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) { + __e_.seed(__q); + } + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()() { return __eval(integral_constant<bool, _Rp != 0>()); } + _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) { + for (; __z; --__z) + operator()(); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI const _Engine& base() const _NOEXCEPT { return __e_; } + + template <class _Eng, size_t _Wp, class _UInt> + friend bool operator==(const independent_bits_engine<_Eng, _Wp, _UInt>& __x, + const independent_bits_engine<_Eng, _Wp, _UInt>& __y); + + template <class _Eng, size_t _Wp, class _UInt> + friend bool operator!=(const independent_bits_engine<_Eng, _Wp, _UInt>& __x, + const independent_bits_engine<_Eng, _Wp, _UInt>& __y); + + template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const independent_bits_engine<_Eng, _Wp, _UInt>& __x); + + template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, independent_bits_engine<_Eng, _Wp, _UInt>& __x); + +private: + _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type); + _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type); + + template <size_t __count, + __enable_if_t<__count< _Dt, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) { + return __x << __count; + } + + template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0> + _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type) { + return result_type(0); + } +}; + +template <class _Engine, size_t __w, class _UIntType> +inline _UIntType independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type) { + return static_cast<result_type>(__e_() & __mask0); +} + +template <class _Engine, size_t __w, class _UIntType> +_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<result_type>(__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<result_type>(__lshift<__w0 + 1>(__sp) + (__u & __mask1)); + } + return __sp; +} + +template <class _Eng, size_t _Wp, class _UInt> +inline _LIBCPP_HIDE_FROM_ABI bool +operator==(const independent_bits_engine<_Eng, _Wp, _UInt>& __x, const independent_bits_engine<_Eng, _Wp, _UInt>& __y) { + return __x.base() == __y.base(); +} + +template <class _Eng, size_t _Wp, class _UInt> +inline _LIBCPP_HIDE_FROM_ABI bool +operator!=(const independent_bits_engine<_Eng, _Wp, _UInt>& __x, const independent_bits_engine<_Eng, _Wp, _UInt>& __y) { + return !(__x == __y); +} + +template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt> +_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const independent_bits_engine<_Eng, _Wp, _UInt>& __x) { + return __os << __x.base(); +} + +template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/is_seed_sequence.h b/contrib/llvm-project/libcxx/include/__random/is_seed_sequence.h new file mode 100644 index 000000000000..c7171cff2eda --- /dev/null +++ b/contrib/llvm-project/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 <__type_traits/is_convertible.h> +#include <__type_traits/is_same.h> +#include <__type_traits/remove_cv.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Sseq, class _Engine> +struct __is_seed_sequence { + static _LIBCPP_CONSTEXPR const bool value = + !is_convertible<_Sseq, typename _Engine::result_type>::value && !is_same<__remove_cv_t<_Sseq>, _Engine>::value; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H diff --git a/contrib/llvm-project/libcxx/include/__random/is_valid.h b/contrib/llvm-project/libcxx/include/__random/is_valid.h new file mode 100644 index 000000000000..a3e0f143ae86 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/is_valid.h @@ -0,0 +1,94 @@ +//===----------------------------------------------------------------------===// +// +// 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_VALID_H +#define _LIBCPP___RANDOM_IS_VALID_H + +#include <__config> +#include <__type_traits/enable_if.h> +#include <__type_traits/integral_constant.h> +#include <__type_traits/is_same.h> +#include <__type_traits/is_unsigned.h> +#include <__utility/declval.h> +#include <cstdint> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +// [rand.req.genl]/1.4: +// The effect of instantiating a template that has a template type parameter +// named RealType is undefined unless the corresponding template argument is +// cv-unqualified and is one of float, double, or long double. + +template <class> +struct __libcpp_random_is_valid_realtype : false_type {}; +template <> +struct __libcpp_random_is_valid_realtype<float> : true_type {}; +template <> +struct __libcpp_random_is_valid_realtype<double> : true_type {}; +template <> +struct __libcpp_random_is_valid_realtype<long double> : true_type {}; + +// [rand.req.genl]/1.5: +// The effect of instantiating a template that has a template type parameter +// named IntType is undefined unless the corresponding template argument is +// cv-unqualified and is one of short, int, long, long long, unsigned short, +// unsigned int, unsigned long, or unsigned long long. + +template <class> +struct __libcpp_random_is_valid_inttype : false_type {}; +template <> +struct __libcpp_random_is_valid_inttype<int8_t> : true_type {}; // extension +template <> +struct __libcpp_random_is_valid_inttype<short> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<int> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<long> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<long long> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<uint8_t> : true_type {}; // extension +template <> +struct __libcpp_random_is_valid_inttype<unsigned short> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<unsigned int> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<unsigned long> : true_type {}; +template <> +struct __libcpp_random_is_valid_inttype<unsigned long long> : true_type {}; + +#ifndef _LIBCPP_HAS_NO_INT128 +template <> +struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {}; // extension +template <> +struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {}; // extension +#endif // _LIBCPP_HAS_NO_INT128 + +// [rand.req.urng]/3: +// A class G meets the uniform random bit generator requirements if G models +// uniform_random_bit_generator, invoke_result_t<G&> is an unsigned integer type, +// and G provides a nested typedef-name result_type that denotes the same type +// as invoke_result_t<G&>. +// (In particular, reject URNGs with signed result_types; our distributions cannot +// handle such generator types.) + +template <class, class = void> +struct __libcpp_random_is_valid_urng : false_type {}; +template <class _Gp> +struct __libcpp_random_is_valid_urng< + _Gp, + __enable_if_t< is_unsigned<typename _Gp::result_type>::value && + _IsSame<decltype(std::declval<_Gp&>()()), typename _Gp::result_type>::value > > : true_type {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_IS_VALID_H diff --git a/contrib/llvm-project/libcxx/include/__random/knuth_b.h b/contrib/llvm-project/libcxx/include/__random/knuth_b.h new file mode 100644 index 000000000000..f5b31cb64fa4 --- /dev/null +++ b/contrib/llvm-project/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<minstd_rand0, 256> knuth_b; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_KNUTH_B_H diff --git a/contrib/llvm-project/libcxx/include/__random/linear_congruential_engine.h b/contrib/llvm-project/libcxx/include/__random/linear_congruential_engine.h new file mode 100644 index 000000000000..9d77649e9cfc --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/linear_congruential_engine.h @@ -0,0 +1,387 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__type_traits/enable_if.h> +#include <__type_traits/integral_constant.h> +#include <__type_traits/is_unsigned.h> +#include <cstdint> +#include <iosfwd> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +enum __lce_alg_type { + _LCE_Full, + _LCE_Part, + _LCE_Schrage, + _LCE_Promote, +}; + +template <unsigned long long __a, + unsigned long long __c, + unsigned long long __m, + unsigned long long _Mp, + bool _HasOverflow = (__a != 0ull && (__m & (__m - 1ull)) != 0ull), // a != 0, m != 0, m != 2^n + bool _Full = (!_HasOverflow || __m - 1ull <= (_Mp - __c) / __a), // (a * x + c) % m works + bool _Part = (!_HasOverflow || __m - 1ull <= _Mp / __a), // (a * x) % m works + bool _Schrage = (_HasOverflow && __m % __a <= __m / __a)> // r <= q +struct __lce_alg_picker { + static _LIBCPP_CONSTEXPR const __lce_alg_type __mode = + _Full ? _LCE_Full + : _Part ? _LCE_Part + : _Schrage ? _LCE_Schrage + : _LCE_Promote; + +#ifdef _LIBCPP_HAS_NO_INT128 + static_assert(_Mp != (unsigned long long)(-1) || _Full || _Part || _Schrage, + "The current values for a, c, and m are not currently supported on platforms without __int128"); +#endif +}; + +template <unsigned long long __a, + unsigned long long __c, + unsigned long long __m, + unsigned long long _Mp, + __lce_alg_type _Mode = __lce_alg_picker<__a, __c, __m, _Mp>::__mode> +struct __lce_ta; + +// 64 + +#ifndef _LIBCPP_HAS_NO_INT128 +template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp> +struct __lce_ta<_Ap, _Cp, _Mp, (unsigned long long)(-1), _LCE_Promote> { + typedef unsigned long long result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __xp) { + __extension__ using __calc_type = unsigned __int128; + const __calc_type __a = static_cast<__calc_type>(_Ap); + const __calc_type __c = static_cast<__calc_type>(_Cp); + const __calc_type __m = static_cast<__calc_type>(_Mp); + const __calc_type __x = static_cast<__calc_type>(__xp); + return static_cast<result_type>((__a * __x + __c) % __m); + } +}; +#endif + +template <unsigned long long __a, unsigned long long __c, unsigned long long __m> +struct __lce_ta<__a, __c, __m, (unsigned long long)(-1), _LCE_Schrage> { + typedef unsigned long long result_type; + _LIBCPP_HIDE_FROM_ABI 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 <unsigned long long __a, unsigned long long __m> +struct __lce_ta<__a, 0ull, __m, (unsigned long long)(-1), _LCE_Schrage> { + typedef unsigned long long result_type; + _LIBCPP_HIDE_FROM_ABI 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 <unsigned long long __a, unsigned long long __c, unsigned long long __m> +struct __lce_ta<__a, __c, __m, (unsigned long long)(-1), _LCE_Part> { + typedef unsigned long long result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + // Use (((a*x) % m) + c) % m + __x = (__a * __x) % __m; + __x += __c - (__x >= __m - __c) * __m; + return __x; + } +}; + +template <unsigned long long __a, unsigned long long __c, unsigned long long __m> +struct __lce_ta<__a, __c, __m, (unsigned long long)(-1), _LCE_Full> { + typedef unsigned long long result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { return (__a * __x + __c) % __m; } +}; + +template <unsigned long long __a, unsigned long long __c> +struct __lce_ta<__a, __c, 0ull, (unsigned long long)(-1), _LCE_Full> { + typedef unsigned long long result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { return __a * __x + __c; } +}; + +// 32 + +template <unsigned long long __a, unsigned long long __c, unsigned long long __m> +struct __lce_ta<__a, __c, __m, unsigned(-1), _LCE_Promote> { + typedef unsigned result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + return static_cast<result_type>(__lce_ta<__a, __c, __m, (unsigned long long)(-1)>::next(__x)); + } +}; + +template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp> +struct __lce_ta<_Ap, _Cp, _Mp, unsigned(-1), _LCE_Schrage> { + typedef unsigned result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + const result_type __a = static_cast<result_type>(_Ap); + const result_type __c = static_cast<result_type>(_Cp); + const result_type __m = static_cast<result_type>(_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 <unsigned long long _Ap, unsigned long long _Mp> +struct __lce_ta<_Ap, 0ull, _Mp, unsigned(-1), _LCE_Schrage> { + typedef unsigned result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + const result_type __a = static_cast<result_type>(_Ap); + const result_type __m = static_cast<result_type>(_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 <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp> +struct __lce_ta<_Ap, _Cp, _Mp, unsigned(-1), _LCE_Part> { + typedef unsigned result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + const result_type __a = static_cast<result_type>(_Ap); + const result_type __c = static_cast<result_type>(_Cp); + const result_type __m = static_cast<result_type>(_Mp); + // Use (((a*x) % m) + c) % m + __x = (__a * __x) % __m; + __x += __c - (__x >= __m - __c) * __m; + return __x; + } +}; + +template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp> +struct __lce_ta<_Ap, _Cp, _Mp, unsigned(-1), _LCE_Full> { + typedef unsigned result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + const result_type __a = static_cast<result_type>(_Ap); + const result_type __c = static_cast<result_type>(_Cp); + const result_type __m = static_cast<result_type>(_Mp); + return (__a * __x + __c) % __m; + } +}; + +template <unsigned long long _Ap, unsigned long long _Cp> +struct __lce_ta<_Ap, _Cp, 0ull, unsigned(-1), _LCE_Full> { + typedef unsigned result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + const result_type __a = static_cast<result_type>(_Ap); + const result_type __c = static_cast<result_type>(_Cp); + return __a * __x + __c; + } +}; + +// 16 + +template <unsigned long long __a, unsigned long long __c, unsigned long long __m, __lce_alg_type __mode> +struct __lce_ta<__a, __c, __m, (unsigned short)(-1), __mode> { + typedef unsigned short result_type; + _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { + return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(-1)>::next(__x)); + } +}; + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +class _LIBCPP_TEMPLATE_VIS linear_congruential_engine; + +template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np> +_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); + +template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np> +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +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(-1); + + 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 - _UIntType(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_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI linear_congruential_engine() : linear_congruential_engine(default_seed) {} + _LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(result_type __s) { seed(__s); } +#else + _LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(result_type __s = default_seed) { seed(__s); } +#endif + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, linear_congruential_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(_Sseq& __q) { + seed(__q); + } + _LIBCPP_HIDE_FROM_ABI void seed(result_type __s = default_seed) { + seed(integral_constant<bool, __m == 0>(), integral_constant<bool, __c == 0>(), __s); + } + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, linear_congruential_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) { + __seed( + __q, + integral_constant<unsigned, + 1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1) / 32 : (__m > 0x100000000ull))>()); + } + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()() { + return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_)); + } + _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) { + for (; __z; --__z) + operator()(); + } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const linear_congruential_engine& __x, const linear_congruential_engine& __y) { + return __x.__x_ == __y.__x_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const linear_congruential_engine& __x, const linear_congruential_engine& __y) { + return !(__x == __y); + } + +private: + _LIBCPP_HIDE_FROM_ABI void seed(true_type, true_type, result_type __s) { __x_ = __s == 0 ? 1 : __s; } + _LIBCPP_HIDE_FROM_ABI void seed(true_type, false_type, result_type __s) { __x_ = __s; } + _LIBCPP_HIDE_FROM_ABI void seed(false_type, true_type, result_type __s) { __x_ = __s % __m == 0 ? 1 : __s % __m; } + _LIBCPP_HIDE_FROM_ABI void seed(false_type, false_type, result_type __s) { __x_ = __s % __m; } + + template <class _Sseq> + _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>); + template <class _Sseq> + _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>); + + template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&); + + template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); +}; + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier; + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::increment; + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::modulus; + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type + linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed; + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +template <class _Sseq> +void linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, integral_constant<unsigned, 1>) { + const unsigned __k = 1; + uint32_t __ar[__k + 3]; + __q.generate(__ar, __ar + __k + 3); + result_type __s = static_cast<result_type>(__ar[3] % __m); + __x_ = __c == 0 && __s == 0 ? result_type(1) : __s; +} + +template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +template <class _Sseq> +void linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, integral_constant<unsigned, 2>) { + const unsigned __k = 2; + uint32_t __ar[__k + 3]; + __q.generate(__ar, __ar + __k + 3); + result_type __s = static_cast<result_type>((__ar[3] + ((uint64_t)__ar[4] << 32)) % __m); + __x_ = __c == 0 && __s == 0 ? result_type(1) : __s; +} + +template <class _CharT, class _Traits, class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +inline _LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> +_LIBCPP_HIDE_FROM_ABI 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<uint_fast32_t, 16807, 0, 2147483647> minstd_rand0; +typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647> minstd_rand; + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H diff --git a/contrib/llvm-project/libcxx/include/__random/log2.h b/contrib/llvm-project/libcxx/include/__random/log2.h new file mode 100644 index 000000000000..74b4889c6402 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/log2.h @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__type_traits/conditional.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _UIntType, _UIntType _Xp, size_t _Rp> +struct __log2_imp; + +template <unsigned long long _Xp, size_t _Rp> +struct __log2_imp<unsigned long long, _Xp, _Rp> { + static const size_t value = + _Xp & ((unsigned long long)(1) << _Rp) ? _Rp : __log2_imp<unsigned long long, _Xp, _Rp - 1>::value; +}; + +template <unsigned long long _Xp> +struct __log2_imp<unsigned long long, _Xp, 0> { + static const size_t value = 0; +}; + +template <size_t _Rp> +struct __log2_imp<unsigned long long, 0, _Rp> { + static const size_t value = _Rp + 1; +}; + +#ifndef _LIBCPP_HAS_NO_INT128 + +template <__uint128_t _Xp, size_t _Rp> +struct __log2_imp<__uint128_t, _Xp, _Rp> { + static const size_t value = + (_Xp >> 64) ? (64 + __log2_imp<unsigned long long, (_Xp >> 64), 63>::value) + : __log2_imp<unsigned long long, _Xp, 63>::value; +}; + +#endif // _LIBCPP_HAS_NO_INT128 + +template <class _UIntType, _UIntType _Xp> +struct __log2 { + static const size_t value = __log2_imp< +#ifndef _LIBCPP_HAS_NO_INT128 + __conditional_t<sizeof(_UIntType) <= sizeof(unsigned long long), unsigned long long, __uint128_t>, +#else + unsigned long long, +#endif // _LIBCPP_HAS_NO_INT128 + _Xp, + sizeof(_UIntType) * __CHAR_BIT__ - 1>::value; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_LOG2_H diff --git a/contrib/llvm-project/libcxx/include/__random/lognormal_distribution.h b/contrib/llvm-project/libcxx/include/__random/lognormal_distribution.h new file mode 100644 index 000000000000..d8724f8bc5ce --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/lognormal_distribution.h @@ -0,0 +1,126 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/normal_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS lognormal_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + result_type __m_; + result_type __s_; + + public: + typedef lognormal_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __m = 0, result_type __s = 1) : __m_(__m), __s_(__s) {} + + _LIBCPP_HIDE_FROM_ABI result_type m() const { return __m_; } + _LIBCPP_HIDE_FROM_ABI result_type s() const { return __s_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__m_ == __y.__m_ && __x.__s_ == __y.__s_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); } + }; + +private: + normal_distribution<result_type> __nd_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI lognormal_distribution() : lognormal_distribution(0) {} + _LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(result_type __m, result_type __s = 1) : __nd_(__m, __s) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(result_type __m = 0, result_type __s = 1) : __nd_(__m, __s) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(const param_type& __p) : __nd_(__p.m(), __p.s()) {} + _LIBCPP_HIDE_FROM_ABI void reset() { __nd_.reset(); } + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return std::exp(__nd_(__g)); + } + + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) { + typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s()); + return std::exp(__nd_(__g, __pn)); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type m() const { return __nd_.mean(); } + _LIBCPP_HIDE_FROM_ABI result_type s() const { return __nd_.stddev(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return param_type(__nd_.mean(), __nd_.stddev()); } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { + typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s()); + __nd_.param(__pn); + } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const lognormal_distribution& __x, const lognormal_distribution& __y) { + return __x.__nd_ == __y.__nd_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const lognormal_distribution& __x, const lognormal_distribution& __y) { + return !(__x == __y); + } + + template <class _CharT, class _Traits, class _RT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const lognormal_distribution<_RT>& __x); + + template <class _CharT, class _Traits, class _RT> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, lognormal_distribution<_RT>& __x); +}; + +template <class _CharT, class _Traits, class _RT> +inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const lognormal_distribution<_RT>& __x) { + return __os << __x.__nd_; +} + +template <class _CharT, class _Traits, class _RT> +inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, lognormal_distribution<_RT>& __x) { + return __is >> __x.__nd_; +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H diff --git a/contrib/llvm-project/libcxx/include/__random/mersenne_twister_engine.h b/contrib/llvm-project/libcxx/include/__random/mersenne_twister_engine.h new file mode 100644 index 000000000000..65280d7c5505 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/mersenne_twister_engine.h @@ -0,0 +1,914 @@ +//===----------------------------------------------------------------------===// +// +// 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 <cstddef> +#include <cstdint> +#include <iosfwd> +#include <limits> + +#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 _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine; + +template <class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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 <class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, + class _Traits, + class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, + class _Traits, + class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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 _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +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<result_type>::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_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} + _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(result_type __sd) { seed(__sd); } +#else + _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(result_type __sd = default_seed) { seed(__sd); } +#endif + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(_Sseq& __q) { + seed(__q); + } + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed); + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) { + __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>()); + } + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()(); + _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) { + for (; __z; --__z) + operator()(); + } + + template <class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> + 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 <class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> + 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 <class _CharT, + class _Traits, + class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> + 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 <class _CharT, + class _Traits, + class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> + 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 <class _Sseq> + _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>); + template <class _Sseq> + _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>); + + template <size_t __count, + __enable_if_t<__count< __w, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) { + return (__x << __count) & _Max; + } + + template <size_t __count, __enable_if_t<(__count >= __w), int> = 0> + _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type) { + return result_type(0); + } + + template <size_t __count, + __enable_if_t<__count< _Dt, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __rshift(result_type __x) { + return __x >> __count; + } + + template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0> + _LIBCPP_HIDE_FROM_ABI static result_type __rshift(result_type) { + return result_type(0); + } +}; + +template <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +template <class _Sseq> +void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed( + _Sseq& __q, integral_constant<unsigned, 1>) { + 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<result_type>(__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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +template <class _Sseq> +void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed( + _Sseq& __q, integral_constant<unsigned, 2>) { + 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<result_type>((__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 <class _UIntType, + size_t __w, + size_t __n, + size_t __m, + size_t __r, + _UIntType __a, + size_t __u, + _UIntType __d, + size_t __s, + _UIntType __b, + size_t __t, + _UIntType __c, + size_t __l, + _UIntType __f> +_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 <class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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 std::equal(__x.__x_, __x.__x_ + _Np, __y.__x_); + if (__x.__i_ == 0 || __y.__i_ == 0) { + size_t __j = std::min(_Np - __x.__i_, _Np - __y.__i_); + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_)) + return false; + if (__x.__i_ == 0) + return std::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_); + return std::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j); + } + if (__x.__i_ < __y.__i_) { + size_t __j = _Np - __y.__i_; + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_)) + return false; + if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, __y.__x_)) + return false; + return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Np - (__x.__i_ + __j))); + } + size_t __j = _Np - __x.__i_; + if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_)) + return false; + if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, __x.__x_)) + return false; + return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Np - (__y.__i_ + __j))); +} + +template <class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +inline _LIBCPP_HIDE_FROM_ABI 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 <class _CharT, + class _Traits, + class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, + class _Traits, + class _UInt, + size_t _Wp, + size_t _Np, + size_t _Mp, + size_t _Rp, + _UInt _Ap, + size_t _Up, + _UInt _Dp, + size_t _Sp, + _UInt _Bp, + size_t _Tp, + _UInt _Cp, + size_t _Lp, + _UInt _Fp> +_LIBCPP_HIDE_FROM_ABI 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< + uint_fast32_t, + 32, + 624, + 397, + 31, + 0x9908b0df, + 11, + 0xffffffff, + 7, + 0x9d2c5680, + 15, + 0xefc60000, + 18, + 1812433253> + mt19937; +typedef mersenne_twister_engine< + uint_fast64_t, + 64, + 312, + 156, + 31, + 0xb5026f5aa96619e9ULL, + 29, + 0x5555555555555555ULL, + 17, + 0x71d67fffeda60000ULL, + 37, + 0xfff7eee000000000ULL, + 43, + 6364136223846793005ULL> + mt19937_64; + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H diff --git a/contrib/llvm-project/libcxx/include/__random/negative_binomial_distribution.h b/contrib/llvm-project/libcxx/include/__random/negative_binomial_distribution.h new file mode 100644 index 000000000000..6d0055d01ed4 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/negative_binomial_distribution.h @@ -0,0 +1,157 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__assert> +#include <__config> +#include <__random/bernoulli_distribution.h> +#include <__random/gamma_distribution.h> +#include <__random/is_valid.h> +#include <__random/poisson_distribution.h> +#include <iosfwd> +#include <limits> + +#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 _IntType = int> +class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution { + static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __k = 1, double __p = 0.5) : __k_(__k), __p_(__p) {} + + _LIBCPP_HIDE_FROM_ABI result_type k() const { return __k_; } + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI negative_binomial_distribution() : negative_binomial_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(result_type __k, double __p = 0.5) : __p_(__k, __p) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5) + : __p_(__k, __p) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type k() const { return __p_.k(); } + _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::max(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const negative_binomial_distribution& __x, const negative_binomial_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const negative_binomial_distribution& __x, const negative_binomial_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _IntType> +template <class _URNG> +_IntType negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + result_type __k = __pr.k(); + double __p = __pr.p(); + // When the number of bits in _IntType is small, we are too likely to + // overflow __f below to use this technique. + if (__k <= 21 * __p && sizeof(_IntType) > 1) { + bernoulli_distribution __gen(__p); + result_type __f = 0; + result_type __s = 0; + while (__s < __k) { + if (__gen(__urng)) + ++__s; + else + ++__f; + } + _LIBCPP_ASSERT_INTERNAL(__f >= 0, + "std::negative_binomial_distribution should never produce negative values. " + "This is almost certainly a signed integer overflow issue on __f."); + return __f; + } + return poisson_distribution<result_type>(gamma_distribution<double>(__k, (1 - __p) / __p)(__urng))(__urng); +} + +template <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/normal_distribution.h b/contrib/llvm-project/libcxx/include/__random/normal_distribution.h new file mode 100644 index 000000000000..889f189e4161 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/normal_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_NORMAL_DISTRIBUTION_H +#define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H + +#include <__config> +#include <__random/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS normal_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __mean = 0, result_type __stddev = 1) + : __mean_(__mean), __stddev_(__stddev) {} + + _LIBCPP_HIDE_FROM_ABI result_type mean() const { return __mean_; } + _LIBCPP_HIDE_FROM_ABI result_type stddev() const { return __stddev_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI normal_distribution() : normal_distribution(0) {} + _LIBCPP_HIDE_FROM_ABI explicit normal_distribution(result_type __mean, result_type __stddev = 1) + : __p_(param_type(__mean, __stddev)), __v_hot_(false) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1) + : __p_(param_type(__mean, __stddev)), __v_hot_(false) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit normal_distribution(const param_type& __p) : __p_(__p), __v_hot_(false) {} + _LIBCPP_HIDE_FROM_ABI void reset() { __v_hot_ = false; } + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type mean() const { return __p_.mean(); } + _LIBCPP_HIDE_FROM_ABI result_type stddev() const { return __p_.stddev(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI bool operator!=(const normal_distribution& __x, const normal_distribution& __y) { + return !(__x == __y); + } + + template <class _CharT, class _Traits, class _RT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const normal_distribution<_RT>& __x); + + template <class _CharT, class _Traits, class _RT> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, normal_distribution<_RT>& __x); +}; + +template <class _RealType> +template <class _URNG> +_RealType normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + result_type __up; + if (__v_hot_) { + __v_hot_ = false; + __up = __v_; + } else { + uniform_real_distribution<result_type> __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 = std::sqrt(-2 * std::log(__s) / __s); + __v_ = __v * __fp; + __v_hot_ = true; + __up = __u * __fp; + } + return __up * __p.stddev() + __p.mean(); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/piecewise_constant_distribution.h b/contrib/llvm-project/libcxx/include/__random/piecewise_constant_distribution.h new file mode 100644 index 000000000000..e19380f97c35 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/piecewise_constant_distribution.h @@ -0,0 +1,302 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <iosfwd> +#include <numeric> +#include <vector> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + vector<result_type> __b_; + vector<result_type> __densities_; + vector<result_type> __areas_; + + public: + typedef piecewise_constant_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI param_type(); + template <class _InputIteratorB, class _InputIteratorW> + _LIBCPP_HIDE_FROM_ABI param_type(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w); +#ifndef _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<result_type> __bl, _UnaryOperation __fw); +#endif // _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw); + _LIBCPP_HIDE_FROM_ABI param_type(param_type const&) = default; + _LIBCPP_HIDE_FROM_ABI param_type& operator=(const param_type& __rhs); + + _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __b_; } + _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __densities_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); } + + private: + _LIBCPP_HIDE_FROM_ABI void __init(); + + friend class piecewise_constant_distribution; + + template <class _CharT, class _Traits, class _RT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_constant_distribution<_RT>& __x); + + template <class _CharT, class _Traits, class _RT> + 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_HIDE_FROM_ABI piecewise_constant_distribution() {} + template <class _InputIteratorB, class _InputIteratorW> + _LIBCPP_HIDE_FROM_ABI + piecewise_constant_distribution(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w) + : __p_(__f_b, __l_b, __f_w) {} + +#ifndef _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI piecewise_constant_distribution(initializer_list<result_type> __bl, _UnaryOperation __fw) + : __p_(__bl, __fw) {} +#endif // _LIBCPP_CXX03_LANG + + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI + piecewise_constant_distribution(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw) + : __p_(__nw, __xmin, __xmax, __fw) {} + + _LIBCPP_HIDE_FROM_ABI explicit piecewise_constant_distribution(const param_type& __p) : __p_(__p) {} + + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __p_.intervals(); } + _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __p_.densities(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return __p_.__b_.front(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__b_.back(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const piecewise_constant_distribution& __x, const piecewise_constant_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const piecewise_constant_distribution& __x, const piecewise_constant_distribution& __y) { + return !(__x == __y); + } + + template <class _CharT, class _Traits, class _RT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_constant_distribution<_RT>& __x); + + template <class _CharT, class _Traits, class _RT> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_constant_distribution<_RT>& __x); +}; + +template <class _RealType> +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 <class _RealType> +void piecewise_constant_distribution<_RealType>::param_type::__init() { + // __densities_ contains non-normalized areas + result_type __total_area = std::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()); + std::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 <class _RealType> +piecewise_constant_distribution<_RealType>::param_type::param_type() : __b_(2), __densities_(1, 1.0), __areas_(1, 0.0) { + __b_[1] = 1; +} + +template <class _RealType> +template <class _InputIteratorB, class _InputIteratorW> +piecewise_constant_distribution<_RealType>::param_type::param_type( + _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w) + : __b_(__f_b, __l_b) { + 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, ++__f_w) + __densities_.push_back(*__f_w); + __init(); + } +} + +#ifndef _LIBCPP_CXX03_LANG + +template <class _RealType> +template <class _UnaryOperation> +piecewise_constant_distribution<_RealType>::param_type::param_type( + initializer_list<result_type> __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 <class _RealType> +template <class _UnaryOperation> +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 <class _RealType> +template <class _URNG> +_RealType piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + typedef uniform_real_distribution<result_type> _Gen; + result_type __u = _Gen()(__g); + ptrdiff_t __k = std::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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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<result_type> __b(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __b[__i]; + __is >> __n; + vector<result_type> __densities(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __densities[__i]; + __is >> __n; + vector<result_type> __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/contrib/llvm-project/libcxx/include/__random/piecewise_linear_distribution.h b/contrib/llvm-project/libcxx/include/__random/piecewise_linear_distribution.h new file mode 100644 index 000000000000..43769dc825e6 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/piecewise_linear_distribution.h @@ -0,0 +1,315 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <vector> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + vector<result_type> __b_; + vector<result_type> __densities_; + vector<result_type> __areas_; + + public: + typedef piecewise_linear_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI param_type(); + template <class _InputIteratorB, class _InputIteratorW> + _LIBCPP_HIDE_FROM_ABI param_type(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w); +#ifndef _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<result_type> __bl, _UnaryOperation __fw); +#endif // _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw); + _LIBCPP_HIDE_FROM_ABI param_type(param_type const&) = default; + _LIBCPP_HIDE_FROM_ABI param_type& operator=(const param_type& __rhs); + + _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __b_; } + _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __densities_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); } + + private: + _LIBCPP_HIDE_FROM_ABI void __init(); + + friend class piecewise_linear_distribution; + + template <class _CharT, class _Traits, class _RT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_linear_distribution<_RT>& __x); + + template <class _CharT, class _Traits, class _RT> + 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_HIDE_FROM_ABI piecewise_linear_distribution() {} + template <class _InputIteratorB, class _InputIteratorW> + _LIBCPP_HIDE_FROM_ABI + piecewise_linear_distribution(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w) + : __p_(__f_b, __l_b, __f_w) {} + +#ifndef _LIBCPP_CXX03_LANG + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI piecewise_linear_distribution(initializer_list<result_type> __bl, _UnaryOperation __fw) + : __p_(__bl, __fw) {} +#endif // _LIBCPP_CXX03_LANG + + template <class _UnaryOperation> + _LIBCPP_HIDE_FROM_ABI + piecewise_linear_distribution(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw) + : __p_(__nw, __xmin, __xmax, __fw) {} + + _LIBCPP_HIDE_FROM_ABI explicit piecewise_linear_distribution(const param_type& __p) : __p_(__p) {} + + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __p_.intervals(); } + _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __p_.densities(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return __p_.__b_.front(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__b_.back(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const piecewise_linear_distribution& __x, const piecewise_linear_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const piecewise_linear_distribution& __x, const piecewise_linear_distribution& __y) { + return !(__x == __y); + } + + template <class _CharT, class _Traits, class _RT> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_linear_distribution<_RT>& __x); + + template <class _CharT, class _Traits, class _RT> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_linear_distribution<_RT>& __x); +}; + +template <class _RealType> +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 <class _RealType> +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 <class _RealType> +piecewise_linear_distribution<_RealType>::param_type::param_type() : __b_(2), __densities_(2, 1.0), __areas_(1, 0.0) { + __b_[1] = 1; +} + +template <class _RealType> +template <class _InputIteratorB, class _InputIteratorW> +piecewise_linear_distribution<_RealType>::param_type::param_type( + _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w) + : __b_(__f_b, __l_b) { + 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, ++__f_w) + __densities_.push_back(*__f_w); + __init(); + } +} + +#ifndef _LIBCPP_CXX03_LANG + +template <class _RealType> +template <class _UnaryOperation> +piecewise_linear_distribution<_RealType>::param_type::param_type( + initializer_list<result_type> __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 <class _RealType> +template <class _UnaryOperation> +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 <class _RealType> +template <class _URNG> +_RealType piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + typedef uniform_real_distribution<result_type> _Gen; + result_type __u = _Gen()(__g); + ptrdiff_t __k = std::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 + std::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / __deltad; +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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<result_type> __b(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __b[__i]; + __is >> __n; + vector<result_type> __densities(__n); + for (size_t __i = 0; __i < __n; ++__i) + __is >> __densities[__i]; + __is >> __n; + vector<result_type> __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/contrib/llvm-project/libcxx/include/__random/poisson_distribution.h b/contrib/llvm-project/libcxx/include/__random/poisson_distribution.h new file mode 100644 index 000000000000..61a092ef9dd4 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/poisson_distribution.h @@ -0,0 +1,241 @@ +//===----------------------------------------------------------------------===// +// +// 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/clamp_to_integral.h> +#include <__random/exponential_distribution.h> +#include <__random/is_valid.h> +#include <__random/normal_distribution.h> +#include <__random/uniform_real_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _IntType = int> +class _LIBCPP_TEMPLATE_VIS poisson_distribution { + static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); + +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; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(double __mean = 1.0); + + _LIBCPP_HIDE_FROM_ABI double mean() const { return __mean_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__mean_ == __y.__mean_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI poisson_distribution() : poisson_distribution(1.0) {} + _LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(double __mean) : __p_(__mean) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI double mean() const { return __p_.mean(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::max(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const poisson_distribution& __x, const poisson_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const poisson_distribution& __x, const poisson_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _IntType> +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<double>::max() : __mean) { + if (__mean_ < 10) { + __s_ = 0; + __d_ = 0; + __l_ = std::exp(-__mean_); + __omega_ = 0; + __c3_ = 0; + __c2_ = 0; + __c1_ = 0; + __c0_ = 0; + __c_ = 0; + } else { + __s_ = std::sqrt(__mean_); + __d_ = 6 * __mean_ * __mean_; + __l_ = std::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 <class _IntType> +template <class _URNG> +_IntType poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + double __tx; + uniform_real_distribution<double> __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<double>()(__urng); + double __u; + if (__g > 0) { + __tx = std::trunc(__g); + if (__tx >= __pr.__l_) + return std::__clamp_to_integral<result_type>(__tx); + __difmuk = __pr.__mean_ - __tx; + __u = __urd(__urng); + if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk) + return std::__clamp_to_integral<result_type>(__tx); + } + exponential_distribution<double> __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 = std::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 = std::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)]; + } else { + double __del = .8333333E-1 / __tx; + __del -= 4.8 * __del * __del * __del; + double __v = __difmuk / __tx; + if (std::abs(__v) > 0.25) + __px = __tx * std::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 / std::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_ * std::abs(__u) <= __py * std::exp(__px + __e) - __fy * std::exp(__fx + __e)) + break; + } else { + if (__fy - __u * __fy <= __py * std::exp(__px - __fx)) + break; + } + } + } + return std::__clamp_to_integral<result_type>(__tx); +} + +template <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _IntType> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/random_device.h b/contrib/llvm-project/libcxx/include/__random/random_device.h new file mode 100644 index 000000000000..52407943d2ec --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/random_device.h @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// 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 <string> + +#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_EXPORTED_FROM_ABI random_device { +# ifdef _LIBCPP_USING_DEV_RANDOM + int __f_; +# elif !defined(_LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT) + _LIBCPP_DIAGNOSTIC_PUSH + _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-private-field") + + // Apple platforms used to use the `_LIBCPP_USING_DEV_RANDOM` code path, and now + // use `arc4random()` as of this comment. In order to avoid breaking the ABI, we + // retain the same layout as before. +# if defined(__APPLE__) + int __padding_; // padding to fake the `__f_` field above +# endif + + // ... vendors can add workarounds here if they switch to a different representation ... + + _LIBCPP_DIAGNOSTIC_POP +# endif + +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_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + + // constructors +# ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI 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; + + random_device(const random_device&) = delete; + void 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/contrib/llvm-project/libcxx/include/__random/ranlux.h b/contrib/llvm-project/libcxx/include/__random/ranlux.h new file mode 100644 index 000000000000..952afde91b10 --- /dev/null +++ b/contrib/llvm-project/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 <cstdint> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base; +typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base; + +typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24; +typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___RANDOM_RANLUX_H diff --git a/contrib/llvm-project/libcxx/include/__random/seed_seq.h b/contrib/llvm-project/libcxx/include/__random/seed_seq.h new file mode 100644 index 000000000000..5cf84aeb8a72 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/seed_seq.h @@ -0,0 +1,166 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__iterator/iterator_traits.h> +#include <__type_traits/is_unsigned.h> +#include <cstdint> +#include <initializer_list> +#include <vector> + +#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; + + // constructors + _LIBCPP_HIDE_FROM_ABI seed_seq() _NOEXCEPT {} +#ifndef _LIBCPP_CXX03_LANG + template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI seed_seq(initializer_list<_Tp> __il) { + __init(__il.begin(), __il.end()); + } +#endif // _LIBCPP_CXX03_LANG + + template <class _InputIterator> + _LIBCPP_HIDE_FROM_ABI seed_seq(_InputIterator __first, _InputIterator __last) { + static_assert(is_integral<typename iterator_traits<_InputIterator>::value_type>::value, + "Mandates: iterator_traits<InputIterator>::value_type is an integer type"); + __init(__first, __last); + } + + // generating functions + template <class _RandomAccessIterator> + _LIBCPP_HIDE_FROM_ABI void generate(_RandomAccessIterator __first, _RandomAccessIterator __last); + + // property functions + _LIBCPP_HIDE_FROM_ABI size_t size() const _NOEXCEPT { return __v_.size(); } + template <class _OutputIterator> + _LIBCPP_HIDE_FROM_ABI void param(_OutputIterator __dest) const { + std::copy(__v_.begin(), __v_.end(), __dest); + } + + seed_seq(const seed_seq&) = delete; + void operator=(const seed_seq&) = delete; + + _LIBCPP_HIDE_FROM_ABI static result_type _Tp(result_type __x) { return __x ^ (__x >> 27); } + +private: + template <class _InputIterator> + _LIBCPP_HIDE_FROM_ABI void __init(_InputIterator __first, _InputIterator __last); + + vector<result_type> __v_; +}; + +template <class _InputIterator> +void seed_seq::__init(_InputIterator __first, _InputIterator __last) { + for (_InputIterator __s = __first; __s != __last; ++__s) + __v_.push_back(*__s & 0xFFFFFFFF); +} + +template <class _RandomAccessIterator> +void seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last) { + using _ValueType = typename iterator_traits<_RandomAccessIterator>::value_type; + static_assert(is_unsigned<_ValueType>::value && sizeof(_ValueType) >= sizeof(uint32_t), + "[rand.util.seedseq]/7 requires the value_type of the iterator to be an unsigned " + "integer capable of accommodating 32-bit quantities."); + + if (__first != __last) { + std::fill(__first, __last, 0x8b8b8b8b); + const size_t __n = static_cast<size_t>(__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 = std::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; + } + // Initialize indexing terms used with if statements as an optimization to + // avoid calculating modulo n on every loop iteration for each term. + size_t __kmodn = 0; // __k % __n + size_t __k1modn = __n - 1; // (__k - 1) % __n + size_t __kpmodn = __p % __n; // (__k + __p) % __n + size_t __kqmodn = __q % __n; // (__k + __q) % __n + + for (size_t __k = 1; __k <= __s; ++__k) { + if (++__kmodn == __n) + __kmodn = 0; + if (++__k1modn == __n) + __k1modn = 0; + if (++__kpmodn == __n) + __kpmodn = 0; + if (++__kqmodn == __n) + __kqmodn = 0; + + result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^ __first[__k1modn]); + __first[__kpmodn] += __r; + __r += __kmodn + __v_[__k - 1]; + __first[__kqmodn] += __r; + __first[__kmodn] = __r; + } + for (size_t __k = __s + 1; __k < __m; ++__k) { + if (++__kmodn == __n) + __kmodn = 0; + if (++__k1modn == __n) + __k1modn = 0; + if (++__kpmodn == __n) + __kpmodn = 0; + if (++__kqmodn == __n) + __kqmodn = 0; + + result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^ __first[__k1modn]); + __first[__kpmodn] += __r; + __r += __kmodn; + __first[__kqmodn] += __r; + __first[__kmodn] = __r; + } + for (size_t __k = __m; __k < __m + __n; ++__k) { + if (++__kmodn == __n) + __kmodn = 0; + if (++__k1modn == __n) + __k1modn = 0; + if (++__kpmodn == __n) + __kpmodn = 0; + if (++__kqmodn == __n) + __kqmodn = 0; + + result_type __r = 1566083941 * _Tp(__first[__kmodn] + __first[__kpmodn] + __first[__k1modn]); + __first[__kpmodn] ^= __r; + __r -= __kmodn; + __first[__kqmodn] ^= __r; + __first[__kmodn] = __r; + } + } +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_SEED_SEQ_H diff --git a/contrib/llvm-project/libcxx/include/__random/shuffle_order_engine.h b/contrib/llvm-project/libcxx/include/__random/shuffle_order_engine.h new file mode 100644 index 000000000000..f54ed17e3838 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/shuffle_order_engine.h @@ -0,0 +1,230 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__type_traits/enable_if.h> +#include <__type_traits/integral_constant.h> +#include <__type_traits/is_convertible.h> +#include <__utility/move.h> +#include <cstddef> +#include <cstdint> +#include <iosfwd> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <uint64_t _Xp, uint64_t _Yp> +struct __ugcd { + static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value; +}; + +template <uint64_t _Xp> +struct __ugcd<_Xp, 0> { + static _LIBCPP_CONSTEXPR const uint64_t value = _Xp; +}; + +template <uint64_t _Np, uint64_t _Dp> +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<num, den> type; +}; + +template <class _Engine, size_t __k> +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_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; } + + static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull; + + // constructors and seeding functions + _LIBCPP_HIDE_FROM_ABI shuffle_order_engine() { __init(); } + _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(const _Engine& __e) : __e_(__e) { __init(); } +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(_Engine&& __e) : __e_(std::move(__e)) { __init(); } +#endif // _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(result_type __sd) : __e_(__sd) { __init(); } + template < + class _Sseq, + __enable_if_t<__is_seed_sequence<_Sseq, shuffle_order_engine>::value && !is_convertible<_Sseq, _Engine>::value, + int> = 0> + _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(_Sseq& __q) : __e_(__q) { + __init(); + } + _LIBCPP_HIDE_FROM_ABI void seed() { + __e_.seed(); + __init(); + } + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd) { + __e_.seed(__sd); + __init(); + } + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, shuffle_order_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) { + __e_.seed(__q); + __init(); + } + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()() { return __eval(integral_constant<bool, _Rp != 0>()); } + _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) { + for (; __z; --__z) + operator()(); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI const _Engine& base() const _NOEXCEPT { return __e_; } + +private: + template <class _Eng, size_t _Kp> + friend bool operator==(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y); + + template <class _Eng, size_t _Kp> + friend bool operator!=(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y); + + template <class _CharT, class _Traits, class _Eng, size_t _Kp> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const shuffle_order_engine<_Eng, _Kp>& __x); + + template <class _CharT, class _Traits, class _Eng, size_t _Kp> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, shuffle_order_engine<_Eng, _Kp>& __x); + + _LIBCPP_HIDE_FROM_ABI void __init() { + for (size_t __i = 0; __i < __k; ++__i) + __v_[__i] = __e_(); + __y_ = __e_(); + } + + _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type) { return __eval2(integral_constant<bool, __k & 1>()); } + _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type) { return __eval(__uratio<__k, _Rp>()); } + + _LIBCPP_HIDE_FROM_ABI result_type __eval2(false_type) { return __eval(__uratio<__k / 2, 0x8000000000000000ull>()); } + _LIBCPP_HIDE_FROM_ABI result_type __eval2(true_type) { return __evalf<__k, 0>(); } + + template <uint64_t _Np, + uint64_t _Dp, + __enable_if_t<(__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)), int> = 0> + _LIBCPP_HIDE_FROM_ABI result_type __eval(__uratio<_Np, _Dp>) { + return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>(); + } + + template <uint64_t _Np, + uint64_t _Dp, + __enable_if_t<__uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min), int> = 0> + _LIBCPP_HIDE_FROM_ABI result_type __eval(__uratio<_Np, _Dp>) { + const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (__y_ - _Min) / __uratio<_Np, _Dp>::den); + __y_ = __v_[__j]; + __v_[__j] = __e_(); + return __y_; + } + + template <uint64_t __n, uint64_t __d> + _LIBCPP_HIDE_FROM_ABI result_type __evalf() { + const double __fp = __d == 0 ? __n / (2. * 0x8000000000000000ull) : __n / (double)__d; + const size_t __j = static_cast<size_t>(__fp * (__y_ - _Min)); + __y_ = __v_[__j]; + __v_[__j] = __e_(); + return __y_; + } +}; + +template <class _Engine, size_t __k> +_LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size; + +template <class _Eng, size_t _Kp> +_LIBCPP_HIDE_FROM_ABI bool +operator==(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y) { + return __x.__y_ == __y.__y_ && std::equal(__x.__v_, __x.__v_ + _Kp, __y.__v_) && __x.__e_ == __y.__e_; +} + +template <class _Eng, size_t _Kp> +inline _LIBCPP_HIDE_FROM_ABI bool +operator!=(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y) { + return !(__x == __y); +} + +template <class _CharT, class _Traits, class _Eng, size_t _Kp> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _Eng, size_t _Kp> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/student_t_distribution.h b/contrib/llvm-project/libcxx/include/__random/student_t_distribution.h new file mode 100644 index 000000000000..110a856ee658 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/student_t_distribution.h @@ -0,0 +1,132 @@ +//===----------------------------------------------------------------------===// +// +// 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/is_valid.h> +#include <__random/normal_distribution.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS student_t_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +public: + // types + typedef _RealType result_type; + + class _LIBCPP_TEMPLATE_VIS param_type { + result_type __n_; + + public: + typedef student_t_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __n = 1) : __n_(__n) {} + + _LIBCPP_HIDE_FROM_ABI result_type n() const { return __n_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__n_ == __y.__n_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); } + }; + +private: + param_type __p_; + normal_distribution<result_type> __nd_; + +public: + // constructor and reset functions +#ifndef _LIBCPP_CXX03_LANG + _LIBCPP_HIDE_FROM_ABI student_t_distribution() : student_t_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(result_type __n) : __p_(param_type(__n)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(result_type __n = 1) : __p_(param_type(__n)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() { __nd_.reset(); } + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const student_t_distribution& __x, const student_t_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const student_t_distribution& __x, const student_t_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +_RealType student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + gamma_distribution<result_type> __gd(__p.n() * .5, 2); + return __nd_(__g) * std::sqrt(__p.n() / __gd(__g)); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/subtract_with_carry_engine.h b/contrib/llvm-project/libcxx/include/__random/subtract_with_carry_engine.h new file mode 100644 index 000000000000..ec25fed49f94 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/subtract_with_carry_engine.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_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 <cstddef> +#include <cstdint> +#include <iosfwd> +#include <limits> + +#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 _UIntType, size_t __w, size_t __s, size_t __r> +class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine; + +template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + +template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI bool operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + +template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + +template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +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<result_type>::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_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; } + _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} + _LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); } +#else + _LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(result_type __sd = default_seed) { seed(__sd); } +#endif + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(_Sseq& __q) { + seed(__q); + } + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed) { + seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>()); + } + template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, int> = 0> + _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) { + __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>()); + } + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()(); + _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) { + for (; __z; --__z) + operator()(); + } + + template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> + friend bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + + template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> + friend bool operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x, + const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y); + + template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + + template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> + friend basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x); + +private: + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd, integral_constant<unsigned, 1>); + _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd, integral_constant<unsigned, 2>); + template <class _Sseq> + _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>); + template <class _Sseq> + _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>); +}; + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size; + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag; + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag; + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +_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 <class _UIntType, size_t __w, size_t __s, size_t __r> +void subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, integral_constant<unsigned, 1>) { + linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> __e(__sd == 0u ? default_seed : __sd); + for (size_t __i = 0; __i < __r; ++__i) + __x_[__i] = static_cast<result_type>(__e() & _Max); + __c_ = __x_[__r - 1] == 0; + __i_ = 0; +} + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +void subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, integral_constant<unsigned, 2>) { + linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> __e(__sd == 0u ? default_seed : __sd); + for (size_t __i = 0; __i < __r; ++__i) { + result_type __e0 = __e(); + __x_[__i] = static_cast<result_type>((__e0 + ((uint64_t)__e() << 32)) & _Max); + } + __c_ = __x_[__r - 1] == 0; + __i_ = 0; +} + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +template <class _Sseq> +void subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, integral_constant<unsigned, 1>) { + 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<result_type>(__ar[__i] & _Max); + __c_ = __x_[__r - 1] == 0; + __i_ = 0; +} + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +template <class _Sseq> +void subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, integral_constant<unsigned, 2>) { + 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<result_type>((__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max); + __c_ = __x_[__r - 1] == 0; + __i_ = 0; +} + +template <class _UIntType, size_t __w, size_t __s, size_t __r> +_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 <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI 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 std::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_); + if (__x.__i_ == 0 || __y.__i_ == 0) { + size_t __j = std::min(_Rp - __x.__i_, _Rp - __y.__i_); + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_)) + return false; + if (__x.__i_ == 0) + return std::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_); + return std::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j); + } + if (__x.__i_ < __y.__i_) { + size_t __j = _Rp - __y.__i_; + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_)) + return false; + if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, __y.__x_)) + return false; + return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Rp - (__x.__i_ + __j))); + } + size_t __j = _Rp - __x.__i_; + if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_)) + return false; + if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, __x.__x_)) + return false; + return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Rp - (__y.__i_ + __j))); +} + +template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +inline _LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/uniform_int_distribution.h b/contrib/llvm-project/libcxx/include/__random/uniform_int_distribution.h new file mode 100644 index 000000000000..4e3ca3efe568 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/uniform_int_distribution.h @@ -0,0 +1,264 @@ +//===----------------------------------------------------------------------===// +// +// 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_INT_DISTRIBUTION_H +#define _LIBCPP___RANDOM_UNIFORM_INT_DISTRIBUTION_H + +#include <__bit/countl.h> +#include <__config> +#include <__random/is_valid.h> +#include <__random/log2.h> +#include <__type_traits/conditional.h> +#include <__type_traits/make_unsigned.h> +#include <cstddef> +#include <cstdint> +#include <iosfwd> +#include <limits> + +#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 _Engine, class _UIntType> +class __independent_bits_engine { +public: + // types + typedef _UIntType result_type; + +private: + typedef typename _Engine::result_type _Engine_result_type; + typedef __conditional_t<sizeof(_Engine_result_type) <= sizeof(result_type), result_type, _Engine_result_type> + _Working_result_type; + + _Engine& __e_; + size_t __w_; + size_t __w0_; + size_t __n_; + size_t __n0_; + _Working_result_type __y0_; + _Working_result_type __y1_; + _Engine_result_type __mask0_; + _Engine_result_type __mask1_; + +#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 _WDt = numeric_limits<_Working_result_type>::digits; + static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; + +public: + // constructors and seeding functions + _LIBCPP_HIDE_FROM_ABI __independent_bits_engine(_Engine& __e, size_t __w); + + // generating functions + _LIBCPP_HIDE_FROM_ABI result_type operator()() { return __eval(integral_constant<bool, _Rp != 0>()); } + +private: + _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type); + _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type); +}; + +template <class _Engine, class _UIntType> +__independent_bits_engine<_Engine, _UIntType>::__independent_bits_engine(_Engine& __e, size_t __w) + : __e_(__e), __w_(__w) { + __n_ = __w_ / __m + (__w_ % __m != 0); + __w0_ = __w_ / __n_; + if (_Rp == 0) + __y0_ = _Rp; + else if (__w0_ < _WDt) + __y0_ = (_Rp >> __w0_) << __w0_; + else + __y0_ = 0; + if (_Rp - __y0_ > __y0_ / __n_) { + ++__n_; + __w0_ = __w_ / __n_; + if (__w0_ < _WDt) + __y0_ = (_Rp >> __w0_) << __w0_; + else + __y0_ = 0; + } + __n0_ = __n_ - __w_ % __n_; + if (__w0_ < _WDt - 1) + __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1); + else + __y1_ = 0; + __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) : _Engine_result_type(0); + __mask1_ = __w0_ < _EDt - 1 ? _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) : _Engine_result_type(~0); +} + +template <class _Engine, class _UIntType> +inline _UIntType __independent_bits_engine<_Engine, _UIntType>::__eval(false_type) { + return static_cast<result_type>(__e_() & __mask0_); +} + +template <class _Engine, class _UIntType> +_UIntType __independent_bits_engine<_Engine, _UIntType>::__eval(true_type) { + const size_t __w_rt = numeric_limits<result_type>::digits; + result_type __sp = 0; + for (size_t __k = 0; __k < __n0_; ++__k) { + _Engine_result_type __u; + do { + __u = __e_() - _Engine::min(); + } while (__u >= __y0_); + if (__w0_ < __w_rt) + __sp <<= __w0_; + else + __sp = 0; + __sp += __u & __mask0_; + } + for (size_t __k = __n0_; __k < __n_; ++__k) { + _Engine_result_type __u; + do { + __u = __e_() - _Engine::min(); + } while (__u >= __y1_); + if (__w0_ < __w_rt - 1) + __sp <<= __w0_ + 1; + else + __sp = 0; + __sp += __u & __mask1_; + } + return __sp; +} + +template <class _IntType = int> +class uniform_int_distribution { + static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type"); + +public: + // types + typedef _IntType result_type; + + class param_type { + result_type __a_; + result_type __b_; + + public: + typedef uniform_int_distribution distribution_type; + + _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = numeric_limits<result_type>::max()) + : __a_(__a), __b_(__b) {} + + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; } + + _LIBCPP_HIDE_FROM_ABI friend bool operator==(const param_type& __x, const param_type& __y) { + return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_; + } + _LIBCPP_HIDE_FROM_ABI friend 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_HIDE_FROM_ABI uniform_int_distribution() : uniform_int_distribution(0) {} + _LIBCPP_HIDE_FROM_ABI explicit uniform_int_distribution( + result_type __a, result_type __b = numeric_limits<result_type>::max()) + : __p_(param_type(__a, __b)) {} +#else + explicit uniform_int_distribution(result_type __a = 0, result_type __b = numeric_limits<result_type>::max()) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return a(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return b(); } + + _LIBCPP_HIDE_FROM_ABI friend bool + operator==(const uniform_int_distribution& __x, const uniform_int_distribution& __y) { + return __x.__p_ == __y.__p_; + } + _LIBCPP_HIDE_FROM_ABI friend bool + operator!=(const uniform_int_distribution& __x, const uniform_int_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _IntType> +template <class _URNG> +typename uniform_int_distribution<_IntType>::result_type uniform_int_distribution<_IntType>::operator()( + _URNG& __g, const param_type& __p) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + typedef __conditional_t<sizeof(result_type) <= sizeof(uint32_t), uint32_t, __make_unsigned_t<result_type> > _UIntType; + const _UIntType __rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1); + if (__rp == 1) + return __p.a(); + const size_t __dt = numeric_limits<_UIntType>::digits; + typedef __independent_bits_engine<_URNG, _UIntType> _Eng; + if (__rp == 0) + return static_cast<result_type>(_Eng(__g, __dt)()); + size_t __w = __dt - std::__countl_zero(__rp) - 1; + if ((__rp & (numeric_limits<_UIntType>::max() >> (__dt - __w))) != 0) + ++__w; + _Eng __e(__g, __w); + _UIntType __u; + do { + __u = __e(); + } while (__u >= __rp); + return static_cast<result_type>(__u + __p.a()); +} + +template <class _CharT, class _Traits, class _IT> +_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const uniform_int_distribution<_IT>& __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.a() << __sp << __x.b(); +} + +template <class _CharT, class _Traits, class _IT> +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, uniform_int_distribution<_IT>& __x) { + typedef uniform_int_distribution<_IT> _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_INT_DISTRIBUTION_H diff --git a/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h b/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h new file mode 100644 index 000000000000..4076f19b2cb2 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/uniform_random_bit_generator.h @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__functional/invoke.h> +#include <__type_traits/integral_constant.h> + +#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 >= 20 + +// [rand.req.urng] +template <class _Gen> +concept uniform_random_bit_generator = invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> && requires { + { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>; + { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>; + requires bool_constant<(_Gen::min() < _Gen::max())>::value; +}; + +#endif // _LIBCPP_STD_VER >= 20 + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H diff --git a/contrib/llvm-project/libcxx/include/__random/uniform_real_distribution.h b/contrib/llvm-project/libcxx/include/__random/uniform_real_distribution.h new file mode 100644 index 000000000000..250cb8bab58c --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/uniform_real_distribution.h @@ -0,0 +1,138 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__random/is_valid.h> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS uniform_real_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {} + + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI uniform_real_distribution() : uniform_real_distribution(0) {} + _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p); + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return a(); } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return b(); } + + friend _LIBCPP_HIDE_FROM_ABI bool + operator==(const uniform_real_distribution& __x, const uniform_real_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool + operator!=(const uniform_real_distribution& __x, const uniform_real_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _RealType> +template <class _URNG> +inline typename uniform_real_distribution<_RealType>::result_type +uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { + static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); + return (__p.b() - __p.a()) * std::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g) + __p.a(); +} + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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/contrib/llvm-project/libcxx/include/__random/weibull_distribution.h b/contrib/llvm-project/libcxx/include/__random/weibull_distribution.h new file mode 100644 index 000000000000..aa3d63c8e866 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__random/weibull_distribution.h @@ -0,0 +1,132 @@ +//===----------------------------------------------------------------------===// +// +// 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 <__random/is_valid.h> +#include <cmath> +#include <iosfwd> +#include <limits> + +#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 _RealType = double> +class _LIBCPP_TEMPLATE_VIS weibull_distribution { + static_assert(__libcpp_random_is_valid_realtype<_RealType>::value, + "RealType must be a supported floating-point type"); + +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_HIDE_FROM_ABI explicit param_type(result_type __a = 1, result_type __b = 1) : __a_(__a), __b_(__b) {} + + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) { + return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_; + } + friend _LIBCPP_HIDE_FROM_ABI 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_HIDE_FROM_ABI weibull_distribution() : weibull_distribution(1) {} + _LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(result_type __a, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#else + _LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(result_type __a = 1, result_type __b = 1) + : __p_(param_type(__a, __b)) {} +#endif + _LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(const param_type& __p) : __p_(__p) {} + _LIBCPP_HIDE_FROM_ABI void reset() {} + + // generating functions + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) { + return (*this)(__g, __p_); + } + template <class _URNG> + _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) { + return __p.b() * std::pow(exponential_distribution<result_type>()(__g), 1 / __p.a()); + } + + // property functions + _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); } + _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); } + + _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; } + _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; } + + _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; } + _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const weibull_distribution& __x, const weibull_distribution& __y) { + return __x.__p_ == __y.__p_; + } + friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const weibull_distribution& __x, const weibull_distribution& __y) { + return !(__x == __y); + } +}; + +template <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 <class _CharT, class _Traits, class _RT> +_LIBCPP_HIDE_FROM_ABI 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 |