mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-06-28 15:28:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Release Cosmopolitan v3.6.0

Browse source 
This release is an atomic upgrade to GCC 14.1.0 with C23 and C++23
This commit is contained in:
Justine Tunney 2024-07-23 03:16:17 -07:00
parent 62ace3623a
commit 5660ec4741
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
1585 changed files with 117353 additions and 271644 deletions
Download patch file Download diff file Expand all files Collapse all files

150
third_party/libcxx/__random/bernoulli_distribution.h vendored
View file

@ -23,119 +23,97 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
{
class _LIBCPP_TEMPLATE_VIS bernoulli_distribution {
public:
// types
typedef bool result_type;
// types
typedef bool result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
double __p_;
public:
typedef bernoulli_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
double __p_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(double __p = 0.5) : __p_(__p) {}
public:
typedef bernoulli_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
double p() const {return __p_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(double __p = 0.5) : __p_(__p) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
bernoulli_distribution() : bernoulli_distribution(0.5) {}
_LIBCPP_INLINE_VISIBILITY
explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
_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_INLINE_VISIBILITY
explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
_LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);}
template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
// 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_INLINE_VISIBILITY
double p() const {return __p_.p();}
// property functions
_LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return false;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return true;}
_LIBCPP_HIDE_FROM_ABI result_type min() const { return false; }
_LIBCPP_HIDE_FROM_ABI result_type max() const { return true; }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const bernoulli_distribution& __x,
const bernoulli_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const bernoulli_distribution& __x,
const bernoulli_distribution& __y)
{return !(__x == __y);}
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 _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();
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;
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

273
third_party/libcxx/__random/binomial_distribution.h vendored
View file

@ -24,101 +24,84 @@ _LIBCPP_PUSH_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");
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;
// 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;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __t_;
double __p_;
double __pr_;
double __odds_ratio_;
result_type __r0_;
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __t = 1, double __p = 0.5);
public:
typedef binomial_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type t() const {return __t_;}
_LIBCPP_INLINE_VISIBILITY
double p() const {return __p_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __t = 1, double __p = 0.5);
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
_LIBCPP_HIDE_FROM_ABI result_type t() const { return __t_; }
_LIBCPP_HIDE_FROM_ABI double p() const { return __p_; }
friend class binomial_distribution;
};
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_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
binomial_distribution() : binomial_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit binomial_distribution(result_type __t, double __p = 0.5)
: __p_(param_type(__t, __p)) {}
_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_INLINE_VISIBILITY
explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
: __p_(param_type(__t, __p)) {}
_LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
: __p_(param_type(__t, __p)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type t() const {return __p_.t();}
_LIBCPP_INLINE_VISIBILITY
double p() const {return __p_.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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return t();}
_LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
_LIBCPP_HIDE_FROM_ABI result_type max() const { return t(); }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const binomial_distribution& __x,
const binomial_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const binomial_distribution& __x,
const binomial_distribution& __y)
{return !(__x == __y);}
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 *);
extern "C" double lgamma_r(double, int*);
#endif
inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
inline _LIBCPP_HIDE_FROM_ABI double __libcpp_lgamma(double __d) {
#if defined(_LIBCPP_MSVCRT_LIKE)
return lgamma(__d);
#else
@ -127,99 +110,85 @@ inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
#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_ = _VSTD::exp(std::__libcpp_lgamma(__t_ + 1.) -
std::__libcpp_lgamma(__r0_ + 1.) -
std::__libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
(__t_ - __r0_) * _VSTD::log(1 - __p_));
__odds_ratio_ = __p_ / (1 - __p_);
}
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 _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();
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;
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

179
third_party/libcxx/__random/cauchy_distribution.h vendored
View file

@ -25,136 +25,111 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS cauchy_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __a_;
result_type __b_;
public:
typedef cauchy_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __a_;
result_type __b_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 0, result_type __b = 1)
: __a_(__a), __b_(__b) {}
public:
typedef cauchy_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type a() const {return __a_;}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __b_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
cauchy_distribution() : cauchy_distribution(0) {}
_LIBCPP_INLINE_VISIBILITY
explicit cauchy_distribution(result_type __a, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_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_INLINE_VISIBILITY
explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit cauchy_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);}
template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
// 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_INLINE_VISIBILITY
result_type a() const {return __p_.a();}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __p_.b();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return -numeric_limits<result_type>::infinity();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const cauchy_distribution& __x,
const cauchy_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const cauchy_distribution& __x,
const cauchy_distribution& __y)
{return !(__x == __y);}
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() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
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;
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;
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

155
third_party/libcxx/__random/chi_squared_distribution.h vendored
View file

@ -11,6 +11,7 @@
#include <__config>
#include <__random/gamma_distribution.h>
#include <__random/is_valid.h>
#include <iosfwd>
#include <limits>
@ -23,118 +24,98 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __n_;
public:
typedef chi_squared_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __n_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __n = 1) : __n_(__n) {}
public:
typedef chi_squared_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type n() const {return __n_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __n = 1) : __n_(__n) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__n_ == __y.__n_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
chi_squared_distribution() : chi_squared_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit chi_squared_distribution(result_type __n)
: __p_(param_type(__n)) {}
_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_INLINE_VISIBILITY
explicit chi_squared_distribution(result_type __n = 1)
: __p_(param_type(__n)) {}
_LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(result_type __n = 1) : __p_(param_type(__n)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit chi_squared_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);}
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p)
{return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);}
// 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_INLINE_VISIBILITY
result_type n() const {return __p_.n();}
// property functions
_LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const chi_squared_distribution& __x,
const chi_squared_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const chi_squared_distribution& __x,
const chi_squared_distribution& __y)
{return !(__x == __y);}
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;
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;
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

22
third_party/libcxx/__random/clamp_to_integral.h vendored
View file

@ -22,17 +22,18 @@ _LIBCPP_PUSH_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_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
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);
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
@ -40,9 +41,8 @@ _LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
//
// The behavior is undefined if `__r` is NaN.
template <class _IntT, class _RealT>
_LIBCPP_INLINE_VISIBILITY
_IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
using _Lim = numeric_limits<_IntT>;
_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();

243
third_party/libcxx/__random/discard_block_engine.h vendored
View file

@ -27,177 +27,142 @@ _LIBCPP_PUSH_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_;
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");
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");
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;
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;
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();
static constexpr result_type _Min = _Engine::min();
static constexpr result_type _Max = _Engine::max();
#endif
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
_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_INLINE_VISIBILITY
discard_block_engine() : __n_(0) {}
_LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(const _Engine& __e)
: __e_(__e), __n_(0) {}
// 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_INLINE_VISIBILITY
explicit discard_block_engine(_Engine&& __e)
: __e_(_VSTD::move(__e)), __n_(0) {}
_LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(_Engine&& __e) : __e_(std::move(__e)), __n_(0) {}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
!is_convertible<_Sseq, _Engine>::value>::type* = 0)
: __e_(__q), __n_(0) {}
_LIBCPP_INLINE_VISIBILITY
void seed() {__e_.seed(); __n_ = 0;}
_LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__is_seed_sequence<_Sseq, discard_block_engine>::value,
void
>::type
seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
_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_INLINE_VISIBILITY
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
// 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_INLINE_VISIBILITY
const _Engine& base() const _NOEXCEPT {return __e_;}
// 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 _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_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 _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>::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>
_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 _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_INLINE_VISIBILITY
bool
operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
const discard_block_engine<_Eng, _Pp, _Rp>& __y)
{
return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
template <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_INLINE_VISIBILITY
bool
operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
const discard_block_engine<_Eng, _Pp, _Rp>& __y)
{
return !(__x == __y);
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>
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_;
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>
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;
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

326
third_party/libcxx/__random/discrete_distribution.h vendored
View file

@ -27,234 +27,182 @@ _LIBCPP_PUSH_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");
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;
// types
typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
vector<double> __p_;
public:
typedef discrete_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
vector<double> __p_;
_LIBCPP_INLINE_VISIBILITY
param_type() {}
template<class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
param_type(_InputIterator __f, _InputIterator __l)
: __p_(__f, __l) {__init();}
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_INLINE_VISIBILITY
param_type(initializer_list<double> __wl)
: __p_(__wl.begin(), __wl.end()) {__init();}
_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);
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;
_LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const;
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
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();
private:
_LIBCPP_HIDE_FROM_ABI void __init();
friend class discrete_distribution;
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_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 _CharT, class _Traits, class _IT>
friend basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, discrete_distribution<_IT>& __x);
};
private:
param_type __p_;
param_type __p_;
public:
// constructor and reset functions
_LIBCPP_INLINE_VISIBILITY
discrete_distribution() {}
template<class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
discrete_distribution(_InputIterator __f, _InputIterator __l)
: __p_(__f, __l) {}
// 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_INLINE_VISIBILITY
discrete_distribution(initializer_list<double> __wl)
: __p_(__wl) {}
_LIBCPP_HIDE_FROM_ABI discrete_distribution(initializer_list<double> __wl) : __p_(__wl) {}
#endif // _LIBCPP_CXX03_LANG
template<class _UnaryOperation>
_LIBCPP_INLINE_VISIBILITY
discrete_distribution(size_t __nw, double __xmin, double __xmax,
_UnaryOperation __fw)
: __p_(__nw, __xmin, __xmax, __fw) {}
_LIBCPP_INLINE_VISIBILITY
explicit discrete_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
vector<double> probabilities() const {return __p_.probabilities();}
// property functions
_LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const { return __p_.probabilities(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return __p_.__p_.size();}
_LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
_LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__p_.size(); }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const discrete_distribution& __x,
const discrete_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const discrete_distribution& __x,
const discrete_distribution& __y)
{return !(__x == __y);}
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_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 _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>
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>
void
discrete_distribution<_IntType>::param_type::__init()
{
if (!__p_.empty())
{
if (__p_.size() > 1)
{
double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
for (vector<double>::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i)
*__i /= __s;
vector<double> __t(__p_.size() - 1);
_VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
swap(__p_, __t);
}
else
{
__p_.clear();
__p_.shrink_to_fit();
}
}
template <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>
vector<double>
discrete_distribution<_IntType>::param_type::probabilities() const
{
size_t __n = __p_.size();
vector<double> __p(__n+1);
_VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
if (__n > 0)
__p[__n] = 1 - __p_[__n-1];
else
__p[0] = 1;
return __p;
}
template<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>(
_VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
__p.__p_.begin());
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;
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;
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

164
third_party/libcxx/__random/exponential_distribution.h vendored
View file

@ -26,129 +26,103 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS exponential_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __lambda_;
public:
typedef exponential_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __lambda_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
public:
typedef exponential_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type lambda() const {return __lambda_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__lambda_ == __y.__lambda_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
exponential_distribution() : exponential_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit exponential_distribution(result_type __lambda)
: __p_(param_type(__lambda)) {}
_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_INLINE_VISIBILITY
explicit exponential_distribution(result_type __lambda = 1)
: __p_(param_type(__lambda)) {}
_LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(result_type __lambda = 1) : __p_(param_type(__lambda)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type lambda() const {return __p_.lambda();}
// property functions
_LIBCPP_HIDE_FROM_ABI result_type lambda() const { return __p_.lambda(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const exponential_distribution& __x,
const exponential_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const exponential_distribution& __x,
const exponential_distribution& __y)
{return !(__x == __y);}
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 -_VSTD::log
(
result_type(1) -
_VSTD::generate_canonical<result_type,
numeric_limits<result_type>::digits>(__g)
)
/ __p.lambda();
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();
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;
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

181
third_party/libcxx/__random/extreme_value_distribution.h vendored
View file

@ -25,136 +25,111 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __a_;
result_type __b_;
public:
typedef extreme_value_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __a_;
result_type __b_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 0, result_type __b = 1)
: __a_(__a), __b_(__b) {}
public:
typedef extreme_value_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type a() const {return __a_;}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __b_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
extreme_value_distribution() : extreme_value_distribution(0) {}
_LIBCPP_INLINE_VISIBILITY
explicit extreme_value_distribution(result_type __a, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_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_INLINE_VISIBILITY
explicit extreme_value_distribution(result_type __a = 0,
result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit extreme_value_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type a() const {return __p_.a();}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __p_.b();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return -numeric_limits<result_type>::infinity();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const extreme_value_distribution& __x,
const extreme_value_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const extreme_value_distribution& __x,
const extreme_value_distribution& __y)
{return !(__x == __y);}
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() *
_VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
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;
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;
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

179
third_party/libcxx/__random/fisher_f_distribution.h vendored
View file

@ -24,136 +24,111 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __m_;
result_type __n_;
public:
typedef fisher_f_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __m_;
result_type __n_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __m = 1, result_type __n = 1)
: __m_(__m), __n_(__n) {}
public:
typedef fisher_f_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type m() const {return __m_;}
_LIBCPP_INLINE_VISIBILITY
result_type n() const {return __n_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __m = 1, result_type __n = 1) : __m_(__m), __n_(__n) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
fisher_f_distribution() : fisher_f_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit fisher_f_distribution(result_type __m, result_type __n = 1)
: __p_(param_type(__m, __n)) {}
_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_INLINE_VISIBILITY
explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
: __p_(param_type(__m, __n)) {}
_LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
: __p_(param_type(__m, __n)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit fisher_f_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type m() const {return __p_.m();}
_LIBCPP_INLINE_VISIBILITY
result_type n() const {return __p_.n();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const fisher_f_distribution& __x,
const fisher_f_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const fisher_f_distribution& __x,
const fisher_f_distribution& __y)
{return !(__x == __y);}
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 _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;
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;
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

265
third_party/libcxx/__random/gamma_distribution.h vendored
View file

@ -26,187 +26,152 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS gamma_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __alpha_;
result_type __beta_;
public:
typedef gamma_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __alpha_;
result_type __beta_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __alpha = 1, result_type __beta = 1)
: __alpha_(__alpha), __beta_(__beta) {}
public:
typedef gamma_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type alpha() const {return __alpha_;}
_LIBCPP_INLINE_VISIBILITY
result_type beta() const {return __beta_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __alpha = 1, result_type __beta = 1)
: __alpha_(__alpha), __beta_(__beta) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
gamma_distribution() : gamma_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
: __p_(param_type(__alpha, __beta)) {}
_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_INLINE_VISIBILITY
explicit gamma_distribution(result_type __alpha = 1,
result_type __beta = 1)
: __p_(param_type(__alpha, __beta)) {}
_LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
: __p_(param_type(__alpha, __beta)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit gamma_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type alpha() const {return __p_.alpha();}
_LIBCPP_INLINE_VISIBILITY
result_type beta() const {return __p_.beta();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const gamma_distribution& __x,
const gamma_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const gamma_distribution& __x,
const gamma_distribution& __y)
{return !(__x == __y);}
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 = _VSTD::sqrt(__c / __w) *
(__u - result_type(0.5));
__x = __b + __y;
if (__x >= 0)
{
const result_type __z = 64 * __w * __w * __w * __v * __v;
if (__z <= 1 - 2 * __y * __y / __x)
break;
if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
break;
}
}
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 = _VSTD::pow(__u, 1 / __a);
if (__x <= __es)
break;
}
else
{
const result_type __e = -_VSTD::log((1-__u)/__a);
__x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
if (__x <= __e + __es)
break;
}
}
} 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();
}
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;
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;
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

28
third_party/libcxx/__random/generate_canonical.h vendored
View file

@ -26,24 +26,22 @@ _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;
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;
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;
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;
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

147
third_party/libcxx/__random/geometric_distribution.h vendored
View file

@ -24,116 +24,93 @@ _LIBCPP_PUSH_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");
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;
// types
typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
double __p_;
public:
typedef geometric_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
double __p_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(double __p = 0.5) : __p_(__p) {}
public:
typedef geometric_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
double p() const {return __p_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(double __p = 0.5) : __p_(__p) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
geometric_distribution() : geometric_distribution(0.5) {}
_LIBCPP_INLINE_VISIBILITY
explicit geometric_distribution(double __p)
: __p_(__p) {}
_LIBCPP_HIDE_FROM_ABI geometric_distribution() : geometric_distribution(0.5) {}
_LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(double __p) : __p_(__p) {}
#else
_LIBCPP_INLINE_VISIBILITY
explicit geometric_distribution(double __p = 0.5)
: __p_(__p) {}
_LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);}
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p)
{return negative_binomial_distribution<result_type>(1, __p.p())(__g);}
// 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_INLINE_VISIBILITY
double p() const {return __p_.p();}
// property functions
_LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::max();}
_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_INLINE_VISIBILITY
bool operator==(const geometric_distribution& __x,
const geometric_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const geometric_distribution& __x,
const geometric_distribution& __y)
{return !(__x == __y);}
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();
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;
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

327
third_party/libcxx/__random/independent_bits_engine.h vendored
View file

@ -10,6 +10,8 @@
#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>
@ -17,7 +19,6 @@
#include <__type_traits/is_convertible.h>
#include <__utility/move.h>
#include <cstddef>
#include <iosfwd>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@ -29,238 +30,172 @@ _LIBCPP_PUSH_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;
};
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;
// types
typedef _UIntType result_type;
private:
_Engine __e_;
_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");
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;
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);
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);
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);
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");
static _LIBCPP_CONSTEXPR const result_type _Min = 0;
static _LIBCPP_CONSTEXPR const result_type _Max =
__w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
// engine characteristics
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
// 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_INLINE_VISIBILITY
independent_bits_engine() {}
_LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(const _Engine& __e)
: __e_(__e) {}
// 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_INLINE_VISIBILITY
explicit independent_bits_engine(_Engine&& __e)
: __e_(_VSTD::move(__e)) {}
_LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(_Engine&& __e) : __e_(std::move(__e)) {}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
!is_convertible<_Sseq, _Engine>::value>::type* = 0)
: __e_(__q) {}
_LIBCPP_INLINE_VISIBILITY
void seed() {__e_.seed();}
_LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd) {__e_.seed(__sd);}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__is_seed_sequence<_Sseq, independent_bits_engine>::value,
void
>::type
seed(_Sseq& __q) {__e_.seed(__q);}
_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_INLINE_VISIBILITY
result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
_LIBCPP_INLINE_VISIBILITY
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
// 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_INLINE_VISIBILITY
const _Engine& base() const _NOEXCEPT {return __e_;}
// 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 _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_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);
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_INLINE_VISIBILITY
result_type __eval(false_type);
_LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
_LIBCPP_HIDE_FROM_ABI result_type __eval(false_type);
_LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
template <size_t __count>
_LIBCPP_INLINE_VISIBILITY
static
typename enable_if
<
__count < _Dt,
result_type
>::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 __x) {
return __x << __count;
}
template <size_t __count>
_LIBCPP_INLINE_VISIBILITY
static
typename enable_if
<
(__count >= _Dt),
result_type
>::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 __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>
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 _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_INLINE_VISIBILITY
bool
operator==(
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
{
return __x.base() == __y.base();
template <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_INLINE_VISIBILITY
bool
operator!=(
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
{
return !(__x == __y);
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>
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();
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>
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;
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

8
third_party/libcxx/__random/is_seed_sequence.h vendored
View file

@ -21,11 +21,9 @@
_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;
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

67
third_party/libcxx/__random/is_valid.h vendored
View file

@ -23,28 +23,55 @@
_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 {};
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
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
@ -54,11 +81,13 @@ template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {};
// (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 {};
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

547
third_party/libcxx/__random/linear_congruential_engine.h vendored
View file

@ -26,372 +26,359 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template <unsigned long long __a, unsigned long long __c,
unsigned long long __m, unsigned long long _Mp,
bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a),
bool _OverflowOK = ((__m | (__m-1)) > __m), // m = 2^n
bool _SchrageOK = (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q
struct __lce_alg_picker
{
static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK || _SchrageOK,
"The current values of a, c, and m cannot generate a number "
"within bounds of linear_congruential_engine.");
static _LIBCPP_CONSTEXPR const bool __use_schrage = _MightOverflow &&
!_OverflowOK &&
_SchrageOK;
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 _UseSchrage = __lce_alg_picker<__a, __c, __m, _Mp>::__use_schrage>
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)(~0), true>
{
typedef unsigned long long result_type;
_LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x)
{
// Schrage's algorithm
const result_type __q = __m / __a;
const result_type __r = __m % __a;
const result_type __t0 = __a * (__x % __q);
const result_type __t1 = __r * (__x / __q);
__x = __t0 + (__t0 < __t1) * __m - __t1;
__x += __c - (__x >= __m - __c) * __m;
return __x;
}
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, 0, __m, (unsigned long long)(~0), true>
{
typedef unsigned long long result_type;
_LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x)
{
// Schrage's algorithm
const result_type __q = __m / __a;
const result_type __r = __m % __a;
const result_type __t0 = __a * (__x % __q);
const result_type __t1 = __r * (__x / __q);
__x = __t0 + (__t0 < __t1) * __m - __t1;
return __x;
}
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)(~0), false>
{
typedef unsigned long long result_type;
_LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x)
{
return (__a * __x + __c) % __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, 0, (unsigned long long)(~0), false>
{
typedef unsigned long long result_type;
_LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x)
{
return __a * __x + __c;
}
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(~0), true>
{
typedef unsigned result_type;
_LIBCPP_INLINE_VISIBILITY
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;
}
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, 0, _Mp, unsigned(~0), true>
{
typedef unsigned result_type;
_LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x)
{
const result_type __a = static_cast<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;
}
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(~0), false>
{
typedef unsigned result_type;
_LIBCPP_INLINE_VISIBILITY
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;
}
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, 0, unsigned(~0), false>
{
typedef unsigned result_type;
_LIBCPP_INLINE_VISIBILITY
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;
}
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, bool __b>
struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
{
typedef unsigned short result_type;
_LIBCPP_INLINE_VISIBILITY
static result_type next(result_type __x)
{
return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
}
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_INLINE_VISIBILITY
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_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>
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);
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
{
class _LIBCPP_TEMPLATE_VIS linear_congruential_engine {
public:
// types
typedef _UIntType result_type;
// types
typedef _UIntType result_type;
private:
result_type __x_;
result_type __x_;
static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
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");
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");
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_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
// 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
// constructors and seeding functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
linear_congruential_engine() : linear_congruential_engine(default_seed) {}
_LIBCPP_INLINE_VISIBILITY
explicit linear_congruential_engine(result_type __s) { seed(__s); }
_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_INLINE_VISIBILITY
explicit linear_congruential_engine(result_type __s = default_seed) {
seed(__s);
}
_LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(result_type __s = default_seed) { seed(__s); }
#endif
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
explicit linear_congruential_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
{seed(__q);}
_LIBCPP_INLINE_VISIBILITY
void seed(result_type __s = default_seed)
{seed(integral_constant<bool, __m == 0>(),
integral_constant<bool, __c == 0>(), __s);}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__is_seed_sequence<_Sseq, linear_congruential_engine>::value,
void
>::type
seed(_Sseq& __q)
{__seed(__q, integral_constant<unsigned,
1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
: (__m > 0x100000000ull))>());}
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_INLINE_VISIBILITY
result_type operator()()
{return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));}
_LIBCPP_INLINE_VISIBILITY
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
// 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_INLINE_VISIBILITY
bool operator==(const linear_congruential_engine& __x,
const linear_congruential_engine& __y)
{return __x.__x_ == __y.__x_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const linear_congruential_engine& __x,
const linear_congruential_engine& __y)
{return !(__x == __y);}
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; }
_LIBCPP_INLINE_VISIBILITY
void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
_LIBCPP_INLINE_VISIBILITY
void seed(true_type, false_type, result_type __s) {__x_ = __s;}
_LIBCPP_INLINE_VISIBILITY
void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
1 : __s % __m;}
_LIBCPP_INLINE_VISIBILITY
void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
template <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 _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_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 _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
_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
_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
_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
_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 _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 _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_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
{
__save_flags<_CharT, _Traits> __lx(__os);
typedef basic_ostream<_CharT, _Traits> _Ostream;
__os.flags(_Ostream::dec | _Ostream::left);
__os.fill(__os.widen(' '));
return __os << __x.__x_;
template <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>
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;
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;
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

39
third_party/libcxx/__random/log2.h vendored
View file

@ -23,47 +23,42 @@ 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;
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;
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;
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;
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<
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>,
__conditional_t<sizeof(_UIntType) <= sizeof(unsigned long long), unsigned long long, __uint128_t>,
#else
unsigned long long,
unsigned long long,
#endif // _LIBCPP_HAS_NO_INT128
_Xp,
sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
_Xp,
sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
};
_LIBCPP_END_NAMESPACE_STD

169
third_party/libcxx/__random/lognormal_distribution.h vendored
View file

@ -10,6 +10,7 @@
#define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
#include <__config>
#include <__random/is_valid.h>
#include <__random/normal_distribution.h>
#include <cmath>
#include <iosfwd>
@ -24,134 +25,98 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS lognormal_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __m_;
result_type __s_;
public:
typedef lognormal_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __m_;
result_type __s_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __m = 0, result_type __s = 1)
: __m_(__m), __s_(__s) {}
public:
typedef lognormal_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type m() const {return __m_;}
_LIBCPP_INLINE_VISIBILITY
result_type s() const {return __s_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __m = 0, result_type __s = 1) : __m_(__m), __s_(__s) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__m_ == __y.__m_ && __x.__s_ == __y.__s_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
normal_distribution<result_type> __nd_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
lognormal_distribution() : lognormal_distribution(0) {}
_LIBCPP_INLINE_VISIBILITY
explicit lognormal_distribution(result_type __m, result_type __s = 1)
: __nd_(__m, __s) {}
_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_INLINE_VISIBILITY
explicit lognormal_distribution(result_type __m = 0,
result_type __s = 1)
: __nd_(__m, __s) {}
_LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(result_type __m = 0, result_type __s = 1) : __nd_(__m, __s) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit lognormal_distribution(const param_type& __p)
: __nd_(__p.m(), __p.s()) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {__nd_.reset();}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{
return _VSTD::exp(__nd_(__g));
}
// generating functions
template <class _URNG>
_LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
return std::exp(__nd_(__g));
}
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p)
{
typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
return _VSTD::exp(__nd_(__g, __pn));
}
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_INLINE_VISIBILITY
result_type m() const {return __nd_.mean();}
_LIBCPP_INLINE_VISIBILITY
result_type s() const {return __nd_.stddev();}
// 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_INLINE_VISIBILITY
param_type param() const {return param_type(__nd_.mean(), __nd_.stddev());}
_LIBCPP_INLINE_VISIBILITY
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 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_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const lognormal_distribution& __x,
const lognormal_distribution& __y)
{return __x.__nd_ == __y.__nd_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const lognormal_distribution& __x,
const lognormal_distribution& __y)
{return !(__x == __y);}
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_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>
friend basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, lognormal_distribution<_RT>& __x);
};
template <class _CharT, class _Traits, class _RT>
inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const lognormal_distribution<_RT>& __x)
{
return __os << __x.__nd_;
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_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is,
lognormal_distribution<_RT>& __x)
{
return __is >> __x.__nd_;
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

1213
third_party/libcxx/__random/mersenne_twister_engine.h vendored
View file

File diff suppressed because it is too large Load diff

213
third_party/libcxx/__random/negative_binomial_distribution.h vendored
View file

@ -9,6 +9,7 @@
#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>
@ -26,155 +27,127 @@ _LIBCPP_PUSH_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");
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;
// types
typedef _IntType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __k_;
double __p_;
public:
typedef negative_binomial_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __k_;
double __p_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __k = 1, double __p = 0.5)
: __k_(__k), __p_(__p) {}
public:
typedef negative_binomial_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type k() const {return __k_;}
_LIBCPP_INLINE_VISIBILITY
double p() const {return __p_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __k = 1, double __p = 0.5) : __k_(__k), __p_(__p) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
negative_binomial_distribution() : negative_binomial_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
: __p_(__k, __p) {}
_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_INLINE_VISIBILITY
explicit negative_binomial_distribution(result_type __k = 1,
double __p = 0.5)
: __p_(__k, __p) {}
_LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
: __p_(__k, __p) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type k() const {return __p_.k();}
_LIBCPP_INLINE_VISIBILITY
double p() const {return __p_.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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::max();}
_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_INLINE_VISIBILITY
bool operator==(const negative_binomial_distribution& __x,
const negative_binomial_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const negative_binomial_distribution& __x,
const negative_binomial_distribution& __y)
{return !(__x == __y);}
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(__f >= 0, "std::negative_binomial_distribution should never produce negative values. "
"This is almost certainly a signed integer overflow issue on __f.");
return __f;
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;
}
return poisson_distribution<result_type>(gamma_distribution<double>
(__k, (1-__p)/__p)(__urng))(__urng);
_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();
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;
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

259
third_party/libcxx/__random/normal_distribution.h vendored
View file

@ -25,183 +25,148 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS normal_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __mean_;
result_type __stddev_;
public:
typedef normal_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __mean_;
result_type __stddev_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __mean = 0, result_type __stddev = 1)
: __mean_(__mean), __stddev_(__stddev) {}
public:
typedef normal_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type mean() const {return __mean_;}
_LIBCPP_INLINE_VISIBILITY
result_type stddev() const {return __stddev_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __mean = 0, result_type __stddev = 1)
: __mean_(__mean), __stddev_(__stddev) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
result_type __v_;
bool __v_hot_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
normal_distribution() : normal_distribution(0) {}
_LIBCPP_INLINE_VISIBILITY
explicit normal_distribution(result_type __mean, result_type __stddev = 1)
: __p_(param_type(__mean, __stddev)), __v_hot_(false) {}
_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_INLINE_VISIBILITY
explicit normal_distribution(result_type __mean = 0,
result_type __stddev = 1)
: __p_(param_type(__mean, __stddev)), __v_hot_(false) {}
_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_INLINE_VISIBILITY
explicit normal_distribution(const param_type& __p)
: __p_(__p), __v_hot_(false) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {__v_hot_ = false;}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type mean() const {return __p_.mean();}
_LIBCPP_INLINE_VISIBILITY
result_type stddev() const {return __p_.stddev();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return -numeric_limits<result_type>::infinity();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const normal_distribution& __x,
const normal_distribution& __y)
{return __x.__p_ == __y.__p_ && __x.__v_hot_ == __y.__v_hot_ &&
(!__x.__v_hot_ || __x.__v_ == __y.__v_);}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const normal_distribution& __x,
const normal_distribution& __y)
{return !(__x == __y);}
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_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 _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 = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
__v_ = __v * __fp;
__v_hot_ = true;
__up = __u * __fp;
}
return __up * __p.stddev() + __p.mean();
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;
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;
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

475
third_party/libcxx/__random/piecewise_constant_distribution.h vendored
View file

@ -26,330 +26,273 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
{
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;
// 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;
class _LIBCPP_TEMPLATE_VIS param_type {
vector<result_type> __b_;
vector<result_type> __densities_;
vector<result_type> __areas_;
_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);
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);
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);
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_INLINE_VISIBILITY
vector<result_type> intervals() const {return __b_;}
_LIBCPP_INLINE_VISIBILITY
vector<result_type> densities() const {return __densities_;}
_LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __b_; }
_LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __densities_; }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
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();
private:
_LIBCPP_HIDE_FROM_ABI void __init();
friend class piecewise_constant_distribution;
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_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 _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_;
param_type __p_;
public:
// constructor and reset functions
_LIBCPP_INLINE_VISIBILITY
piecewise_constant_distribution() {}
template<class _InputIteratorB, class _InputIteratorW>
_LIBCPP_INLINE_VISIBILITY
piecewise_constant_distribution(_InputIteratorB __f_b,
_InputIteratorB __l_b,
_InputIteratorW __f_w)
: __p_(__f_b, __l_b, __f_w) {}
// 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_INLINE_VISIBILITY
piecewise_constant_distribution(initializer_list<result_type> __bl,
_UnaryOperation __fw)
: __p_(__bl, __fw) {}
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_INLINE_VISIBILITY
piecewise_constant_distribution(size_t __nw, result_type __xmin,
result_type __xmax, _UnaryOperation __fw)
: __p_(__nw, __xmin, __xmax, __fw) {}
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_INLINE_VISIBILITY
explicit piecewise_constant_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_HIDE_FROM_ABI explicit piecewise_constant_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_LIBCPP_HIDE_FROM_ABI void reset() {}
// generating functions
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
vector<result_type> intervals() const {return __p_.intervals();}
_LIBCPP_INLINE_VISIBILITY
vector<result_type> densities() const {return __p_.densities();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return __p_.__b_.front();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return __p_.__b_.back();}
_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_INLINE_VISIBILITY
bool operator==(const piecewise_constant_distribution& __x,
const piecewise_constant_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const piecewise_constant_distribution& __x,
const piecewise_constant_distribution& __y)
{return !(__x == __y);}
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_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 _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());
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;
// 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 = _VSTD::accumulate(__densities_.begin(),
__densities_.end(),
result_type());
for (size_t __i = 0; __i < __densities_.size(); ++__i)
__densities_[__i] /= __total_area;
// __densities_ contains normalized areas
__areas_.assign(__densities_.size(), result_type());
_VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
__areas_.begin() + 1);
// __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
__densities_.back() = 1 - __areas_.back(); // correct round off error
for (size_t __i = 0; __i < __densities_.size(); ++__i)
__densities_[__i] /= (__b_[__i+1] - __b_[__i]);
// __densities_ now contains __densities_
template <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>
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>
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();
}
_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>
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();
}
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>
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();
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 = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
__u) - __p.__areas_.begin() - 1;
return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
template <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;
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;
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

506
third_party/libcxx/__random/piecewise_linear_distribution.h vendored
View file

@ -13,8 +13,8 @@
#include <__config>
#include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd>
#include <numeric>
#include <vector>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@ -26,346 +26,286 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
{
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;
// 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;
class _LIBCPP_TEMPLATE_VIS param_type {
vector<result_type> __b_;
vector<result_type> __densities_;
vector<result_type> __areas_;
_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);
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);
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);
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_INLINE_VISIBILITY
vector<result_type> intervals() const {return __b_;}
_LIBCPP_INLINE_VISIBILITY
vector<result_type> densities() const {return __densities_;}
_LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __b_; }
_LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __densities_; }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
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();
private:
_LIBCPP_HIDE_FROM_ABI void __init();
friend class piecewise_linear_distribution;
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_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 _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_;
param_type __p_;
public:
// constructor and reset functions
_LIBCPP_INLINE_VISIBILITY
piecewise_linear_distribution() {}
template<class _InputIteratorB, class _InputIteratorW>
_LIBCPP_INLINE_VISIBILITY
piecewise_linear_distribution(_InputIteratorB __f_b,
_InputIteratorB __l_b,
_InputIteratorW __f_w)
: __p_(__f_b, __l_b, __f_w) {}
// 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_INLINE_VISIBILITY
piecewise_linear_distribution(initializer_list<result_type> __bl,
_UnaryOperation __fw)
: __p_(__bl, __fw) {}
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_INLINE_VISIBILITY
piecewise_linear_distribution(size_t __nw, result_type __xmin,
result_type __xmax, _UnaryOperation __fw)
: __p_(__nw, __xmin, __xmax, __fw) {}
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_INLINE_VISIBILITY
explicit piecewise_linear_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_HIDE_FROM_ABI explicit piecewise_linear_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_LIBCPP_HIDE_FROM_ABI void reset() {}
// generating functions
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
vector<result_type> intervals() const {return __p_.intervals();}
_LIBCPP_INLINE_VISIBILITY
vector<result_type> densities() const {return __p_.densities();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return __p_.__b_.front();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return __p_.__b_.back();}
_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_INLINE_VISIBILITY
bool operator==(const piecewise_linear_distribution& __x,
const piecewise_linear_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const piecewise_linear_distribution& __x,
const piecewise_linear_distribution& __y)
{return !(__x == __y);}
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_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 _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());
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;
// 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>
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>
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>
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();
}
_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>
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();
}
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>
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();
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 = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
__u) - __p.__areas_.begin() - 1;
__u -= __p.__areas_[__k];
const result_type __dk = __p.__densities_[__k];
const result_type __dk1 = __p.__densities_[__k+1];
const result_type __deltad = __dk1 - __dk;
const result_type __bk = __p.__b_[__k];
if (__deltad == 0)
return __u / __dk + __bk;
const result_type __bk1 = __p.__b_[__k+1];
const result_type __deltab = __bk1 - __bk;
return (__bk * __dk1 - __bk1 * __dk +
_VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
__deltad;
template <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;
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;
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

372
third_party/libcxx/__random/poisson_distribution.h vendored
View file

@ -28,250 +28,210 @@ _LIBCPP_PUSH_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");
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;
// 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_;
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;
public:
typedef poisson_distribution distribution_type;
_LIBCPP_HIDE_FROM_ABI explicit param_type(double __mean = 1.0);
_LIBCPP_HIDE_FROM_ABI explicit param_type(double __mean = 1.0);
_LIBCPP_INLINE_VISIBILITY
double mean() const {return __mean_;}
_LIBCPP_HIDE_FROM_ABI double mean() const { return __mean_; }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__mean_ == __y.__mean_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
friend _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;
};
friend class poisson_distribution;
};
private:
param_type __p_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
poisson_distribution() : poisson_distribution(1.0) {}
_LIBCPP_INLINE_VISIBILITY
explicit poisson_distribution(double __mean)
: __p_(__mean) {}
_LIBCPP_HIDE_FROM_ABI poisson_distribution() : poisson_distribution(1.0) {}
_LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(double __mean) : __p_(__mean) {}
#else
_LIBCPP_INLINE_VISIBILITY
explicit poisson_distribution(double __mean = 1.0)
: __p_(__mean) {}
_LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
double mean() const {return __p_.mean();}
// property functions
_LIBCPP_HIDE_FROM_ABI double mean() const { return __p_.mean(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::max();}
_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_INLINE_VISIBILITY
bool operator==(const poisson_distribution& __x,
const poisson_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const poisson_distribution& __x,
const poisson_distribution& __y)
{return !(__x == __y);}
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>
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_ = _VSTD::exp(-__mean_);
__omega_ = 0;
__c3_ = 0;
__c2_ = 0;
__c1_ = 0;
__c0_ = 0;
__c_ = 0;
}
else
{
__s_ = _VSTD::sqrt(__mean_);
__d_ = 6 * __mean_ * __mean_;
__l_ = _VSTD::trunc(__mean_ - 1.1484);
__omega_ = .3989423 / __s_;
double __b1 = .4166667E-1 / __mean_;
double __b2 = .3 * __b1 * __b1;
__c3_ = .1428571 * __b1 * __b2;
__c2_ = __b2 - 15. * __c3_;
__c1_ = __b1 - 6. * __b2 + 45. * __c3_;
__c0_ = 1. - __b1 + 3. * __b2 - 15. * __c3_;
__c_ = .1069 / __mean_;
}
: __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);
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);
}
else
{
double __difmuk;
double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
double __u;
if (__g > 0)
{
__tx = _VSTD::trunc(__g);
if (__tx >= __pr.__l_)
return _VSTD::__clamp_to_integral<result_type>(__tx);
__difmuk = __pr.__mean_ - __tx;
__u = __urd(__urng);
if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
return _VSTD::__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 = _VSTD::trunc(__pr.__mean_ + __pr.__s_ * __t);
__difmuk = __pr.__mean_ - __tx;
__using_exp_dist = true;
}
double __px;
double __py;
if (__tx < 10 && __tx >= 0)
{
const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
40320, 362880};
__px = -__pr.__mean_;
__py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)];
}
else
{
double __del = .8333333E-1 / __tx;
__del -= 4.8 * __del * __del * __del;
double __v = __difmuk / __tx;
if (_VSTD::abs(__v) > 0.25)
__px = __tx * _VSTD::log(1 + __v) - __difmuk - __del;
else
__px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) *
__v + .1421878) * __v + -.1661269) * __v + .2000118) *
__v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
__py = .3989423 / _VSTD::sqrt(__tx);
}
double __r = (0.5 - __difmuk) / __pr.__s_;
double __r2 = __r * __r;
double __fx = -0.5 * __r2;
double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
__r2 + __pr.__c1_) * __r2 + __pr.__c0_);
if (__using_exp_dist)
{
if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
__fy * _VSTD::exp(__fx + __e))
break;
}
else
{
if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
break;
}
}
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 _VSTD::__clamp_to_integral<result_type>(__tx);
}
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();
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;
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

75
third_party/libcxx/__random/random_device.h vendored
View file

@ -23,56 +23,53 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE)
class _LIBCPP_TYPE_VIS 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")
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
// 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 ...
// ... vendors can add workarounds here if they switch to a different representation ...
_LIBCPP_DIAGNOSTIC_POP
#endif
_LIBCPP_DIAGNOSTIC_POP
# endif
public:
// types
typedef unsigned result_type;
// types
typedef unsigned result_type;
// generator characteristics
static _LIBCPP_CONSTEXPR const result_type _Min = 0;
static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
// generator characteristics
static _LIBCPP_CONSTEXPR const result_type _Min = 0;
static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
_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();
// 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()();
// generating functions
result_type operator()();
// property functions
double entropy() const _NOEXCEPT;
// property functions
double entropy() const _NOEXCEPT;
random_device(const random_device&) = delete;
void operator=(const random_device&) = delete;
random_device(const random_device&) = delete;
void operator=(const random_device&) = delete;
};
#endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE

2
third_party/libcxx/__random/ranlux.h vendored
View file

@ -21,7 +21,7 @@
_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 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;

237
third_party/libcxx/__random/seed_seq.h vendored
View file

@ -14,6 +14,7 @@
#include <__algorithm/max.h>
#include <__config>
#include <__iterator/iterator_traits.h>
#include <__type_traits/is_unsigned.h>
#include <cstdint>
#include <initializer_list>
#include <vector>
@ -27,149 +28,135 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TEMPLATE_VIS seed_seq
{
class _LIBCPP_TEMPLATE_VIS seed_seq {
public:
// types
typedef uint32_t result_type;
// types
typedef uint32_t result_type;
// constructors
_LIBCPP_INLINE_VISIBILITY
seed_seq() _NOEXCEPT {}
// constructors
_LIBCPP_HIDE_FROM_ABI seed_seq() _NOEXCEPT {}
#ifndef _LIBCPP_CXX03_LANG
template<class _Tp, __enable_if_t<is_integral<_Tp>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY
seed_seq(initializer_list<_Tp> __il) {
__init(__il.begin(), __il.end());
}
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_INLINE_VISIBILITY
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);
}
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);
// generating functions
template <class _RandomAccessIterator>
_LIBCPP_HIDE_FROM_ABI void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
// property functions
_LIBCPP_INLINE_VISIBILITY
size_t size() const _NOEXCEPT {return __v_.size();}
template<class _OutputIterator>
_LIBCPP_INLINE_VISIBILITY
void param(_OutputIterator __dest) const
{_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
// 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;
seed_seq(const seed_seq&) = delete;
void operator=(const seed_seq&) = delete;
_LIBCPP_INLINE_VISIBILITY
static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
_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);
template <class _InputIterator>
_LIBCPP_HIDE_FROM_ABI void __init(_InputIterator __first, _InputIterator __last);
vector<result_type> __v_;
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 _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)
{
if (__first != __last)
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;
{
_VSTD::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 = _VSTD::max(__s + 1, __n);
// __k = 0;
{
result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p]
^ __first[__n - 1]);
__first[__p] += __r;
__r += __s;
__first[__q] += __r;
__first[0] = __r;
}
// 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;
}
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

344
third_party/libcxx/__random/shuffle_order_engine.h vendored
View file

@ -30,253 +30,197 @@ _LIBCPP_PUSH_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;
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;
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;
class __uratio {
static_assert(_Dp != 0, "__uratio divide by 0");
static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
typedef __uratio<num, den> type;
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");
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;
// types
typedef typename _Engine::result_type result_type;
private:
_Engine __e_;
result_type __v_[__k];
result_type __y_;
_Engine __e_;
result_type __v_[__k];
result_type __y_;
public:
// engine characteristics
static _LIBCPP_CONSTEXPR const size_t table_size = __k;
// 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;
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();
static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
#endif
static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
static_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;
static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
// constructors and seeding functions
_LIBCPP_INLINE_VISIBILITY
shuffle_order_engine() {__init();}
_LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(const _Engine& __e)
: __e_(__e) {__init();}
// 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_INLINE_VISIBILITY
explicit shuffle_order_engine(_Engine&& __e)
: __e_(_VSTD::move(__e)) {__init();}
_LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(_Engine&& __e) : __e_(std::move(__e)) { __init(); }
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
!is_convertible<_Sseq, _Engine>::value>::type* = 0)
: __e_(__q) {__init();}
_LIBCPP_INLINE_VISIBILITY
void seed() {__e_.seed(); __init();}
_LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd) {__e_.seed(__sd); __init();}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__is_seed_sequence<_Sseq, shuffle_order_engine>::value,
void
>::type
seed(_Sseq& __q) {__e_.seed(__q); __init();}
_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_INLINE_VISIBILITY
result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
_LIBCPP_INLINE_VISIBILITY
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
// 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_INLINE_VISIBILITY
const _Engine& base() const _NOEXCEPT {return __e_;}
// 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 _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_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);
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_INLINE_VISIBILITY
void __init()
{
for (size_t __i = 0; __i < __k; ++__i)
__v_[__i] = __e_();
__y_ = __e_();
}
_LIBCPP_HIDE_FROM_ABI void __init() {
for (size_t __i = 0; __i < __k; ++__i)
__v_[__i] = __e_();
__y_ = __e_();
}
_LIBCPP_INLINE_VISIBILITY
result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
_LIBCPP_INLINE_VISIBILITY
result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
_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_INLINE_VISIBILITY
result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
_LIBCPP_INLINE_VISIBILITY
result_type __eval2(true_type) {return __evalf<__k, 0>();}
_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>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
(__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
result_type
>::type
__eval(__uratio<_Np, _Dp>)
{return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}
template <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>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
result_type
>::type
__eval(__uratio<_Np, _Dp>)
{
const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (__y_ - _Min)
/ __uratio<_Np, _Dp>::den);
__y_ = __v_[__j];
__v_[__j] = __e_();
return __y_;
}
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_INLINE_VISIBILITY
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 <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 _Engine, size_t __k>
_LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
template<class _Eng, size_t _Kp>
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_ && _VSTD::equal(__x.__v_, __x.__v_ + _Kp, __y.__v_) &&
__x.__e_ == __y.__e_;
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_INLINE_VISIBILITY
bool
operator!=(
const shuffle_order_engine<_Eng, _Kp>& __x,
const shuffle_order_engine<_Eng, _Kp>& __y)
{
return !(__x == __y);
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>
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_;
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>
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;
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

162
third_party/libcxx/__random/student_t_distribution.h vendored
View file

@ -26,127 +26,103 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS student_t_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __n_;
public:
typedef student_t_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __n_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __n = 1) : __n_(__n) {}
public:
typedef student_t_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type n() const {return __n_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __n = 1) : __n_(__n) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__n_ == __y.__n_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
normal_distribution<result_type> __nd_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
student_t_distribution() : student_t_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit student_t_distribution(result_type __n)
: __p_(param_type(__n)) {}
_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_INLINE_VISIBILITY
explicit student_t_distribution(result_type __n = 1)
: __p_(param_type(__n)) {}
_LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(result_type __n = 1) : __p_(param_type(__n)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit student_t_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {__nd_.reset();}
_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_INLINE_VISIBILITY
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);
// 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_INLINE_VISIBILITY
result_type n() const {return __p_.n();}
// property functions
_LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); }
_LIBCPP_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__p_ = __p;}
_LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
_LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
_LIBCPP_INLINE_VISIBILITY
result_type min() const {return -numeric_limits<result_type>::infinity();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const student_t_distribution& __x,
const student_t_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const student_t_distribution& __x,
const student_t_distribution& __y)
{return !(__x == __y);}
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) * _VSTD::sqrt(__p.n()/__gd(__g));
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;
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;
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

453
third_party/libcxx/__random/subtract_with_carry_engine.h vendored
View file

@ -28,320 +28,245 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _UIntType, size_t __w, size_t __s, size_t __r>
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 _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
_LIBCPP_INLINE_VISIBILITY
bool
operator!=(
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
template <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>
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);
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>
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);
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
{
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;
// types
typedef _UIntType result_type;
private:
result_type __x_[__r];
result_type __c_;
size_t __i_;
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");
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");
static _LIBCPP_CONSTEXPR const result_type _Min = 0;
static _LIBCPP_CONSTEXPR const result_type _Max =
__w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
// engine characteristics
static _LIBCPP_CONSTEXPR const size_t word_size = __w;
static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
_LIBCPP_INLINE_VISIBILITY
static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
// 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
// constructors and seeding functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
_LIBCPP_INLINE_VISIBILITY
explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
_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_INLINE_VISIBILITY
explicit subtract_with_carry_engine(result_type __sd = default_seed) {
seed(__sd);
}
_LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(result_type __sd = default_seed) { seed(__sd); }
#endif
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
explicit subtract_with_carry_engine(_Sseq& __q,
typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
{seed(__q);}
_LIBCPP_INLINE_VISIBILITY
void seed(result_type __sd = default_seed)
{seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
template<class _Sseq>
_LIBCPP_INLINE_VISIBILITY
typename enable_if
<
__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
void
>::type
seed(_Sseq& __q)
{__seed(__q, 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 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_INLINE_VISIBILITY
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
// 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 _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_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);
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>);
_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>::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>::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 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
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, 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>
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, 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>
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 _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 _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
if (__x.__i_ == 0 || __y.__i_ == 0)
{
size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_);
if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
__y.__x_ + __y.__i_))
return false;
if (__x.__i_ == 0)
return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
}
if (__x.__i_ < __y.__i_)
{
size_t __j = _Rp - __y.__i_;
if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
__y.__x_ + __y.__i_))
return false;
if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp,
__y.__x_))
return false;
return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
__y.__x_ + (_Rp - (__x.__i_ + __j)));
}
size_t __j = _Rp - __x.__i_;
if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
__x.__x_ + __x.__i_))
return false;
if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp,
__x.__x_))
return false;
return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
__x.__x_ + (_Rp - (__y.__i_ + __j)));
template <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_INLINE_VISIBILITY
bool
operator!=(
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
{
return !(__x == __y);
template <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>
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;
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>
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;
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

387
third_party/libcxx/__random/uniform_int_distribution.h vendored
View file

@ -29,263 +29,232 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _Engine, class _UIntType>
class __independent_bits_engine
{
template <class _Engine, class _UIntType>
class __independent_bits_engine {
public:
// types
typedef _UIntType result_type;
// 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;
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_;
_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);
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);
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;
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);
// 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>());}
// 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);
_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);
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 (_Rp == 0)
__y0_ = _Rp;
else if (__w0_ < _WDt)
__y0_ = (_Rp >> __w0_) << __w0_;
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);
__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
__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);
__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 _Engine, class _UIntType>
inline
_UIntType
__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
{
return static_cast<result_type>(__e_() & __mask0_);
}
template <class _IntType = int>
class uniform_int_distribution {
static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
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;
// types
typedef _IntType result_type;
class param_type
{
result_type __a_;
result_type __b_;
public:
typedef uniform_int_distribution distribution_type;
class param_type {
result_type __a_;
result_type __b_;
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0,
result_type __b = numeric_limits<result_type>::max())
: __a_(__a), __b_(__b) {}
public:
typedef uniform_int_distribution distribution_type;
_LIBCPP_HIDE_FROM_ABI result_type a() const {return __a_;}
_LIBCPP_HIDE_FROM_ABI result_type b() const {return __b_;}
_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
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);}
};
_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_;
param_type __p_;
public:
// constructors and reset functions
// 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)) {}
_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)) {}
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() {}
_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);
// 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();}
// 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 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 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);}
_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 _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();
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;
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

14
third_party/libcxx/__random/uniform_random_bit_generator.h vendored
View file

@ -28,14 +28,12 @@ _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;
};
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

179
third_party/libcxx/__random/uniform_real_distribution.h vendored
View file

@ -24,134 +24,111 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __a_;
result_type __b_;
public:
typedef uniform_real_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __a_;
result_type __b_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 0,
result_type __b = 1)
: __a_(__a), __b_(__b) {}
public:
typedef uniform_real_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type a() const {return __a_;}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __b_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructors and reset functions
// constructors and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
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)) {}
_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_INLINE_VISIBILITY
explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);}
template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
// 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_INLINE_VISIBILITY
result_type a() const {return __p_.a();}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __p_.b();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return a();}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return b();}
_LIBCPP_HIDE_FROM_ABI result_type min() const { return a(); }
_LIBCPP_HIDE_FROM_ABI result_type max() const { return b(); }
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const uniform_real_distribution& __x,
const uniform_real_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const uniform_real_distribution& __x,
const uniform_real_distribution& __y)
{return !(__x == __y);}
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())
* _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
+ __p.a();
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();
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;
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

171
third_party/libcxx/__random/weibull_distribution.h vendored
View file

@ -11,6 +11,7 @@
#include <__config>
#include <__random/exponential_distribution.h>
#include <__random/is_valid.h>
#include <cmath>
#include <iosfwd>
#include <limits>
@ -24,128 +25,104 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template<class _RealType = double>
class _LIBCPP_TEMPLATE_VIS weibull_distribution
{
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;
// types
typedef _RealType result_type;
class _LIBCPP_TEMPLATE_VIS param_type
{
result_type __a_;
result_type __b_;
public:
typedef weibull_distribution distribution_type;
class _LIBCPP_TEMPLATE_VIS param_type {
result_type __a_;
result_type __b_;
_LIBCPP_INLINE_VISIBILITY
explicit param_type(result_type __a = 1, result_type __b = 1)
: __a_(__a), __b_(__b) {}
public:
typedef weibull_distribution distribution_type;
_LIBCPP_INLINE_VISIBILITY
result_type a() const {return __a_;}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __b_;}
_LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 1, result_type __b = 1) : __a_(__a), __b_(__b) {}
friend _LIBCPP_INLINE_VISIBILITY
bool operator==(const param_type& __x, const param_type& __y)
{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const param_type& __x, const param_type& __y)
{return !(__x == __y);}
};
_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_;
param_type __p_;
public:
// constructor and reset functions
// constructor and reset functions
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
weibull_distribution() : weibull_distribution(1) {}
_LIBCPP_INLINE_VISIBILITY
explicit weibull_distribution(result_type __a, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_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_INLINE_VISIBILITY
explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
_LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
: __p_(param_type(__a, __b)) {}
#endif
_LIBCPP_INLINE_VISIBILITY
explicit weibull_distribution(const param_type& __p)
: __p_(__p) {}
_LIBCPP_INLINE_VISIBILITY
void reset() {}
_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_INLINE_VISIBILITY
result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);}
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p)
{return __p.b() *
_VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
// 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_INLINE_VISIBILITY
result_type a() const {return __p_.a();}
_LIBCPP_INLINE_VISIBILITY
result_type b() const {return __p_.b();}
// 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_INLINE_VISIBILITY
param_type param() const {return __p_;}
_LIBCPP_INLINE_VISIBILITY
void param(const param_type& __p) {__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_INLINE_VISIBILITY
result_type min() const {return 0;}
_LIBCPP_INLINE_VISIBILITY
result_type max() const {return numeric_limits<result_type>::infinity();}
_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_INLINE_VISIBILITY
bool operator==(const weibull_distribution& __x,
const weibull_distribution& __y)
{return __x.__p_ == __y.__p_;}
friend _LIBCPP_INLINE_VISIBILITY
bool operator!=(const weibull_distribution& __x,
const weibull_distribution& __y)
{return !(__x == __y);}
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;
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;
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